Beyond Java - Java, JavaScript, and Beyond

Bye bye AWS!

Stephan Rauh — Sun, 13 Apr 2025 00:00:00 +0200

In these uncertain times, it seems prudent to reconsider spending money on American companies. The ongoing tariff fluctuations make it difficult to predict costs, especially for cloud services. Who knows how much your cloud service will cost tomorrow? That's why, effective March 1st, 2025, I've moved this blog away from AWS. It's now hosted on a German server. This change not only saves money but also simplifies the legal complexities of hosting a blog on an American server. However, there is a downside: you can no longer comment on this blog. Truthfully, blogging itself feels like a relic of the past, and I only continue because I enjoy it. The last comment I received was a long time ago, so I doubt anyone will miss the comment feature. The visitor counter is gone too. On the bright side, this blog no longer requires any cookies. So, along with saying goodbye to AWS, we can also bid farewell to those annoying cookie banners!

Data Protection Declaration and Impressum

Stephan Rauh — Sun, 13 Apr 2025 00:00:00 +0200

(no details available)

Migrating from Jasmine to Jest

Stephan Rauh — Mon, 01 Jan 2024 00:00:00 +0100

If you want to migrate Jasmine tests to Jest, jest-codemods helps you a lot. I used it in a project with more than 200 tests, and it slashed the effort by several days: ```sh npx jest-codemods ``` The tool is going to ask you a few questions. Here are the correct answers for a standard Angular project: ```sh ? Which parser do you want to use? ! TypeScript ? Which test library would you like to migrate from? ! Jasmine: globals ? Are you using the global object for assertions (i.e., without requiring them)? ! Yes, and I'm not afraid of false positive transformations ? Will you be using Jest on Node.js as your test runner? ! Yes, use the globals provided by Jest (recommended) ``` The tool doesn't fix every incompatiblity. Luckily, most issues are pretty obvious. Richard Wotzlaw has written a deep dive on migrating to Jest, including list of replacements.

How to set up Jest for an Angular 17 monorepo using @angular-builders/jest

Stephan Rauh — Mon, 01 Jan 2024 00:00:00 +0100

Using a Jest builder is an attractive option for using Jest in an Angular project. @angular-builders/jest:run is a production-ready solution. The name is a bit cumbersome, so let's call it the "Just Jeb" plugin because the author has published it on his website JustJeb.com. In a few years, we'll probably prefer Angular's native builder, but it's not fit for production yet. I'm covering it here.

How to set up Jest for an Angular 17 monorepo manually

Stephan Rauh — Mon, 01 Jan 2024 00:00:00 +0100

The nice thing about Jest is it's easy to get started. However, most tutorials tell you about setting up Jest in a default Angular project. I was interested in using Jest in a monorepo, so I had to research. As far as I can see, there are five roads you can go:

Starting with Angular 18 (or even later?), you can use the native support Angular offers. I'm covering this in another article, but as of Angular 17, I don't think it's ready for use in production. Experiment with it and tell the Angular team about it because that's how open source progresses, but don't use it in production.
You can configure Jest manually. That's what this article is about.
You can use the Briebug schematics to set up Jest in your Angular project or workspace.
You can use a plugin like the "Just Jeb" builder (aka @angular-builders/jest. I'm covering this here. You may also want to read Jeb's article.
You can use nx. That's almost certainly a good option, but until now, I have always shied away from using nx. I don't want to add another dependency until I need it. That's why I can't tell you much about it.

Native Jest Support for Angular 17 (Sneak Preview)

Stephan Rauh — Mon, 01 Jan 2024 00:00:00 +0100

Since Angular 16, we've got native support for Jest! It's experimental, but that didn't stop me. I took it for a test ride. TL;DR: Angular's native Jest integration works surprisingly well. However, it's a technology preview, so several limitations stop me from adopting it. For example, it doesn't support multi-projects, and there is no support for Visual Studio Code.

Using custom libraries with npm link

Stephan Rauh — Mon, 01 Jan 2024 00:00:00 +0100

If you're developing a library and an app in a monorepo, the `npm link` is your friend. It allows you to use the library the same way you're using a library you're downloading from npm. But it's more flexible: changes to the library immediately show in the app.

TL;DR

If you're in a hurry, skip to the "wrapping it up" section or scan this picture.

Islands Architecture

Stephan Rauh — Wed, 22 Nov 2023 00:00:00 +0100

Let's talk about the new kid on the block. The islands architecture answers the ever-growing challenges of the popular single-page architecture (SPA). Well-written SPA applications offer superior UX. That's why tools like Gmail and Google Maps became popular in the early 2010s.

Using GitHub Copilot or Code Whisperer on your customer's code

Stephan Rauh — Sat, 28 Oct 2023 00:00:00 +0200

Recently, I've been trying to find out whether it's legal to use tools like GitHub Copilot or AWS Code Whisperer on my customer's code. To be honest, I still don't know. I expected the answer to be a simple "Yes, you can!" but it doesn't seem that easy.

Disclaimer

I'm no legal expert. This text is a layman's assessment of a legal issue. Please do not take it at face value. I've written it to ignite thought and prompt questions. It's by no means legal advice. But no matter what you make of it, you're still responsible, and I urge you to consult your lawyer. Copyright law is a hornet's nest.

BeyondJava @ Conference

Stephan Rauh — Fri, 27 Oct 2023 00:00:00 +0200

(no details available)

Angular Compatibility List

Stephan Rauh — Mon, 26 Jun 2023 00:00:00 +0200

Twice a year, a new major of Angular ships, and I need to update my Angular projects. More often than not, the automated update doesn't work, so I have to do it manually. In other words, twice a year, I wonder which version of TypeScript is compatible with the new Angular version. Not to mention the versions of node.js, zone.js, and Rx.js. Until recently, I used to create a new sandbox Angular project to find out. Does this sound familiar? Here's help. More to the point, here on StackOverflow.

Running JavaScript on OpenJDK 17

Stephan Rauh — Sat, 25 Mar 2023 00:00:00 +0100

After my Javaland 2023 talk about GraalVM, I was asked how to GraalJS on a stock JDK. At first, I was puzzled. It's possible, but it doesn't make sense. Only it does: since Java 15, OpenJDK ships without a JavaScript engine.

Yes, you can!

GraalJS is available on Maven Central, so nothing stops you from using it:

Angular Universal: Server Side Rendering on a simple S3 bucket

Stephan Rauh — Mon, 13 Mar 2023 00:00:00 +0100

Adopting server-side rendering pays! Especially if you're running an Angular application on the web. Today, I activated Angular Universal for my blog, and it exceeded my wildest expectations. According to WebPageTest, SSR shaved up to 66% off the rendering time of the first page. That's what counts if you're into SEO. Google rewards fast websites, and it cares mostly about first contact. Once your reader or user is hooked, they tend to be patient. But on first contact, they're shy prey. Nothing of this is new. So what was stopping me? Well, I'm stuck with a static web server. Even after migrating my blog to AWS, I shied away from using Fargate or EC2 to run my blog. These technologies are cheap if you're running a company, but the monthly $30 fee is heavy for a hobbyist like me. Static web servers are way more affordable. So AWS S3 is my choice. It's an excellent static webserver, especially when combined with Cloudfront. So let's figure out how to run Angular on a commodity server. I wouldn't call S3 "commodity", but my recipe also works for the average plain-vanilla web hoster. TL;DR: modern Angular makes it a walk in the park!

Java Records vs. Value Types

Stephan Rauh — Thu, 05 Jan 2023 00:00:00 +0100

Some time ago, I noticed many developers confuse value types and records. Admittedly, that happens to me all the time, too, but these two concepts are fundamentally different. The term "value record" adds to the confusion. Plus, it seems the idea has evolved quite a bit since 2017, when I first heard about it. So I invite you to join my deep dive.

In a nutshell

Java records are syntaxtic sugar. You use a record to store immutable data. They make programming easier and more expressive, but they're not improving performance. They improve your semantics.
The value types of project Valhalla enable the compiler to generate faster code. They trade a few features you don't need anyway for improved performance.
Project Valhalla also plans to introduce a slightly more restricted value type called "primitive classes," allowing for a streamlined memory layout and blurring the difference between primitive types and objects.
There's also a design pattern called value objects. That's probably where the name comes from, but the value objects of project Valhalla have a different scope and definition. So the design pattern is confusing. Forget about it, at least for the next ten minutes. When I'm talking about value classes, they are a synonym of value types, and value objects are the instances of these value classes.

Records and value types are different concepts, but they aren't opposites. You can have a value record. Well, not now, unfortunately. Both value and primitive types are still under development. Faster performance and less memory footprint is always exciting. But the real fun is learning why value classes and primitive classes perform better.

Two Million Downloads!

Stephan Rauh — Wed, 04 Jan 2023 00:00:00 +0100

My PDF viewer has been downloaded almost two million times in 2022! When I started the project in April 2018, I suspected there was a market niche to fill, but I never expected it to be so big. 1,946,858 downloads between 01.01.2022 and 31.12.2022 are 1,946,858 signs of trust. Here's a screenshot from npmtrends.com:

Bye bye Twitter! Hello Mastodon!

Stephan Rauh — Wed, 28 Dec 2022 00:00:00 +0100

After almost ten years, I've made up my mind to leave Twitter. I won't delete my account because I hope Twitter becomes a friendly place again, as it was in the early days.

Which is Better for AWS Lambdas: Spring Boot or Quarkus?

Stephan Rauh — Tue, 27 Dec 2022 00:00:00 +0100

That's the wrong question. You shouldn't use either of them. Granted, that's probably not the answer you expected, so let me explain. Like so often, I don't insist on being right. Quite the contrary, I'm looking forward to heated and fruitful discussions. I want to make you think. But I guess I can convince you!

How to Deploy Spring Boot to AWS Fargate

Stephan Rauh — Sun, 25 Sep 2022 00:00:00 +0200

I didn't expect it to be so easy! The internet has many tutorials covering how to deploy Spring Boot on Fargate, and they all have one thing in common: they consist of many screenshots. You can follow their recipes step-by-step, but it doesn't seem trivial. AWS CDK takes the sting out of it. Look:

Snake-Case Parameters in Spring Boot REST Controllers

Stephan Rauh — Tue, 21 Jun 2022 00:00:00 +0200

My crusade for simplicity goes on. This time, I've run into another trivial and useless mapping. The controller mapped snake_case parameters to camelCase like so: ```java @GetMapping("/employee") @ResponseStatus(HttpStatus.OK) public EmployeeDto findByName( @RequestParam("first_name") String firstName, @RequestParam("last_name") String lastName) { return employeeService.findEmployeeByFirstName(firstName, lastName); } ``` There's an easier way. You can add a converter to your project. I've ~~written~~ googled an OncePerRequestFilter converting the requests for you. The source code isn't exciting, so suffice it to point you to my GitHub repository. With the converter, it doesn't matter if users call your API with camel-case or snake-case parameters. Plus, your API definition is much cleaner: ```java @GetMapping("/employee") @ResponseStatus(HttpStatus.OK) public EmployeeDto findByName( @RequestParam(String firstName, @RequestParam(String lastName) { return employeeService.findEmployeeByFirstName(firstName, lastName); } ```

End-to-end testing with Playwright

Stephan Rauh — Sun, 19 Jun 2022 00:00:00 +0200

The hours of Protractor are numbered: The Angular team has announced to stop development by the end of the year. So I started looking for alternatives and found Playwright.

How to Convert a Callback to Async/Await

Stephan Rauh — Thu, 16 Jun 2022 00:00:00 +0200

Async/await simplifies your JavaScript code tremendously. But what if you're stuck with an old API using callbacks? You can easily convert it to modern JavaScript with a few lines of code. This option comes in particularly handy with PrimeNG dialogs. Their callback API is annoying because a modal dialog is just that: it's a blocking dialog. You want to wait until the user reacts, and in the meantime, you can't do anything useful. So there's no point in putting up with callbacks, observables, and subscriptions you have to cancel later. This is the code we'd like to use:

Mapstruct, DTOs, and Java Records

Stephan Rauh — Thu, 16 Jun 2022 00:00:00 +0200

MapStruct takes the sting out of mapping entities to DTOs, and Java records make for elegant DTOs. Add Lombok to the equation, and you end up with almost pure data classes and very little boilerplate code. Don't take my word for it. I can prove it. Have a look at GitHub repository to see how simple a Spring Boot application can be.

Complexity

Stephan Rauh — Thu, 09 Jun 2022 00:00:00 +0200

Two opposite trends dominate the Java world. Frameworks and infrastructure become simpler over time, but the average application becomes more clumsy and convoluted. When I enter a new project, I need more and more time to get to speed. It's not just my age or the demanding business use cases. My impression is the source code is more complex than it needs to be. When I talk to Java developers, I often learn they don't even notice. They put up with a frustrating development experience, and they don't even know it. To me, writing 400 lines of codes spread over five classes to fulfill the guidelines of the team architect is infuriating if I knew I could get away with 50 lines if only I were allowed to use a more streamlined design. To my astonishment, most developers accept the guidelines without asking.

Finally, Angular 14 Has Typed Reactive Forms!

Stephan Rauh — Tue, 07 Jun 2022 00:00:00 +0200

Angular 14 ships with typed reactive forms, and it's just great. Type inference, backward compatibility, fine-tuning options, and user-defined type definitions - it's all there. It's been a long wait, but it was worth it!

Implementing a month picker with Angular Material

Stephan Rauh — Sat, 23 Apr 2022 00:00:00 +0200

What's so Cool About AWS CDK?

Stephan Rauh — Mon, 21 Mar 2022 00:00:00 +0100

AWS can be overwhelming. Such a vast ecosystem, so many options, and so many configuration dialogs. But at least there is a UI giving you a search function and some guidance. It's just that nobody wants to use the UI in the age of DevOps, and it's out of fashion for a good reason. Modern programmers embrace the infrastructure as a code pattern, using nice and clean source code written in a contemporary programming language like Cloudformation or Terraform. Wait, what? These are configuration files, not code! Enter AWS CDK. It's a proper implementation of the IaC pattern.

Checking npm Licenses

Stephan Rauh — Wed, 02 Mar 2022 00:00:00 +0100

Every once in a while, your boss asks you to check the licenses of your project. I've good good news for you: it's easy. Most popular open-source projects care about licensing, so you're probably already safe by looking at the licenses of the libraries you're using. But that's nothing you can rely on. Better check the transitive licenses yourself. That's a matter of minutes - at least if you've got an npm project:

Invest in Internet Security. Now!

Stephan Rauh — Wed, 02 Mar 2022 00:00:00 +0100

We've seen way too many attacks to IT systems over the last years. That's a flourishing industry run by criminals. That, in itself, is already worrying. It is a major threat to our lives. Literally. Granted, most hacker attacks are less dramatic, but there are many ruthless hacker attacks endangering lives. It's no fun when hospitals have to be closed for weeks or months, leaving their patients to suffer, potentially some of them even dying. That's exactly what happening all the time. In 2021, we've counted at least 43 successful hacker attacks on hospitals - and that's only German hospitals. I didn't even mention other countries, and I didn't mention power plants, water supply, and many other important branches of the industry. It's a shame we haven't managed to solve IT security problems in 2022. I believe we had the opportunity to solve the problem twenty or thirty years ago. We were naïve. We missed the opportunity that would've been cheap at the time. Now we have to pay dearly for our short-sightedness. According to dataprot.net, ransomware generates roughly one billion dollars revenue in 2022. Not everybody pays: the global cost is estimated to be $20 billion, according to the same source. More likely than not, you don't work on a critical project, but even so, being the victim of a hacker attack is a permanent threat. To my dismay, many desperate companies pay money to the attacker. That's as stupid as can be, because that's fuelling the threat. Until February 24, 2022, the common theory was that's the work of criminals. Hackers want to get rich without caring about other people. Now we know it's even worse. Parallel to the Russian invasion on Ukraine, hacker attacks have reached an unprecedented level. There's a full-blown cyber war raging out there.

Simulating Touch Gestures

Stephan Rauh — Thu, 30 Dec 2021 00:00:00 +0100

Everybody and their grandma agree on 'Mobile First!', but we still develop on a laptop or desktop PC. Frequently, it's cumbersome to attach a mobile and debug remotely, and most of the time, it's not even necessary. Modern browsers allow you to emulate a wide variety of mobile devices. However, touch gestures seem to be ill-supported. I've found many helpful pages like https://www.frontify.com/de/blog/how-to-emulate-touch-events-in-chrome/, but most of them describe a version of Chrome I'm not using. So I've looked for a way to emulate tough gestures with a few lines of JavaScript. I've found the HammerJS Touch Emulator decided to improve it.

What's the window scope in a Service Worker?

Stephan Rauh — Sat, 11 Dec 2021 00:00:00 +0100

How do you know if your code is running in a Service Worker thread or not? Can you use the global namespace for Service Workers the way you're using the global window namespace in UI threads? Is there a unified global namespace?

Reactive Forms, Validation, and Formulas

Stephan Rauh — Tue, 30 Nov 2021 00:00:00 +0100

Let's collect some best practices for implementing reactive forms in Angular applications. Today I'll focus on chains of dependencies. If a FormControl controls another FormControl, which, in turn, controls a third FormControl, things quickly become messy. That's a pretty common scenario. So let's look at how to do it wrong and do it better. I'm pretty convinced talking about bad implementations is instructive, so that's what I'm going to do. I'll walk you through the ugly solutions. At the end of the article, we'll end up with a clean and neat solution that's inspired by Redux but without all the boiler-plate code.

How to Patch a Broken Npm Library

Stephan Rauh — Sun, 28 Nov 2021 00:00:00 +0100

You're stuck with an abandoned npm library? Most of the time, you can fix the problem yourself, at least for a while. I'll show you how to do that: My fork of ng2-smart-table uses the tool patch-package to keep the library alive with Angular 13. BTW, if you're in a hurry, scroll right down to the walk-through.

constructor.name

Stephan Rauh — Sun, 31 Oct 2021 00:00:00 +0200

Never use .constructor.name in production code unless you like working long hours! I know from experience because that's what we did the other day. But wait - are you already familiar with the constructor.name idiom? It's tremendously useful. I'm using it almost every day for debugging.

Angular Change Detection & Zone.js Deep Dive

Stephan Rauh — Sun, 31 Oct 2021 00:00:00 +0200

Angular developers love change detection. You never have to care about it. It just works. Only sometimes it doesn't. When it fails, StackOverflow has many weird answers (among many good ones), so I often observe programmers following one cargo cult or another. I hate to admit it, but that includes even me, despite being a long-term Angular teacher. When I researched the article, I found out I got at least two concepts wrong. Have you ever seen the famous ExpressionChangedAfterItHasBeenCheckedError? Have you ever triggered change detection manually? And what does ChangeDetectionStrategy.OnPush do, precisely? To my surprise, these questions are mysteries to many good Angular developers. Let's shed some light on it.

My Favorite VSCode Plugins for Angular

Stephan Rauh — Sun, 31 Oct 2021 00:00:00 +0200

Many people ask me which Angular plugins I'm using. So here's my list. Most of these plugins are part of John Papa's Angular Essentials, the Angular Productivity Pack, and the TypeScript Extension Pack. You only need to install these plugins individually if you've behind a restrictive Firewall which doesn't allow you to install plugins from Visual Studio Code.

Testing an Angular Service that manipulates the DOM

Stephan Rauh — Sat, 25 Sep 2021 00:00:00 +0200

Sometimes one of your Angular services manipulates the DOM tree. That's an exotic use case, but PrimeNG puts that idea to good use. Remains the question of how to test such a service automatedly.

How to Test an Angular Service with Jest

Stephan Rauh — Sat, 25 Sep 2021 00:00:00 +0200

Most Angular services store data, implement a few calculations or validations and deal with the backend. For example, many Angular services are a queer variation of the backend-for-frontend pattern. They condense the data sent from the backend to match the requirements of the frontend. In an ideal world, you convince your backend team to implement this conversion in the backend - that's the classical backend-for-frontend pattern. But if that's not an option for you, you'll want to protect this conversion by tests. None of the tasks I've mentioned above require much of Angular. They'll probably use dependency injection and use the httpClient provided by Angular. As a consequence, I recommend not to use the Angular TestBed. Test your code as a simple class. That's faster, and it's one layer of abstraction less.

Mocking an Angular Service with Jest

Stephan Rauh — Sat, 25 Sep 2021 00:00:00 +0200

There are two ways to test an Angular service. Either you test it as a regular class. Or you use the entire machinery of Angular. If you do the latter, ng-mocks is your friend.

Null vs. undefined

Stephan Rauh — Sun, 19 Sep 2021 00:00:00 +0200

Dealing with null and undefined is always fun in JavaScript. It really is, once you've got the knack of it. Until then, it's a nightmare. Understanding the difference between null and undefined seems to be the initiation rite of the JavaScript tribe. So be it. Let me be your priest guiding you through your initiation!

Mocks and Spies with Jest and Angular

Stephan Rauh — Sat, 11 Sep 2021 00:00:00 +0200

Jest is fast, powerful, popular, and it uses a different approach to Mocks and Spies than Jasmine. Let's have a look at how to do it. Spoiler: you'll want to use ng-mocks. It's a significant productivity boost, no matter if you're using Jest or if you stick to Jasmine and Karma. But let's have a look at the basics first.

A Good Angular Architecture is Simple!

Stephan Rauh — Thu, 09 Sep 2021 00:00:00 +0200

The best architecture for an Angular app is not having an architecture. No, I'm not preaching chaos. There's nothing wrong with clean folder structure, loose coupling, and all the other architectural trivia we all know and love. But beyond that? Keep it simple. Let's put it bluntly: when you feel you need to implement an architecture, you're probably already deep on your road to hell.

Configuring Jest for Visual Studio Code

Stephan Rauh — Sat, 07 Aug 2021 00:00:00 +0200

The Jest plugin for VS Code is a bit shy. By default, it hides most of its helpful features. Here's how to unlock its power.

Testing Angular with Jest

Stephan Rauh — Sat, 07 Aug 2021 00:00:00 +0200

We've just converted an Angular project to Jest, and we love it. It takes half an hour to get everything up and running. You're rewarded with faster tests and the power of one of the leading test frameworks. Plus, you get rid of the browser. You don't have to install Chrome on your CI server. Even on your local developer PC, that's a big plus. Jest uses jsdom to simulate a browser. So you get rid of the unreliable attempt to remote-control a real browser. Bye, bye, flaky tests!

What's so Cool About Reactive Programming?

Stephan Rauh — Thu, 05 Aug 2021 00:00:00 +0200

Reactive programming is a lot harder than traditional, linear programming. Each time my Angular training progresses to the RxJS chapter, I'm looking into blank faces. What's all this fuzz about RxJS? It's confusing if you're coming from an older community, such as the Java world. Why bothering with callback methods, asynchronous code execution, and unfamiliar RxJS operators? Most learners get it after a while, but even so, they usually have a hard time until they speak RxJS fluently. Adding insult to injury, good old single-threaded Java programming also starts to embrace the reactive pattern. Quarkus propagates reactive programming, and even legacy stuff like Spring tries to embrace reactive programming. So what's the advantage of such a difficult programming pattern?

Simplifying Angular with Async/Await

Stephan Rauh — Sat, 17 Jul 2021 00:00:00 +0200

Asynchronous programming is hard. Evolution gifted us with a marvelous brain capable of doing many things, but asynchronous and concurrent processes weren't top on the list. We can do it, but only to a certain degree. You should do everything to keep it simple. The async-await pattern is a marvelous tool to reduce complexity. But what does Angular do? Several years ago, Angular replaced the Promises of AngularJS 1.x with Observables. Since then, Promises are frowned upon. async/await has been invented later, but from an Angular programmers point of view, async/await never became a thing. That's a pity, because it simplifies your REST calls tremendously. By the way, during my research, I learned that Netanal Basal had the same idea five years ago. Maybe I'm not entirely wrong. Another hint is that Aurelia - the framework that tries to be the better fork of Angular - doesn't use Observables for simple HTTP requests, either. Aurelia still uses Promises.

Development Build and Angular 12

Stephan Rauh — Sun, 04 Jul 2021 00:00:00 +0200

Angular 12 uses the production build by default. That doesn't mean the development build is gone - but if you don't update your project correctly, you'll end up without development build. Here's how to fix your project again.

How npm Deals with Transitive Dependencies

Stephan Rauh — Thu, 29 Apr 2021 00:00:00 +0200

npm has a clever approach to dealing with transitive dependencies. Cutting a long story short: it does the exact opposite of what Maven does. npm trades a waste of memory for a lot of headaches. I've seen worse trade-offs! I've written a small application to demonstrate the features. It uses three different versions of the same library simultaneously. At first glance, that's scary because it means you never get rid of security issues that have been fixed ages ago. But fear not - that's one of the reasons why the package.lock file has been invented. npm audit fix solves most of those old security issues. Let's have a closer look at the topic.

Curriculum Vitae

Stephan Rauh — Thu, 29 Apr 2021 00:00:00 +0200

(no details available)

Simulating docker --net="host" on Windows and WSL

Stephan Rauh — Sat, 13 Mar 2021 00:00:00 +0100

We're living in crazy times. Nowadays, it's possible to run Linux applications on Windows. But when you add Docker to the equation, many people run into trouble with the local networks. Either they can access the server running in Docker, or the Docker container can't access a server running on Windows or WSL2. The latter proved to be a challenging problem. In a standard Linux installation, you can solve the problem by adding the parameter --net="host", but that doesn't seem to work on Windows.

Selecting a Java Version on MacOS, Linux, and Windows

Stephan Rauh — Sun, 07 Mar 2021 00:00:00 +0100

Once upon a time, you could use Java without installing it. Nowadays, most operating systems make a developer's life difficult by trying to help. That's not a big deal if you need only one version of Java. However, if you need to switch between different versions, it doesn't suffice to set the environment variables PATH and JAVA_HOME. Here's what you need to do.

Multilingual Programming with GraalVM

Stephan Rauh — Sun, 07 Mar 2021 00:00:00 +0100

GraalVM allows you to run Java, JavaScript, Ruby, and a broad range of other programming languages. They all run in the same virtual machine. So let's do the next logical step. Let's write a polyglot, multilingual application.

Optimization Strategies of the GraalVM

Stephan Rauh — Mon, 07 Dec 2020 00:00:00 +0100

GraalVM promises to be the Swiss army knife among the JVM. It runs a wide range of languages and allows you to use them side-by-side in the same application. But at its heart, GraalVM is still a virtual machine for Java. It's a plug-in replacement for the JVM. Remains the question why you should do that. Which advantages does GraalVM have over the OpenJDK? If we're using GraalVM to run our good old Java application, it can't be any killer feature. So the most convincing feature of GraalVM is speed. Today we examine how fast GraalVM really is, and - much more interesting - what fuels the performance of both GraalVM and OpenJDK.

What About GraalVM?

Stephan Rauh — Sun, 11 Oct 2020 00:00:00 +0200

So there's this shiny new Java virtual machine called GraalVM I've already blogged about last Spring. In the meantime, Graal's managed to make an impact on the Java universe.The holy grail by Erich Ferdinand, published under a CC BY 2.0 license. Most prominently, there's the flagship project called Twitter. They're using GraalVM for some time now. They're running their Scala microservices on Graal. Graal has also arrived in a more conservative business world. It seems to be particularly attractive to cloud-native applications. Just think about Lambda functions. So it's time to revisit GraalVM. Mind you; it's 2020. Is it time to abandon your good old Java virtual machine and to move to something new?

JavaScript Gems: KaTeX - Beautiful Formulas in the Browser

Stephan Rauh — Fri, 25 Sep 2020 00:00:00 +0200

KaTeX is a JavaScript library to render formulas in Mathematics, Physics, and Chemistry, and probably several related realms. It shows how much technology has evolved since I wrote my diploma thesis. At the time (well, 1996), I wrote the text in the LaTeX language. Before I could see the result, I had to compile it. That took several minutes. Nowadays, KaTeX would probably display render the whole text in a few seconds. Only it wouldn't. KaTeX renders HTML pages, but it doesn't render an entire document. I didn't find support for page numbers or chapters, nor did I find \tableofcontents command in the list of supported functions. It doesn't support commutative diagrams yet. If you need these diagrams, have a look at MathJax and tikzcd.

535 Ways to Reload Your Page In JavaScript

Stephan Rauh — Tue, 22 Sep 2020 00:00:00 +0200

JavaScript never ceases to surprise me. One of these days, I had some trouble changing the theme of my PDF viewer. Usually, the browser updates the CSS rules immediately - but for some reason unknown, it doesn't refresh the ngx-extended-pdf-viewer showcase on the fly when I update the theme. More precisely, it updates it partially, but it always misses some CSS rules. As a quick workaround, I decided to reload the page. Not exactly elegant, but this approach works. It's simple, too. All you have to do is call... well, what? Page.reload()? StackOverflow to the rescue. And what rescue it has! Can you imagine my surprise when it offered not one, but 535 choices? Have a look yourself: 535 options to reload your HTML page.

Dig deeper

535 options to reload your HTML page. the StackOverflow article pointing me to the 535 solutions.

Why Optional does not Solve the NullPointerException Problem

Stephan Rauh — Tue, 21 Jul 2020 00:00:00 +0200

Most Java developers believe that Oracle introduced Optional to protect you from running into NullPointerExceptions. That's wrong on almost all levels. Let's have a look why Optional has been invented, and why so many programmers believe it solves the NPE problem, and why that's wrong. It's just a misconception you can't evade when you're coming from a language like Haskell.

Getting Rid of the NullPointerException - 2020 Edition

Stephan Rauh — Sun, 19 Jul 2020 00:00:00 +0200

Published under an CC-BY-3.0 licence by Oliver Widder.Wouldn't it be nice to get rid of the dreaded NullPointerException? They've called it the "billon dollar mistake" of Java. Regular readers of this blog know this is a recurring topic of mine. And not only mine. Many good developers are fed up with having to guard every second variable access with a NPE guard. The good news is you can do something about it. There's an overwhelming range of choices. Let's summarize them and give you a decision matrix when choosing which.

Performance Impact of Functional Programming in Java

Stephan Rauh — Sun, 28 Jun 2020 00:00:00 +0200

Contemporary Java shows a couple of unique traits and mannerisms. When Lambda functions became part of Java after many years of heated discussion, the Java community used it to do surprising stuff. I can't evade the impression that programmers felt obliged to embrace it full-heartedly once functional programming came into reach. And they do. Chaining functions is strangely attractive to many programmers. Sometimes I agree, sometimes I don't. I'm always a bit puzzled when people replace an if statement with a combination of Optional.of(), filter(), and orElseGet(). The rationale is that nested if statements have a tendency to get messy, while chains of functional operators look a lot cleaner. This example shows the idea - and it also shows that the idea doesn't always work:

Projects

Stephan Rauh — Mon, 15 Jun 2020 00:00:00 +0200

(no details available)

Guest Posts

Stephan Rauh — Mon, 15 Jun 2020 00:00:00 +0200

(no details available)

Polyglot Programming with GraalVM

Stephan Rauh — Thu, 21 May 2020 00:00:00 +0200

There are at least three exciting things about GraalVM: the AOT compiler (aka "substrate VM", recently baptized "native image"), the all-new JIT compiler, and a new approach to polyglot programming. Polyglot programming opens new opportunities, so we're positive to see many new uses of polyglot programming in the future, although we believe it will always remain a bit exotic. Even so, Graal's approach to polyglot programming is fascinating from the perspective of a language designer.

Supersonic Subatomic Java

Stephan Rauh — Tue, 14 Apr 2020 00:00:00 +0200

Such a bold mission statement. Supersonic subatomic Java. And I'm tempted to fall for the marketing. Everything I've seen and heard about Quarkus sounds just great. So it's time to question the marketing and to examine Quarkus thoroughly. Official Quarkus logoThat's what I'm going to do during the next couple of weeks. This article is an early assessment, so maybe it's sort of a living document. I'm going to edit it every once in a while when I learn more about Quarkus. What is Quarkus, and what makes it stand out among other frameworks?

Getting GraalVM up and Running on a Mac

Stephan Rauh — Mon, 13 Apr 2020 00:00:00 +0200

I hope this article is superfluous by the time you're reading it. But at the time of writing, installing GraalVM on a Mac isn't that easy. I've been googling for the solution at least three times, so I've decided to document the solution here. Basically, installing GraalVM is a walk in the park. Download the GraalVM package bearing "Darwin" in its name. Unpack it and copy the folder to /Library/Java/JavaVirtualMachines/. Now GraalVM is almost ready for use. Almost.

Elvis Operator (aka Safe Navigation) in JavaScript and TypeScript

Stephan Rauh — Sat, 11 Apr 2020 00:00:00 +0200

Update April 11, 2020: The Elvis operator has finally landed with TypeScript 3.7. You find it as optional chaining in the TypeScript 3.7 documentation. I'll keep the original article online, but be aware it's slightly outdated. Consider it a document of history. Here we go: One of the first feature requests of TypeScript was the Elvis operator. More precisely, the null-safe navigation operator. That's a variant of the "dot" operator allowing you to access attributes and methods even if the object preceding the dot is null or undefined. In most languages implementing the Elvis operator, the expression null?.firstName simply returns null, relieving the developers of guarding the attribute accesses with countless if statements. Languages like JavaScript are even worse than the average programming languages. Not only can an attribute be null, it can also be undefined, which is sort of even more astral than null itself. Obviously, the Elvis operator is very useful. It's been an important part of the success story of languages like Groovy and Kotlin. It's even a part of the Angular HTML template language. But it hasn't been added to the TypeScript language, and for a good reason.

GraalVM Hands-On Experience. Is it Ready Yet?

Stephan Rauh — Mon, 06 Apr 2020 00:00:00 +0200

Let's have a look at some boring stuff. Or maybe it's not boring at all, because it's about you. The last parts of this series covered many awesome things you can do. But can you do it? In other words: is GraalVM ready for production?

Dynamic CSS with Interpolation in Angular

Stephan Rauh — Sun, 05 Apr 2020 00:00:00 +0200

Wouldn't it be nice to use TypeScript variables in CSS files, the same way you can do it in the HTML templates? For some reason, Angular doesn't allow interpolation in CSS, but it's easy to implement this feature yourself.

Tree Rewriting - or How Your Compiler Optimizes Your Source Code When You're Looking Away

Stephan Rauh — Mon, 30 Mar 2020 00:00:00 +0200

Most of the research around GraalVM is about optimizing performance. Even better, much of revolves around how to make optimizing performance a walk in the park. Our previous article covered several of the optimization strategies of GraalVM. Now let's have a look at how to implement such an optimizer. Many articles mention the role of the abstract syntax tree, or AST in short. Almost everything the optimizer has to do with this tree. Truth to tell, using an AST is pretty much what every optimizing compiler does. It's not limited to GraalVM. It's also what Oracle's HotSpot compiler does, or Google's V8 engine, or your average C compiler. Abstract syntax trees are a recurring topic in compiler technology. So let's have a look at the tree and what to do with it. You'll learn something about GraalVM, and you'll learn something about optimizing compilers in general. We've also decided to add some background information, so you'll even pick up some insight about human languages along the way.

Angular PDF viewers - 2020 edition

Stephan Rauh — Mon, 16 Mar 2020 00:00:00 +0100

My PDF viewer crossed the ten thousand downloads per week mark! What started as a little pet project has become tremendously popular. So let's talk about it. I've also done a little research, and my PDF viewer isn't the only one. I've found several alternatives. I will present these alternatives, too, and I will give you a few hints on when to use which.

GraalVM Dictionary: Bytecode, Interpreters, C1 Compiler, C2 Compiler, CPUs, and More

Stephan Rauh — Mon, 10 Feb 2020 00:00:00 +0100

Let's talk about what a compiler does. More specifically, what a Java compiler does. Or any compiler, for what it's worth. Most languages use similar concepts so that this article won't be lost on C# developers or JavaScript aficionados. Google's V8 compiler works more or less the same way as the Java compiler does (at least from a high-level perspective). It only omits the bytecode phase. C#, in turn, uses an "IR" code resembling Java bytecode. That's one of the reasons why so many different languages peacefully co-exist and even co-operate in the .NET universe. All these languages compile to the same IR code, so there's a common basis. That's pretty much the same with Kotlin and Java: both compile to Java bytecode, so there's a common basis allowing you to write an application using both languages side-by-side.

A Hurried Programmer's CSS Survival Guide

Stephan Rauh — Sun, 05 Jan 2020 00:00:00 +0100

CSS is fun. Nonetheless, many seasoned programmers approach me, asking me to help them with their CSS problem. This article is for you. It's not an in-depth tutorial. There are plenty of tutorials telling you every advanced feature of CSS. Try as I might, I couldn't do that. I'm not that familiar with CSS. But that's all right. I've watched many good developers struggle with CSS (including myself). You don't need an advanced tutorial. You need a compass and a map. Once you've got that, you know how to get along. So I decided a collection of strategies helping you to find your way in the dark. You're still with me? Great. Let's start. If you're reading this article on your desktop or laptop PC, please open the developer tools. Depending on which browser you're using, the simplest way to do that is hitting the F12 key on Windows or ALT + CMD + I on macOS.

Truffle - GraalVM's Compiler-Compiler

Stephan Rauh — Fri, 27 Dec 2019 00:00:00 +0100

They say Truffle is GraalVM's interpreter framework. What an understatement! True, Truffle allows you to write an interpreter without the pain. But what's really cool about Truffle is your interpreter runs at full speed. Truffle uses some clever magic to generate highly optimized machine code. It's compiler-compiler. Let's have a look at this remarkable feat.

Speeding Up your Website with Brotli

Stephan Rauh — Mon, 26 Aug 2019 00:00:00 +0200

A friend of mine claims a successful website must load in 400 milliseconds. What an ambitious claim! BeyondJava.net is not even close. In North America, it loads within two seconds. Truth to tell, the situation isn't that bad. My blog loads in less than a second in Europe. Most readers already have some of the files in their browser cache, so BeyondJava.net is even faster. My own browser even reports half a second when I activate caching. Not too bad for an Angular application. But still, I'm always looking for ways to speed up things. One of the many secrets to unleashing performance is compression. Today, let's talk about Brotli and gzip. In particular, let's talk about activating Brotli on a cheap Apache httpd server.

ngx-extended-pdf-viewer 1.0

Stephan Rauh — Sun, 25 Aug 2019 00:00:00 +0200

Recently, I've published the first 1.0 version of my Angular PDF viewer widget.

Update April 13, 2020

A lot has happened since writing this article. Check out the 2020 edition of this article.

I'm still overwhelmed by the community support. 50.000 downloads in 2019 alone. And it's only August. Not to mention the 106 closed issues. I've even received eight pull requests. Awesome!

Showcase

You're in a hurry? Then I'll point you to my showcase. https://pdfviewer.net has code snippets, live demos, and all the information to get you started.

Maven, Spring, and Angular

Stephan Rauh — Sun, 19 May 2019 00:00:00 +0200

Let's talk about non-standard Angular project layouts. Not every Angular project has the priviledge to live in its own domain. Many - or most? - Angular projects are tenants in a shared building. If I've picked it up correctly on the recent JAX conference, there's a new standard architecture. Everybody and their grandma are using Angular as the front-end and Spring Boot as the backend. I'm sure there are many other architectures out there, but the bottom line is still valid: Angular is only as good as its back-end, and more often than not, both coexist in the same deployment unit. Originally, Martin Fowler's definition of the word "microservice" optionally included the client. For some reason, this idea has gone out of fashion. However, it has resurrected as a "self-contained system", aka SCS, and it's an important part of my approach to micro-frontends. But that's another day's story. Today, let's cover one simple point: How can Angular and - say - Spring Boot peacefully coexist in the same building? More generally speaking, how to integrate Angular in a Maven project?

Fine-tuning the assets folder of Angular

Stephan Rauh — Sun, 19 May 2019 00:00:00 +0200

Angular 6+ allows you to copy arbitrary files during the build process. Well, within certain limits, of course. The target folder must be somewhere in the output directory (i.e. dist/ by default). You configure that in the angular.json. Browse for the assets section under architect/build/options. Unless you haven't modified the default, this is what you'll see:

Spring Data 2019

Stephan Rauh — Fri, 19 Apr 2019 00:00:00 +0200

Over the ages, Spring's approach to database programming has changed a lot. If you're still using the merry old template approach, this article is for you. Templates are old technology, revolutionary when I had my first love affair with Spring in 2003. Java 5 made them superfluous by introducing annotations. Later, Java 8 made using templates fun by adding Lambdas. Too bad everybody and their grandma already had abandoned templates in favor of annotations. Sometimes technology evolves like a river, meandering oxbows included. Hint: if you're an experienced Spring user, just ignore this article. It's an entry-level article, written by a Spring noob for other Spring newbies. It's not even a tutorial. It's just a collection of ideas that work so you can start with the useful tutorials instead of learning outdated technology. That's the downside of the famous backward-compatibility of Spring. Everything that's ever been added to Spring is still there. When new ideas are added to Spring, that doesn't mean old ideas are pruned. After almost 16 years, it looks more like a jungle than like a garden.

Spring Developer Tools and Hot Code Replacement

Stephan Rauh — Sun, 31 Mar 2019 00:00:00 +0100

The other day I mentioned that hot code replacement is broken in most Spring applications I've seen. My co-workers contradicted, claiming hot code replacement works fine. They suggested using the Spring Developer Tools to fix the problem. Well, not quite. But I have to admit the developer tools are interesting. Interesting enough to write a blog post about it. Spoiler: instead of fixing hot code replacement, they break it. That's a pity because hot code replacement works a lot better than I expected.

Using Spring REST with Spring Data

Stephan Rauh — Sun, 31 Mar 2019 00:00:00 +0100

Let's write a REST service providing all the CRUD functionalities of an entity! Yes, I know, that's a lot of work. This blog post is gonna be soporific, second only to your TV. But fear not: We're using Spring Boot, 2019 edition. Spring is doing all the hard work for us.

Spring Boot 2019

Stephan Rauh — Sun, 31 Mar 2019 00:00:00 +0100

In my business life, Spring and Spring Boot are my love-hate-relationship. Simple at first, Spring turned out to be difficult to master when I used it in real-world projects. Adam Bien convinced me to embrace JavaEE, which got ridiculously simple over time. That was a couple of years ago. In other words: it's time to have a look again. Chances are the Spring team wasn't lazy during the last couple of years.

What happened to the Polyfills?

Stephan Rauh — Mon, 18 Mar 2019 00:00:00 +0100

The other day I demonstrated the polyfills file during my Angular course. I'm teaching this course several times a year, so I knew what the polyfills.ts looks like. Only - it looked different. The list of ES6 polyfills wasn't there. What happened? Well, Angular CLI 7.3 happened. The Angular team has found a better approach to polyfills. It saves 56 KB of bandwidth on most browsers. For some reason, this change went by widely unnoticed.

What about MobX?

Stephan Rauh — Thu, 07 Mar 2019 00:00:00 +0100

Are you looking for a state-management framework without the boilerplate code? You'll love MobX!

Pure CSS tooltips

Stephan Rauh — Sun, 03 Mar 2019 00:00:00 +0100

CSS never ceases to surprise me. It has many tricks up its sleeve. Nowadays, you can implement tooltips without JavaScript.

Simplifying JSF: Merge Bean Validation Annotations into JSF Files

Stephan Rauh — Tue, 26 Feb 2019 00:00:00 +0100

Update February 2019, 26

This article describes one of my first attempts to make JSF a developer-friendly space. It's what I did seven years ago. In the meantime, I've first implemented the feature in AngularFaces. Later, I've migrated it to BootsFaces. Since version 1.1.0 of BootsFaces, our JSF components recognize the validation constraints of the beans without further ado. You don't have to do anything, it just works. Exactly as it should be. That's how my journey into JSF in particular and open-source software development in general began.

JSF and the DRY

Simplifying JSF

Stephan Rauh — Tue, 26 Feb 2019 00:00:00 +0100

Update February 2019, 26

This article describes my first attempt to make JSF a developer-friendly space. It's what I did seven years ago. In the meantime, I've implemented the feature in AngularFaces. At the time, I was proud of the feature, and I still am. It's just great, especially for rapid prototyping. For some reason, the idea never took off. Few developers picked off the idea. If you're a JSF programmer, reducing the amount of boiler-plate code isn't your number-one-priority. Most JSF developers I've talked to are just happy to get the job done, no matter how ugly or tedious it is. So I never migrated the feature to BootsFaces. In a way, that's a pity. Doing so would be easy. However, the market (that's you!) decided, and this article is only interesting from a historical point of view. That's how my journey into JSF in particular and open-source software development in general began.

Fighting boiler-plate code!

This is the first part of a multipart series showing you how to make writing JSF page more fun. You'll get better results writing less code. Let's have a look at a simple, yet typical form consisting of a single input field:

We have to write three lines of code to implement one input field. Looking carefully at the code, you see the repetitions:

Displaying PDF Files in Your Angular Application

Stephan Rauh — Sat, 17 Nov 2018 00:00:00 +0100

There are two popular libraries to embed a PDF file in your Angular application. Actually, when you're googling, you'll find three solutions. However, I reckon you're not interested in good old AngularJS 1.x. Plus, there's the option you won't find easily on Google (yet). That's my pet library. It had grown surprisingly popular on npm even before I started any marketing effort, but even so, it has yet to make an impact on the Google search index.

Update April 13, 2020

A lot has happened since writing this article. Check out the 2020 edition of this article.

Let's have a look at these four options. Why are there three

What's New in BootsFaces 1.3.0?

Stephan Rauh — Sun, 30 Sep 2018 00:00:00 +0200

This time, it took us half a year to publish a new release. But that doesn't mean we were lazy in the meantime. We didn't collect enough new features to justify a new version. Only - one day we realized we'd closed no less than 70 tickets since the last release. That's a whole lot of bugs solved! Funny thing is that it took even more time to publish this article. I planned it for June 17, 2018. Now I have to hurry up in order to publish it before we publish BootsFaces 1.4, which should arrive any day soon.

Download coordinates

Before starting the long list of details, let me provide you with the download coordinates:

How to Extract Exif Metadata from an Image

Stephan Rauh — Thu, 27 Sep 2018 00:00:00 +0200

You've had some great time off. Maybe you've been traveling a foreign country. So you've been taking pictures diligently. Of course, you don't have to care much about how to organize these pics. Mind you, it's 2018. Your smartphone cares about it all. It orders your photo collection by date, by location, and there's even a map showing where you've taken all the pictures. At home, you import the entire collection to your PC and upload it to Dropbox. All the extra information gets lost. But fear not: you're a JavaScript programmer. So it's a piece of cake to access all the metadata hidden in the EXIF section. If you're a Java programmer, that's probably a piece of cake, too. But using node.js you can do in with a just a handful of lines of code. Enjoy!

How to Tell the Location from the GPS Coordinates

Stephan Rauh — Thu, 27 Sep 2018 00:00:00 +0200

Modern smartphones tell you where you've taken a photo. Unfortunately, as soon as you copy the image to your PC, the information seems to be lost. Well, it isn't, but it hides in the EXIF metadata of the image. Plus, it's not the name of the city, but the precise GPS coordinate. Luckily, it's surprisingly simple to convert that to a real address.

How to Put a JavaScript Application Asleep

Stephan Rauh — Thu, 27 Sep 2018 00:00:00 +0200

Your computer is never fast enough. However, in rare cases, you need to slow down. In my case, is was OpenStreetMap that forced me to go a slower pace. The free plan only allows one access per second, so I had to make my node.js program pause a second between two accesses. As it turns out, you can't do that in node.js. Luckily, modern node.js allows you to simulate the feature so you hardly notice the difference.

Adding a Seamless Offline Mode to Your Web Application

Stephan Rauh — Tue, 17 Jul 2018 00:00:00 +0200

D3.js for the busy Angular Developer, Stephan Rauh explores how to use the D3.js library with Angular. A typical use case is using D3 to display a chart. At the end of the article, there seemed to be a limitation to his approach. Angular's change detection updates the chart immediately instead of generating smooth transitions without further ado. When developing a pie chart with Angular, I stumbled upon this limitation. After some researching and trying, I found a possible solution. Animations with D3.js and Angular can be realized simpler than you will think.

Computed Properties in Angular

Stephan Rauh — Sun, 15 Jul 2018 00:00:00 +0200

There are no computed properties in Angular. Period. So what happens when you Google for computed properties? Yeah, something unexpected happens. There's a tool called MobX which is well-known as a lightweight alternative to Redux and ngrx/store. As it turns out, it's lightweight enough to use without introducing a central data store. You can use it to implement computed properties without further ado.

What's the Difference Between Map and a Simple Object in JavaScript?

Stephan Rauh — Sat, 30 Jun 2018 00:00:00 +0200

In JavaScript, everything's a map. So why did EcmaScript 6 introduce Map?

ngx-d3-pie-chart

Stephan Rauh — Sun, 17 Jun 2018 00:00:00 +0200

I promised to much. My last post showed how to implement a D3.js chart without having to understand D3.js. But it's not always that easy. Today's example is slightly more difficult. We'll end up with an Angular component that's almost identical to the native D3.js solution. We're going to write an Angular pie chart component. The article is a bit heavy on the source-code side. Probably it's easier to understand if you open the source code in your IDE. I've uploaded the source code to GitHub and the binaries to npm.

D3.js for the Busy Angular Developer

Stephan Rauh — Wed, 13 Jun 2018 00:00:00 +0200

When a problem is hard, you're probably tackling it from the wrong angle. Some time ago I've contributed a pull request to the awesome ngx-charts library which is based on D3.js. So I knew for sure that it's not that difficult to use D3.js with Angular. But still, each time I find a fancy D3.js chart and ask one of my co-workers to add it to our Angular application, I drive them nuts. What's the secret of ngx-charts? How to use D3.js with Angular correctly? I took me some research to find out what we were doing wrong. You'll be surprised how simple it is to do it right.

How to Inline Images into CSS Files with Node.js

Stephan Rauh — Wed, 06 Jun 2018 00:00:00 +0200

This is just a little tool I wrote instead of reading the manual. Inlining images as base64 images is one of the core features of webpack. However, I didn't want to set up a full-blown webpack project for a task I need exactly once. Actually, I tried, but my project is an Angular 6 project. In theory, Angular offers a nice feature: it can eject the webpack configuration of the project. However, in Angular 6.0.0 this feature is temporarily deactivated. I ended up with merely 24 lines (plus comments and blank lines). Node.js is a nice tool for such ad-hoc tasks!

Pretty URLs, .htaccess, SPAs, and SEO

Stephan Rauh — Mon, 04 Jun 2018 00:00:00 +0200

Porting my blog to Angular was a success story. There was just one catch: Google wouldn't see my articles. So I dived deep into the anatomy of .htaccess files, learned that the Google crawler can read Angular pages, and ended up with pre-rendered HTML pages. I also learned how vital "pretty URLs" are. Talking of Angular: the hints of this article apply to every SPA, including React and Vue.js. I'll frequently talk about Angular simply because I used Angular in my project. Plus, some of the source code in the article is Angular code. Similarly, I always talk about "Google." Again, that's a pars pro toto. I'm totally aware there are other search engines as well, and I reckon they are using similar strategies. However, from day one, the vast majority of my readers found my blog in a Google search. So I tend to forget the other search engines.

Adding JSF AJAX to Non-AJAX Widgets

Stephan Rauh — Sat, 02 Jun 2018 00:00:00 +0200

Since JSF 2.2, JSF programs frequently use native JavaScript widgets. Of course, these widgets (and even some JSF widgets) know nothing about the way JSF uses AJAX. But fear not: if you're using BootsFaces, PrimeFaces or OmniFaces, it's easy to add AJAX to these widgets.

Running BootsFaces on Glassfish or Payara

Stephan Rauh — Thu, 31 May 2018 00:00:00 +0200

Glassfish is the official reference implementation of JavaEE. Nonetheless, there's an annoying incompatibility with JSF. Glassfish doesn't recognize the components of BootsFaces at server startup reliably. Sometimes it does, sometimes it doesn't. Payara is affected, too. The bug happens more often on older versions, but we've got a bug report for a current Glassfish 5.0.1. We receive this error report every once in a while on our BootsFaces bug tracker. Luckily, thanks to GitHub user jimmc929, there's a solution.

Refactoring? I write a tool for that!

Stephan Rauh — Tue, 29 May 2018 00:00:00 +0200

Did you ever modify dozens or even hundreds of classes of your program? It doesn't have to be something complicated. Just imagine a minor change of the corporate design. Please make the headers blue. Oh, also remove the rounded borders and the shadows from the input fields. And while you're at it, the buttons should have that fancy ripple effect of Material Design, but only the "OK" buttons. Guess you're awe-stricken? I'm not. I'll write a tool for that.

Bye, Bye, Wordpress - Welcome BeyondJava.net GDPR Edition

Stephan Rauh — Sun, 27 May 2018 00:00:00 +0200

Last Tuesday, I made up my mind to rewrite my blog from scratch. I lost my hope to make my Wordpress blog compatible with the GDPR. So after almost six years, it's time to kiss Wordpress goodbye. It's time to eat my own dog food. It's time to create a blog running on Angular! I started the project Wednesday, so I had only two days. To my surprise, I managed to finish working version of the blog by Thursday midnight, when the GDPR came into effect. Of course, that version hastily cobbled together. In other words, it was a bit buggy, not to mention the horrible design of the GDPR notice. Nonetheless, I'm impressed by the level of productivity Angular gives you.

Crawling one's own blog

Stephan Rauh — Sun, 27 May 2018 00:00:00 +0200

Recently, I've decided to migrate my blog to Angular. One of the first challenges was to find out which URLs my blogs has and to pull the HTML code of these articles from the web. There are more than 350 articles, so it's obvious I had to write a program for it. As it turns out, that's simple with node.js and a few lines of JavaScript.

Angular 6 Brings TypeScript 2.7 Bringing Improved Null-Safety

Stephan Rauh — Sat, 05 May 2018 00:00:00 +0200

The web is full of articles praising the improvements of Angular 6, such as library support (great!) and Angular Elements (even greater!). One small change usually passes by as a mere side-remark. But it's a useful change, too. Angular 6 now officially supports TypeScript 2.7. That, in turn, is a major step forward for our project, because TypeScript 2.7 fills a nasty gap concerning null-safety. You know, I played benevolent dictator, decreeing that null values need to be declared explicitly. In other words, I activated the flag strictNullChecks in the tsconfig.json file. Unfortunately, I wasn't prepared for the reaction. It took me a lot of talking to convince the team to keep the setting. Actually, I coaxed them to wait until Angular 6, which is "about to come out every day". Adding insult to injury, Angular 6 took several weeks more than I expected, but now it's there.

Combining Object-Oriented Programming and Functional Programming

Stephan Rauh — Wed, 02 May 2018 00:00:00 +0200

When someone like Brian Goetz is giving a talk, it's almost always worth listening. His talks at the 2018 JAX in Mainz, Germany, were no exception. There was an idea resonating particularly well with me, so let me paraphrase this part of Brian's talk. Or rather, what I made of it: I didn't take a recording, so adding my own thoughts and misconceptions is inevitable. Brian is the chief architect of the Java language, so it's not surprising his talk focused on Java. But this article is not about Java. It's much more general. In particular, much of it also applies to JavaScript. Actually, it applies to any programming language flexible enough to support both object-oriented and functional programming. But in the case of JavaScript, I (@beyondjava) observe that the flame wars are particularly nasty. A significant part of the community considers object-oriented programming a thing of the past. They've abandoned it in favor of functional programming. You can observe this particularly well in the React.js community.

Unsubscribing From an Observable in Angular

Stephan Rauh — Tue, 01 May 2018 00:00:00 +0200

Since version 2.0, Angular uses RX.js observables a lot. Such an observable is potentially infinite. So in many cases, you need to unsubscribe from the observable manually. If you forget to do so, you end up with a memory leak. Actually, you'll probably get away without unsubscribing for a long time. First, Angular cares about unsubscribing in most cases:

The async pipe unsubscribes automatically for you.
HTTP requests are short-lived observables. They call onComplete or onError after returning the result, so they unsubscribe automatically.
The same applies to every finite observable, such as Observable.timer(1000).subscribe(...);.
You don't have to unsubscribe from @HostListener and ActivatedRoute.

However, even the official documentation of Angular recommends unsubscribing nonetheless, because it's little effort and you never know. For instance, there seems to be a bug preventing ActivatedRoute from unsubscribing automatically under certain circumstances. You might also destroy finite Observables (such as HTTP requests) because you don't want them to be processed if the component has already been destroyed. IMHO that's no memory leak, but it's useless to continue loading data after the user has pressed the "back" button.

How to Add a New Breakpoint in Bootstrap

Stephan Rauh — Fri, 27 Apr 2018 00:00:00 +0200

Bootstrap claims to be a "mobile first" framework. However, judging from the breakpoints, it's a mobile-only layout framework. The largest breakpoint is 1200 pixels wide. Even my 15'' MacBook has much more screen estate: its screen is 1440 pixels wide. Many desktop monitors have a width of 1920 pixels, and 4k monitors are gaining popularity by the day. Obviously, the "lg" breakpoint of Bootstrap 3 is merely a toy in 2018. Bootstrap 4 adds a new breakpoint called "xl", but in reality, it only adds a breakpoint for super-narrow screens. The largest breakpoint is still 1200 pixels wide. Luckily, both Bootstrap 3 and Bootstrap 4 can be customized. Adding a breakpoint to the new version (BS4) is very simple. It's a little more work in Bootstrap 3. It took me a while to collect the information from the web, so it's high time for a compact walk-through.

Console.log Surprises with Internet Explorer 11 and Edge

Stephan Rauh — Wed, 04 Apr 2018 00:00:00 +0200

Like countless other developers, I decided to monkey-patch console.log to implement the logger of our Angular application. You may or may not like this approach, but it worked flawlessly. The first time it broke was when we deployed it to production today. What had happened?

ngx-translate and ngx-translate-extract - Internationalization Made Easy

Stephan Rauh — Wed, 04 Apr 2018 00:00:00 +0200

It's a bit surprising that there so many libraries offering internationalization for Angular applications. It's surprising because there the Angular cookbook describes a well-thought approach to internationalization. Unfortunately, ng-xi18n was broken last time I checked, so let's explore another library today. ngx-translate is a simple but useful library for supporting multiple languages. The companion library ngx-translate-extract makes working with ngx-translate even easier by extracting texts to be translated automatically. Update Nov 18, 2017: Luckily, the official Angular i18n approach has been fixed since I've written the original version of this article. Even better, it's part of the Angular CLI. See the documentation of xi18n for full details. Nonetheless, ngx-translate is still interesting. It's a lightweight alternative. Plus, it translates the application at runtime. In contrast, x18n forces you to provide a pre-compiled application for each language. That's better because it's faster, but it's also a bad thing because you can't switch between languages without starting the application from scratch.

What's the difference between ng-xi18n and ngx-translate?

Talking of ng-xi18n: there's a big difference to ngx-translate. ng-xi18n has been developed with professional translators in mind. In particular, this library uses the well-known XLIFF standard. Developers probably tend to think this standard is clumsy. It's XML, and it's sort of bloated. ngx-translate, in contrast, uses slime Json file to map one language to another. The backside being it supports fewer use-cases than XLIFF.

How to Use a JavaScript DataTable in an Angular Application

Stephan Rauh — Wed, 04 Apr 2018 00:00:00 +0200

There are several data table widgets for Angular, but none of them matched our project's needs. I'm sure that's simply a matter of time. Angular2 is young, and the third-party libraries are even younger. They simply didn't have enough time to accumulate features and maturity. So why don't we use one of the seasoned JavaScript data tables? (Update April 4, 2018: Keep in mind that the original version of this article has been written in Januar 2017). As it turns out, Louis Lin had the same idea creating the Angular DataTables project. It looks promising, but at the time of writing, it was only 26 days old. So the feature list is pretty short. When you're reading this article, things have probably improved. However, today I don't want to tell you how to use a third-party data table. Instead, I'll tell you how to do it yourself. Before we start to wallow in the source code, let's start with what developers usually do: a short market survey. If you're in a hurry, skip that section or jump directly to the source code of the demo on GitHub. Update April 4, 2018: By now, the datatable written by Louis has gained a lot of traction. It's definitely worth a look. Basically, it's a materialization of the ideas of this post: take the DataTables.net project, add a small Angular API and smooth the rough edges caused by integration what was never intended to be integrated.

Graal - Towards the Holy Grail of Polyglot Programming

Stephan Rauh — Tue, 27 Mar 2018 00:00:00 +0200

Anybody ordered a new JVM compiler? Whoever ordered it - now it's there, and it's exciting! But wait: is it a compiler? No, it's not. It's more. Currently, it's half a dozen compilers, plus a framework making it easy to write your own compiler. In a nutshell, this is what the Graal project promises:

It's a compiler generating faster Java code than ever. Or it will be, in a few months. The version bundled with Java 10 is marked experimental, probably for a good reason, such as a performance penalty in some applications.
It's a compiler everybody can understand and modify. People like you and me can contribute improvements.
It brings polyglot programming to a whole new level.
Plus, it's a great opportunity for minor or new languages. It's never been so easy to create a new language with a decent performance from day one.
Finally, it brings AOT compilation to the Java world. That's a big plus in cloud environment like AWS Lambda, taking the scare out of hibernation.

OK, you get it: I'm excited. Let's examine Graal piece by piece. And let's have a look at the current state of the art.

Should You Embrace "var" in Java 10?

Stephan Rauh — Fri, 23 Mar 2018 00:00:00 +0100

Java 10 is there! And the most controversial feature of it is the var keyword. Should you embrace it or not? If you're a regular reader of BeyondJava.net, you probably know that I already propagated the var keywords years ago. But I'm spending enough business hours each day with Java to know how Java programmers feel. So I recommend reading and heeding the Guidelines for using the var keywords in Java 10 by Stuart W. Marks.

What About Monkey Patching? Is it as Dangerous as They Say?

Stephan Rauh — Fri, 09 Mar 2018 00:00:00 +0100

Monkey patching is modifying a third-party class. It's a great tool, coming in handy all the time. Only it's frowned upon by the experienced programmers. Should you adopt or abandon monkey patching? Let's have a look at some useful applications of monkey patching first.

Java UIs: State of JavaServer Faces (JSF) in 2017

Stephan Rauh — Tue, 06 Mar 2018 00:00:00 +0100

How to update a popular article that made it to rank 2 on the Google search results? My survey article about Java UIs is three years old, so it clearly needs an update. Instead of rewriting I decided to write a series of short articles each covering a single UI framework. I'll concentrate on the JavaScript and Java world. On my list are MVC 1.0 (aka Ozark), Angular2, D3.js (even it's not a general-purpose framework), JavaFX and many others. Maybe I'll also add an excursion to the Microsoft world. For instance, UWP / Xamarin is an interesting UI framework I'd like to cover.

Angular Components with Non-Standard Selectors

Stephan Rauh — Tue, 27 Feb 2018 00:00:00 +0100

When I teach Angular, I keep telling my students that Angular components are custom HTML elements, while Angular directives are custom attributes. Every tutorial I know teaches the same. Nonetheless, Angular is much more flexible. In reality, the selector of both components and directives can be any CSS selector. For instance, you are allowed to define a component like so:

What Does the Keyword "new" do in JavaScript?

Stephan Rauh — Sat, 24 Feb 2018 00:00:00 +0100

As an Angular teacher, I often say that JavaScript objects are functions. Most of the time, I get away with this bold claim. It's not entirely wrong. But it leaves many things in the dark. For one, my short-hand explanation makes it hard to understand why Json objects are objects, too. By the way, a few hours after publishing this article I remembered that every function is a first-class object in JavaScript. The only property distinguishing it from other objects is that a function can be called. However, this article investigates the other direction. Can every object be defined by a function? Are functions better compared to classes? Or are they something else?

Bang, Bang, You're a Boolean!

Stephan Rauh — Tue, 20 Feb 2018 00:00:00 +0100

Did you ever wonder why there are such strange operators like !!, === and !== in JavaScript? Developers coming from other languages, such as Java, often have a hard time to accept they have to write a triple equals character instead of a double one. Actually, the first language I learned was Basic, followed by Pascal, so I still consider the double == weird. But that's just one of the peculiarities you have to accept if you're learning a language following the C tradition. But of course, all these things have a reason. Hitting SHIFT+0 thrice, hundreds of times a day clearly gets on my nerves. It feels like stuttering. But the reason it had to be introduced was the attempt to save a few keystrokes.

How to Show the Assembly Code Generated by the JVM

Stephan Rauh — Sun, 18 Feb 2018 00:00:00 +0100

Common wisdom says that Java runs on bytecode. Most developers also know there's something like a JIT compiler, but few developers are aware that the JIT compiler generates real machine code. Let alone that we can see it.

Guiding NPM Through a Firewall

Stephan Rauh — Wed, 07 Feb 2018 00:00:00 +0100

npm doesn't like to be fenced in by a corporate firewall. Too bad most npm installations live precisely there. The other day, I ran an npm install on the customer's PC. The same command that finishes in 40 seconds on my machine took roughly a quarter of an hour. Plus several hours of troubleshooting. It was a Deja-Vue experience to me, having lived this nightmare several times before, so it's high time to collect a short list of hints. BTW, if you want to contribute to this list of life-savers, please do so. Just leave a comment, thus giving me an opportunity to include it to the list.

Basic proxy settings

These two settings almost always do the trick:

What About the Performance of Java 8 Lambdas?

Stephan Rauh — Mon, 05 Feb 2018 00:00:00 +0100

Isn't it funny that I start writing a series of articles about Java 8 Lambdas in 2018? Mind you: my first article dates back to April 2012, six years ago. I fell in love with functional programming even earlier. I suppose it was roughly in 2008, ten years ago. From this perspective, functional programming is nothing new to me. I'm using it on a daily basis when I'm writing TypeScript code. As things go, I work in a very conservative environment, so I know a lot of projects that have adopted Java 8 last year. And I'm bewildered what programmers make of it - and why. It's high time for a reality check. Java's Lambdas and method handles are great, no doubt about that. Streams are great, too. Sometimes. More often than you might think, they are not.

Material Design for Bootstrap

Stephan Rauh — Mon, 05 Feb 2018 00:00:00 +0100

After a long search, I've finally found two good libraries bringing the design language of Material Design to Bootstrap. Actually, I've seen similar attempts before. Just think of the Paper theme bundled with BootsFaces. It's not bad, but I wasn't too excited when I saw it. I didn't run a comprehensive test yet, but at first glance, the libraries I present today match my idea of Material Design better. Please take that with a grain of salt: beauty lies in the eye of the beholder, so that's just my personal opinion.

UI Survey 2017: Java vs. JavaScript

Stephan Rauh — Fri, 02 Feb 2018 00:00:00 +0100

Recently, I've seen a number of surveys covering the popularity of Java and Java UI frameworks. Most surveys show that either Spring or Java EE is more popular. However, they don't answer two important questions: is Java becoming more or less important? Currently, I'm mostly interested in UI frameworks, so the next logical question is: what is the market share of Java UI frameworks compared to JavaScript UI frameworks? To my disappointment, I didn't find a clear answer by researching the internet or by asking the question on Twitter. So I've started to gather information myself. That wasn't easy, so most of the article is based on indirect hints and educated guesses.

Using Grunt in Mixed Java and JavaScript Maven Projects

Stephan Rauh — Fri, 02 Feb 2018 00:00:00 +0100

In recent years, JavaScript is becoming more and more popular - even in Java programs. It's hard to evade the temptation to pimp up your Java program with a bit of JavaScript here and there. Or a jQuery plugin. Before long, you've got a lot of JavaScript code. Now, you've got Maven to manage your Java builds. What about the JavaScript part of your application?

Why should I use Grunt?

Grunt is one of the most popular JavaScript build tools. It's really powerful. Even the plain vanilla tasks are interesting enough: combine and minify both JavaScript and CSS files. But Grunt doesn't stop there. It can also minify images, or compile LESS and SASS files to CSS. Another interesting option is to run JSHint, a tool detecting potential errors in your JavaScript code (following the Lint tradition). By the way, I expect this article to grow over time as I gather experience with Grunt. Feel free to leave comments to foster this growth :).

Which Is the Hottest UI Framework in the Java World: JSF or JavaFX?

Stephan Rauh — Fri, 02 Feb 2018 00:00:00 +0100

One of my web site's visitors inspired me to write an article about which of the Java GUI frameworks I recommend. They specifically wanted to compare JSF and JavaFX. So I'll begin with these two frameworks before I talk about other frameworks as well. Please feel free to leave a comment if you'd like to add something. The article covers a lot of frameworks, and I can't know every framework equally well.

Update Aug 05, 2017:

Since writing the article, Java UI framework have become remarkably unpopular. Nowadays the majority of front-end developers quarrels whether Angular, React or another JavaScript framework is the tool of choice. This blog covers these frameworks frequently, so I keep the original post online. Personally, I think it's a weird idea to drop the Java frameworks. I'm teaching Angular, so I'm biased towards the JavaScript world. Even so, I believe there are good reasons to continue using the Java based frameworks. Like always, it depends on your application. There's no "one size fits all". At least not if you care about a good user experience.

JSF

Java Server Faces is the GUI framework offered by JEE. So if you choose JSF, you can't do anything wrong: it's part of the JEE standard. You don't have to worry that other JEE features like CDI or JSR303 Bean Validation aren't supported

Managing global libraries

Stephan Rauh — Fri, 02 Feb 2018 00:00:00 +0100

These days we had some difficulties updating the libraries we used. We had to update them pretty often, sometimes twice a week. So I was looking for a neat way to update the libraries on my colleagues' computers without blocking their work.

Short Introduction to Vue.js

Stephan Rauh — Tue, 30 Jan 2018 00:00:00 +0100

They announced Vue.js to me saying "It's like Angular, only they did it right this time". I don't think there's anything wrong with Angular, so my curiosity was piqued, and the stakes were high. What does Vue.js better than Angular? So I spend two afternoons playing around with Vue.js.

First impressions

Before starting to dig into the source code, let me share my first impressions with you. Vue.js is fast, it's simple, and it's easy to find info on the internet. I also felt that the error messages could be better, but then, that's a typical beginner's problem. In the early days, the error messages of Angular weren't helpful at all. Vue.js is younger than Angular, so I guess they've done a good job here, too. There were two pleasant surprises I didn't expect. First, there's a small but useful ecosystem. There's tool support, there's a small CLI to get started, and there's even a browser plugin to help you debugging. Second, there's decent TypeScript support. At first glance, the source code seems to benefit a lot from the syntactical sugar of TypeScript. I always thought Vue.js was meant to be the successor of AngularJS, founded and supported by developers who didn't accept the design choice of Angular 2. And one of the key choices was to embrace TypeScript. So TypeScript support comes as a surprise.

Scope of Vue.js

Before anybody starts a useless flame-war again, let's have a look at the scope of Vue.js. It covers a rather limited scope. It supports the "V" of MVC. Everything else is up to you. Most people opt for third-party libraries. Some of these libraries (Vuex, the router, the CLI, and - until recently - vue-resources) are maintained by the Vue.js team, so the scope of Vue.js is slightly larger than the scope of React.js, but even so, these libraries are optional.

Using Java 8 Lambdas Efficiently

Stephan Rauh — Sat, 27 Jan 2018 00:00:00 +0100

Functional programming is en vogue. There are many good reasons to adopt functional programming. Recently, I watch more and more Java programmers using the new programming style. As things go, they experiment and play with their new toy, pushing it to the limits. This article briefly shows why Lambdas are useful, what Java programmers make of it, and concludes with a few recommendations to do it right.

Escape Analysis in Java

Stephan Rauh — Fri, 19 Jan 2018 00:00:00 +0100

Spectre and Meltdown came as a shock. They showed that low-level CPU optimizations have an impact on our lives. Plus, they proved an illusion of most programmers wrong. Yes, you're using a high-level language. But that doesn't mean all those abstraction layers shield you completely from the CPU. I've demonstrated the effect of the CPU cache on a Java program some time ago. Spectre and Meltdown took this to another level. If my sources are right (I still can hardly believe it!), it's possible to observe the effect of speculative execution in JavaScript. Speculative execution is a very low-level CPU optimization. JavaScript is a very high-level language - it doesn't even use bytecode, and the design of JavaScript makes compiling it a challenge. But that's another day's story. The link between my click-bait introduction and the topic of the day is the RAM of your PC. CPUs have evolved much faster than main memory. Nowadays, CPUs spend most of their time waiting. A modern CPU can perform several instructions per CPU cycle. But if it has to access main memory, bypassing each of the three caches, it has to wait for roughly a hundred cycles. See this article on Extremetech.com for more details.

Migrating to Bootstrap 4

Stephan Rauh — Tue, 09 Jan 2018 00:00:00 +0100

The first application I migrated to Bootstrap 4 recently worked out of the box. Add the new CSS and JavaScript, find a replacement for the Glyphicons and you're done. Awesome! Only... well, it took me a couple of days to realize that my application was broken. There's a great migration guide for Bootstrap 4, and for a good reason. It's a good idea to read it. By the way, if you're already familiar with the migration guide from an alpha version of Bootstrap 4, read it again. The Bootstrap team has made a couple of last-minute changes.

What's New in BootsFaces 1.2.0?

Stephan Rauh — Tue, 02 Jan 2018 00:00:00 +0100

We start the new year with a new version of BootsFaces! BootsFaces 1.2.0 brings a few new features, a lot of bugfixes, and an improved navigation on the documentation page.

Value Types: Revamping Java's Type System

Stephan Rauh — Mon, 25 Dec 2017 00:00:00 +0100

Value types

This morning Brian Goetz revealed interesting news at the end of his talk at the JAX conference. Oracle is considering to extend Java's type system. Did you ever wonder why there are no call by value parameters in Java methods? Why there's no Array in Java? Why functions return one - and only one - value at a time? Why there are no tuples in Java? Why arrays are created in such a weird way, making them effectively scattered all around the memory? Brian Goetz told us they might fix all this after adding value types to the language, which allows for an efficient implementation of these ideas. Truth to tell, he didn't really promise value types. In particular, he says Java 9 will almost certainly not include the feature. However, judging from the quality and level of detail of his "State of the Values" paper I'm positive they are going to make it into a future version of Java. I'd also like to point out value types are a revolution in that they require new JVM byte codes. Remember how rarely new JVM byte codes are added. Obviously byte codes are considered a valuable resource. If value types are worth new byte codes, chances are they're worth it.

Why are Angular Components more Successful than JSF Components?

Stephan Rauh — Sat, 18 Nov 2017 00:00:00 +0100

At first glance, there are many similarities between Angular and JSF. Both offer a decent abstraction layer from the DOM, both offer two-way binding (yes, I know it's optional since Angular2), and both use components as building blocks of the application. Even better, both frameworks offer a way to create your own custom components. The difference is that hardly anybody creates custom components in JSF. Angular programmers do it all the time. Things get even more mysterious when you learn that JSF has been designed with creating components in mind. It should be easy. But the vast majority of developers doesn't think so.

Angular: Components first

Angular takes components to a whole new level. When AngularJS 1.0 was released seven years ago (on Oct 20, 2010), that was a revolution. Developers used components all the time, no matter which framework they used. Everybody knew it's a good idea to download or buy a powerful third-party framework. The idea was that powerful components like datatables or charts should be developed by experts. AngularJS and its predecessors changed all that. They made the process of creating components much more democratic. They enabled everybody to create their own component. React and Angular 2+ go one step further down that road. They force every developer to write their own components. The entire program is built on custom components. There's no way to avoid custom components.

Customizing Bootstrap 4 with Angular

Stephan Rauh — Thu, 16 Nov 2017 00:00:00 +0100

Gone are the days of customizing Bootstrap with the sweat of your brow. At least if you're using a current version of Angular and Bootstrap 4. Mind you: Bootstrap 4 is built with SASS. Angular supports SASS as a first-class citizen. So it's hardly surprising that it's a child's game to customize Bootstrap with an Angular application.

Four easy steps

Basically, you have to follow these four steps:

Add Bootstrap to your package.json. The easiest way to do this is running the command npm i bootstrap@next. A short note on the "@next" bit: At the time of writing, Bootstrap 4 is still beta. Chances are you're reading this article a lot later, so maybe the final version of Bootstrap 4 has already been released. If so, install Bootstrap via npm install bootstrap (omitting the "@next" bit).
Tell the Angular CLI to use SCSS by default. To do so, rename the styles.css to styles.scss and set the default extension in the .angular-cli.json to SCSS. There's even an Angular CLI command for that: ng set defaults.styleExt scss.
Create an empty file customize-bootstrap.scss the in src folder, next to the styles.scss file. Later you'll add your customizations in this file.
Add these two lines to the styles.scss file:

Angular Animations API

Stephan Rauh — Wed, 15 Nov 2017 00:00:00 +0100

The Angular Animations API adds a shallow abstraction layer to the animations offered by CSS. It's a bit like so many other Angular libraries: it adds enough syntactic sugar to make it useful, but it adds little value to the underlying technology. At least, that was my first impression. During my research for this article, I've learned that such a shallow abstraction layer make a lot of sense. For instance, the same API could be used with AngularNative. As far as I know (correct me if I'm wrong!), that's not the case today, but who knows what the future has in store for us.

Example animation

'nuff said. Let's get our feet wet with real source code. Have you ever seen at the back-side of your application? This demo doesn't work with Internet Explorer because I wanted to keep the source code of the demo simple, so please use another browser to see the animation:

Code Reviews Done Right

Stephan Rauh — Mon, 06 Nov 2017 00:00:00 +0100

Recently, I've been working with a project team embracing code reviews. The experience wasn't pleasant. Most of the time, it was downright annoying. The general idea of code reviews is that one of your team members dedicates several hours of their precious time to look at your code and help you to improve it. That's a generous offer. Plus, hardly anybody rejects an opportunity to learn and improve their coding style. I, for one, definitely don't. So how come the code reviews were such a pain in the ass?

Lazy Loading in a Angular Carousel

Stephan Rauh — Sun, 05 Nov 2017 00:00:00 +0100

Today's tech tip is almost too primitive to mention. However, on second glance, it shows how to use Angular efficiently. I reckon there's a general pattern there, even if I haven't been able to distill it yet to make it a textbook lesson.

Setting the stage

Consider a carousel, such as the first demo at our BootsFaces showcase. It displays three images. At every point in time, only one of the three images is shown, unless you click to show the next image. In that case, the next image starts to slide into view, replacing the old image. Things get ugly if we've got hundreds of images. They also get ugly if the carousel is used to implement a wizard. Chances are that the content of the second page of the wizard depends on the input provided on the first page of the wizard. In other words, the second page can't be rendered at load time. As you can imagine, our use case was a combination of these two options.

Is React.js Just a Library?

Stephan Rauh — Thu, 02 Nov 2017 00:00:00 +0100

The other day, I was asked to compare frameworks like Angular and React.js. It was an interview, so I didn't notice the tiny slip. Developers reading the interview didn't hesitate to point out that React is a library, not a framework. A few months earlier other developers reminded me you can't compare Angular with React because the former is a framework, while the latter is not. The reactions of the community where so emotional that I gather many people consider it an important difference. That, in turn, means it's fun to play devil's advocate. It's the kind of games generating new insights.

Java Classpath Tales – or: The Mystery of the Empty Beans.xml

Stephan Rauh — Sat, 28 Oct 2017 00:00:00 +0200

Image source: PixabayThe age of a programming language shows in the clever tricks programmers use. One such trick is used by CDI. Did you ever wonder why you have to put an empty beans.xml into the META-INF directory? By the way, you may not even aware that the beans.xml is allowed to be empty. Many developers aren't. You can use the beans.xml to configure a couple of things, leading developers to believe they have to do that. Plus, the IDEs tend to complain about an empty XML file because they consider it ill-formed. As far as I know, Netbeans generates a non-empty beans.xml by default. But still, even if you haven't seen it yet, it's allowed to put an empty beans.xml into the META-INF folder of your jar (or the WEB-INF folder of your *.war file). Empty meaning really empty: it's a file of zero bytes length. What good is such a weird file? We'll answer this question in a minute. Plus, this article shows you how to read arbitrary files hidden in a jar file, or - more generally speaking - somewhere in the classpath. By the way, this is one of the few situations when the Junit test succeeds but the real application fails. That is interesting enough in itself.

BeyondJava @Conference: Angular vs. React - When to Choose Which?

Stephan Rauh — Sat, 28 Oct 2017 00:00:00 +0200

A couple of days ago, Marius Hofmeister and I held a talk about "Angular vs. React" at the International JavaScript conference iJS at Munich. Which one is better, Angular or React? Truth to tell, we can't answer the question. Actually, it's the wrong question, anyway. The real question is "Which one is better for my project?"

It depends!

Because that's what we found out during our investigation: During the last couple of years, Angular and React have learned a lot from each other. Each team is watching the progress of the other team. Good ideas tend to be adopted by the other team after a while, provided they match the general philosophy of the framework. So we came to believe you can do anything with either framework. We've collected a couple of technical criteria helping you choose the right tool for the job. But you should base your decision on technical considerations alone.

Comments in JSF Files

Stephan Rauh — Wed, 27 Sep 2017 00:00:00 +0200

Earlier this day, a developer opened a bug ticket for BootsFaces. , they said, is buggy. Adding a comment between the columns corrupts the layout, they said. Actually, that's true, but I wouldn't call it a bug of BootsFaces. It's a peculiarity of JSF. We could solve it in BootsFaces. At least, most of the time. I'm sure there are corner cases we'll always miss unless we start to parse the code as thoroughly as a compiler. That's possible, but it doesn't match the general idea of JSF. Even worse, we can only solve the bug for BootsFaces components. It still exists for standard JSF, PrimeFaces, ButterFaces, and every other JSF framework you combine with BootsFaces. So I prefer to explain the bug instead of solving it.

Modbus in a Nutshell (Plus a Short Introduction to IoT and PLC Programming)

Stephan Rauh — Sat, 23 Sep 2017 00:00:00 +0200

Have you ever had the opportunity to work on a factory automation project? Currently, I've got the opportunity to program software controlling real hardware in an assembly line. My program influences real machines in the real world. Most of the software I'm writing remains in cyberspace, so I consider "getting real" pretty exciting. One of the key requirements of our project is that we have to use the Modbus protocol. That's an old protocol dating back to the 80s. Even so, I wasn't happy with the documentation. One might expect such an old, battle-tested protocol to be thoroughly documented. Well, it is, in a sense. The only problem being that most of it has been written for experts. So I decided to write a cursory introduction for the hurried Java developer. After reading it, you should be able to understand the expert documentation. Along the way, you'll learn something about the IoT world the media keep raving about. If you're only interested in Modbus, just scroll to the PLC section.

A Java Programmer's Guide to Byte Code

Stephan Rauh — Thu, 21 Sep 2017 00:00:00 +0200

It's funny how this article came into being. I only wanted to write about such a simple thing as how CPU caches influence Java programs. But then, I couldn't help but notice the topic isn't quite as simple. Simple to me, who has written a lot of assembler code (granted: decades ago). But many Java developers - actually, most Java programmers I know - don't know much about things like CPUs, registers, let alone caches and out-of-order execution, which play a crucial role in my article. So I decided to write an article explaining assembler programming to Java programmers. But the most simple approach to Java programmers is the HotSpot compiler, which in turn deals a lot with Java bytecode. That became article number three, the article you're reading. So I ended up with three articles. You're lucky: three article for the price of one! Four articles, actually. I started to investigate how to write bytecode and wrote an article about it. Another interesting topic is what the JVM does to optimize your code on the fly, and how you can watch it. But this article has yet to be written. Today I'd like to start the series with a short and cursory instruction to Java bytecode. I'll tell you what bytecode is, how to see it in your editor and how to read it. But it's not a textbook: I'll try to bring you to speed fast, which means the article is exhausting, not exhaustive. You can read the textbooks later. This article is about getting the gist of it.

Mocking HTTP Services With Angular Generically

Stephan Rauh — Mon, 18 Sep 2017 00:00:00 +0200

Angular has been designed with testing and mocking in mind. This includes mocking HTTP services in general, and mocking REST services in particular. The Angular team even provides a fairly generic mock HTTP service. That service is a horn of plenty of good ideas. The only problem is the limited scope of the solution. It's meant to serve the needs of the documentation of Angular. The team even promises that the service may break at any point in time. In other words: it pays to implement your own generic mock HTTP service. That's what we'll do today.

Static Code Analysis: SonarQube, Facebook's Infer, and TypeScript

Stephan Rauh — Sat, 16 Sep 2017 00:00:00 +0200

Infer is a static code analysis tool promising finding many bugs that escape the attention of many other tools. My curiosity was piqued. The result was underwhelming: Infer found four possible NullPointerExceptions in the source code of BootsFaces. Later I ran SonarQube. It found many other potential NullPointerExceptions. Any in both cases, half of the findings where false positives. Since version 2.0, TypeScript has a built-in NPE finder. It works very well. Of course, it sometimes finds false positives, too. But if you activate the compiler switch --strictNullChecks from day one, that's not a big problem because you notice the problem while you're writing the code. You can tell the compiler to ignore the non-bug in a couple of seconds.

Running CDI on a Simple Tomcat

Stephan Rauh — Sat, 16 Sep 2017 00:00:00 +0200

I'm big into CDI, but I'm not fond of application servers at all. So I'm bound to find out how to configure how to activate the CDI magic on a simple servlet container like Tomcat. That shouldn't be too difficult. Mind you, it's easy to run Weld (which happens to be the reference implementation of CDI) without a servlet container. However, in the past getting Weld on Tomcat proved to be a tad difficult, due to mediocre documentation. Luckily, that has changed. Jo Desmet (at least I suppose he's the man behind the Musings in Java blog) has published a nice walk-through to get CDI and JSF on Tomcat 8 up and running. I followed his step-by-step tutorial and managed to activate CDI on my Tomcat 8 in a couple of minutes. Highly recommended! However, no tutorial is so good it can't be improved, so let me add one or two notes on it:

For some reason, declaring JTA and JSF as provided API and runtime implementation didn't work for me. In theory, it should work, but I ended up adding both as compile time dependencies.
Jo didn't say precisely where to put the context.xml and the beans.xml. I chose to put put into the src/main/webapp folder. To be pedantic, the context.xml went into the src/main/webapp/META-INF folder, and the beans.xml file went into the src/main/webapp/WEB-INF folder. (From what I remember from earlier experiments, both file should also work when put into the classpath - but I didn't take the time to check this, too).

Cutting a long story short, you don't need a full-blown application server just to use CDI!

Dig deeper

Zakee-Web: a project template supporting CDI, JSF and JAX-RS on a Tomcat comparing Angular 2 and React. But we all know how fast the JavaScript world progresses. Cory's article still contains a lot of insights, but it's time for an update. Plus, I'd like to add my point of view.

Compiler as a Service: Why TypeScript 2.5 Biggest Feature is a Refactoring

Stephan Rauh — Sat, 02 Sep 2017 00:00:00 +0200

TypeScript 2.5 is there! That's the headline of the tweet sending me to the TypeScript 2.5 announcment. To my surprise, the article described a new refactoring of Visual Studio Code. Did they choose the wrong title? Is this article really about TypeScript, or is it about an IDE? As it turns out, refactoring is baked into the programming language. In former times, refactoring used to be what IDEs do. Nowadays, refactoring is a compiler feature. At least in the case of .NET languages and TypeScript.

What's New in BootsFaces 1.1.3?

Stephan Rauh — Mon, 28 Aug 2017 00:00:00 +0200

Two weeks ago, Neil Griffin, the head of the LiferayFaces project, approached us. He asked us to do a few minor changes so the next version of Liferay and LiferayFaces can be shipped with a BootsFaces demo. That, in itself, is quite a surprise. Liferay has finally migrated to Bootstrap 3. Obviously, BootsFaces wasn't compatible with previous versions of Liferay. Funny thing is that at the same time the BootsFaces team discusses when it's time to move on to Bootstrap 4. It seems the Bootstrap 3 version is going to be maintained a bit longer than expected. So we published BootsFaces 1.1.3 quickly to align it with the Liferay release, which is expected by the end of this month (i.e. August 2017).

BootsFaces Resource Loading Deep Dive

Stephan Rauh — Sun, 27 Aug 2017 00:00:00 +0200

Many BootsFaces developers want to add third-party code to BootsFaces. Usually, that's a Bootstrap component, a jQueryUI plugin or another combination of JavaScript and CSS. Almost always, these plugins fail to work if they are loaded in the wrong order. So BootsFaces added a fine-grained mechanism allowing you to control the load order. To my dismay, the resource ordering still causes a lot of trouble, so it's high time to describe it in detail.

Newsflash: Investing in a Good Corporate Culture Boosts Your Team's Productivity

Stephan Rauh — Sun, 27 Aug 2017 00:00:00 +0200

Basically, this article is simply a pointer to another article I've just read. In a way, we all know what happens if we discourage other people in a critical moment, but I can't help but observe how often we ignore it. Every once in a while, I even meet team making bullying a hobby. John Looney describes the effect of such a behavior in his article. Highly recommended!

Software Testing Techniques in a Nutshell (Part 2: Machines Take Over)

Stephan Rauh — Sat, 26 Aug 2017 00:00:00 +0200

The previous article of this series explained how humans run software tests. Or rather, being an "in a nutshell" article, it gave a very brief overview. Now let's continue the article with the testing techniques involving test automation.

Software Testing Techniques in a Nutshell (Part 1: The Human Factor)

Stephan Rauh — Sat, 26 Aug 2017 00:00:00 +0200

The previous article in this series explained why it takes so many techniques to ensure software quality. This article explains a couple of these techniques.

Test methods in a nutshell

When I started investigating for this article, I stumbled upon a post resonating many of my thoughts on testing. In the meantime, the post has been deleted. It has been replaced by a Youtube video that's slightly different (probably better). Be that as it may, the original post of Itamar Turner-Trauring inspired me to draw this picture, covering most of the popular test approaches and summarizing the post. Let's start with the quadrant you probably don't associate with testing. The green quadrant focuses on the user and on our customer.

Software Testing Beyond Unit Testing - the Bigger Picture

Stephan Rauh — Mon, 14 Aug 2017 00:00:00 +0200

Each time I write about unit testing, people get angry. So let me explain why I rant about unit tests every once in a while. First of all, there's nothing wrong with unit testing. That's not the point. Usually, I start ranting when I notice people believe in unit tests religiously. Many good developers seem to believe that unit testing is the only test tool they ever need. Both agile programming and continuous delivery make us believe such a nonsense. There's so much more to testing than just unit tests. This post gives you a short overview about different test techniques. It's not an in-depth explanation of these approaches to testing. Instead, it focuses on telling you why they are important. You'll see there are many important tests that can't be automated at all. You'll always need human beings to test your software.

Comparing TypeScript to Java

Stephan Rauh — Sun, 13 Aug 2017 00:00:00 +0200

To my surprise, I saw that many people visit my website after searching for "TypeScript vs. Java". The question makes sense, so let's answer it. What's the difference between the two languages? When to chose which? Do they compete at all?

Why should we compare TypeScript to Java?

At first glance, the answer is simple. TypeScript "lives" in the browser. Java lives everywhere else. So they don't compete at all. End of the article. However, TypeScript is an attractive language for people with a Java background. To them, the question is slightly different. Is TypeScript an easy language to learn? Plus, there's Node.js. Using JavaScript on the server has become surprisingly popular. TypeScript compiles to JavaScript, so it has become a direct competitor to Java.

Converting a Java class to Groovy

Stephan Rauh — Fri, 11 Aug 2017 00:00:00 +0200

Today I tried to convert a couple of Java classes to Groovy. Groovy is just Java on steroids, I thought, so this should be pretty simple. Just change the file name extension and be happy. Alas! Red squiggly lines all over my project. As it turns out, there are subtle differences between the languages.

VertxUI: Java as a Front-End Language

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

Yesterday I had a job interview for a senior Java back-end job. They asked me whether I was a full-stack developer or not. Although my answer was a proud yes, I stated that I don't really like JavaScript, but I can find my way through HTML/CSS and JavaScript code. Then I had to explain why I don't like JavaScript.Guest author's biography Niels Gorisse (39) is a senior full-stack Java developer with a lot of back-end experience. Also see cv.bonneville.nl. I said I don't like it because of many reasons. JavaScript doesn't - or actually: didn't - work the same on all browsers, there is a global scope with all variables in it, and besides that, there are thousands of libraries fixing missing language and API features. Even worse, it seems none of them can be considered to be 'default.' So, there is no chance of knowing whether you've picked the lasting libraries. I guess I did not get the job.

Hey, We've Got a New Team Member!

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

I guess you all know the situation. One day or another, you realize that you've got more work than you can manage. So your boss adds a new team member to your team. It goes without saying that you embrace them full-heartedly and teach them their new job with all the respect and empathy they deserve. In virtually no time, they are just as productive as everyone else, and they become a valuable part of your team. Or not. It's the "or not" part this article is about. As to my experience, many people are badly prepared for onboarding new team member. Software developers are no exception. Quite the contrary: many software developers are more interested in tech than in people, which doesn't help to embrace new team members.

BootsFaces 1.1.0 RC1

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

The next version of BootsFaces was scheduled to be published during the Easter holidays. However, we decided to spend a few extra weeks to improve the quality of the documentation of the framework. When testing the showcase, we observed that it is a bit confusing because many examples use old API fallen out of grace during the last couple of updates. The advantage for you is that you can test the release candidate and report bugs you've found. We believe that the release candidate is stable enough to publish it as the final version. Nonetheless, the delay is an opportunity to fix bugs that may have slipped our tests.

Angular Takes the Sting out of Writing Components

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

It's astonishing how simple writing web components is with Angular. In a way, this shouldn't be a surprise: components are the building blocks of every Angular application. However, last week we wrote a component I already knew to be difficult to implement in merely an hour or two. That was really a surprise. Our choice was a multiple-choice select box. There are plenty finished components out there. However, Angular 2+ is still young, so there are few (if any) native Angular multiple-choice boxes we can use. Integrating a component based on other technologies like jQuery is possible, but usually, it takes some time and it's always a compromise. So I reluctantly agreed when my coworker suggested to quickly write our own component. "It's simple", he said. "It ain't much work". It's true. It wasn't.

What's New in BootsFaces 1.0?

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

BootsFaces 1.0 has been released. Actually, we've already published the first bugfix release, BootsFaces 1.0.1. I was a bit shy to proudly announce the 1.0.0 version because we had so many obstacles to overcome. Apart from the usual obstacles like exhausting projects at work (and they were exhausting this time!), there were also the earthquakes in Italy, which kept at least one of our team members busy, although they didn't suffer any physical harm. Be that as it may, BootsFaces 1.0 (and 1.0.1 in particular) is a great step to maturity. It's the first version we officially call "production-ready". Truth to tell, we were always convinced you can safely use BootsFaces in production. But most versions we've published in the past focused on features. This time we tried to focus on stability instead of new features when we prepared the 1.0 version. I counted 26 bugfixes that were important enough to open a bug ticket. Plus, almost twenty minor enhancements and three new components. However, we also added one or two major improvements, such as adding support for both horizontal and inline forms.

Angular2 Component Libraries

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

A good third-party component library can give your application development team a boost. This article collects a list of popular UI component libraries for Angular2. It goes without saying that this list can never be complete, so it's probably going to change and expand over time. If you know of a useful Angular2 widget library, don't hesitate to leave a comment so I can complete the list. By the way, this list is just that: a list. I'm adding a short introduction to each library, but it's not the same as a review. I'll postpone that to follow-up articles. If you like or dislike on of the library, I'd like to hear from you, especially if you also add a short explanation.

HTML5: Optional HTML Tags

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

The other day Marco Rinck tweeted something that's very confusing, almost disturbing. Google's HTML style guide suggests to omit optional HTML tags. Taking in mind that the page rank of your website is influenced (among other things) by whether your page has a clear layout and a good coding quality, following these guidelines is almost mandatory. Granted, I didn't check whether this particular style guide is linked to the results shown in the webmaster tools, but you get the idea: if Google publishes a style guide on HTML and CSS, it's going to have an impact on the market. So let's have a close look at it.

Blisk - a Browser to Make Web Programming Easier

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

Mobile first! Seriously? Do you really optimize your application for mobile usage? Actually, you can't. The current state-of-the-art makes it difficult to adopt the "mobile first!" approach seriously. Mind you: that would require you to program your application on the phone instead of using your desktop browser. Until today, I've seen such an approach only with iOS programming and with UWP/Xamarin. The application is developed on the desktop, but run and tested on the cell phone or the tablet. The other day a friend of mine, Dario D´Urzo, showed me another option for web developers. What started as a small JavaScript plugin two years ago has evolved to a full-blown browser in 2016. More precisely, it's a browser based on Chromium which adds a number of tools dedicated to web designers and web programmers.

Newsflash: Sometimes Using Float is Faster Than Using Int in Java

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

Performance considerations in the eighties

Time and again, I'm surprised by the performance of modern CPUs. Actually, the speed boost astonishing me most took place a decade ago, give or take a few years. Before that, floating point operations were a lot slower than integer operations. When I learned my first assembly language, the 6502 processor was state of the art. This processor was so simple that you had to write a program to implement the integer multiplication. Multiplying floating point numbers was an even longer program. I've forgotten the actual numbers, but as a rule of thumb, multiplying integers was ten times slower than adding two integers. Multiplying floating point numbers was another magnitude slower.

HTML Includes

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

Almost every programming language offers you an option to use the content of another file in the file at hand. Basically, it's a very old idea. Sooner or later programs become large and larger, so developers started to split the files into smaller building blocks. First, they invented subroutines, later procedures, and functions. Later they invented higher-level building blocks like modules, classes, and packages. One of the early ideas was to include the content of another file. To a certain extent, that's always been possible in HTML. You can include CSS files by writing . Similarly, you can add JavaScript code stored in an external file by writing . Funny thing is there's no way to include the content of an HTML file into another HTML file.

BootsFaces 0.8.6 has been Released

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

This weekend, we've published a new version of BootsFaces. Basically, BootsFaces 0.8.6 is not a big deal. It fixes half a dozen bugs. The most annoying bug that has been fixed was compatibility with Internet Explorer.

Adding Type Inference to Java: Good or Evil?

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

My previous post raved about the simplicity type inference is going to bring to Java. I love the idea. Java is such a verbose, ceremonious language. Little wonder so many developers prefer dynamically typed languages, which seem to be so much simpler to use until you write a huge enterprise application. Java's proposed type inference is strongly and statically typed, so it's going to make life simpler without introducing problems. JEP 286 is good news, indeed!

Java May Adopt (Really Useful) Type Inference at Last

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

I'm all for simplicity - and that's why I'm complaining so much about Java and many Java libraries. Java is such a ceremonious language, and it attracts so many people who love ceremonies and design their libraries to be used in a very elaborate way. More often than not, this results in a lot of boring key strokes. That's a pain to write, but it's also painful to read. As you may or may not know, I love complaining, but I also love to do something about the pain points. Just thinks of BootsFaces and AngularFaces, my attempts to simplify JSF programming. However, there's one domain I have very little influence: core Java. And that's a pity because that's a domain that influences everybody. Every Java programmer, that is. Can you imagine my joy when I read there's an official proposal to introduce type inference to the Java language? Even better, the author is Brian Goetz, and the proposal calls type inference a "non-controversial feature". Better still, there's also a survey allowing you to influence the development.

What's New in BootsFaces 0.8.1?

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

The open source branch of BootsFaces is still young. Only 14 months went by since the first release on Halloween 2014. But it's already an impressive success story. In November, we've seen more than 1.000 downloads from Maven Central and Bintray. Ed Burns mentioned BootsFaces in one of his talks at JavaOne. JSFCentral and Jaxenter.de have asked us to write articles about BootsFaces. Obviously, BootsFaces has stirred a lot of attention, and many projects use it for their daily work. Since the Halloween 2014 release, we've published five releases. That's roughly a release every three months. The latest release took quite bit longer to finish. But it's loaded with a host of new features, so it has surely been worth the wait. Personally, I call it the AJAX release, because that's my big ticket. But there's more in store four you. Other big tickets are the advanced search expressions inspired by PrimeFaces and the theme support. Plus, BootsFaces 0.8.1 has six new components. Seven, if you count the experimental . But that not a finished component yet. However, I felt it already is useful enough to include it with BootsFaces, even if it still requires polishing and "sugaring". But let's talk about first things first.

Does Super-Fast Storage Impact Programming?

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

Now, that's a disruptive change. Actually, it developed in the open, but still, I didn't really think about it until today. We all have learned to love SSDs. My old company PCs used to boot for a couple of minutes, sometimes even for a quarter of an hour, before I could start my daily work. If you've got an SSD, that's typically done in a minute, and if you've got a Mac, it's a matter of seconds. The extreme being tablets and smartphones: Most of the time they run in standby, so they are just there when you need them. Let's think this to the end. Imagine that storing or retrieving data on your hard disk doesn't take any perceptible time. Imagine that external storage of mass data isn't your system performance's bottleneck. What does this mean to programmers? What does it mean to hardware designers?

An Alternative API to JSF AJAX

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

As BootsFaces gains traction, people start to ask for AJAX capabilities. We've implemented some rudimentary AJAX support, but obviously, that's not enough. Developers need the full power of JSF 2.2 AJAX. Funny thing is they demand it precisely the way JSF 2.0 defines it. It was a really clever approach when it was introduced. But I think in 2015 we can do better. I was always puzzled by the slightly counter-intuitive approach of JSF AJAX. Why do we have to use a facet to activate AJAX? Why do we need so many ids? And what does the attribute name execute mean, for that matter? For execute doesn't execute anything. Instead, it defines which data to send.

Cucumber Meets Selenium - How to Make Testing Web Applications Fun

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

Do you know anybody who loves to test their code? I don't. Granted, there are those guys raving about the test first approach, but I always wonder which drugs they take. Maybe I've found the answer. Maybe it's a simple Cucumber. No, I'm not talking about the green stuff some of you grow in your garden. (Don't even try to smoke it!) I'm talking about a framework that makes testing a lot more fun. I use it together with another interesting test framework, Selenium, which in turn builds on WebDriver, which is a remote control for your browser. You end up with a series of commands in plain - if slightly stilted - English that test your web application in a real browser. How do you like this test case?

Does Your Programming Language Influence Code Quality?

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

These days Twitter had a couple of interesting tweets about programming languages. Which one is the best one? According to the tweets the question has been settled: (click the image to see the original tweet)

How to Invoke JSR 303 Bean Validation Programmatically

Stephan Rauh — Sat, 05 Aug 2017 00:00:00 +0200

These days I've found a nice tutorial on bean validation, that shows - among other things - how to invoke Hibernate Validator manually. This may be useful if you want to use JSR 303 validation but are reluctant to use the full blown J2EE server (just think of writing a JUnit test). I'll provide you with the link at the end of the article.

A close look at Java's JIT: Don't Waste Your Time on Local Optimizations

Stephan Rauh — Fri, 04 Aug 2017 00:00:00 +0200

At this year's JAX I attended a talk Charles Nutter held. He explained some of the optimizations Java's just in time compiler (aka JIT) does. After hearing the talk, I began to experiment with the JIT myself, doing some benchmarks and playing with the VM's parameters.

Getting Started with Angular 2: Your First Application

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

Since I started my Angular 2.0 series, Angular 2 has evolved considerably. Version numbers went up from 2.0.0-alpha.36 to 2.0.0-alpha.45. Plus, they've added quite a lot of content to the documentation pages. So I wasn't surprised it took me two evenings to update my AngularJS 2.0 chess demo to the actual version. However, this turned out not to be Angular's fault: the library responsible to deal with Angular's module system, System.js, introduced one or two breaking changes. The good news being: the API of Angular 2 is pretty stable, stable enough to continue with a couple of hands-on articles. Update Oct 06, 2016: As it turns out, the API of Angular2 wasn't quite as stable as I expected it to be when writing this article. I'm going to update the article soon. In particular, the @View decorator isn't used anymore, because it was more or less identical to @Component. Plus, the bootstrap code has changed considerably. I suggest you download the Angular-CLI and use it to create skeletons of your applications and your modules. If you prefer Ionic, you can also use the ionic-cli. I'll describe this in more detail soon. Stay tuned! Today, I'd like to make you familiar with the basic concepts of Angular 2. Let's write your first application together. Or rather - well, writing a simple demo application is something virtually every tutorial does. Let's tackle Angular 2 from a different Angle. I've uploaded a slightly simplified version of my Angular 2 chess program on GitHub. So you can start with a real-world application. I won't explain every feature of the chess program - that'd be an entire book, not a blog entry. This article simply gives you a head start to grasp the look and feel of an Angular 2 application, and to play with it. Curious? Clone the repository at https://github.com/stephanrauh/ExploringAngular.git and open the subfolder /Blog01. That's a full-blown, running Angular 2

Why Sometimes Unit Tests do More Harm than Good?

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

I always wondered how to write truly efficient and useful unit tests. So I'm glad my co-worker Thomas Papendieck offered to write a guest article, sharing his expertise with you. Thomas, it's your stage!

Unit tests are cool!

Unit tests secure already existing behavior in the code base and support the programmer while doing changes by detecting damages. Almost every programmer knows this statement.

...but are they really?

On the other hand, almost every programmer made the opposite experience: Unit tests come in the way of the programmer when she wants to introduce changes to the production code. After the change, a whole bunch of unit tests broke and it takes a big effort to make them pass or even compile again. I remember projects where fixing tests took up to ten times longer that the actual change. Why does that happen? Is it that unit tests are only hyped by ivory-tower screwballs propagating academic ideals? Those lucky dreamers never being responsible for a real life application? The staggering answer is: No.

Model-View-Whatever

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

These days it's kind of official: AngularJS implements the Model-View-Whatever paradigm. That's a nice solution to a series of fruitless discussions about whether AngularJS implements MVVM, MVC or something else. However, one of these days I stumbled upon a couple of slides claiming AngularJS implements the MVC pattern during my research for another article. I knew from various tutorials that this isn't exactly true. My curiosity was piqued. What exactly is the difference between MVC, MVVM and MVP? Are there other useful design patterns? And while we're at it: do JSF and AngularJS implement one of these design patterns?

Model-View-Whatever :)

Actually, I already knew there are different design patterns you can use successfully. When I implemented my former company's framework, I got the idea of MVC wrong. So I implemented something slightly different. That earned me a lot of trouble with external consultants. You know, every once in a while we invited a consultant to look over our architecture. Inevitably, they would complain about our non-standard implementation. But our implementation worked, and it worked well, so what? That's an important thing to keep in mind: don't waste your time on this nonsense. It's like talking about politics: it's a lot of fun to discuss about the advantages of MVP over MVC and whether your program following on paradigm or the other. But at the end of the days, it'll change little. It's more important to chose a clean, sustainable architecture and stick to it. If you need a name, call it Model-View-Whatever. Whatever works for you. But today I'm not going to listen to the voice of reason. Today I want to have fun. Let's dissect the design patterns, and let's see how JSF and Angular fit into the pattern.

At a glance

Look at these pictures. They cover three of the most popular patterns: MVP, MVC and MVVM. Don

Did AngularJS Ruin JavaScript?

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

Ever since I've read Rob Ashton's ardent flame "You have ruined JavaScript", I thought about writing an answer. What is it that makes Rob react so emotionally about AngularJS? And while we're at it: what does AngularJS make stand out?

JSF ViewState and CSRF Hacker Attacks

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

One of the implementation details of JSF hardly any developer knows anything about is the hidden field "javax.faces.ViewState" that's included in every JSF view. On the one hand, it's good that you don't have to know anything about this field. Thing is, this lack of knowledge is filled with many myths. One of these myths is that the view state protects JSF pages against "cross-site request forgery attacks" (CSRF for short). Which is true, but it's not the primary purpose of the field. I started to investigate the topic because our professional penetration tester managed to run a CSRF attack using a simple replay script. He made me believe that the view state doesn't protect JSF application against CSRF attacks. But what is it for? And while we're at it, how to protect your application against CSRF?

Continuous Query Language - Processing Data in Real Time

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

The other day I learned about Odysseus, a framework to process data in real time. Truth to tell, I know little about the topic, but I consider it interesting enought to share it with you. Most of you are familiar with relational databases, SQL, O-R-mappers, transactions, the ACID principle and things like this. Working with streaming data is similar - and at the same time, it requires a major shift of mind. The more you look into it, the bigger the differences.

What's New in BootsFaces 0.7.0?

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

BootsFaces 0.7.0 now is available at Maven Central. And in a couple of days it will arrive on the jCenter repository. It's an update bringing you a host of new features. By the way, don't get confused by the small version number: We're convinced that BootsFaces is ready for production. It's just the Unix tradition that makes us stick with small version numbers.

Download coordinates

BootsFaces is available in two different flavors. There's the regular version at Maven Central, and there's a highly-optimized version at GitHub. The optimized version is 50 KB smaller and should be a bit faster. Both versions are compiled with Java 1.6. Alternatively, you can check out the repository from GitHub and build BootsFaces from source.

Updating To Mojarra 2.2.11+ May Break Your Spring Boot Application

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

One of our BootsFaces users surprised me by reporting that his application ceased to work after updating to Mojarra 2.2.11. After some investigation, I found out that the Mojarra team had implemented something that looked like an optimization. It works fine on a traditional Tomcat, but it doesn't on Spring Boot.

What happened?

After reporting the bug to the Mozilla team, I learned two things:

Spring Boot is not officially supported by the Mojarra team. They'll accept your bug fixes happily, but they're reluctant to fix bugs related to Spring Boot themselves. Now, that shouldn't come as a surprise. Spring considers itself as a competitor to JavaEE, so it's just a happy coincidence that it's possible to combine Spring Boots and JSF.
There was a good reason to implement the breaking change, and it wasn't performance.

Getting Started With Continuous Delivery

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

Basically, Continuous Delivery is simply a clever idea to make software development more simple, more reliable and more efficient. Sounds like simply tweaking the development process here and there, doesn't it? But when you're an experienced developer starting with Continuous Delivery, you'll be surprised to meet a whole bunch of new tools you've never heard of. I found this pretty confusing: CD is a development process, but when I asked how to employ CD in my company, all of sudden people started to talk about tools. Worse, you'll even learn new vocabulary, and you'll have to acquire a lot of knowledge that's previously been the exclusive domain of your operations department. On second thought, that's not surprising: One of the key ideas of Continuous Delivery is to make developers and operations collaborate more closely (an idea commonly known as "devops"). Operations departments have always been using their own tools, and will continue to do so for good reasons, so developers have to make themselves familiar with the tools of the operations department. In particular, they have to get familiar to Unix shells, which is quite a chunk to swallow if you're a visually oriented developer like me. Adopting Continuous Delivery has at least three challenges:

The development process changes.
The cultural shift. Both developers and operations have to learn about each others job, and they have to do tasks they could previously delegate to "the other department".
Your team has to install and use several tool they wouldn't need without CD. Expect to invest in courses and trainings.

it's tempting to sell CD tools and to tell you that's all you need

Type Erasure Revisited

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

You can't beat type erasure, they say. Information about generic Java data types is lost during compilation, and there's no way to get it back. While that's absolutely true, Mahmoud Ben Hassine and I found a tiny loophole which allowed us to improve Mahmoud's jPopulator framework tremendously. Under certain circumstances, it's possible to find about the type which is supposed to be erased. So jPopulator is able to populate not only simple beans but also complex generic data types. Mahmoud agreed to write an article about the ups and downs of our investigation. You'll see it wasn't exactly easy-going. Along the way, you'll learn about the loophole allowing us to beat type erasure.

What's New in PrimeFaces 5.2?

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

The next version of PrimeFaces is planned to be released on April 6, 2015. Continuing what already has become a tradition, BeyondJava.net gives you a round-up of what's new and noteworthy in in PrimeFaces 5.2. The list isn't complete, by the way. Among other things, the PrimeFaces team has improved the screen reader support and closed more than 200 issues.

Scala.js

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

When I heard about Scala.js a couple of years ago, I thought to myself: "Well, that's an interesting project, but sure it's bound to fail". Only it didn't. The other day I've stumbled over an impressive technology demo. You can write a ray tracer in object-oriented and functional Scala, compile it to Javascript an run it in the browser. Ray tracers are power-hungry, so the good performance shows that Scala.js generates surprisingly good code. I didn't run benchmarks, but judging from what I've seen I believe Scala.js is "good enough" on a modern browser. Native Javascript may be faster, but in many cases you won't notice the difference.

BootsFaces 0.6.5 Published on Maven Central

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

After a while, our team is finally proud to publish the new v0.6.5 release. This time we added more examples, a couple of handy components and exciting features. Here's a short summary of the highlights:

Font Awesome Support ( #23 , #39 , #53 )
compatibility to both Oracle Mojarra and Apache MyFaces
improved AngularFaces Integration
Primefaces integration
Omnifaces integration
and better documentation.

AngularJS 2.0: Sneak Preview on Data Binding

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

The AngularJS team presented a straw-man's proposal for AngularJS 2.0 syntax one or two weeks ago. According to the proposal, AngularJS 2.0 is going to look substantially different from what we used to consider Angular, and nothing shows this better than the overhauled core of AngularJS: data binding. It's a fresh new take on AngularJS, or, like Cagatay Civici tweeted, it's almost like a new framework that just happens to have the same name. He isn't the only one to think so. Developers protested against the changes, and soon discovered several issues with the syntax. This article shows the original ideas nonetheless - I consider them interesting, even if they're likely not to come.

Evolving W3C standards open new opportunities

So they decided to make a new start, dropping compatibility to AngularJS 1.x. And why not? I suppose the Angular team learned a lot about HTML and Javascript along the way, so they now know how to make things better. Who might have envisioned the flexibility of HTML concerning attribute names? Back in 2000, valid HTML attribute names were basically characters, digits, underscores and colons. By 2009, the W3C organization had added a lot of flexibility. Now, almost every Unicode character can be used in attribute names - this even includes Chinese and Devenagari characters (such as क्तु):

Newsflash: BootsFaces Now is Open Source

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

The BootsFaces team have published the source code of the BootsFaces JSF library on GitHub. BootsFaces is a JSF widget library that translates Bootstrap code to a dialect more familiar to JSF programmers. For instance, a navigation bar is written like so:

AngularFaces 2.0.0 RC3 Published

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

Release candidate 3 of AngularFaces 2 has been published. Basically, it's a bug fix release. Here are the release notes:

Bugfix: compatibibility with PrimeFaces
Bugfix: AngularFaces now copes with bean attributes, even if they are Strings (quite a funny bug, if you take in mind Strings are usually tested first).
Improved translation support (now includes the attributes "header" and "headertext")
Bugfix: Labels and messages aren't added automatically if the JSF view designer already defined a label an/or a message

In addition, I've started to write a tutorial. To read the tutorial, go to AngularFaces.com (nowadays taken offline). The example projects accompanying the tutorial are on https://github.com/stephanrauh/AngularFaces/tree/master/AngularFaces.com (nowadays taken offline). At the time of writing, the first two steps ("Bootstrapping" and "Labels and Messages") of the tutorial are finished (plus a couple of sketches of the remaining chapters).

BabbageFaces 1.0 RC2 Now Available for Download

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

BabbageFaces 1.0 RC2

My guts tell me BabbageFaces is ready to be released into the wild. Most of the time that's a reliable measure. Today I've tested it with the new PrimeFaces 5 showcase. BabbageFaces passed the test without problems. There's also a decent showcase example containing most of the elements of a typical business application, running both on Apache MyFaces and Mojarra. I'm optimistic all that's missing is a couple of source code comments, tidying and documentation to call it a final version. The showcase demo also shows BabbageFaces allows you to stop scattering ids all around your JSF code just to make AJAX efficient. BabbageFaces compares the response with the current DOM tree and sends only the minimum set of changes to the clients. If network load is giving you headaches, BabbageFaces may be your tool of choice. It reduces network traffic. At the same time, it simplifies the programming model.

Stability vs. performance

As for the current version, I decided to trade some efficiency for stability. Among other things I dropped the command. This command allows for very efficient AJAX if something's added to the HTML page. Unfortunately, it's also suffering from a couple of compatibility problems. For instance, the syntax of the command differs between JSF 2.0, JSF 2.2, Apache MyFaces and PrimeFaces 5. I hope I can re-activate the feature in a future version of BabbageFaces. Another feature I may introduce in a future version is optimized ids. BabbageFaces inserts a lot of ids in the HTML code to make optimizations possible. In general, you don't need mo

Announcement: BabbageFaces 1.0 RC1

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

Today I've uploaded the new (broken link). After fixing every bug I know of, I made up my mind to call the current version a release candidate. Now it's up to you: download BabbageFaces and tell me whether it works with your application. You can build BabbageFaces from source or you can use the binary distribute on Maven Central. Please let me know about your experience. Report errors as a comment at the end of this page (don't forget to provide the source code so I have a clue what's going wrong!). But of course, I'd also like to hear from you if you're using BabbageFaces successfully :). In any case, be prepared to receive an e-mail if I need further information to reproduce your bug or to answer your question.

What's New in PrimeFaces 5?

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

PrimeFaces 5.0 is going to be released any day now - most likely tomorrow (May 5, 2014). Çagatay Çivici, Thomas Andraschko, and a few others invested a lot of work in the new version: The source code repository lists more than a thousand commits since the last version, PrimeFaces 4.0, which in turn has been released only half a year ago. So it's time to look what's happened since October 3, 2013.

How to Display PDF Files in the Browser

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

Update April 13, 2020

A lot has happened since writing this article. Check out the 2020 edition of this article.

PDF files are very popular in web applications. They make it possible to deliver documents that can't be easily tampered, and you know in advance how PDF documents look like when printed. That's a major advantage over HTML page: printing an HTML page will almost invariably result in surprises. In many cases, cross-browser compatibility - which is always a challenge - comes to a screeching halt when it comes to printing the page. You can avoid a lot of headache by simply using PDF files.

Inside JSF: Understanding and Optimizing the AJAX Response

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

What's BabbageFaces about?

A couple of months ago Thomas Andraschko and I observed that AJAX responses do a lot of thing they don't need to do. That's a waste of resources, network bandwidth in particular. In rare occasions this behavior even causes errors. So we decided to do something about it. We started to write a JSF plugin - BabbagesFaces - that reduces the size of AJAX responses considerably. Needless to say we had to look very closely at JSF's AJAX implementation along the way, finding a couple of features neither of us had expected. This article serves two purposes. The major part of this article explains the features of JSF 2.2 AJAX responses. It also explains how BabbageFaces works and how it uses advanced JSF 2.2 features to optimize the AJAX client, both improving the user experience and reducing network load. Let's start with the basics. Before we come to the interesting stuff I'll dedicate a section to things most JSF programmers are already familiar with.

Looking at AJAX from an external point of view

How does JSF 2 AJAX work? That's easy: JSF merely provides the basic infrastructure needed to implement AJAX. Basically it leaves it to the programmer to define what AJAX does. Don't get me wrong: The AJAX client of JSF is a major achievement. It helped to lift quite a few applications to another level. Nonetheless I'm pretty sure I can convince you this was only the first step. JSF 2.0 makes AJAX possible. BabbageFaces makes it both fun and efficient. With JSF 2.0 every button (and every other clickable JSF component) influences a certain region of the screen. It's up to you to define which button influences which region. This is done by an HTML concept: IDs. Every compo

BabbagesFaces: Fast and Efficient JSF AJAX Made Simple

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

Introducing BabbageFaces

JSF is a great framework. Nonetheless it could be a whole lot simpler. That's what BabbageFaces does for you: it's a JSF 2.2 plugin addressing a particularly nasty issue. It allows you to reduce the complexity of JSF views, making JSF more efficient along the way. Every once in a while it even fixes an AJAX error.

Installing BabbageFaces

Installing BabbageFaces is as simple as can be. Just add the Maven dependency to your project. Restart the server, run your application and you'll see - nothing. Your application works just the way it did before. Just a little faster and smoother. That's because BabbageFaces works at the lowest possible technical level. It allows you to simplify your programs, but it doesn't require you to do so. BabbageFaces optimises every JSF application out of the box, without breaking the compatibility.

Verifying your installation

If BabbageFaces has been successfully installed, you'll see three differences:

There's a message in the console windows or catalina.out ("Initializing BabbageFaces DifferentialResponseWriter").
Looking at the HTML source code of your browser you'll find that many
and tags bear a couple of IDs you didn't enter.

Update 08.01.2014 I just tried it with Glassfish, and simply copying the jar file didn't work. So the better alternative may be to copy the jar file to your applications WEB-INF/lib folder, or to add the dependency to the POM file if you're using Maven:

How Come Nobody Cares About UML in 2013?

Stephan Rauh — Sat, 29 Jul 2017 00:00:00 +0200

There are already quite a few articles raising "Why?" questions on BeyondJava.net. This seems to become a special feature of this web site. Today's "Why?" question came to me when I was reading Scott Ambler's article UML 2.5: Do You Even Care? Scott writes he used to be big on UML a couple of years ago. He's clearly been one of us who were propagating graphical modeling. But now he's struggling to get interested in the new version of UML that's coming soon. Does this sound familiar to you?

Newsflash: Generate Random Test Data With jPopulator

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Writing unit tests is hard work. Much of the hardship is preparing the test data. In my daily work life, I often deal with large business objects you can't really mock. Refactoring might help, but it's not an option: I don't own the data structure. I encountered this scenario more often than not, so I suppose it's a scenario familiar to most of you, too. Another difficult scenario is load and performance test. Wouldn't it be nice to populate the database with thousands or millions of records to see what happens to the performance? jPopulator comes to the rescue. jPopulator is a small framework written by Mahmoud Ben Hassine" (together with a couple of contributors). The nice thing about jPopulator is it deals with complex data structures. The example on the jPopulator GitHub page consists of four classes, related to each other by 1:1 relations. I didn't try the framework with other test scenarios yet, but judging from the source code jPopulator also supports much more complex data structures. Be that as it may, even writing tests for those four classes is a pain if done manually: they consist of 15 attributes that have to be filled.

How to Modify JSF Library Load Order

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Why ordering matters

Every once in a while it's important to control the order in which JSF libraries are loaded

How to Modify the JSF 2.2 Component Tree Safely: TagDecorators, TagHandlers and PreRenderViewEvent

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Earlier this week Rudy de Busscher published an interesting article about JSF TagHandlers. Today I'd like to go a step further. Let's have a closer look at them and discuss another class of JSF tree manipulation classes: the TagDecorators. And, while I'm at it, I'll also cover to system events, PostRenderViewEvent and PostAddToViewEvent, that can also be used to manipulate the JSF component tree. Putting it in a nutshell, TagDecorators create JSF tags, whereas a TagHandler can be used to modify tags that already exist. Every JSF application can implement its own TagHandlers or TagDecorators. However, you hardly ever see one of them in the wild. Obviously, most people consider these classes a fairly advanced topic. You can work a long time with JSF without ever seeing one of them. But every once in a while, they come in handy. Rudy's example is pretty impressive in that regard: sometimes even an everyday task like enforcing user input in capital letters can be implemented simpler and more safely using a TagHandler. AngularFaces uses both TagDecorators and TagHandlers a lot, and JSF 2.2 itself made TagDecorators popular by using them to implement the new HTML5 friendly markup style.

JSF 2.2 and PrimeFaces 5 on Spring Boot

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Recently I reported about Spring Boot (see Application Servers are dead! (Sort of)), an interesting approach to embed your application server into your application instead doing it the other way round. However, Spring Boot is a fairly new technology, so the documentation is still work in progress. Most of the documentation is great, but there are still sentences like

Applications that are not already Spring applications might be convertible to a Spring Boot application, and the guidance above might help, but your mileage may vary.

Most JSF applications clearly fall into this category. So I've prepared a JSF template project to spare you some of the mileage. Currently there's a simple simple PrimeFaces project and a more advanced project demonstrating Spring and JSF scopes. To make things more interesting, I added Gradle and JSF custom scopes to the equation.

Useful PrimeFaces DataTable Events

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

I always used to skip over page 167 of the PrimeFaces 5 manual. That's too bad: it's an exciting page. It's a list of the events a can fire. That's no less than 19 interesting events.

Quick reminder: what are JSF events?

Chances are you already know the concept of JSF events from the section of your JSF applications. A standard JSF event, preRenderView, is frequently used together with view parameters. Doing so, your parameterized JSF page can be stored as a bookmark in the browser, much in the same way Amazon allows you to simply copy the link of the book review you're currently reading and send it to your friends:

Define Your Own HTML Tag!

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Introduction

It's astonishing what you can achieve with modern frameworks. Take HTML, for example. I always believed HTML to be a fixed set of tags with immutable semantics. This is going to change soon (there's a W3C spec dedicated to standardizing custom components), but as of today, the HTML vocabulary is still limited to a small set of predefined words. However, AngularJS found a way to circumvent this limitation. Truth to tell I doubt Angular really does modify the way the browser reads HTML code, but Angular's clever magic makes you believe you taught the browser a new HTML tag. From a practical point of view, you define your own HTML tag. You can also add new attributes to existing HTML tags. It's surprisingly simple, by the way.

Why should you want to define a new HTML tag?

Programmers have been creating and using building blocks ever since: functions, methods, classes and packages allow you to structure your code. Complex and tedious tasks are hidden behind a simple facade. In the past web designers couldn't do so because they were limited to the HTML dictionary. Recently many Javascript frameworks offer component libraries. However, the source code of those components typically looks a bit weird. Take Rudy de Busscher's great AngularPrime project, for instance. At first glance, there's little to complain about the code needed to display a menu:

Teaching Scala as the First Programming Language?

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Using Scala for educational purposes

A couple of years ago I proposed to teach our company's students Scala instead of Java. At the time my suggestion was rejected. That's a pity: I'm pretty much convinced it might have helped our apprentices a lot. So I'm glad to learn other people are less shy. Recently I've read two articles on the topic, both covering positive experiences.

They say Scala's way too complicated!

Rumors have it Scala is beyond the average Java programmers level. I've seen Scala programs I've considered completely incomprehensible. Scala's syntactical flexibility allows you to write programs that don't resemble anything you're familiar with, let alone computer programs. For instance, Scala's operator overloading has been used way to much by a number of frameworks. The resulting programs strongly resemble lectures on particle physics or probability theory. A good example is Lift's way of defining a menu:

Google Adds Asm.js Test To Its Octane Benchmark

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Update July 28, 2017: This article is about a refinement of Google's Octane benchmark four years ago. In the meantime, the benchmark has been abandoned. It has been replaced by (guess what!) Octane 2.0. Also see this interesting article about the transition to Octane 2.0. Also, read the comment: while adding little information to the main article, it provides an insider's view of things. Google enhances its Octane Benchmark measuring Javascript performance in an interesting way. It adds two benchmarks measuring technologies developed by Google's competitors: Typescript has been developed by Microsoft, while asm.js is a Mozilla project aiming at speeding up a subset of Javascript. Google does not support the asm.js. According to them, it's better to optimize the entire Javascript runtime instead of focusing on a subset of it. In my eyes, this is a convincing argument: asm.js code is designed to be generated by compilers, not by humans. As for now, Javascript compilers like Dart, Ceylon, Kotlin or Typescript haven't had that much of an impact. The majority of Javascript code is written by humans.

Using Javassist To Implement Mixins or Traits in Java

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Reusing code scattered among the inheritance tree

Many components of the (broken link) library share common properties and methods. Some of these methods are simple, some of them are complex. I'd like to move them to another class instead of implementing them multiple times. Unfortunately, the component classes don't derive from a common base class. That's nothing I can fix. That's just the way PrimeFaces and Mojarra are designed. So I can't factor out the common traits using inheritance. The second common approach, the delegation pattern, certainly works. However, it amounts to writing a lot of boiler plate code. At first glance, this isn't much of a problem since most modern IDEs offer a refactoring tool to implement the boiler plate code. Eclipse is going to help you. But as Venkat Subramaniam pointed out in his Java One 2013 talk, this approach has severe disadvantages. Adding a method to the base class forces you to add it to every class using the base class as a delegate. The same applies to removing a method or changing the signature of a method.

Scala to the rescue!

So what we really want to have is something like Scala's or Groovy's @delegate annotation. This is often referred to as "mixin".

JavaOne 2013 Talks and Slides on Parleys.com

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

There's good news to all those who hadn't the opportunity to visit this years JavaOne: Quite a few talks have been published on parleys.com. At the time of writing roughly 60 talks are available for you. Most of the videos are just the sliders with the audio track underlaid, so don't be surprised if you don't see the speaker waving her or his hands. Update July 28, 2017: To my surprise, Parleys.com has vanished from the web. From BeyondJava.net's point of view, it's interesting only seven talk deal with languages other than Java. The languages covered are Scala and Groovy, and of course the inevitable lingua franca of the internet: Javascript. Maybe - just maybe - Scala and Groovy are slowly making it into the mainstream development. The news I've read lately indicate dynamically typed languages such as Ruby are slowly declining, while there's growing interest in the Scala language.

Why JSF 2.0 Hides Exceptions When Using AJAX

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

I always wondered why my application tends to hide exceptions. An exception occurs on the server side without getting visible on the client side. The client doesn't show any reaction at all. Often you need a tool like FireBug to become aware there's an error. It took me a while to realize this only happens with AJAX requests, and that this is a well-known behavior in the JSF community. However, there's at least one excellent book (also available at ~~jsfatwork.irian.at~~) which doesn't mention the problem. So maybe it's worth spending a couple of minutes to write a small article on an old topic.

Why Don't You Write a JSF Composite Component?

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Composite components: a JSF 2.0 highlight

They say it's hard to write a JSF component. That's rubbish. JSF has been designed with user defined components in mind. Beyondjava.net has a couple of articles on the topic, and my AngularFaces Github repository has a couple of working components you can use as a base. You'll see creating JSF components isn't rocket science at all. But it true, it isn't done in a minute, either. Thus JSF 2.0 introduced a great feature to create user-defined components. Simple components are created in no time. As for not-so-simple components - well, they are not created in time. I'll return to that later. First I want to tell you the success story. It's an inspiring story to tell.

Why don't you just write a composite component?

Maybe you don't already know that you want to write a composite component. What about a little experiment? Have a look at your JSF pages (or whichever GUI you use, for that matter). Print them in small letter, pin the print-out upside-down at the wall and look at it from some distance. Now you can see the structure of the code without being distracted from the content. It's kind of geometrical, isn't it? That's the common patterns of your code shining through. You'll find groups of similar components repeated over and over again. If you don't, you've probably forgotten to format the code nicely. Or you've already read this article :). What do you do when you find yourself repeating over and over? Yeah, refactoring. In JSF terms this usually means writing a component. So why don't you just write a JSF 2.0 composite component? They say it's the easiest way to write a JSF component.

Getting started with JSF 2.0 composite components

Basically creating a JSF 2.0 component is just extracting

PrimeFaces 4.0 Search Expressions - And How to Extend Them

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Referencing by IDs isn't enough

While I like JSF as a component framework, I always feel JSF becomes less attractive once IDs come into play. The most common playground for IDs are AJAX requests, but they're also used in watermarks, sliders and even simple labels and error messages. The problem with IDs is they aren't really flexible. They frequently don't survive simple operations such as refactoring the JSF code and copying fields. That's one of the reasons why I began to develop my AngularFaces library. But you don't have to go as far as to change your framework. The PrimeFaces JSF library has been offering improved search expressions for some time now, and they are even going to improve them with the upcoming version 4.0.

Client side search expressions

The attributes that are evaluated on the client side benefit from the power of jQuery. Basically that's the attribute update and the much less frequently used attribute process. jQuery expressions have to be surrounded by @(...) and are described in great detail at the jQuery documentation page. A very simple but useful idea is not to use CSS pseudo-classes instead of IDs

How to Eliminate Those Annoying Tomcat Deployment Waits

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Introduction

Java developers must be patient. Even incredibly so. Mind you, back in the mid-90s IBM invented Hot Code Replacement to hide how slow their WebSphere Application Server was at the time. It took several minutes to start the application server and to deploy an application. This resulted in very slow turn-around cycles. In other words: developers spent a lot of time with waiting. Luckily IBM implemented Hot Code Replacement in their JDK 1.3 virtual machine (IBM J9 VM), eliminating the nasty waits almost completely. It was an awesome experience at the time. When Hot Code Replacement later was introduced to SUN's JDK 1.4.1, we were very quick to adopt it. And today? By default, both Eclipse and Tomcat are configured such that every change of the source code results in reloading the context, which is just another word for restarting the application. Depending on the application, this is just a matter of seconds. It also may take a few minutes if you're working on a bigger application. In most cases, your application state is lost. You have to sign on again and to dig all the way through the seven pages of the wizard you're working on. Did I mention the error you're hunting occurs in wizard's last step?

What about you?

It doesn't have to be so. I'll show you some ways to get rid of the waits in a second. But before that, I'd like to ask you how you cope with deployment waits? Feel free to leave a comment if you're as impatient as I am. Or if you're just happy with you IDE even if it's a little slow at times. I've been asking a lot of people, and most of them didn't even understand my question. This even applies to Liferay developers. Those guys are suffering a lot more than the average developer: the server takes roughly a minute to start, and deploying a portlet typically takes 30 seconds. A colleague of mine had been working on a

AngularFaces: Check Boxes, Drop Down Menus And Tables

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

The AngularFaces saga continues! AngularFaces now offers seven components, and I learned how to angularize JSF components without having to derive from them. Update Sept 16, 2014 AngularFaces 2.0 takes a different - and better - approach to adding fuctionality to JSF. This article describes the older version AngularFaces 1.0. Have a look at the tutorial at (broken link) if you're interested in AngularFaces 2.0 and above. Since my last AngularFaces post I've added two simple components: and . Suffice it to say they are derived from the corresponding PrimeFaces components and work exactly the same way does. Angularizing data tables proved to be much more difficult.

Closure Scope - Why Java 8 Prefers Simple Lambda Expressions

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

To my surprise and disappointment the Java 8 programming team decided not to deliver full-blown closures. They prefer to call their closures lambda expressions, indicating that those lambdas won't deal with variables. This Groovy example won't work in Java 8:

Getting Started with AngularFaces

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

As I mentioned in a previous post, AngularFaces is a JSF component library aiming to simplify JSF development significantly by allowing you to replace a lot of clever AJAX code by simple AngularJS code. Remember, in software engineering cleverness is not always a virtue. You may be able to write clever code, but later it has to be maintained by someone else who doesn't appreciate your ingenuity. The difficult part of software engineering is not to write complicated code. The difficult part of software engineering is writing simple code everybody can understand. The AngularFaces approach to simplicity is to reduce the boiler plate code you have to write. Key features are

bringing JSR 303 annotations to the client,
labelled input fields
validating constraints as you type
and of course integrating AngularJS.

This article shows you an example consisting of merely three input fields. Even this tiny example is six lines shorter than the standard JSF version. At the end of the article, you will know everything you need to get started with AngularJS. Update Sept 16, 2014 AngularFaces 2.0 takes a different - and better - approach to adding fuctionality to JSF. This article describes the older version AngularFaces 1.0. Have a look at the tutorial at (broken link) if you're interested in AngularFaces 2.0 and above.

AngularFaces: AngularJS Puts JSF on Steroids

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Where Java Server Faces shines - and where it does not

JSF 2.0 is a nice framework to create web applications. It offers a decent level of abstraction. Most of the time you don't have to deal with basic technologies like HTML and Javascript. It fun to use it. You can create an attractive-looking application in no time. But things become ugly once you start to write an AJAX client. It looks deceptively innocent at first sight. What's so difficult about adding simple attributes like update="@form" or - if you happen not to use Primefaces - a nested tag like ? Beware: You'll end up wading knee-deep in Javascript code, DOM trees and HTML. You'll add an id to virtually every component of your dialogues, and you have to know a lot about when events are fired. Firebug soon becomes your best friend

Java 8's Optional Type, NullPointerExceptions and the Elvis Operator

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Every Java programmer is maddened every once in a while by the notorious NullPointerException. Not only Java programmers, by the way. Probably every JVM programmer is suffering from the problem, and many other languages know similar problems. I'd even claim the infamous NPE is the most important productivity killer of Java programming productivity

JavaFX and GroovyFX: Two Frameworks You May Have Missed

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Like most Java programmers I've gradually become a web developer during the last years. In a way, that's strange: most projects don't deal with the internet. It's a pity, too. Browsers used to be dedicated tools for the internet, so it's hard to meet the demands of a full-blown desktop application. It's a real pain to integrate Excel sheets seamlessly into a web application. So what about desktop GUI frameworks? There's an interesting Java framework you most probably know by name without ever having looked at: JavaFX. It makes for nice-looking GUIs, and it matches Java 8 pretty good. Combine it with GroovyFX to get GUI classes that strongly resemble JSF files. Without suffering from JSF's inherent complexity.

Second Glance into the Crystal Ball: Java 8 Lambda Expressions

Stephan Rauh — Fri, 28 Jul 2017 00:00:00 +0200

Introduction Lambda expressions will change the Java programming style considerably. Java 8 programs are going to look more alien to Java programmers than Groovy programs. I'd like to show you some code snippets based on the current (early December 2012) developer build of project lambda. A simple example Let's start with a simple real world example I frequently need. Every once in a while I want to know how many lines of code my project has. Ad-hoc-statistics like this are a lot of fun in Groovy:

How to Connect HTML Elements With an Arrow Using SVG

Stephan Rauh — Thu, 27 Jul 2017 00:00:00 +0200

The other day, had a list of items on the left-hand side, and another list of items on the right-hand side. Some of these items are connected, some of them are not. Wouldn't it be nice to show this by connecting the item with an arrow? At first, there's nothing new here. We've been drawing and connecting boxes, circles and arbitrary shapes in the IT business for ages. Just think of flow charts or organigrams. There's even a nice PrimeFaces component for that. The problem is that my application was an Angular2 application, not a JSF application. Plus, the PrimeFaces component, which is really nice, didn't match my requirements. I didn't want to display a flow chart. The boxes I wanted to connect contain live data and even images. So the task is to connect arbitrary

elements with an arrow. At first, the task seems a bit intimidating, but once I've started to delve into it, it became surprisingly simple. Simple enough I can even provide the source code at the end of the post.

Electron Brings JavaScript to the Desktop

Stephan Rauh — Thu, 27 Jul 2017 00:00:00 +0200

Let's continue my "Java on the desktop" series with something that's not Java, but interesting nonetheless. Electron is a framework wrapping your HTML5 application in a native window of your operation system. Other than most projects in the JavaScript universe, Electron does not follow a "mobile first" approach. Quite the contrary, it's fairly opinionated in that it supports only three platforms: Windows, OSX, and Linux. This includes access to your computers file system and access to the Windows registry via third-party NPM modules. If I've got it right, it even allows you to install your application as a Windows service, which is kind of scary. You know, not too long ago every security expert recommended deactivating JavaScript in the browser because of alleged security risks. Obviously, we've come a long way.

Is Java Going to Become Invisible?

Stephan Rauh — Thu, 27 Jul 2017 00:00:00 +0200

In a sense, Java has vanished from the client many years ago. With the exception of Android, the vast majority of Java runs on a server in a data center. From the average user's perspective, Java has become invisible. When we talk about Java UI programming, most people think of Spring MVC, JSF and Ozark. I'm still trying to make sense of the new Java EE 8 plans Oracle revealed at JavaOne a couple of weeks ago. My first impression was that the new focus on cloud computing means that Java is going to molt again. The Java EE 8 roadmap proposal indicates just that.

A Funny Groovy Bug (and a Strange One)

Stephan Rauh — Thu, 27 Jul 2017 00:00:00 +0200

Today I stumbled over a bug that probably can occur only in Groovy. Can you spot it?

Lombok, AspectJ and JUnit

Stephan Rauh — Thu, 27 Jul 2017 00:00:00 +0200

A couple of posts ago I mentioned the incompatibility between Lombok and the AspectJ Eclipse plugin. Of course, JUnit tests also suffer from the incompatibility. Today I've been looking for a solution to that problem.

When Unit Tests Backfire

Stephan Rauh — Sat, 22 Jul 2017 00:00:00 +0200

Everybody knows that unit tests are valuable. So it's a lot of fun playing Devil's advocate as I did some time ago when I raved about the value of compiler checks for keeping up the quality of your program. So here we go: unit tests are expensive. You never know when or if they pay off. Thing is, my experience shows that unit tests are not always good. Sometimes they even backfire. I've seen this in at least two projects. This time, I don't want to talk you out of using unit tests (maybe another day), but I want to make you aware of the risks.

What's New in BootsFaces 1.1.2?

Stephan Rauh — Sat, 22 Jul 2017 00:00:00 +0200

BootsFaces 1.1.2 is chiefly a maintenance release. But as usual, there are also a couple of improvements.

Reactive Programming with Angular by Example (Part 3)

Stephan Rauh — Thu, 20 Jul 2017 00:00:00 +0200

In the previous parts of this series, we've learned how to work with data loaded asynchronously. Now let's have a look at some of the advanced use cases. How can we combine multiple REST calls if we need the result of both to start working? Let's continue our address example. Let's assume we want to send a letter to a customer. To send the letter, we need two chunks of data: the content of the letter itself, and the address we want to print on the envelope. We can't send the letter until we've received the response of both REST calls.

Reactive Programming with Angular by Example (Part 2)

Stephan Rauh — Tue, 18 Jul 2017 00:00:00 +0200

In the first part of this series, we've seen how to call a REST service and how to display the result asynchronously. Now we're going one step further. How to work with data that isn't really there, but can only be observed as a volatile stream of data events? Because that's what an Observable is. Reactive programming is stream processing, and the strictest form of reactive programming uses Observables without memory.

Reactive Programming with Angular by Example (Part 1)

Stephan Rauh — Mon, 17 Jul 2017 00:00:00 +0200

Web applications benefit a lot from reactive programming. The application reacts immediately when the user clicks, even if it takes a couple of second to load the data. In the early days, applications used to stall at this point. The computer froze, and you couldn't say whether it had crashed or not. So developers invented the progress bar. That's still freezing but in a more entertaining way. Modern web applications do a lot better. They show the next page immediately, filling in data a bit later. That approach has many advantages. It gives the user immediate feedback. You can also load the top-most data first and load less often used data later. In most cases, this even means the user can continue their work earlier. Let's have a look how to do this with Angular. Reactive programming isn't difficult, but if you're not used to it, you have to learn to think outside the box.

Newsflash: JavaEE 8 Road Map Proposal

Stephan Rauh — Mon, 17 Jul 2017 00:00:00 +0200

This newsflash is a true "flash", currently consisting only of a single link to the current proposal of the JavaEE 8 road map: Proposal of the JavaEE 8 road map as of September 19, 2016 However, if time allows, I'll either add to this newsflash later or write blog entries covering certain aspects of the modified plans. Stay tuned!

Progressive Web Apps

Stephan Rauh — Mon, 17 Jul 2017 00:00:00 +0200

The other day, we had a discussion in the office. Is HTML5 the solution to every problem, or are native apps the way to go? For a long time, I was very reluctant to force our users to use the browser to do their work. At the time, we had a nice Java applet running in the browser, which seemed to be a nice compromise to me. We could offer a rich user interface, and every user who had access to the internet could install our application. But installing the applet soon turned out to be above the skill and will of the average user, causing a lot of hotline calls. Plus, developing simple HTML pages was cheaper. That tipped the scales. We kissed Swing goodbye and never looked back.

What's New in BootsFaces 0.8.5?

Stephan Rauh — Mon, 17 Jul 2017 00:00:00 +0200

What started as a small bugfix release, ended as a full-blown feature release. If the sheer number of commits is an indicator, the new release is awesome: the previous release counted 599 commits. In the meantime, 240 commits went into the 0.8.5 version, give or take a few. Needless to say, this amounts to a lot of added functionality: 11 new components, countless improvements and - of course - bugfixes. Plus, we've migrated the relaxed HTML-like markup style from AngularFaces to BootsFaces.

Too Old to Learn a New Language?

Stephan Rauh — Sat, 08 Jul 2017 00:00:00 +0200

The other day, a co-worker and I held a talk at the Java Forum Stuttgart. Our topic was the UI techradar we're currently developing. So much of the talk was devoted to comparing UI frameworks, raving about Angular, about the advantages of programming your smartphone natively in ObjectiveC, and why it's still a good idea to stick to Java and JSF. All of a sudden one of the attendees asked a question I wasn't prepared for. It was a good question, but I didn't take it as seriously as it deserved. Even worse, I laughed it off. That's something you must never do. When I noticed my mistake, it was too late to correct it. So I decided to blog about it. It's a late answer, and I don't know if it's ever going to be read by the guy asking the question, but here it is. The question was:

Angular and React may be great. But do you really expect everybody who's crossed the 35 years mark to learn a new programming language each year, just to use the UI framework of the week?

Embracing Redux - or What's Wrong with Object-Oriented Programming?

Stephan Rauh — Wed, 21 Jun 2017 00:00:00 +0200

Before you ask, I don't think anything's wrong with object-oriented programming. But recently I've attended an interesting talk at the JAX conference. By the look of it, the speaker, Manuel Mauky, wasn't happy with object-oriented programming. Instead, he propagated functional programming and Redux. While I don't agree with him, I considered his reasoning compelling. I'll try to summarize it as best as I can. By definition, object-oriented programming means to combine data with algorithms. To me, this always seemed to be natural. After all, data is meaningless until you know what to do with it. From this point of view, objects join two concepts that belong naturally together. Manuel tackles things from a different angle. He doesn't believe that data and behavior belong together. He's pretty much convinced that the application state should be separate from the functions defining the behavior of the application. We'll see that this approach has many advantages.

Java 8 Update 20: String Deduplication

Stephan Rauh — Thu, 15 Jun 2017 00:00:00 +0200

Remember my last April prank? I span a yarn about the great way Oracle managed to squeeze every conceivable String into a 64-bit number. Funny thing is my vision comes sort of true. Of course, not the way I claimed. That was nonsense meant to be easily seen through ("There are only so many Strings a gal or a guy can think of - so everything you have to do is to assign them a 64-bit number"). But it's true that a lot of work at Oracles' is dedicated to optimize String management. Java 7 Update 6 improved the speed of String.substring() by sacrificing a little memory efficiency (see my article Recent Improvements of Java’s String Implementation). Java 8 Update 20 takes the opposite approach: it sacrifices a little CPU efficiency in order to reduce memory footprint. On the long run this should reduce the strain on the CPU, too. In other words: most real worlds programs should run faster. Everybody who's analyzing a Java program in a profiler can't avoid noticing: Java programs create incredible quantites of character arrays. Most of them are part of String objects. Java represents its String as objects, meaning there's a pointer to a character array. That's not exactly the most efficient way to represent a sequence of characters. It's just what you get if you want to represent a String as an object instead of defining it as a native primitive type. However, the developers of Java got aware of the problem a long time ago, so they invented the String.intern() method. In general, it's a bad idea to call this method by yourself (because you're trying to outperform the JVM's optimization), but sometimes it reduces your application's memory footprint tremendously. Putting it in a nutshell, String deduplica

What's New in BootsFaces 1.1.0?

Stephan Rauh — Tue, 02 May 2017 00:00:00 +0200

Putting it in a nutshell, the new version of BootsFaces doesn't bring you new features. Instead, it focuses on quality and compliance with the HTML code recommended by the Bootstrap team. There's only one new component, a few more concepts, but more than a hundred bug fixes. Granted, several of these bug fixes solve bugs introduced during the development of BootsFaces 1.1.0 itself, but even so, it's an enormous progress. Since BootsFaces 1.0.2, we've committed to the core library more than 200 times, not to mention the commits to the showcase project. As it turns out, even a version introducing a single new component can be a major release.

Update May 02, 2017: Typo gremlin

Despite several weeks of testing, our good old friend, the typo gremlin, has sneaked into BootsFaces 1.1.0 again. This time, and the are affected. We'll publish version 1.1.1 soon, probably already this week-end.

JavaLand 2016

Stephan Rauh — Tue, 11 Apr 2017 00:00:00 +0200

Conferences are different if your are a speaker. Listening to talks is still important. So are the usual chores, like hunting for a cup of coffee from a dwindling supply just before the next exciting talk starts. But it's not as important as it usually is. I'd rather use the time to prepare myself for our speech!

Newsflash: "Secure" in Your Browser's URL doesn't Always Mean "Safe"

Stephan Rauh — Tue, 28 Mar 2017 00:00:00 +0200

This is a topic I consider important enough to abandon the "non-commercial-only" policy of BeyondJava.net. I hardly ever quote from or link to professional web pages unless they are so ubiquitous you can't avoid them or there's a good reason to do so. Web security definitely is one of the best reasons. Today, Wordfence - a professional company providing a popular Wordpress security plugin - has published an interesting blog post about the green "secure" bar in your browser's URL.

Secure vs. safe

Cutting a long story short, "secure" doesn't mean the same as "safe". That's particularly annoying for Spanish and German users because these languages don't distinguish between secure and safe. (Chances are that this holds true for many, if not most, other languages, too). Users read a green "secure" in the address bar and feel "safe". But in reality "secure" means that the connection between the client and the server is secure. That's great. It means that nobody can intercept the messages and manipulate them. But that's all it means. It does not prevent the server from being malicious.

Revoking security certificates

The good news is that when a malicious website is discovered, the certificate guaranteeing the security of the connection usually is revoked, and the server is added to a blacklist. But that takes time, and it's not guaranteed it'll ever happen for a particular malicious website. Plus, Wordfence reports that the revocation of a certificate does not or not always result in a red address bar. You can see the revocation, but this information is buried in the developer tools. In other words, it's invisible to most casual users.

Stay alert!

It's a good thing that Google has added the "secure" and "insecure" bars to the browser's address bar, but that doesn't mean you don't have to be careful. Keep looking at the addre

Date Patterns Cheatsheet: Moment.js and Java's SimpleDateFormatter

Stephan Rauh — Mon, 27 Mar 2017 00:00:00 +0200

More and more projects seem to abandon Java as a front-end programming language in favor of JavaScript. Usually, they keep with Java as the backend programming language. Most of the time, both ecosystems exist peacefully. But there are sources of confusion. One of them being dates and times. Does this sound familiar? Yes, you're right. Dates and times are a pain point of Java since day one. JavaScript just adds another layer of complexity to this. Moment.js is a very popular library to deal with dates and times in JavaScript. So I've assembled an ~~interactive cheatsheet~~ helping you to convert the formats into each other.

UI Roundup 2017: Polymer

Stephan Rauh — Sun, 26 Feb 2017 00:00:00 +0100

Two years ago, Polymer looked like an equal competitor to AngularJS. At the time, it wasn't clear which one would win the race. Truth to tell, it's not clear today. The JavaScript world is incredibly volatile and capricious. But the numbers I collected clearly indicate Angular (nowadays without JS) is much more important. At the same time, they indicate that Polymer is here to stay.

Newsflash: Saving HTML Pages or Snippets as an Image

Stephan Rauh — Sat, 28 Jan 2017 00:00:00 +0100

There's a nice JavaScript project allowing you to save HTML snippets as an image. I didn't test it yet, but the Fiddles look nice (for instance, this one). Basically, the library traverses the DOM, using an HTML5 canvas to draw the elements it finds. In other words, it's an HTLM rendering engine written in JavaScript. Most likely, that means that the library only supports a small fraction of the giant set of HTML attributes and elements. But still, it seems to support many common use cases. Another approach is putting foreign objects into an SVG and to draw that SVG image into an HTML5 canvas. The foreignObject is currently only partially supported by most browsers, but even so it seems to do the trick for many common usecases.

The Dark Path?

Stephan Rauh — Sun, 22 Jan 2017 00:00:00 +0100

It always pays to listen to Uncle Bob Martin. He's clearly someone who's got something to say. But that doesn't mean I always agree. Today, I don't. And I consider it interesting why we disagree. I've just read Robert Martin's post"The Dark Path". He picks three innovative traits of Kotlin and Swift: strict null checks, strict exception handling and making classes final (in Java speech) or closed (in Kotlin lingo) by default. It's an interesting post I recommend to read. Uncle Bob shortly explains these features, continues with complaining about languages becoming too complex because they try to fill each leak of their predecessor languages, and closes with an ardent call to write tests. Like usual, he arguments very convincingly. It's hard to disagree after reading the article. Yet I do.

Charts with Angular: ngx-charts (Formerly: ng2d3)

Stephan Rauh — Sat, 21 Jan 2017 00:00:00 +0100

Originally, I wanted to write an article about ng2d3. That's a fine library bringing the power of D3.js charts to the Angular2 world without the price. D3 requires you to adopt a special programming style. You have to learn and use a new programming paradigm, the data-driven programming style. ng2d3 doesn't require such a thing. You just pass it the data, and it'll draw the diagram for you. The only problem with ng2d3 is that it doesn't exist anymore. More precisely, when I started writing, the team published a new major version (including a couple of breaking changes) and changed the name of the project. Now it's called ngx-charts. In the view of the new semantic versioning strategy of Angular, the name makes a lot of sense. Calling a framework "ng2-something" won't work when Angular4 will have been published, skipping Angular3 altogether.

What's New in BootsFaces 0.9.0?

Stephan Rauh — Mon, 09 Jan 2017 00:00:00 +0100

After seven weeks of hard work, we've published BootsFaces 0.9.0. It's a major improvement over BootsFaces 0.8.6. Unfortunately, a little error slipped through our QA gate: It seems we've involuntarily published a Java 8 version. If you are using Java 6 or 7, you'll have to wait until 0.9.1 comes out in a few weeks, or you may use the developer snapshot on Maven Central. It was a small bug, easy enough to fix it within a day. While BootsFaces 0.9.0 is more than a bug-fix version, it clearly concentrates on polishing BootsFaces, removing bugs and finishing things we had started in previous versions. That's not a small achievement: the number of commits on GitHub went from 856 (BootsFaces 0.8.6) to 1028. And that's only the base library. The showcase has improved a lot, too. And we've managed to finish a component many developers desperately need: . What makes this component unique in the JSF world is that it is rendered on the client. That makes it feel a lot faster and much more responsive than traditional server-side data tables. We've already received a lot of bug reports and enhancement requests, even during the development phase. Thus I'm sure the data table will remain in our focus during the new few updates of BootsFaces.

A more liberal license

Probably the most important point of BootsFaces 0.9.0 is the license. Now, BootsFaces is available under an Apache V2 license being a lot more liberal than the old GPL V3 license. For example, you can use BootsFaces in commercial products without further ado.

How to Use BootsFaces and PrimeFaces in the Same Project

Stephan Rauh — Tue, 27 Dec 2016 00:00:00 +0100

I've always promoted BootsFaces as a companion framework for PrimeFaces, but many developers report it's difficult, if not impossible, to combine these two frameworks. Things are particularly nasty if you've already got a (possibly huge) PrimeFaces application. Some developers report that even adding a single BootsFaces component will distort your application's layout. So I've decided to examine the problem more closely and to do something about it. This article sketches how to integrate BootsFaces components into a PrimeFaces application. I've also created a project at GitHub demonstrating the idea. Note that this article doesn't show how to use a PrimeFaces component in a BootsFaces application. Of course, that's almost the same problem, but the source codes below only consider the first use case.

How to Wrap BootsFaces (or JSF in General) as a Native Desktop Application

Stephan Rauh — Thu, 24 Nov 2016 00:00:00 +0100

When I showed the draft of my last post (the "Java on the Desktop" survey article), my friends surprised me by saying that nowadays, desktop applications are exotic. Everybody's making mobile or at least web applications. But the good old desktop has fallen into oblivion. That's pretty strange, given that most of us do our daily work on desktop PCs or decent-sized laptops.

Java on the Desktop

Stephan Rauh — Wed, 23 Nov 2016 00:00:00 +0100

For some reason, the vast majority of developers has accepted the browser as the operation system for their applications. While there are some good reasons for this, I never really bought into it. HTML5 has eliminated most of the pain point of web applications, but I still insist that most customers don't really want to use a web application. We've taught them to accept to open the browser to do their daily work, but there are still quite a few disadvantages to this approach. The "old stagers" among you know how many obstacles we had to overcome before the browser became a really useful operation system for writing applications. Just for the fun of it, let's start this article summarizing some of them:

How to deal with the "back" and "forward" buttons in a web application?
How to print a document from a web application? Most developers export documents to be printed as PDF files, but wouldn't it be nice to be able to print documents without this detour?
How to import an Excel file into your application?
More generally speaking, web applications run in a sandbox preventing access to low-level resources such as your computer's file system.

The Rise and Fall of Scala

Stephan Rauh — Sun, 23 Oct 2016 00:00:00 +0200

There seems to be a consensus in the Java community that the Scala programming language is already on the decline. I consider this a pity because I always enjoyed programming in Scala. Actually, I even started this blog to support alternative JVM languages like Scala. But the market has decided differently. Moshe Kranc has written an excellent analysis about the rise and fall of Scala. I found Moshe's article interesting enough to summarize it and to add a couple of thoughts of mine.

Before I start

However, I've also read some of the 169 comments to Moshe's article, so I'd like to add a few words. First of all, I'm really fond of the Scala language. I'm not trying to write an anti-Scala article. Quite the contrary. I'm following the fate of Groovy and Scala for at least ten years now, and I'm still puzzled why the industry doesn't adopt one of these languages. In many aspects, both languages are clearly superior to Java.

Getting Started with AngularJS 2.0: Tools and Compiler

Stephan Rauh — Thu, 06 Oct 2016 00:00:00 +0200

Update Aug 4, 2016

Recently, this article received a couple of harsh comments calling it "useless". So I should point out that I've published this article some time ago when Angular2 was still being developed. At the time, it wasn't even an alpha version. So expect an introductory-level article which may even be partially outdated. If so, please leave a comment so I can correct it. It's a popular article, so your comment is going to help a lot of developers. Thanks!

Update Oct 06, 2016

Currently, I'm evaluating a couple of tools that weren't available to me when I wrote the first version of the article: Webstorm, IntelliJ, angular-cli and ionic-cli. I'll cover them in an article soon, and update this blog entry subsequently. Until then, keep in mind that I wrote the article when Angular2 was still an alpha version, so don't be disappointed if parts of the article are outdated.

Live in the early days of AngularJS 2.0

Probably it's still a bit early to investigate AngularJS 2 thoroughly. The release date of AngularJS 2 is still open, documentation is scarce and I'm told many important APIs are still unfinished. But that's the fate of an early adopter. On the other hand, it's already possible to work with the current Alpha versions, and if I'm not mistaken the fundamental decisions of what AngularJS 2 is going to look like already have been made. So I thought by myself that the time is ripe to explore AngularJS 2. Along the way, I wrote a little chess program consisting of 1500 lines, give or take a few. Cutting a long story short: AngularJS 2.0 is fun, even today. It's a big step forward. Today's article is not so much about the architecture of AngularJS - BeyondJava.net is going to cover this soon - but concentrates on how to set up an efficient development environment. Coming from a Java developer team, I'll report many things JavaScript developers are already familiar with. Bear wi

UI Roundup 2016: Microsoft UWP and Xamarin

Stephan Rauh — Wed, 05 Oct 2016 00:00:00 +0200

No comprehensive survey about UIs can ever be complete without covering the Microsoft world. Java and JavaScript may be all good and well, but sometimes you need more control over your hardware. Both languages run in a sandbox trying to abstract from the hardware the application is running on. Most of the time you won't notice, but there's a major performance penalty, and you can't access low-level resources. So let's have a look at what Microsoft has in store for you. Traditionally, the particular advantage of using native Windows programming is the seamless integration with the operating system and - to a lesser extent - with the hardware. So let's have a look at Microsoft's UWP platform and at Xamarin, a framework they've acquired in February 2016.

Kudos to my co-author

But before that, I'd like to introduce you to my co-author, Janis Saritzoglou. This article wouldn't have been possible without him. Janis wrote his bachelor thesis about UWP and dedicated an afternoon to explain UWP and Xamarin to me. He also proofread this article and added a couple of interesting insights. That said, let's continue with UWP.

PrimeFaces 4.0 (and 5.0+) Client Side Validation

Stephan Rauh — Thu, 07 Jul 2016 00:00:00 +0200

Comparing the PrimeFaces approach to the AngularFaces approach on client side validation

These days I've been so busy implementing client side validations in my JSF library AngularFaces that I missed one of the most important features of the upcoming new version 4.0 of PrimeFaces: client side validation. PrimeFaces 4.0 approaches client side validation from a slightly different angle than I did. By default PrimeFaces delays client validation until a button is pressed. That's probably the behaviour most people expect. They already know it from traditional JSF applications and even most desktop applications. Most likely I'll remove client side validation from AngularFaces. After all AngularFaces is just an extension of PrimeFaces 4.0, so there's little point in offering the same feature twice.

Activating client side validation

By default, client side validation is disabled. It has to be disabled explicitly by setting the commandButton's validateClient attribute:

Simulating HTML Include Files

Stephan Rauh — Thu, 07 Jul 2016 00:00:00 +0200

There is no standard way to include an html fragment into an html page. You either have to use weird hacks or wait until HTML import becomes a features supported my most current browsers. Most likely this will take years, so let's have a look at the weird hacks. In my particular use case, I wanted to show some user specific data on a pure HTML page. The data were to be delivered by a servlet, so the basic idea was something like that:

Newsflash: OmniFaces 2.4 has been Released

Stephan Rauh — Sat, 02 Jul 2016 00:00:00 +0200

OmniFaces 2.4 has been released. This time, the new version concentrates on bug fixing and polishing. There is only a handful of new features, the most notable being , which bring the old of JSF 1.x back to the JSF 2.x world. There are also improvements to the FullAjaxExceptionHandler and better support for logging. As usual, the team has written an exhaustive blog post covering the changes, so I won't repeat their description. Instead, I suggest you follow the links below.

JSF 2.3

Maybe more important is that the OmniFaces team brought a couple of features from OmniFaces to the upcoming JSF 2.3 standard. That's exciting because it puts the commotion about Oracle's presumed withdrawal from JavaEE into perspective. Even if the rumors we to come true and Oracle were to stop their efforts on JavaEE, it wouldn't be the end of the Java world. If need be, there are other developers ready to contribute suggestions, improvements, code and documentation.

Dig deeper

Announcement written by BalusC What´s new in OmniFaces 2.4?

Newsflash: Comma Separated Json

Stephan Rauh — Wed, 22 Jun 2016 00:00:00 +0200

Recently I noticed how cumbersome Json becomes if it's used to describe large quantities of simple data. Have a look at the definition of the Coffee Wheel created by (no pun intended!) Jason Davies. On the one hand, Json is a great and simple format to describe the wheel (see the source code). On the other hand, writing your own coffee wheel description is another story altogether. You have to count curly braces, square brackets, commas, and quotation marks meticulously. It almost drove me nuts. This shows another problem of Json. It's not well suited for stream processing. Json objects are JavaScript objects, so they have to be parsed completely before you can start working. That's one of the few area XML has an edge of Json. Since 2004, XML stream processing is an official part of JavaSE. So I became curious when I stumbled of the CSJ API of Kirit Sælensminde. I didn't try it, so I can't say anything about the quality of the implementation, but at first glance, it looks both well-thought and promising. In many cases, the Json stream object is just as simple as a traditional CSV file you can import by Excel, but it offers much more flexibility. By the way, CSJ wouldn't simplify the coffee wheel description. The coffee wheel is a recursive data structure, so it doesn't benefit from stream processing.

Newsflash: Material Design with Materialize.css

Stephan Rauh — Thu, 02 Jun 2016 00:00:00 +0200

This morning I became aware of a nice CSS library: Materialize.css. In many respects, it reminds me of Bootstrap. Among other things, there's a similar grid system, which is even slightly simpler and more logical than its Bootstrap counterpart. The class names are shorter, there are only three screen sizes, and my first impression it's easier to learn "s, m, l" than "xs, sm, md, lg".

Community support (speculative until confirmed by further research)

What caught my attention was the ambitious translation of the huge showcase. The German translation is pretty good, and my quick survey showed that the Spanish and French translations aren't bad, either. Granted, the major part of the showcase is yet to be translated. But some time ago, I've started to translate the AngularFaces showcase to German. I didn't manage to finish it because I ran out of time. So offering a large part of the Material.css showcase in ten (!) languages is no small feat. To me, that's a good sign: I don't think the four team members speak ten languages, so I render it likely that there's a broad community support for Materialize.css.

Virtually every component you'll ever need

The other thing that caught my eye is the large list of components. At first glance, everything you need to write a business application seems to be there: input fields, combo boxes, radio buttons, and checkboxes, just to name a few. Check boxes come with a nice twist: they optionally have an "indeterminate" style, which looks very intuitive to me. This makes Materialize.css one of the few UI libraries offering a convincing approach to three-state checkboxes. Another nice twist is the labels of input fields, which may optionally be displayed as watermarks until you enter your input. That's one of the things difficult to explain but easy to show, so I recommend you follow this link to have a look yourself.

When Your Framework Gets in Your Way

Stephan Rauh — Sun, 22 May 2016 00:00:00 +0200
These days, my framework of choice got spectacularly in my way. Don't get me wrong: D3.js is a good framework. It was the right tool for the job. But it slowed my progress nonetheless. You know, I wanted to write a particularly fancy presentation. Everybody knows PowerPoint slides by heart, and even a nifty presentation framework like reveal.js has become boring. But there that nice little framework I always wanted to play with. And there's this nice interactive sunburst diagram. What about converting it into an interactive presentation? And while we're at it, why don't you translate the code to TypeScript? This turned out to be a stupid idea. Luckily I'm not in a hurry, so I don't mind, and the result is impressive indeed. But with a tight deadline it had been a disaster. It's not the first time I experienced this. Even the best framework comes at a price.

How different languages pass parameters to functions (Part 1)

Stephan Rauh — Wed, 04 May 2016 00:00:00 +0200
Sometimes things you are familiar with because you deal with them every day turn out to be surprisingly unfamiliar one you start to think thoroughly about them. Chances are that functions and their parameter belong to this category of things. I suspect you are a programmer or a software architect (who else should be attracted to a page like "Beyond Java"?), so I'm pretty sure you pass parameters to functions on a daily basis. This is routine to you, so you don't think much about it. This article wants to show you the wealth of possible parameter passing mechanisms. I split this article into two parts. The first part deals with the semantics, and the second part shows the syntactic sugar some programming languages offer (or fail to offer). Maybe I will add a third part dealing with the implementation of parameter passing mechanisms.

Let's Make JavaScript Development Simple Again!

Stephan Rauh — Sun, 01 May 2016 00:00:00 +0200
Recently, I've grown increasingly uneasy about the current state of JavaScript development. I'm a full-time Java developer who tries to get familiar with JavaScript. Over the years, JavaScript has become a really nifty programming language. There's hardly anything you can't do with JavaScript. It's one of the most exciting areas of development in 2016. Only... each time I start to read a tutorial about JavaScript, I feel stupid. I know I'm not stupid - at least if it comes to programming - so the explanation must be something different. I freely admit I'm lazy. That's a valid explanation why I don't cope with most tutorials.

NewsFlash: Lukas Eder's JAX Talk And Turing Complete SQL

Stephan Rauh — Tue, 26 Apr 2016 00:00:00 +0200
Did you know SQL is Turing complete? Obviously, it's not. It's a purely declarative language. It's designed with a single purpose in mind: dealing with relational databases. Surprisingly, modern SQL is Turing complete, indeed. This stunning claim has been proven by David Fetter. He's also written an example that really blew my hat off. It's possible to write a SELECT statement drawing a Mandelbrot set. As I've mentioned before, SQL is a purely declarative language. So are HTML and XML. But there's no way HTML could be Turing complete, so this insight came as a surprise to me. The key to being Turing complete are the window functions offered by most modern SQL databases. These, in turn, allow for recursion, and that's one of the loopholes allowing a purely declarative language like SQL to sneak into the realm of procedural languages. That's the same trick that makes PROLOG a Turing complete language. I got aware of the phenomenon when I attended the great JAX talk of Lukas Eder. Today, he's published a transcript of his talk, including the slides. Highly recommended!
Dig deeper
10 SQL Tricks That You Didn’t Think Were Possible by Lukas Eder SQL Is Now Turing Complete drawing a Mandelbrot set with PostgreSQL 8.4

TypeScript and ES2016 Decorators vs. Java Annotations

Stephan Rauh — Fri, 22 Apr 2016 00:00:00 +0200
Consider this TypeScript snippet. It's a very simple Angular2 component. It looks almost like a Java class, doesn't it?

AngularBeans: A Fresh New Take on AngularJS and JavaEE

Stephan Rauh — Mon, 18 Apr 2016 00:00:00 +0200
I’m proud to have convinced Bessem Hmidi to present his AngularBeans framework at BeyondJava.net. AngularBeans is a fresh, new approach integrating AngularJS with a JavaEE backend and has stirred some attraction in the JavaEE world recently. Bessem works at "Business & Decision" as a Technical Architect. He is also founder and leader of the "Esprit Tunisian Java user Group" and was a part of the Research & Development program at ESPRIT (Tunisian school of engineering). Bringing over 9 years of working with Java related technologies especially Java EE, he is also a professional course instructor, an educator and an international speaker. Plus, he’s founder of the Tunis conference JUG Day.
Introduction
The Java ecosystem doesn’t lack of web frameworks. There’s a framework for every taste. No matter if you prefer an action based, component driven, request driven… there’s a framework for everyone. But at a closer look on what happened those few last years in web development, we will be driven to accept the evidence: it’s the era of single page applications, of client side rendering and of the real-time web. Users have become much more demanding. They don't put up with a single black-and-white terminal screen any more. They're familiar with highly responsive, interactive user interfaces which are both more fun and more efficient to use. Those needs are the sources of countless modern client side JavaScript frameworks such as Ember.js, react.js, meteor.js and of course AngularJS. They all consider the server a “pure” service provider, only responsible for processing and providing data, as opposed to the classic “dynamic views generator” server. Most – maybe even most – developers consider server-side rendering a thing of the past. From a technical point of view, server-side rendering was inevitable in earlier times, but nowadays browser technology has evolved to a point that allows us to shift both rendering and business logic to the client sid

Microservices - The New Silver Bullet?

Stephan Rauh — Sat, 16 Apr 2016 00:00:00 +0200
Recently microservices are getting popular in the Java world. So I, too, have started to hype microservices as a clever way to manage the complexity of huge applications. The general idea is that our applications have become too complex. Better split them into smaller chunks, small enough to swallow for a small team or even an individual. They have "to be small enough to fit in your head". Actually, this idea is far from being new. When functions, classes, modules, portlets, SOA services and business processes were invented, people used pretty much the same words to advocate the new idea. Microservices add a new twist in that they optionally contain the GUI, and in that every microservice uses it's own database or it's own backend. The application is sliced vertically (as opposed to the horizontal slicing imposed by the MVC model). The result is a small library that can be deployed independently from the other parts of the application. The application consists of a collection of largely independent microservices working together. This means you gain a lot of flexibility. Different parts of the application can be developed at different speeds. You also get the freedom to experiment. Individual microservices can be deployed and undeployed quickly, so you can afford to deploy a microservice features a new concept and see what happens. If it doesn't work out, you simply replace it with the previous version.

How to Use Mockito to Test JSF Components

Stephan Rauh — Wed, 13 Apr 2016 00:00:00 +0200
There are two strategies to write JUnit test for JSF applications. The first strategy uses a tool like Arquillian to start both an application server and a browser that runs a JSF application. Yeray Santana Borges used this strategy to contribute a couple of JUnit tests to BootsFaces. This approach has many advantages. It runs on a real application server, and it runs on a browser that can execute Javascript. In other words, it's a very close approximation of the real world. You can test a lot of things, including behavior and AJAX requests. The big disadvantage is performance. It takes a while to start an application server. That's bad if you want to run hundreds of JUnit tests on every build. Usually projects prefer to define a dedicated Maven profile to run this kind of tests. By default, the tests are skipped by the build. They are run only during a nightly build.

Newsflash: Concurrency Explained with Starbucks

Stephan Rauh — Tue, 12 Apr 2016 00:00:00 +0200
It's hard to get concurrency right! Especially for programmers who try to program it using a low-level language like, say, Java 5. In no time, you'll run into all kinds of problems like deadlocks, race conditions and synchronization, just to name a few. That's why I recommend using a language like Scala if you need to leverage the power of all your CPU's core. Funny thing is that it's surprisingly easy to explain concurrency in simple words. This article maps concurrency to a real-world example. Serving coffee to customers is a good example on how to use multithreading to improve performance. Read the full story at particular.net. This article even explains advanced topics like out-of-order execution and speculative execution. Highly recommended!

Newsflash: Java, UTF-8 Surprises and Character Encodings

Stephan Rauh — Tue, 12 Apr 2016 00:00:00 +0200
Did you know characters don't always fit into chars? Did you know `String::length()` does not always return the number of letters of the `String`? Did you know you can't reliably read a text using a `ByteArrayInputStreamReader`? Did you know many characters have more than one Unicode encoding? The latter you should know, at least if you're concerned about writing a secure web application. Hackers sometimes hide their malicious code by using ambiguous UTF-8 encodings. If the request is interpreted correctly, it simply contains an odd character. But if your application interprets the request as simple ASCII code, it contains executable Javascript code. The "<" sign can be hidden as a modifier to a unicode character, so a (careless?) firewall doesn't recognize it as the start of malicious code. Before leading you to McDowells great "guide to character encoding", I'd like to show a couple of interesting characters to you:

The letter A is encoded in UTF-8 as 0x41. That's simply good old 7-bit ASCII code.

The french letter é (as in écouter) is part of many 8-bit extensions of ASCII. In UTF-8 it's encoded as C3 A9.

However, it also can be constructed as a combination of "e" and the accent "´". That amounts to 0x65CC81 in Unicode. That's the first example of the three byte representation of a character.

Characters can become as complicated as क्तु. That's a 12 byte encoding in UTF-8: E0A495 E0A58D E0A4A4 E0A581. As far as I can tell, that's a base character followed by three modifiers.

The last character doesn't fit into a Java `char`, and `"क्तु".length()` yields 4 - albeit it's considered a single Devenagari letter. There's a lot more information on Java character encoding on McDowells "exhausting, but not exhaustive" article interesting option on his blog. For some reason, he suggests to add an option that's already the standard configuration of Tomcat 8 (at least on my machine), but it might be interesting nonetheless. Thing is, Tomcat scans every Jar file it finds at startup time. This is necessary for frameworks like Servlet 3.0, CDI and JSF, which enable to you add some magic to your application by simply annotating a class. However, many jar files don't contain such an annotation, so it's a waste of time to have them scanned. Adding such a library to Tomcat's skip list gives your application a boost. Especially, if you skip not one, but many library. Read the full story at Gavin Pickin's blog.

A Comprehensive Guide to JSF AJAX

Stephan Rauh — Fri, 01 Apr 2016 00:00:00 +0200
These days I analyzed the AJAX implementation of Mojarra. My goal was to learn enough about it to implement an improved version of the original AJAX implementation in our BootsFaces libraries. Along the way I learned that I had chosen quite a chunk to swallow. The JSF AJAX specification has many, many options, most of which I wasn't even aware of. Time to write an exhaustive guide. Apart from the JSF specification we'll also have a look at it's PrimeFaces counterpart and - of course - what BootsFaces 0.8.0 will bring to you.
Source code of the examples
You can find the source code of the examples on GitHub. There's a second project on GitHub covering the BootsFaces AJAX examples.

Ceylon's Approach To Eliminate NullPointerExceptions

Stephan Rauh — Fri, 25 Mar 2016 00:00:00 +0100
Maybe you've already heard of Ceylon. Ceylon's a language initiated by Gavin King, the creator of both Hibernate and Seam. Putting it in a nutshell, Ceylon is an attempt to create a better version of Java. The Ceylon developer team has released an early preview version (milestone 5). Andrew C. Oliver considered it to be mature enough to have a first look at it (see his article at Infoworld.com). A very nice feature of Ceylon is the approach to `NullPointerExceptions`. This kind of mistake is a real plague of the Java world. Usually they are caused by programmers who forgot to implement the "nasty case". This is why I baptized the `NullPointerException` a `NotImplementedYetException` in disguise in an earlier article. Ceylon solves the problem by adding an option type to the language. In a way, this is similar to Java 8's and Guava's `Optional` class. The optional type can hold a value, or it can be empty. However, it can't be null. The nice thing about Ceylon's option type is it's implemented directly in the core of the language. In general, values can never be `null`. If you need empty values, you define the variable slightly differently. Instead of using the type of the variable, you use the corresponding option type by adding a question mark:

Newsflash: The Wrong Abstraction

Stephan Rauh — Mon, 21 Mar 2016 00:00:00 +0100
I've just read an interesting article of Sandi Metz. I consider it important (and provocative) enough to dedicate a newsflash to Sandi's article. Basically, my article is a commented link. Mind you, how often did you do stupid things during your working hours just because you valued existing to code high? That's a common trap I've often watch catching other people (and myself, of course). Like Sandi says,
Existing code exerts a powerful influence. Its very presence argues that it is both correct and necessary.

The State of Polyglot Programming in 2016: Mission Impossible?

Stephan Rauh — Sat, 19 Mar 2016 00:00:00 +0100
Once upon a time, they used to say every programmer has to learn a new programming language each year, just to stay in shape. When I mention this to Java programmers, they usually start laughing. What used to be true in the 70s, maybe even in the 80s and the early 90s, has become utterly impossible in 2016. Modern programming ecosystems like JavaEE have reached such a level of complexity that it has become challenging to master a single programming language, let alone a second.
Learning the core language is not the problem
Thing is, it doesn't suffice to learn the language. That's easy. Once you've learned an object oriented programming language, you'll quickly be fluent in any other object oriented language. Only shifting to another programming paradigm may give you a hard time. I, for one, have to admit I never managed to wrap my head around PROLOG. It's not difficult, but it's so different from what I'm usually doing. My rich experience which is so useful at other times prevents me from being a successful PROLOG programmer. But the vast majority of modern languages follow the procedural paradigm, spiced with object oriented programming or functional programming (and in same cases, both). So there's not to much a challenge from the language side per se.

Type-safe Navigation in JSF

Stephan Rauh — Sun, 14 Feb 2016 00:00:00 +0100
What to make of this? In general, I eagerly embrace everything offering type safety. However, in this particular case, I'm not entirely convinced. Probably I won't use this feature in my projects any time soon. On the other hands, this stuff has so many options that it may easily pay off in larger projects. Especially, if some of the JSF views of your applications require authorization. I'm talking about the "type-safe navigation" offered by the JSF module of Deltaspike. Basically, that's a Java file describing every JSF page of your application.
Back to the future!
In a way, it's funny that Deltaspike, which aims to improve JavaEE in general and JSF in particular, adds such a feature. One of the key advantages of JSF 2 was to get rid of the navigation rules file of JSF 1.x. Deltaspike brings it back, albeit in a different way.

Junit 5

Stephan Rauh — Fri, 12 Feb 2016 00:00:00 +0100
When I heard about JUnit 5 this morning, I was baffled. How can you improve something that's already perfect?
Java 8 and Lamba expressions
Apparently, you can. Actually, it's fairly easy to improve JUnit 4. The most obvious step is to migrate to Java 8. JUnit 5 fully embraces the new features of Java 8. In particular, now you can use Lambda expressions in assertions. As a consequence, JUnit 5 requires Java 8. It doesn't support the older versions of the Java language. Given the mature status of JUnit 4, this isn't even a bold step. I suppose most conservative developers who insist on using an older version than Java 8 can cope with JUnit 4.

The Art of Efficient Programming in the Agile Ages

Stephan Rauh — Fri, 12 Feb 2016 00:00:00 +0100
Heck, this article is going to make me sound like my own grandfather. Everything was better in the old days! But I'm still convinced this article tells a story, and it seems to be important to me. At least, it's a thought I've been nurturing for years. By the way, this article does not tell you everything was better in the early days of programming. Can you imagine to program without the help of the internet? You have to buy actual books to learn more about programming. Those books were hard to get hold of. Editors didn't have autocompletion. Monitors used to flicker, causing a lot of eye strain and headaches. There wasn't even such a thing as StackOverflow. No, programming was a lot worse in almost every way. I'm happy to have arrived at the agile ages. But still: Did you ever think about what gets lost in agile projects? Simple. Agile projects are about producing software efficiently. But they are not about writing efficient software. Writing efficient software costs time and money, and that's what agile programming tries to avoid.

Running the Atom Editor Behind a Firewall

Stephan Rauh — Mon, 08 Feb 2016 00:00:00 +0100
Granted, this is a minor topic, much less sophisticated than most of my blog's posts. But it took me a couple of hours to find out how to run the Atom editor behind a firewall, so it me be worth a short article. If you're running Atom behind a firewall, you won't be able to install plugins not updates until you configure the proxy settings. Basically, all you have to do is to set two user-defined variables: `http-proxy` and `https-proxy`. However, it's not that obvious where to configure these variables. The easiest way find or create the configuration file is to open the settings dialog ("File" --> "Settings"). On bottom of the left hand side, there's a button called "Open config folder". Clicking it opens a new project (`.atom`). That's the settings folder in your user profile. The root folder should contain a file called `.apmrc`. If it doesn't, create it. Next you add these lines to the file (replacing `username`, `password`, `proxyserver` and the port number with the settings you use in your internet browser):

The Only One Dependency You Need in JavaEE 7?

Stephan Rauh — Fri, 05 Feb 2016 00:00:00 +0100
Adam Bien is a charismatic evangelist of JavaEE 7. He's got something to say, and he always makes me think. But that doesn't mean I always agree with him. In his latest blog post, he propagates to use a simple, single dependency to use JavaEE 7. All you have to use is to install a JavaEE 7 server, add this dependency to you application's `pom.xml`, and you're good to go. You really are. And it's tempting:

CDI: Lazy Injection at Runtime or How to Obtain Every Matching Implementation

Stephan Rauh — Wed, 03 Feb 2016 00:00:00 +0100
These days I've discovered a nice feature of CDI. What do you make of this code?

Nomin - Mapping Java Objects Without the Pain

Stephan Rauh — Sun, 31 Jan 2016 00:00:00 +0100
Many best practices in the Java world involve mapping Java objects to other Java objects. More often than not, this is downright stupid. Both objects are more or less identical, but you have to write a lot of code to map object A to object B. Plus, you have to write the backward mapping, too. It goes without saying that this is a very error-prone task. Not to mention it's boring as hell, making the task even more error-prone. This is why I start to roll my eyes every time someone asks me to map objects. Granted, the underlying design pattern has its virtues. Decoupling the front-end code from the back-end code gives you a lot of flexibility. But do you need this flexibility? Even if you do, is it worth the pain?
Mapping objects automatically
Nomin to the rescue. It's one of those little tools that come in handy. It allows you to write very compact Groovy scripts to map object. Even better, if the attribute names of the objects are identical, Nomin is able to figure out how to map the objects without you help. You don't have to write a script at all. All you have to do is to invoke Nomin and have it map the objects for you:

JSF vs. PrimeFaces vs. BootsFaces Search Expressions

Stephan Rauh — Tue, 19 Jan 2016 00:00:00 +0100
It's a bit inconvenient and error-prone to define an ID for each input field, each label and each message of a JSF view. You can make your life easier using advanced search expressions. Used wisely, advanced search expressions enable you to move input fields on the screen or between JSF views without having to update zillions of ids. In fact, search expressions are possibly the most compelling reason to use PrimeFaces or - since version 0.8.0 - BootsFaces. Their search expression engines go far beyond the JSF standard.
Why are there different search expression engines?
Traditionally, JSF relies heavily on ids. Standard JSF 2.x adds a few generic search expressions that allow you to get rid of the ids in many cases. The PrimeFaces team - and Thomas Andraschko in particular - took the idea to another level. They implemented a variety of new search expressions such as `@next` and `@previous`. Unfortunately, these search expressions can only be used with PrimeFaces widgets. There's an open ticket offering to implement the PrimeFaces search expressions in the Mojarra framework. Last time I looked the ticket was still dormant, laid aside due to performance considerations.

Single-Page Applications With BootsFaces

Stephan Rauh — Sat, 16 Jan 2016 00:00:00 +0100
Singe-page applications have become tremendously popular in the last couple of years. They are fast, they are responsive and they can save network bandwidth. The first SPAs that caught the attention of the community were based on JavaScript. So nowadays everybody seems to believe you can't write an SPA with JSF. But you can. It's not even difficult. And it pays: the application becomes much more responsive. This article shows two approaches how to do it with BootsFaces. I'm sure you can do the same with other JSF frameworks like PrimeFaces, too, but I didn't test it yet. Currently, there are at least two approaches. You can exploit BootsFaces AJAX to do your navigation, or you can add AngularJS to the equation. The latter approach requires you to learn both Angular and JSF, but it may be useful because it allows you to use client-side AngularJS components.

About Owls, Nightingales and Clean Code

Stephan Rauh — Sat, 09 Jan 2016 00:00:00 +0100
Sigh! Today I've been wading knee-deep through all-to-clean code. Code that might have been written in a textbook. Code following the style - yeah, once I was young and naive enough to believe the textbooks without asking - I taught at university. Code that follows all the best practices. Code following the rules of the Clean Code Initiative. Code that's illegible. Illegible? Yeah, illegible. I love clean code - but believe it or not, code that's all too clean is every bit as illegible as spaghetti code.

Getting Started With AngularJS 2.0: Forms (Part I)

Stephan Rauh — Tue, 24 Nov 2015 00:00:00 +0100
Let's continue our journey into the universe of Angular2 with exploring forms. Actually, that's something odd: many articles and tutorials on Angular2 spend a lot of time explaining that the old two-way-binding of AngularJS 1.x has been replaced by something different, something superior.
Putting it in a nutshell
Forget about that. You can learn about the subtleties of Angular2 later. From a beginners view of point, good old two-way-binding is still there. It even has become more simple. Putting it in a nutshell, you simply use the new, slightly controversial syntax Newsflash: How to Develop Efficiently In TypeScript Stephan Rauh — Wed, 18 Nov 2015 00:00:00 +0100 In one or two of my recent posts, I claimed that the TypeScript compiler is extremely fast, and that that Google Chrome caches your TypeScript code to aggressively. Both things have changed since then. The bad news is that the editor I use, Atom, has started to compile the entire project each and every time I edit a file. I don't know whether this is a configuration error of mine, or if it's a bug of Atom, or even a peculiarity of the current version of TypeScript. I'm positive the error is on my side, but as long as I haven't found the reason I reluctantly have to revoke my claim that TypeScript compiles in virtually no time. Now for the good news. The Angular2 team recommends to use "live-server", and it works just great. Install it via Newsflash: Angular2 Release Date Projection Stephan Rauh — Tue, 17 Nov 2015 00:00:00 +0100 Nobody knows when Angular2 is going to be released. Chances are this includes the Angular team (although they don't tell us). So people start to try to look into the crystal ball. One thing is that the API feels mature. Granted, it still happens to break more often than is to my liking, but the basic design decisions seem to have been done. Another indicator for the progress is the documentation site. The developer guide is still incomplete, but it's growing by the day. Another indicator is the progress on the open tickets. Currently, each day 2.2% of the open tickets are solved. Judging by this measure, the release date of Angular2 isn't far away. Actually, the Angular 2 Beta Burndown Chart indicated Angular2 is going to be released in 2015. Personally, I think that's nonsense - there's more to releasing software than just closing tickets on the bug tracker - but it's a good idea. Plus, it's fun, and it looks great. There's only one thing that's odd: the burndown chart isn't an Angular application. Let alone an Angular2 application. :) Update Nov 9, 2015: My article and my tweet about it started a funny discussion, which lead to an full-blown Angular2 implementation of the Angular2 Release Date Projection tool. Sometimes it's fun to be a catalyst :). Update Nov 17, 2015: In the meantime, the release projection has been migrated to Angular2. It's really fun to be a catalyst! Newsflash: How to Migrate an AngularJS 1.x Application to Angular 2 Stephan Rauh — Thu, 12 Nov 2015 00:00:00 +0100 Do you remember how disturbing the initial announcement of Angular2 was? As far as I remember, it was at ngEurope, roughly 12 months ago. At the time, the Angular team said there wasn't a migration plan. I guess they should have added the word "yet". Most developers and project managers understood there wouldn't be a migration plan at all. Many of them saw the future of their AngularJS projects in tatters. Well, that was premature. It's far from being impossible to migrate from AngularJS 1.x to Angular2. Quite the contrary, there's even a project dedicated to make the migration as smooth and easy as possible. Or, as Pascal Precht and Misko Hevery put it, boring. Today I've stumbled upon an in-depth analysis of how to use the project, which is called - guess what - ngUpgrade. Read the full story written by Pascal Precht. It's a great read, and I'm sure it'll be useful to many Angular 1.x project teams. Highly recommended! By the way, that's not the only great news for those of us working for major companies: According to Brian Green's announcement at the AngularConnect 2015 conference in London, Angular2 is going to support Internet Explorer 9 and 10 (at 53'40''). Angular 2.0: Courageous Plans Stephan Rauh — Tue, 10 Nov 2015 00:00:00 +0100 Angular 2.0: "Designed for the future" This morning the AngularJS team published their plans on AngularJS 2.0. Among lots of minor and major improvements there are two courageous ideas: AngularJS 2.0 is written in a new language developed for AngularJS, AtScript, which is sort of a superset of ECMAScript 6 and TypeScript. Plus, they are dropping support for older browsers. The only browsers to be supported are evergreen browsers, i.e. browsers that update themselves automatically. This might be a dangerous decision: many companies are very reluctant to update their browsers. Update Nov 02,2014: AngularJS 2.0 at ngEurope Since I wrote the original version of this article, the AngularJS team revealed more informations about the coming Angular and AtScript. See What is AngularJS 2.0 going to look like? and sneak preview on data binding (and both article contain links to the AngularJS design documents). The plans raised a controversial debate among AngularJS programmers. The nice thing is the AngularJS team listens to the feedback and is looking for a better approach. No support for IE 10 and below Update Nov 10, 2015: According to Jaxenter, Brad Green announced support for IE 9 and 10 on the AngularConnect 2015 conference. I don't want to delete or rewrite the paragraph below, but keep in mind it's partially outdated. Angular 2.0 requires at least Internet Explorer 11 (see above: now it's IE9). However, the older browsers haven't extinguished yet. According to gs.statcounter.com, IE8-10 are down to roughly 14% market share this month. In many situations that's a neglectable Newsflash: Angular 2 Survey Results Stephan Rauh — Wed, 04 Nov 2015 00:00:00 +0100 Granted, I can hardly call the news of this newsflash "new": it has been published Sept 01, 2015. But it's very interesting nonetheless. The AngularJS team's blog has the results of a survey asking developers what they expect of Angular 2. Each survey result is spiced with an in-depth analysis, many of which provide additional information about Angular 2. Highly recommended. Read the survey results at http://angularjs.blogspot.de/2015/09/angular-2-survey-results.html. Getting Started with TypeScript Stephan Rauh — Tue, 03 Nov 2015 00:00:00 +0100 The other day I showed a TypeScript program to our architect. He doesn't like JavaScript, but when he saw my TypeScript program, he was pleasantly surprised. TypeScript looks pretty familiar to Java programmers, making it a good language to get started with client-side programming. Plus, the core feature of TypeScript is types, making development much more fun. I know fans of dynamic types disagree, but wait until you've seen the autocompletion and refactoring features of your editor before you judge. Be that as it may: TypeScript comes with powerful type inference, too, so most of the time you can use it as a dynamically typed language and still benefit from types. If you're still sceptical: hard-core JavaScript may be relieved to learn types are optional. After a couple of works I'd say that TypeScript is the language of choice for me. In earlier times, I've propagated Dart, which is an even nicer choice as a language. Unfortunately, Dart suffered from needing a virtual machine of its own, and the lacking interoperability with existing JavaScript code. So, it didn't make a bit impact on the market yet, so I prefer a language that compiles natively to JavaScript. So, I've decided to write a tiny tutorial on TypeScript. It's not an exhaustive step-by-step tutorial. I can't beat the official TypeScript manual, so I won't even try. Instead, I'll give you a short tour-de-force from a Java programmers perspective. How to Count Java Objects in Memory Stephan Rauh — Tue, 27 Oct 2015 00:00:00 +0100 There are all these wonderful tools for profiling Java programs. JVisualVM, JProfiler, Mission Control and the Flight recorder, jhat, just to name a few. Yet every once in a while, you can't use any of them, for one reason or another. Where do we go from here? How come there's no profiler? The situation is not quite as exotic as you may think. When I was asked recently to write programs in the middleware layer, the lack of tools was the one of the reasons why I denied. More precisely, I was asked to write Java programs running in the webMethods ESB. In theory, that's a great idea, but the lack of tools makes programming a pain. No debugger. No profiler. In theory, you can debug such a program using remote debugging, but that requires many preconditions to be fulfilled. The administrator has to start the program with additional parameters, and they have to open the ports in the firewall. Sometimes that's possible in the development and test stages, but usually it's completely out of question in the production stage. However, being a consultant, sometimes I'm asked to help our customer nonetheless. Model-View-Why-Bother? Stephan Rauh — Thu, 22 Oct 2015 00:00:00 +0200 My previous article focused on what the MV* paradigms are. But it didn't answer the question whether using one of the MV* patterns is worth the pain. One thing is for sure: none of the MV* paradigms comes for free. It depends on your project whether using an MV* patterns is a wise investment or a waste of time and money. Dissecting a chess application For instance, consider my AngularJS 2.0 chess program (see the source code at GitHub or play it at (broken link)). It doesn't follow any particular architectural pattern. Or rather, it doesn't follow one of the established MVW patterns. To begin with, there's no model. I simply didn't need it. The program's data are stored in the controller component of the program. I don't know all the subtleties of the MV* theory, but I guess it's OK to say the chess demo stores its data in the viewmodel layer. Actually, the chess demo doesn't consist of many layers. There's the HTML code, there's the chess engine and there's some glue code. My previous post (and the majority of tutorials) claims that AngularJS favors the MVVM pattern. Let's stick to this fiction for a moment. It's easy to identify the view layer: that's the HMTL pages and the CSS stylesheets. The glue code is the viewmodel. I already said that there's no need for a model layer. Newflash: Are Java 8 Lambdas Closures? Stephan Rauh — Sun, 18 Oct 2015 00:00:00 +0200 Bruce Eckel has published some interesting thoughts about closures and lambda expressions in Java 8. He claims that Java's lambdas are essentially closures because the original definition of closures stems from functional programming languages, and pure functional languages don't know variables. Hence, Java's restriction that lambdas can only access effectively final variables of the surrounding scope is not a real restriction, he claims. Plus, it can be circumvented by encapsulating the interesting variable in an object. Basically, that's the same trick Java programmers use to implement call-by-reference parameters. I can't say I really agree with Bruce Eckel. In my eyes closures are a lot more useful than lambda expressions because they can access variables of the surrounding scope, while lambda can only access constant values of the outer scope. But it's an interesting article nonetheless. Read the full story on Bruce Eckel's blog. Newsflash: Running Example of Spring Boot + JSF Stephan Rauh — Tue, 29 Sep 2015 00:00:00 +0200 Some time ago, I wrote about the challenges of getting JSF in a Spring Boot container up and running. The problem is that Spring Boot is officially not supported by the Mojarra team, which means it's up to the Spring Boot team to ensure compatibility. The Spring Boot ticket Phil Webb opened in response to my article is still open, but he pointed me to an interesting article. Alex Bath of Oakdale Software managed to run a JSF application on Apache MyFaces 2.2.6. However, I suspect that compatibility between JSF and Spring will deteriorate more and more in the (possibly near) future. If I'm not mistaken, JSF is going to be tightly integrated with CDI, so many interesting features simply won't work without CDI. On the long run, this may render JSF useless without CDI. That said, I'd like you to point to the GitHub repository of the project of Alex and invite you to read the full story. Has OO Done More Harm Than Good? Stephan Rauh — Mon, 21 Sep 2015 00:00:00 +0200 Ten years ago, this question would have been heresy. Even today, it's perfect to start a lively discussion, as Eberhard Wolff did today on Twitter. Object oriented programming still has a lot of defenders (including me), but recently the critics are gathering, too (also including me). So what is it that makes people skeptical about object oriented programming? What About TypeScript? A Java Programmers Perspective Stephan Rauh — Thu, 10 Sep 2015 00:00:00 +0200 Introduction Is it a déjà-vu, or did I accidentally enter a time machine this morning? A couple of minutes ago I saw a video introducing two brand new features: Intellisense (aka auto-completion) and refactoring. It wasn't even a particularly fancy refactoring – just “rename variable". And it felt just great! Believe it or not, even in 2014 there's still a wide range of popular programming languages that simply aren't suited for auto-completion, let alone complex refactorings. Groovy is one of the languages, but it's not a big problem, because the Groovy community is small. But one of them isn't merely popular, it's ubiquitous, so ubiquitous that the lack of refactoring and (good) auto-completion is a real pain: Javascript. So today I'm going to introduce you to TypeScript, a language trying to address some of the issue of current Javascript while trying to keep the spirit of the language alive. By the way, part of the déjà-vu impression was to observe which IDE was used to present the all-new Intellisense feature: Visual Studio. Back in 1996 I sort of fell in love with Visual Studio because of it's famous Intellisense! However, times have changed a lot. In 2014 TypeScript programmers aren't restricted to a Microsoft product. There seems to be decent support by JetBrains WebStorm / IntelliJ IDEA and by Eclipse, just to name a few. A little disclaimer At this point I should mention I don't have any hands-on experience with TypeScript. This article is merely a compilation of several blogs, articles, forum discussions and the TypeScript project page itself. So if I happen to get something wrong, please help me to improve this article by dropping me a short comment. What's it all about? TypeScript was conceived at Microsoft, in a .NET centric environment. .NET programmers are used to languages designed to support large applications. Javascript, in contrast, hat originally been desig First Alpha Version of Bootstrap 4 Released - What's New? Stephan Rauh — Mon, 31 Aug 2015 00:00:00 +0200 On August 19, the Bootstrap Team has released the first alpha version of the fourth major release of their widely adopted front-end framework. Roughly two weeks later, August 31, they published their second alpha version. State of the art Please take this article with a grain of salt: the release post lists many highlights, many changes this version is going to bring out, but currently we are still talking of the first alpha version, so some things might change until we reach the final release. Newsflash: Angular 1.x and 2.0 Integration Allows Seamless Upgrade Stephan Rauh — Tue, 25 Aug 2015 00:00:00 +0200 A lot has been complained about the hard cut between AngularJS 1.x and AngularJS 2.0. In the early days of AngularJS 2, the Angular team announced to have started a complete rewrite of AngularJS, without trying to remain compatible. The reaction of the community was harsh: many developers turned away from Angular. Maybe this has been to early. Today, the Angular team announced to plan a surprisingly tight integration between the two versions. According to their blog, you can mix Angular1 and Angular 2 in the same application write views displaying Angular 1 and Angular 2 components simultaneously inject services between the two branches of the framework and they say even databinding works across Angular 1 and Angular 2. Read the full story at the Angular blog. Enjoy! The Rise of TypeScript? Stephan Rauh — Tue, 25 Aug 2015 00:00:00 +0200 I've made up my mind to start a series of AngularJS 2 articles. As you may or may not know, AngularJS 2 is not being developed in JavaScript, but in TypeScript, a language compiling to JavaScript. While it's perfectly possible to write an AngularJS 2 application in pure JavaScript, it's made for TypeScript (and maybe Dart). My bet is that TypeScript is the language of choice if you're serious about AngularJS 2. So, starting a series of Angular 2 articles inevitably includes a number of articles about TypeScript. BeyondJava.net already published such an article some time ago, but that was before the release of TypeScript 1.5, so it's time to deliver an update. During my research I stumbled upon an interesting article: The rise of TypeScript?". I wasn't even aware that TypeScript is on the rise, but since I've read the article I guess the author can safely omit the question mark. He gives a number of good reasons why TypeScript has an opportunity to lift off. Let me pick out one interesting aspect of the article: the time is right for a language compiling to JavaScript. How is that possible? Comparing JavaScript to ECMAScript 6 Stephan Rauh — Mon, 24 Aug 2015 00:00:00 +0200 Not long ago, the specification ECMAScript 6 - the successor of (guess what) ECMAScript 5, more commonly know as current JavaScript - has been finalized. Already browser developers are busily implementing ECMAScript 6 features into their browsers. So it's interesting to compare the two versions of the language. As to my impression, ES6 is much more concise, legible and accessible to developers coming from classical object oriented languages. Ralf Engelschall compiled a nice comparison of typical snippets of the two languages. There's also a comprehensive compatibility matrix. It's interesting that at the time of writing even the best transpilers don't exceed 59% (Traceur) or 71% (Babel+core.js) compatibility (according to the compatibility matrix). On the other hand, the most popular desktop browsers - which are targeted at the mass market and can't afford to implement features speculatively, only to remove them later - support ES6 already remarkably well, most of them exceeding the 50% mark. Selenium Dreams Stephan Rauh — Sun, 16 Aug 2015 00:00:00 +0200 Last week I've blogged about Cucumber and Selenium. In the meantime, my enthusiasm has cooled down considerably. I ran into a host of problems. Browsers simply aren't intended to be controlled remotely. Quite the contrary. A remote control for your browser is a hacker's dream. As a consequence, browsers tend to resist the remote control. However, Cucumber and Selenium are still the best tools I know, so I continued to work with them, and by the look of it, they will continue to work with them next week. Newsflash: Compiling Java to Javascript Stephan Rauh — Sun, 12 Jul 2015 00:00:00 +0200 These days I stumbled upon Dukescript, which is a very innovative and ambitious approach to bring Java to various client platforms: traditional desktop applications, iOs devices, Android devices and the browser. Two of these target platforms - the desktop and Android - run Java natively (at least after installing a JRE in the case of desktops). Running Java on iOS is a brain-twister, but RoboVM takes the scare out of it, I'm told. Which leaves the browser, and that piqued my curiosity: Dukescript uses Bck2Brwsr to compile Java to Javascript. How to Detect a Page Reload in JSF Stephan Rauh — Fri, 10 Jul 2015 00:00:00 +0200 One of our customers wants to reload everything from scratch when they hit the F5 key. Many web applications work like that, so customers have learned over the years that a page reload gives you fresh data. Usually that works because the web application doesn't cache data in the session or view scope. Unfortunately, some of our database queries take a long time, so we need caching. Reloading everything from scratch during each request is not an option. So we need to detect the F5 key. Plus the browser's reload button, plus the reload command of the browser's context menu. At first, I didn't think it wasn't possible to accomplish this. At least not in a generic way. You know, the F5 button simply causes a GET request. The challenging part is to find out that the user has not clicked a button before. After some investigation on the web, I came up with a clumsy solution. When I implemented it, I realized that there's also a simple solution. The only problem is, I don't know yet why it works (which makes me skeptical). Eclipse Code Recommenders Stephan Rauh — Sun, 05 Jul 2015 00:00:00 +0200 Roughly a year ago, I attended a talk held by a very charismatic Marcel Bruch. Why, he asked, don't we use the collective brains of the Java developer community? The Eclipse plugin written by his team does just that: Eclipse Code Recommenders observes what developers are doing to provide better code completions. Eclipse autocompletion drives me crazy! The idea is simple. Sooner or later, probably every developer gets nuts because Eclipse autocompletion suggests the same odd completions over and over again. For instance, some AWT classes are frequently at the top of the list. When I joined the Java world - that's a long time ago, when Java 1.2 was new - AWT has already been legacy, having been superseded by Swing. So why does it appear in the list at all? Let alone at the top? AngularFaces 2.1.7 published Stephan Rauh — Sun, 28 Jun 2015 00:00:00 +0200 I made it a habit to publish a new version of AngularFaces every couple of weeks. Today I've published AngularFaces 2.1.7 on Maven Central. It should also arrive on JCenter within the next few days. The new version brings a couple of features that make it more apt for big applications. AngularFaces in the wild This week I spent a couple of days at a customer's project, which happens to use AngularFaces. It's a big project - several hundred JSF views, if I'm not mistaken, so it was really exciting to see how AngularFaces works in such a scenario. The good news is: it works just great. JSF applications become much more responsive with a little help from AngularFaces and Bootstrap. As things go, the sheer size of the application brought a couple of shortcomings of AngularFaces to the light of the day. AngularFaces 2.1.7 addresses an important part of that. I decided not to wait until I solved every point of my backlog, but to publish the version early. The improvements of the current version are clearly worth it. Download coordinates Vagrant Makes Installing MediaWiki Simple and Painless Stephan Rauh — Fri, 12 Jun 2015 00:00:00 +0200 One of our customers wants me to document our application in MediaWiki. I'm not too big into working remotely, especially not when I'm working with a tool that's new to me. So I thought by myself, it would be nice to install MediaWiki on my desktop PC. But... the installation manual is such a big book! Easier said than done. You need an Apache, you need PHP with a couple of plugins, you need a database and I've read something about installing Ruby. I didn't want to install all this stuff on my computer just to run a short-lived experiment. Vagrant to the rescue. Last week I reported about a couple of tools that are popular in the Continuous Delivery community. The main goal of these tools is to automate the installation process of complex software. Now if someone already had taken the trouble to prepare a vagrant box... Bingo! A quick internet search revealed a vagrant box, and guess what? I found it on the MediaWiki homepage. Clearly a good sign. Vagrant up! I already had installed a virtual machine - VirtualBox - and Vagrant on my machine. So all I had to do was to clone a GitHub repository, run a setup.bat file and start MediaWiki by typing "Vagrant up" on the command line. The first start takes a lot of time (maybe half an hour if you're on a fast network), but it runs unattended. When I returned from my jogging trail, MediaWiki was up and running. Risk-free installation The nice thing about it is, that all the gory details of the installation are sandboxed in a single directory on your hard disk. Newsflash: Will Java 9 Break Your Code? Stephan Rauh — Sun, 31 May 2015 00:00:00 +0200 Developers should plan some extra time to migrate to Java 9. According to Nicolai Parlog, the new module system of Project Jigsaw will hide many internal APIs that have been visible for years. While this is a good thing on the long run, it may break existing code. Another possible source of incompatibilities are modified URLs to access resources within class files. Read the fully story at Nicolai Parlog's article. Sparkling Services Stephan Rauh — Thu, 28 May 2015 00:00:00 +0200 WebServices and REST services have come a long way in Java. Nowadays, it's very easy to create a webservice. Basically, it's adding an annotation to a method. All you need is a servlet container, such as Tomcat. But then, configuring and running a servlet container isn't really simple. Chances are you think it's simple, but that's because most Java programmers have been using application servers for years. They already carry everything they need in their toolbox. But from a newbie's point of view, things look a little different. Spark is a nice alternative making it really easy to write a REST service: Non-Object-Oriented Java Stephan Rauh — Tue, 26 May 2015 00:00:00 +0200 Hardly ever have I seen code reuse in business-related code. That's a puzzling observation, given that Java programmers are expected to write object-oriented programs for many reasons, code reuse being an important reason. My puzzlement even grew when I started to analyze my former company's SAP programs. They aren't object oriented. Quite the contrary, the coding conventions discourage using ABAP objects. Does this make the ABAP code any worse? I don't think so. The average ABAP program is focused on business code. Plus, ABAP programmers usually prefer customizing over programming. SAP delivers a framework covering most of the technical issues, so there's no point in creating your own class hierarchy of business classes. It's better to take the data structures and objects SAP gives you and to customize them. More often than not, the result violates requirements concerning cognitive ergonomics, usability and performance, but that's not today's topic. SAP's ABAP framework allows for efficient programming, and it's perfectly possible to write huge programs without resorting to object orientation. Dropping OO is even a sensible choice. OmniFaces CombinedResourceHandler Gives Your Application a Boost Stephan Rauh — Sat, 16 May 2015 00:00:00 +0200 OmniFaces 2.1 is soon to be released. Time to present a useful OmniFaces component which has been improved in version 2.1: the CombinedResourceHandler. How does the CombinedResourceHandler boost your application? These days, the average web page has a size of 800 kilobytes, and figures are still rising. Unfortunately, such a web page isn't a single file, but a collection of HTML files, CSS files, Javascript files and images. Thing is, the browser can't display anything until every necessary resource file has been loaded. Adding insult to injury, the files aren't loaded simultaneously, but sequentially. Most modern browsers load up to eight files in parallel. If your web page consists of nine or more files, page load times increase significantly. Modern JSF pages tend to consist of much more than 9 files. Typically 30 resource files are loaded. I've also seen a Liferay application loading 130 files on each request, give or take a few. Granted, most resource files are cached by the browser, but even so that's a lot of network traffic. Remember, these 130 files are requested in chunks of eight files at a time, so that's 17 turnaround cycles. How Static or Dynamic Typing Affects Your Coding Style Stephan Rauh — Sat, 09 May 2015 00:00:00 +0200 Erik Osheim has written an excellent article comparing dynamic and static typing. More precisely, he compares Python to Scala. What makes his article interesting, is that he focuses on the consequences of the type systems. The article you're currently reading is a (not so) short summary of Eriks article, plus a few thoughts of mine. Should You Avoid or Embrace "Static"? Stephan Rauh — Thu, 30 Apr 2015 00:00:00 +0200 More often than not, the keyword static confuses Java programmers. As a consequence, Ken Fogel asks his students never to use static in Java unless explicitely told to do so. While that's a good hint for starters, it's only part of the story. Funny thing is, I recommend to use static as often as possible. There's a twist: Never use static variables, but always use static methods. Creating Annotations is Fun! Too Much Fun? Stephan Rauh — Mon, 27 Apr 2015 00:00:00 +0200 Once again Lukas Eder has written an article I mostly agree with - but not completely. Lukas claims Annotations have become an antipattern. The nice thing about annotations is you can define your own annotation. It's easy, and it's extraordinary popular among framework designers. So we see annotations in the bean validation API, in JPA, in CDI, in JSF, in EJBs, WebServices and Rest and much more. Annotations - a programming language of their own While I absolutely love these annotations, there's a problem: they are starting to become a programming language of their own. What do you think about something like this? Newsflash: Java to Scala Converter Stephan Rauh — Wed, 22 Apr 2015 00:00:00 +0200 JavaToScala.com may help you to learn Scala. It takes an arbitrary Java class and converts it to Scala. Naturally, this approach emphasizes the similarities between the two languages. The few examples I tried were converted into solid Scala classes, but nothing out of the ordinary. The converter won't introduce a case class or a trait if it seems fit. However, emphasizing the similarities is not a bad thing: many Java programmers are scared away from Scala after seeing advanced code. The core of the converter is another project available on GitHub: Scalagen is a Maven plugin converting Java source code to Scala. The project home page states that the converter isn't perfect, but may introduce errors for certain Java constructs, so I take it the same applies for JavaToScala.com. But still, it's an interesting way to get familiar with Scala. AngularJS: What About Adding ng-type? Stephan Rauh — Fri, 17 Apr 2015 00:00:00 +0200 I found an interesting search keyword in the visitor statistics: ng-type. Looking at the AngularJS doc, you'll never find ng-type. Every input field they show uses the plain old HTML attribute type. Introducing ng-type adds the option to change an input field's data type dynamically. Why hasn't ng-type been added to Angular? BootsFaces 0.6.6, Easter Edition Stephan Rauh — Sat, 04 Apr 2015 00:00:00 +0200 Stop looking for our Easter egg: you've found it. The BootsFaces team celebrate Easter with a new version of their responsive JSF framework. By now, BootsFaces is available on Maven Central, and in a couple of days it'll arrive on the jCenter repository. Basically, BootsFaces 0.6.6 is a bug fix release. There are also a number of minor improvements, such as adding the style attribute to a number of components that ignored in in the previous version. How to Embed a Servlet or an HTML Page in a JSF 2.x View Stephan Rauh — Thu, 02 Apr 2015 00:00:00 +0200 As trivial as the task may sound, hardly anybody seems to embed a servlet or an HTML page in a JSF view. That's the impression my team and I got after a lengthy Google investigation. Finally we found OmniFaces, better known as the Swiss Army Knife of JSF. OmniFaces is one of those JSF libraries that are different: It's not about visual widgets (not in the first place, at least), but it's full of other useful stuff. There's the FullAjaxExceptionHandler BeyondJava.net reported about in an earlier article. There are several useful converters that make using comboboxes (or SelectOneMenus in JSF speak) much simpler. There's the useful CombinedResourceHandler I'm going to cover soon. And there's the component of the day: . AngularFaces 2.1.4 published Stephan Rauh — Wed, 25 Mar 2015 00:00:00 +0100 Today I've published AngularFaces 2.1.4 on MavenCentral. It should also arrive on JCenter within the next few days. The new version fixes a couple of annoying bugs, so I recommend to update soon. New, improved documentation There's also news from the documentation page of AngularFaces. Currently, it's moving from www.angularFaces.com to https://www.angularFaces.net. The new documentation page is an AngularFaces application featuring BootsFaces 0.6.5, PrimeFaces 5.1 and Omnifaces 2.1. Among other things, running on a web server makes it possible to show interactive live demos instead of static screenshots. Getting Started with BootsFaces: Responsive Design Stephan Rauh — Wed, 11 Mar 2015 00:00:00 +0100 BootsFaces is a JSF framework adding Bootstrap to JSF pages. One of the more attractive traits of Bootstrap is its built-in responsive design. Probably you already know the idea: screen elements are resized to fit on smaller screens. If everything else fails, Bootstrap starts to stack screen elements over each other if they can't be displayed side-by-side. Usually, that doesn't look as good as the original design aimed at larger screen estates, but the bottom line is that the application can be used even on small phones. Maybe you have to scroll a lot on a small device, but that's a small price to pay. Without Bootstrap you'd have to scroll both horizontally and vertically, which is clearly worse. Let's write a simple BootsFaces application showing how easy it is to add responsive design to JSF applications. I've prepared a repository on GitHub, so you can check out the source codes used in this article. Today's project is the subfolder ResponsiveDesign of this repository. AngularFaces 2.1 Blurs the Difference Between JSF and HTML Stephan Rauh — Sat, 07 Mar 2015 00:00:00 +0100 I always considered JSF to be to verbose, to ceremoniously. AngularFaces allows you to write JSF pages that almost look like HTML pages. What it looks like JSF 2.2 introduced the new HTML5 style of writing JSF pages. Basically, that's ordinary HTML decorated by a few JSF attributes. AngularFaces picks up this idea and takes it to another level. For example, look at this snippet from my Tetris demo that demonstrates both BootsFaces and AngularFaces 2.1 at the same time: Newsflash: Google to Support AngularJS 1.x Longer, Dropping AtScript Stephan Rauh — Fri, 06 Mar 2015 00:00:00 +0100 According to Jaxenter, the AngularJS team reacted to the harsh reaction of the Javascript community on Google's AngularJS 2.0 plans. As a consequence, they decided to support AngularJS 1.x longer, giving companies who've already invested in AngularJS applications more time to migrate to AngularJS 2.0. Plus, they decided to drop AtScript. Instead, the team decided to merge AtScript with Microsoft's TypeScript. That's a pity because AtScript seemed to be an interesting language, but at the same time it's good news since alternative browser languages start to cannibalize each other's market share. Read the full story at Jaxenter. By the way, the original AngularJS 2.0 plans BeyondJava.net reported about have changed considerably in the meantime. The AngularJS team listened to the feedback of the community and adapted their former, much more radical ideas in order to align better with existing editors, existing tools and older browsers. Read the current state of the discussion at the AngularJS design documents folder. Newsflash: Hope for Groovy Stephan Rauh — Tue, 03 Mar 2015 00:00:00 +0100 Pivotal's recent announcement to drop both Groovy and Grails shook the Groovy community. The entire Java community, actually. Can we afford to invest in an open source project run by a company? Companies are sold and bought all the time, and the new owner may drop the previous owner's pet projects without warning. That's the story of Groovy and Grails. I can't help but wonder what that means to other projects. What if management decides to cut costs by releasing a project to freedom? You get the point: this move cost a lot of trust in frameworks run by a company. Any company, actually. Among other things, the affair shows that open source isn't a free lunch. Why don't you support a project you're fond of? It's easy: tweet about it, or report a bug. You may even complain about the lousy documentation. That's not a big deal, but it helps the developers a lot. They learn their documentation is read, and start to improve it. At least in the case of Groovy, there's hope. Guillaume Laforge, the public face of Groovy, has found a new job at a company that uses Groovy for their products. He won't be able to work on Groovy full-time, but still, Guillaumes statement on reddit sounds encouraging: Of course Groovy lives on! And I'll still be wearing my Groovy hat on, even if only part time during my day job at Restlet. The project will indeed continue to be developed, with new features, performance improvements, more Java 8 related features, etc. We're also going to announce in the coming days that the project is joining a foundation, to make the project more resilient! That's the second good news, provided it comes true. The Groovy project isn't going to be homeless, but will be run by a foundation, which hopefully gives it an opportunity to flourish as lively as it did in the past. Dig deeper AngularFaces 2.1 is more than a bug fix release. It contains a couple of features I deliberately postponed in order to get a thoroughly tested version 2.0 out in times. The list below counts no less than 15 improvements. One of the improvements has nothing to the with code: I put AngularFaces 2.1 under an Apache V2 licence, which is much more liberal than the GPL licence of the previous version. The Double Curly Braces Idiom - a Poisoned Gift Stephan Rauh — Thu, 29 Jan 2015 00:00:00 +0100 Lukas Eder has an interesting story: The popular double braces idiom is a poisoned gift. It causes memory leaks. Let me start with a quick note on my article. Originally, I simply wanted to provide a link to the article written by Lukas. However, there are several points I disagree with him. You need some background to understand my contradictions, so I ended up with an article that covers almost the same story as the original article. That said, I recommend to read The Double Curly Braces Anti Pattern as well as reading my article. There's a lot of shared content, but there are also differences. Is Java 8 a Functional Programming Language? Stephan Rauh — Thu, 29 Jan 2015 00:00:00 +0100 A surprising observation I'm pretty excited about Java 8 most important feature: lambda expressions. I can think of so many ways to utilize them I can hardly wait until I can use Java 8 in vocational life. Lambdas stem from the world of functional programming languages, so obviously Java 8 is a functional programming language. It's in the same league as languages like LISP, Clojure and Scala. But wait - is this true? Some ten months ago I used Java 8 to write a Mandelbrot set plotter. No matter how hard I tried, the program wouldn't become functional. It was just a good old procedural program using a couple of lambda expressions. It can't be the algorithms fault: Mandelbrot sets are all about functions. So what is it that stops Java 8 from being a functional language? Effectively final: closing over values instead of variables Project Lambda's decision to dismiss full-blown closures has been criticized a lot. To avoid confusion and disappointment the team members call their closures lambda expressions. Most people expect closures to be able to modify variables defined outside the closure. A closures variable scope "closes over" AngularFaces 2.1: Apache License V2, AngularJS 1.3 and much more Stephan Rauh — Wed, 21 Jan 2015 00:00:00 +0100 Yesterday, I've published what I hope to be the last release candidate of AngularFaces on Maven Central. Basically, AngularFaces 2.1 RC5 already is the final version. I only called it a release candidate I did a few last-minute changes. I felt the need to run more tests. AngularFaces 2.1 offers many new features. Today, I'll present four of them: the new license, AngularJS 1.3, first-class divs and the new AJAX support contributed by Marco Rinck. A Child's Garden of Cache Effects Stephan Rauh — Sat, 17 Jan 2015 00:00:00 +0100 One of these days Joshua Bloch twittered a link pointing to "a child's garden of cache effects". Igor Ostrovsky demonstrates the effect of CPU caches using a high-level programming language, such as C#. Highly recommended! When I read his article, I wondered if we can demonstrate the same effects in Java. At first glance, the odds are against us: Java isn't compiled to native machine code, but to an intermediate byte code, which in turn may or may not be compiled to native machine code (depending on the circumstances). So, can we show cache effects in a Java program? Yes, we can! A Java Programmer's Guide to Assembler Language Stephan Rauh — Sat, 17 Jan 2015 00:00:00 +0100 Imagine a programming language without variables. A language without function parameters and return values. A language without floating point numbers, maybe even without multiplication and division. A language without type casting. Without types, actually. Not to mention classes or objects. Join me in a journey to the world of assembler languages. Programming Over Convention Over Configuration? Stephan Rauh — Sat, 17 Jan 2015 00:00:00 +0100 The Java community moved to a new paradigm during the last five years, and nobody talked much about it. Act 1: Programming When I entered the enterprise Java world, every programmer did what was expected from them. They wrote programs. Act 2: Configuration over Programming Enter Spring. Or EJB before version 3.0, for that matter. Programming - they said - is bad. It's OK to write small modules, building blocks of your application that can be glued together. But the glue code needn't be code. It's better to adopt a declarative programming style. Design configurable modules, and configure them in XML. That programming model has great advantages: you can replace modules by different module as seems fit. Configuration gives you a big boost of productivity. A Quick Guide to Writing Bytecode With ASM Stephan Rauh — Sat, 17 Jan 2015 00:00:00 +0100 My previous article gave you a short introduction on reading Java bytecode. Now let's do it the other way round: today we're going to write bytecode ourselves. So grab your hex editor and get prepared to type endless sequences of cryptic numbers! Wait - that's not how we're going to do it. Actually, I'm mostly interested in showing you the general idea. We're going to cut a couple of corners. We'll add code to an existing method of a class on your hard disk. And we'll use a framework that does the hard work for us. You don't have to download a hex editor. The Java class file format is a bit convoluted, so editing a Java class in a hex editor isn't too much fun. Observe the difference between a high-level language like Java and a low-level language like Java bytecode or assembler. Bytecode programmers have to think a lot smaller. A single line of Java code can translate to half a dozen bytecode instructions. Remember the for loop of the previous article: Depending on what you count, it consists of five to eight instructions. Programming in assembler is even worse: a single high-level instruction can trigger thousands of machine-code instructions, especially on older CPUs. Which in turn also means that high-level languages tend to be slow. They do a lot of things that could be streamlined in assembler. But nowadays hardly anybody wants to pay the price: your program may run faster, but you don't program it quickly. The effort only pays in special areas such as games and hardware drivers. Apart from showing you the different state of mind you need to adopt to program in a low-level language, the article also shows you how to get started with the ASM library. I picked a very small task: modifying a method of a class at runtime. Happy New Year 2015 - the Year of the Palindrome! Stephan Rauh — Sat, 17 Jan 2015 00:00:00 +0100 You readers rock! In 2014, BeyondJava has been read more than 400.000 times. That's 400.000 reasons to carry on. What's in score for you in 2015? Time will tell... but there are a few articles I've already prepared, so I can pique your curiosity. BootsFaces 0.6 has just been released, so it deserves an article or two. Soon I'll release AngularFaces 2.1. That's the first version of AngularFaces that has extensions specifically for BootsFaces. JSF will remain a hot topic, as well as AngularJS and AngularDart. I'd like to write a couple of philosophical articles. "How to Abuse a Framework" is the working title of one of those articles. I'm also preparing a series of articles dealing with how the JVM works. Did you know your Java program is compiled to machine code - sometimes, that is? Did you know how to read and analyze this assembler code? Did you know which optimizations the JVM performs? Stay tuned! Maybe I'll also include articles about WordPress. That's the platform of this website, so I've learned a lot how to do thing and how not to do things. During the last couple of days I've started to make the website faster again. Chances are I'll write an article about how to optimize WordPress performance. Oh, just in case you didn't read the geeky part of Twitter: 2015 is a palindrome. Written as a binary number, it's 11111011111. Welcome to the year of the palindrome! BootsFaces 0.6.0 Now Available on Maven Central Stephan Rauh — Thu, 15 Jan 2015 00:00:00 +0100 Maven coordinates BootsFaces - the JSF framework that makes Bootstrap much more accessible to JSF programmers - is now available on Maven Central. To use it, add a dependency to your Maven pom.xml file: How to Make Your WordPress Blog Fast Stephan Rauh — Sun, 04 Jan 2015 00:00:00 +0100 Many bloggers know the problem: at first, their WordPress site is fast. After a while it starts to get slow. The same happened to BeyondJava.net. Time to do something about it. I didn't want to wait until the Google rankings began to drop. About Stephan Rauh — Sun, 04 Jan 2015 00:00:00 +0100 (no details available) Newsflash: BootsFaces 0.6 released Stephan Rauh — Thu, 01 Jan 2015 00:00:00 +0100 Yesterday, BootsFaces 0.6 has been released. You can download it at the BootsFaces documentation pages. Among other things, there are six new components (checkbox, combobox, panel grid, tab and a password input field). BootsFaces now is compatible to both Oracle MyFaces and Apache MyFaces 2.2. The next version 2.1 of AngularFaces will also support BootsFaces (and vice versa). BeyondJava.net will report about BootsFaces in more detail soon. By the way, I (Stephan Rauh) joined the BootsFaces team recently, so I can give you first-hand informations about the project. Final Version of AngularFaces 2.0 Published Stephan Rauh — Wed, 31 Dec 2014 00:00:00 +0100 It was a hot summer day when I was sitting in the garden and started to dream. Wouldn't it be nice to add AngularJS to JSF? Today it's a sunny day too, I'm sitting in the garden again and AngularFaces 2.0 is finished (it's even available on Maven Central). Now it's possible to use AngularJS without abandoning JSF. Even better: it's very simple, and AngularFaces 2.0 has much more in store for you. It adds a couple of features beyond AngularJS, such as bringing the Bean Validation annotations to the client and helping you to target an international market by reducing the boiler plate code needed to translate an application. AngularFaces is worth a look if you don't want to involve yourself AngularJS programming. AngularFaces 2.0 RC4 Published Stephan Rauh — Wed, 31 Dec 2014 00:00:00 +0100 The final release of AngularFaces 2.0 is coming near! The latest - and possibly last - release candidate RC4 has been published today. Here's what's new and noteworthy about the version: Reduced requirements on the Java version: Java 6, 7 and 8 are supported. The binaries in the distribution folder are compiled with Java 6. You can now use traditional JSF AJAX requests with AngularFaces (although it's not advisable to do so, because AngularJS doesn't seem to support this). Improved compatibility to Internet Explorer 11 (and probably older versions as well, but since I've updated my PC to the latest version, I can't really tell). Several common HTML tags can now be used without preceding "h:". can now be used without "type" attribute. The type is derived from the JSF bean. This isn't exactly a new feature: AngularFaces supports the same feature for since a long time. The news is that also the native HTML5 is supported. Client-side error messages use the PrimeFaces design in PrimeFaces views (and the simpler Mojarra design otherwise). AngularFaces input fields can now display boolean JSF bean attributes (and are displayed as checkboxes). Work on the manual on AngularFaces.com (nowadays taken offline) is also progressing nicely. The same applies to the demo applications. As usual, you find the updated jar file and two demo war files on the AngularFaces dist folder on GitHub. Blazing Fast Pure Java Mixins Using Advanced Javassist Stephan Rauh — Sat, 27 Dec 2014 00:00:00 +0100 Speed'em up! Last week I showed you how to utilize the Javassist library to mix up several Java classes into one. That's more or less the concept of "mixins" most modern programming languages offer. The most important disadvantage of my approach is it mixes the classes at run time. Your compiler can't help you. Neither can your IDE. So my idea may deliver the features of a mixin, but it doesn't look nor feel like a mixin. You need an interface or a type cast to access every method of the mixin - something you don't need in, say, Scala. There's nothing I can do about that. Java's just the way it is. If you aren't happy with it, use a more modern language :). What we can fix is the second disadvantage: performance. That's what we'll do today. Let's get down to real byte code! Javassist allows you to do real byte code manipulation. Last week we just added a proxy to a class to change it. While this approach works it adds an additional layer of complexity to the class. The price is a huge performance penalty. Plus I consider the resulting code pretty hard to read. This week we'll build a class from scratch. Alternatively we could use the same technique to take an existing class and to manipulate it. More precisely, we can take an existing class and create a new class by modifying it. The original class remains unchanged. Actually, that's good news: there's no security risk associated with Javassist. Creating a class - doesn't this involve complicated tasks like creating a constant pool? Starting a file with CAFEBABE - the famous magic number of Java classes - may be simple, but anything beyond that... but wait. That's what Javassist does for you. We don't even have to know about byte code. Javassist allows you to create a class and to populate it with fields, methods and algorithms without even knowing there's something like byte code. What is OmniFaces? For those who don't know OmniFaces yet: OmniFaces is... different. It's a JSF library that doesn't focus on providing GUI widgets. Instead, it integrates into your existing JSF ecosystem and adds functions lacking in JSF. OmniFaces 2.0 offers 90 components, give or take a few, most of them dedicated to non-GUI components. My favorite OmniFaces features are the CombinedResourceHandler, which accelerates the delivery of most JSF pages tremendously, the SelectItemsConverter which makes JSF comboboxes a lot less scary and the FullAjaxExceptionHandler, which make exceptions occurring during an AJAX request visible. What's new in OmniFaces 2.0? Many things. In this article I'll focus on two interesting new features: Bean validation at class level and simplified display of images. Eclipse Compiler Surprises Stephan Rauh — Fri, 14 Nov 2014 00:00:00 +0100 I guess you know exactly what the class file of this Java source code looks like: What is AngularJS 2.0 Going to Look Like? Stephan Rauh — Sun, 02 Nov 2014 00:00:00 +0100 At last week's ng-conference in Paris the AngularJS team gave us an early impression of how AngularJS 2.0 is going to look like. Maybe you remember me writing in an earlier article that AngularDart is a preview on AngularJS 2.0. It wasn't my own claim. I found it at the AngularDart web site. When I was jotting it down I couldn't help but wonder how this might be done. AngularDart benefits largely from classes, annotations and an optional type system. This can't be ported to Javascript, I thought? Java 8 Named Method Parameters Stephan Rauh — Fri, 17 Oct 2014 00:00:00 +0200 I was very surprised when I read Adam Bien's blog post on named parameters in Java 8. Named parameters? Well... not quite. At least not the kind of named parameters we know from languages such as Visual Basic, Groovy and many others. But it turned out to be an interesting read nonetheless. Newsflash: AngularJS 1.3 Released Stephan Rauh — Wed, 15 Oct 2014 00:00:00 +0200 Oct 15, 2014. AngularJS 1.3 aka "superluminal-nudge" has been released two days ago. AngularFaces will support AngularJS 1.3 starting with the next version (AngularFaces 2.1). According to the AngularJS blog, AngularJS 1.3 contains 400 bug fixes, a lot of performance improvements - both concerning speed and memory consumption - better support for users with a handicap and much more. An improvement I particularly like is ng-messages, a directive that simplifies the tedious chore of adding error messages (even if it's still a far cry from the ease of use of of AngularFaces): Newsflash: Java Decompilers Stephan Rauh — Wed, 15 Oct 2014 00:00:00 +0200 Nowadays everybody seems to pull their libraries from Maven Central, which encourages to upload both the binaries and the source code of a library. Most developers follow the guidelines, so nowadays it has become painless to read the source code of the open source libraries you use. Debugging such a library usually is pretty simple. You don't have to look for the source code, it's just there. Still, every once in a while you're looking for a bug occurring in a library without source code. In such a situation a Java decompiler comes in handy. It analyzes the Java byte code and tries to reconstruct the original source code. Some things get lost, of course, such as comments. However, depending on how the library has been compiled, even the original line numbers and the variable names can be reconstructed. That's a huge difference to languages like C that compile to native machine code. JAD The decompiler I used for years fell into negligence with the advent of Java 1.4. However, Thomas Varanenackas still mirrors various versions. Work on Java 9 already has begun, so this feels a bit like software archeology. Don't get me wrong: I'm very grateful people store and value historic stuff. It's astonishing how fast knowledge falls into oblivion in the internet. (At the same time it's true the internet never forgets - especially embarrassing posts - but that's another story). Java Decompiler Today a co-worked showed my a Java decompiler that works with current versions. It's simply called Java Decompiler. According to the web site it supports most JDKs up to 1.7 and a few other compilers: jrockit90_150_06, jikes-1.22, harmony-jdk-r533500, Eclipse Java Compiler v_677_R32x, 3.2.1 release. It's available as a stand-alone version with GUI, as an Eclipse plugin and as an IntelliJ plugi Newsflash: Ceylon 1.1 published Stephan Rauh — Sat, 11 Oct 2014 00:00:00 +0200 Yesterday (Oct 9, 2014) Ceylon 1.1 has been published. For those who don't know Ceylon yet: Ceylon is one of the interesting emerging JVM languages introducing many interesting features. For example I reported about Ceylon's interesting approach to get rid of NullPointerExceptions some time ago. Ceylon is developed by Red Hat's Gavin King, who's already well-known from his work on Hibernate and Seam. As far as I can see, the language itself hasn't changed much. Instead the team concentrated on performance, the SDK, the Eclipse IDE and the libraries. Dig deeper: Gavin King's Ceylon 1.1 announcement Reddit discussion on Ceylon 1.1 What's New in PrimeFaces 5.1? Stephan Rauh — Mon, 06 Oct 2014 00:00:00 +0200 After two consecutive major, quite revolutionary releases it's time for consolidation. Çağatay Çivici and his team seem to think the same and call the new release of PrimeFaces a minor version (5.1). It's not that small, by the way: I've counted 660 commits, Granted, many commits deal with the new showcase, some deal with PrimeUI, but what remains is still impressive. According to the PrimeFaces blog the new version brings 225 filed improvements and more than 140 bug fixes. So what's new in PrimeFaces 5.1? TomEE-Based JavaEE Counterpart to Spring Boot Stephan Rauh — Fri, 03 Oct 2014 00:00:00 +0200 Spring Boot stirred up the Java world. Developers always put up stoically with slow server start-ups, long deployment times and difficult server configurations. Those times seem to come to an end. There's only so much coffee you can drink during the breaks. The disadvantage of Spring Boot is it uses Spring, excluding roughly half of the Java community. As far as I know you can't use CDI on Spring Boot. Even if you were to find a way how to do it, it's questionable if it's wise to use two different dependency injection frameworks simultaneously. So what about the JavaEE world? The TomEE team are currently exploring what needs to be done to implement a JavaEE counterpart to Spring Boot. These days Alex Soto published a surprisingly simple prototype (complete source code here). At the moment it's only a sketch which can run servlets and REST services. Spring Boot goes far beyond that: just think of the amount of effort that went into monitoring. Alex Soto's prototype has a long way to go yet to become a real competitor. In any case he has announce to publish more source code soon on GitHub. Be that as it may, even the current prototype can already be useful. In an earlier article (Application Servers are dead!) I've sketched how to embed Jetty or Tomcat in a JAR file. TomEE is much more complete. Embedded TomEE also brings CDI, EJBs, JSF and the rest of the JavaEE stack. Of course documentation is still sparse, but an adventurous developer should be able to implement a full-blown JavaEE application on the 70-lines prototype. By the way, this isn't the only project inspired by Spring Boot. After finishing the article I stumbled about a similar, less ambitious project. If you're interested only in CDI and REST services, forseti AngularFaces 2.0 Embraces Both HTML5 and PrimeFaces Stephan Rauh — Wed, 17 Sep 2014 00:00:00 +0200 Now that's a surprise: AngularFaces becomes more powerful by getting rid of it's widgets. Quite a development for JSF widget library. Instead of defining its own widgets AngularFaces 2.0 pimps up widgets provided by other widget libraries. In particular, it adds AngularJS to the new JSF 2.2 HTML5-style widgets. But of course it doesn't stop there. It's also compatible to the widgets of Mojarra and MyFaces and to many PrimeFaces widgets. Plus, it allows AngularJS to modify almost every JSF attribute. Update Sept 16, 2014: In the meantime I've released the final version of AngularFaces 2.0, so you may also be interested in the announcement of the final version. What's in store for you You may already have guessed it: AngularFaces underwent a profound overhaul during the last three weeks. Now it's much more versatile and much more "Angular". Let's summarize the key points of AngularFaces 2.0: It integrates AngularJS and JSF seamlessly. The difference between the two technologies becomes blurry. It doesn't matter if you modify an attribute on the server side or in your AngularJS code. Both options are available to you. You can even do both, if you insist. In particular, JSF bean attributes are mapped into the AngularJS model. The mapping works in both directions, of course: the next request transfers changes made on the client side back to the server. After processing the user input the server update the AngularJS model again. Bean validation attributes (JSR 303) are evaluated on the client side by AngularJS (resembling the Client Side validation of PrimeFaces). Labels and error messages are added automatically to your input field (unless you tell Angula Make or Buy? Drawing a Balance on Coding 11pictures.com Myself Stephan Rauh — Wed, 17 Sep 2014 00:00:00 +0200 Introduction During the last couple of weeks, I've been preparing a relaunch of my second blog. 11pictures.com shows some photographies of mine. If you're interested in western Europe, you may want to have a look at it. After reading this post, that is :). I'd like to explain how I did this blog - or at least the Javascript part of it. Make or buy? As it happens, 11pictures.com isn't exactly a new blog. It exists since Spring 2012. To my surprise it attracted a lot of visitors. So why did I want to re-do it? With so many open source slide shows available on the market, why didn't I just use one of them? Well, I did. The first incarnation of 11pictures.com was exactly that. At first, I was looking for a standard Wordpress theme I could use. I have to admit there are gorgeous themes around there. But most of them didn't match what I wanted to do. In the first place my idea was to create something similar to Fotopedia. They've modified their design since then, but the basic idea is still visible: My blog is about pictures, so the pictures should dominate everything. I didn't want to disturb the impression with menus, texts, white space, legal notes and all the other things blogs are typically made of. Update Sept 17, 2014: I've just seen Fotopedia has been been shut down due to financial problems. I just wanted to show my pictures. But I also wanted to tell stories. That's when things become difficult. Telling stories amounts to writing texts, and those texts distract from viewing the images. They also need space, by the way. Space that's lost to the images. My first successful attempt So I decided to write my own slide show. However, I wasn't ready to delve deep into Javascript, so I was looking for standard software. I decided to use a small but Do You Need a Portal Server? Stephan Rauh — Wed, 17 Sep 2014 00:00:00 +0200 This year's JAX conference left me with the impression portal servers are a fashion in decline. How can this be? Just a few years ago virtually everybody was talking about portal servers, claiming them to be the future. Now it seems "virtually everybody" were the marketing guys. The majority of the Java world gracefully ignored the self-acclaimed fashion and went on developing other frameworks like Spring, JEE, HTML5, just to name a few. All right, that was then. What about today? Do you need a portal server? Or rather: Who needs a portal server? Why are portal servers that attractive? In some countries the word "portal" has a nice ring to it. Germans in particular use the word "portal" almost exclusively to talk about the impressive if inviting doorways of old churches. Everybody who reads about a portal server can't help but think about something like the picture above. So it's not surprising he'll say "Yes, I do want a portal server". That's a great misconception. He doesn't want a portal server, he wants to have an attractive web site. You can build such things both with or without portal servers. Let's have a look at Java portal servers. A portal server is a web application server delivering a lot of infrastructure and a lot of useful programs. You get an elaborated user management with single sign on, you get a menu, you can add your programs as well as third party programs. You get a content management system, a forum, a blog, chat, calendars. The list of pre-defined applications is sheer endless. Portal servers allow you to work collaborati Regional Distributions of Browser Market Shares Stephan Rauh — Wed, 17 Sep 2014 00:00:00 +0200 Being a web developer, I investigate browser market shares every couple of years to learn about the target platforms I have to optimize my applications for. The most exhaustive resource on the topic I found is Wikipedia's article. It combines the data of five internet statistics providers. Frequently there are major differences between two providers' data, because their data is collected in difference ways, and there's a wide range of things biasing the statistics. So it's a good idea not to rely on a single providers data, but to read them all. In any case, the only reliable statistics you can get is collected by your product. Unfortunately, you get those statistics after shipment - in other word, you get them when it's too late to change your web site or your application. Even worse, the statistics of today's product may differ from the statistics of tomorrows product. For example, if you're attracting a lot of users from countries like Belarus or China, you'll have a strong bias towards browsers that are exotic in most other countries. One of the providers - https://gs.statcounter.com/ - caught my eye because of the nice and interesting statistics they provide. I used their website to generate the graphics below. Please keep in mind that Statcounter's statistics probably aren't better than the other providers. I chose them because of their attractive-looking graphics licensed under a liberal license AngularFaces 2: Even Better Steroids for JSF Stephan Rauh — Tue, 16 Sep 2014 00:00:00 +0200 Boarding the client AngularJS and other fancy Javascript frameworks stir up the Java world. The Java world has been dominated by server side framework for more than a decade now. But now, everybody's moving to the client side. Everybody? Not quite. A lot of developers want to steer a middle course. That's AngularFaces for you. By the way, the interest in AngularFaces is tremendous. The AngularFaces announcement has become the second most read article of this blog, being read a hundred times each day. So I decided to re-write AngularFaces from scratch. You know, the first version hadn't really been designed carefully. It just happened. Originally it was just a little experiment. Granted, it works fine, but it's difficult to build new features upon it. The second version is designed for the future. AngularFaces 2.0 has a lot of advantages over it's predecessor. The nice thing about AngularFaces 2.0 is it's already available. Update Sept 16, 2014 Actually, the final version of AngularFaces 2.0 looks completely different from the AngularFaces 2.0 I envisioned four months ago. It doesn't define components, it's a plugin to existing components. In other words, it adds functionality to most components of Mojarra, MyFaces, PrimeFaces and probably (although I haven't run a test yet) to most other JSF widget libraries. Nonetheless I think the ideas described in this article are good ideas worthy to be implemented. The AngularFaces widgets have moved to a project called AngularFacesWidgets. Have a look at the tutorial at AngularFaces.com (nowadays taken offline) if you're interested in AngularFaces 2.0 and above. AngularFaces 2.0 example 'Nuff said. You've c AngularFaces: Synchronize Angular Models With JSF Beans Stephan Rauh — Tue, 16 Sep 2014 00:00:00 +0200 Introducing This component is different. Thus far every AngularFaces component was essentially a JSF component with some AngularJS sugar on top of it. works the other way round. It enables a pure AngularJS application to benefit from the JSF engine. Every time a JSF request is submitted, moves parts of the AngularJS model to the JSF bean's attributes. A little later, when the response is send to the client, injects JSF bean attributes into the model of AngularJS. Strictly speaking, the "a" prefix of the library makes sort of a misnomer. It's not about doing thing in an asynchronous way. It's about synchronizing AngularJS models with JSF beans. Update Sept 16, 2014 AngularFaces 2.0 takes a different - and better - approach to adding fuctionality to JSF. This article describes the older version AngularFaces 1.0. However, is also part of the new version. Now it's called , and synchronizing data from the client back to the server has been postponed to version 2.1 of AngularFaces. Have a look at the tutorial at (broken link) if you're interested in AngularFaces 2.0 and above. How it's used takes two parameters: value denotes the JSF bean's attribute. direction can take three values: direction="clientToServer" and direction="serverToClient" makes send data in one direction only. To achieve re AngularFaces: Comboboxes, Checkboxes, Sliders and 3D-Graphics Stephan Rauh — Tue, 16 Sep 2014 00:00:00 +0200 When I learned about threejs two weeks ago, I immediately knew the next AngularFaces demo would look fancy. Threejs makes it easy to explore the third perspective in the browser. I even daresay threejs makes Javascript is the language of choice to do fast 3-D graphics. Most people agree number crunching isn't the natural domain of Javascript. So I hope to convince you it's sensible to do the calculation of a Mandelbrot set on the server and to do the 3-D magic on the client AngularFaces: Calling AngularJS Controllers via a:angularButton Stephan Rauh — Tue, 16 Sep 2014 00:00:00 +0200 This article concentrates on the AngularJS side of an AngularFaces application. The standard AngularJS approach to calling a controller function is adding an ng-submit attribute to the tag. In a JSF application, this isn't a good idea. It might make Angular intercept button clicks intended to be send to the server. To avoid the problem, AngularFaces offers the tag. Update Sept 16, 2014 AngularFaces 2.0 takes a different - and better - approach to adding fuctionality to JSF. This article describes the older version AngularFaces 1.0. Have a look at the tutorial at AngularFaces.com (nowadays taken offline) if you're interested in AngularFaces 2.0 and above. JSF 2.2 HTML5 Cheat Sheet Stephan Rauh — Tue, 09 Sep 2014 00:00:00 +0200 I've read a lot about the new JSF 2.2 HTML5 input fields, but until today I didn't realize I hadn't read a comprehensive introduction about this feature. I used to be happy with the short examples I was presented at conferences. However, there's more than just . As it happens, the documentation hides in plain sight. The JavaEE Javadoc tells you everything you have to know about the Mapping between HTML tags and JSF components. For the sake of convenience, this article summarizes the key points. The general idea is to enable a web designer to design your JSF page without running a server. So it's native HTML, and it should display nicely in a browser if opened as a simple HMTL file. Putting it in a nutshell, renaming a JSF file from .xhtml to .html doesn't modify the design of the page. Application Servers Are (Sort of) Dead! Stephan Rauh — Fri, 08 Aug 2014 00:00:00 +0200 Recently it crossed my mind there's something wrong with Java application servers. You know, our team is still using them the way they're meant. The way they were originally meant. We've got many applications running on a common application server that's managed centrally. I'm told we're one of the last companies to do so. These days, most companies dedicate an entire application server to a single application and put them in a virtual machine. In other words, application servers have become part of the application. Originally, it was meant to be the other way round, and that's why Eberhard Wolff claims application servers are dead. His JAX talk was a real eye-opener, by the way. He expressed the thoughts that ware already lingering in the subconscious part of my mind. As usual, I'll mention a few key points of his talk in this post, plus a few thoughts of my own. If you're interested in the entire talk, have a glance at his slides. He also published an article in the Java-Magazin 7.2014 (in German language, and as far as I know, only available in print). So what's wrong with the original idea of applications servers? Let me put the question differently: Have you ever seen an application server that runs out of the box, without being modified? How to Integrate JSF 2 and Spring 3 (or Spring 4) Nicely Stephan Rauh — Thu, 07 Aug 2014 00:00:00 +0200 Why we abandoned CDI in favor of Spring (just a little rant) Oops. We did it again. We heeded the consultant's advice once again. You shouldn't do that, you know. Not thoughtlessly, that is. It's all right to call a consultant and listen to his advice. But don't you follow his advice blindly. If he's a good consultant, most of his advice is good. But every once in a while it's just poisoned. A consultant's job is to spread idea's he's already seen in other companies. In other words: he's spreading something just above mediocrity. Respectable consultants don't give really bad advice, but sometimes they kill good ideas they haven't seen before - often without actually intending to do so. A piece of advice you definitely should not heed is to combine Spring and JSF. They just aren't made for each other. They aren't precisely incompatible, but you have to split your application into two parts: JSF-land and Spring Country. Between those two countries, there is a clearly defined border. Complete with fences, customs checks and everything else a frontier needs. You'd rather use CDI with JSF. That's a marriage made in heaven. Unfortunately, we did heed the consultant's advice to abandon CDI. As it turned out, it was a silly decision, but sometimes you can't revert decisions immediately. Maybe we will switch back to CDI later, but as for now, we want to explore Spring more thoroughly. So it's my team's job to make the best of it. We're not the only ones: Searching the web for solutions quickly revealed many people consider combining JSF and Spring quite a challenge. At this point, I should admit this article is work in progress. We've just begun to investigate Spring, so I guess there's more to come. Stay tuned :). Are Java 8 Method References Going to be More Important Than Lambdas? Stephan Rauh — Wed, 30 Jul 2014 00:00:00 +0200 Having experimented with Java 8 for a couple of days, it dawned on me the long-awaited closures won't have the impact on Java programming I expected them to have. There are a couple of reasons to this. Method references do the same trick as lambdas while being more expressive and in many cases more elegant. And they are always shorter. There is no accurate documentation of your code but your code itself Stephan Rauh — Mon, 28 Jul 2014 00:00:00 +0200 It's a common misconception that every program needs documentation. Most people seem to be scared by programs lacking documentation. Whenever someone asks where my documentation is, inevitably this question is followed by the next question: "What happens if you leave the company? Nobody´ll be able to figure out your code!" That's nonsense. GIT Explained in Really Simple Words Stephan Rauh — Fri, 25 Jul 2014 00:00:00 +0200 @tabqwerty twittered an explanation to git's secrets that makes everything clear: git gets easier once you get the basic idea that branches are homeomorphic endofunctors mapping submanifolds of a Hilbert space. Funny thing is it took me a while to figure out that the sentence really is utter nonsense. Most people immediately dismiss it as a joke - but they'll never know for sure. It sounds oh so scientific. Mathematicians like me know what the words mean How to Run the Eclipse Formatter From the Command Line Stephan Rauh — Mon, 07 Jul 2014 00:00:00 +0200 Today I've dug out an Eclipse 3.2 article that's seven years old and is still valid. Considering how much Eclipse has changed since 2007 that's pretty astonishing. So, if you want to know how to format an entire Java Eclipse project in no time, you may ask Peter Friese. Of course you're invited to read on instead and learn some additional hints. Why Primefaces File Download Does Not Work in Liferay Stephan Rauh — Thu, 05 Jun 2014 00:00:00 +0200 A great PrimeFaces component refusing to work properly These days my team had a hard time implementing a simple file download in a PrimeFaces portlet. There's a nifty PrimeFaces component to do just that: . But it won't work. Update June 5, 2014:Neils Griffing reports to have fixed the bug (see the comments section below). So the rest of this article may be outdated (if you use a current version of Liferay and the LiferayFaces bridge, that is). Instead of showing our PDF file, it simply tells us not to set an illegal content type. We checked the MIME type settings both of Liferay and our portlet, added "application/pdf" to the portlet.xml file, but it didn't help. We were puzzled until we looked at the source code of com.liferay.portlet.PortletRequestImpl, were the list of legal content type is defined: Getting Started With PrimeUI – HTML5 With Style Stephan Rauh — Mon, 26 May 2014 00:00:00 +0200 I'm looking for a new UI framework, both for my private website and for my business. At company we moved from CDI to Spring, and that makes JSF more or less useless. My private website runs on PHP, so I can't use any of the frameworks or languages I love. There's no JVM to build on. But of course there's the lingua franca of the internet: HTML, Javascript and CSS. So I was glad to learn that my favorite JSF framework - Primefaces - has a pure HTML5 offspring. I'm reluctant to recommend Primefaces since they've left the open source community, at least partially. But I can't help it, I still like their products. Luckily today's topic - PrimeUI - hasn't been commercialized yet. Update 15.03.2014: AngularPrime and AngularPrime/Dart This article is becoming popular recently. So you may also be interested in the younger siblings of PrimeUI. Rudy de Busscher's AngularPrime makes using PrimeUI a lot simple. As you can see in the showcase, it favors a declarative style of programming, and it adds the power of AngularJS. You may also want to look at project of my own: AngularPrime/Dart is a Dart port of AngularPrime that's going to simplify things even further. Newsflash: Can You Rely on System.nanoTime()? Stephan Rauh — Tue, 06 May 2014 00:00:00 +0200 If you're like me, you're concerned about your application's performance. So you're familiar with profiling your application. The simplest way to measure your application's performance is to time how long a method call takes. Most of you probably know System.currentTimeMillis(), but there's a better alternative: Newsflash: React Speeds Up AngularJS Rendering Stephan Rauh — Mon, 05 May 2014 00:00:00 +0200 Today I've read about a small but interesting framework called React.js that convinced me to start a new series on this blog. Newsflashes are small articles, just two or three sentences, describing an interesting idea and providing a link to read on. They are less thoroughly researched than the full-fledged articles of BeyondJava.net. Instead I'll go with my guts to choose interesting bits of information. React is a lightweight Javascript framework focusing on the UI. According to the project page, using a virtual DOM difference algorithm makes it very fast. Thierry Nicola decribes in his article - which is now offline - how to combine AngularJS and React to make your AngularJS application faster. While the effect is impressive, chances are you're going to benefit from React without having to use it yourself. My bet is many frameworks, possible even browsers, are going to use virtual DOM by default. Use Exceptions. Use'em Wisely! Stephan Rauh — Fri, 25 Apr 2014 00:00:00 +0200 When it's hailing exceptions The other day I was reviewing another department's code. Soon I was puzzled by the way they use exceptions. They used them very often and in unexpected ways. I examined a tiny module, just a handful of classes, and the vast majority of the classes were exceptions. After a while it crossed my mind they followed an old style that's come out of fashion for a good reason. So I decided to write an article on how to use exceptions efficiently. In a way, this is a strange article: it's a kind of a 101 article (actually a topic already covered by many, many other writers), but it's not the newbies who do it wrong. It's the old hands who walk into the trap. Tweaking the Hot Spot Compiler's Settings Stephan Rauh — Tue, 15 Apr 2014 00:00:00 +0200 A couple of days ago Chris Newland published two interesting articles. He's looking at the JVM's Hot Spot compiler settings, looking for possible optimizations. Regular readers of my blog may remember I analyzed the JVM optimizations two years ago. At the time I found out you can help the optimizing compiler to get to speed, but it doesn't matter on the long run. After 10.000 invocations methods are compiled to machine code, and after that there's nothing left to optimize. However, if you happen to work on one of the vast number of algorithms that call methods frequently, but less than - say - 1.000 times, low-level optimizations may help. AngularFaces Mentioned by Oracle's Aquarium Stephan Rauh — Tue, 15 Apr 2014 00:00:00 +0200 It's astonishing how much attention BeyondJava's AngularFaces project gets. It has been mentioned in the November issue of the JSF central postcast - at a time when AngularFaces was a far cry from being mature. Last Thursday Reza Rahman mentioned AngularFaces in Oracle's Aquarium (JSF + AngularJS = AngularFaces?). I'm very pleased by your tremendous feedback. It's a great motivation to carry on. Just in case anyone of you is puzzled by the apparent lack of progress in the repository: progress is there, it just happens in another repository. When I wrote BabbageFaces - which basically was meant to be a small exercise - I noticed many folks in the JSF community want to reduce network traffic. BabbageFaces is nice, but it isn't compatible to AngularFaces, and it won't be. So I decided to tackle the challenge from another angle. Recent Improvements of Java's String Implementation Stephan Rauh — Fri, 04 Apr 2014 00:00:00 +0200 Three days ago, I wrote an article about Strings in Java 8. I claimed they'd rewritten java.lang.String from scratch, supporting a 64 bit encoding that can be processed by the processor's FPU. Of course, it was an April prank. So I was pretty surprised to learn there really are improvements of Java's string implementation. They aren't even subtle. Java 7 Update 6 introduced a new implementation of java.lang.String that's better suited for large numbers of Strings. As you may or may not know, the former implementation had been designed with optimizing the substring() method in mind. It was super-fast because it didn't copy the characters of the substring. Instead it created a new pointer to the old String. Sometimes this prevents effective garbage collection, and it makes the intern() function extremely expensive. So they opted to implement a new version that's simpler. As a result of the new implementation substring() has to copy the character array. In the age of multi-gigabyte PCs and servers that's more efficient than trying to save a few bytes. In Java 7 they also abandoned 8-bit Strings. Now 16-bit Unicode strings are always used. That's funny because it almost matches my April prank, where I claimed they abandoned the 16-bit character encoding in favor of 64-bit encoding. I wonder if java.lang.String makes use of the FPU? Read the full story at Attila Balazs article on the state of strings in Java. Java 8: Major Speed Boost by Overhauled String API Stephan Rauh — Fri, 04 Apr 2014 00:00:00 +0200 April 1st, 2014 Glassfish 4.0 enables Method Level Contraints (Bean Validation 1.1) Stephan Rauh — Thu, 03 Apr 2014 00:00:00 +0200 A small addition to JavaEE 7 makes Design by Contract a lot more attractive to Java programmer. The idea is to annotate your method and / or the parameters of your methods with annotations. The most common case is @NotNull, indicating a particular parameter of a method must not be until. How to Write Your Own SonarQube Plug-In Stephan Rauh — Wed, 02 Apr 2014 00:00:00 +0200 You already know SonarQube, I suppose? If you don't, don't waste your precious reading this article. You'd rather have a look at their live demo first. Sonarcloud shows the result of SonarQube's analysis of quite a few popular open source projects. But wait, I'd like to tell you what Sonar is about first. After that I'd like to tell you it's possible to write your own Sonar plugin. What's it all about? Sonar (which recently has been renamed to SonarQube) is an open-source Java 8 - Catalyst for a Superior Language? Stephan Rauh — Tue, 01 Apr 2014 00:00:00 +0200 These days I've read two language-related stories at Lavalobby. The first story I read matched my own experience on the topic. It has also an refreshingly optimistic air. Obviously, the author believes in progress. The second article also had a lot of ideas matching my experience. Thing is, both articles contradict each other. While the first article expects Java 8 to be merely a catalyst giving rise to more innovative languages, the second article insists that Java is here to stay. It the programming world's lingua franca, and it won't be replaced by a fancy new language. Both articles have a point. Your IDE Supports Java 8 From Day One Stephan Rauh — Wed, 19 Mar 2014 00:00:00 +0100 Yesterday the lambda revolution has been released: Java 8 is there. Java programmers can finally benefit from closures, function pointers and multiple inheritance. Or rather, limited versions of these features that are almost as useful. BeyondJava.net has a series of articles on the topics (see method references, lambda expressions, functional programming and closures vs. lambdas). There's even an interesting (and very unique) approach to type inference in Java 8: target typing. For the first time in Java history each of the major IDEs support Java 8 from day one. In earlier times we had to wait roughly half a year until Eclipse supported the new version of the language. This time, there's a feature patch you can install in Eclipse 4.3.2 (aka Kepler SR2). To install it, click "Help > Install new software", enter the URL http://download.eclipse.org/eclipse/updates/4.3-P-builds/ into the "Work with" field and proceed the usual way. According to netbeans.org NetBeans 7.4 also supports Java 8. And of course IntelliJ IDEA does: I tried it more than a year ago with a preview version of Java 8, and the IDE supported lambdas, method references and defender methods flawlessly. An interesting question is the future of Java. Which impact will lambdas have on our programming style? Here's an ea Announcement: AngularPrime/Dart Stephan Rauh — Wed, 19 Mar 2014 00:00:00 +0100 Last week I have begun to port Rudy de Busscher's Javascript widget library, AngularPrime, to Dart. AngularPrime/Dart aims to take PrimeUI and AngularJS to another level. It's going to simplify Single Page Applications considerably. The applications have the same look and feel as PrimeFaces or PrimeUI applications, have the simplicity of AngularPrime and of course the wealth of features of AngularJS. Or rather, the wealth of features of AngularDart, the Dart port of AngularJS that's currently slightly more advanced than AngularJS itself Java Threatens Your Company and Your Computer, They Say Stephan Rauh — Sun, 02 Mar 2014 00:00:00 +0100 Java - the number one security risk? Recently I've been reading a lot of disturbing articles along the lines "get rid of Java, it's a security risk". At least one them even said "Java should have been abolished years ago.". One of the commentators on ars technica found refreshingly clear words about the topic. I summarize his points: He says we need to switch to safer languages. we need to prove the correctness of programs and languages formally. He also claims there already are language that are both safe and allow formal proofs of correctness. Stuxnet and the NSA are just a foretaste of what's to come if we continue to neglect the problem, he predicts. Harsh words. Convincing, too. You know, these days Stuxnet and NSA are killer arguments. But let me put it bluntly: many comments BabbageFaces Now Supports Full Page Submits Stephan Rauh — Fri, 28 Feb 2014 00:00:00 +0100 Allowing @all without penalty BabbageFaces - the framework I'm currently developing to reduce the size of AJAX responses - has learned a couple of new tricks during the last weeks. Now it supports and optimized full page submits. This is good news because it allows to simplify programming even further. You can safely use update="@all" with and without sacrifying performance. Quite the contrary. Probably most of you use JSF templates. A common use case is providing a uniform corporate design to to every page of your application. Common menus and footers are other typical use cases. In such a scenario BabbageFaces reduces the footprint of considerably. By default, updates the entire page (@all). BabbageFaces update only the parts of the page that have really changed. Eclipse Unleashed: Coding Like A Rock Star! Stephan Rauh — Fri, 14 Feb 2014 00:00:00 +0100 Everybody believes I'm diligent, but I'm not. I just know how to make Eclipse do my work. It's got so many little helpers built-in that it almost feels like an additional team member. tl;dr :) Too long - won't read? Yes, Eclipse is such a powerful beast I can't cut the article short. For those in a hurry: there's a short cheat sheet at the end of the article. That said, let's start with a feature you almost certainly already know. The light bulb When Eclipse believes it can improve your code, it shows a little light bulb. Get used to clicking it - Eclipse has a lot of artificial intelligence. Often it's kind of scary. Eclipse seems to know what you want to do. CTRL-1 You don't need the mouse to hit the light bulb. CTRL-1 will do as well. Just make sure you put the cursor behind the code you want to have improved. CTRL-1 is a little more sensitive to the cursor position than the light bulb. However, after a short period of practicing using the keyboard is a lot faster than using the mouse. Split Variable declaration Just an example of CTRL-1: consider the line PrimeFaces Selector Framework: Use jQuery in JSF Expressions Stephan Rauh — Thu, 16 Jan 2014 00:00:00 +0100 These days I re-discovered a really cool PrimeFaces feature. It's one of those features that raise JSF to another level. I'm talking about the PrimeFaces Selector API which allows you to use arbitrary jQuery expression instead of ideas. For instance, this feature comes in handy with BabbageFaces, my JSF plugin that allows and even encourages you to do AJAX without IDs. In most cases it suffices to update the @form. However, when I started to port the Pet Store demo application written by Antonio Goncalves to AJAX and BabbageFaces, I discovered the language selector. Switching from - say - English to French requires you to update every text on the screen, no matter whether it's inside or outside a form. When Political Decisions Raise Java Exceptions Stephan Rauh — Wed, 18 Dec 2013 00:00:00 +0100 Preparing another example for the (broken link) I just noticed a funny thing: the current period of low interest rates is a challenge to programmers! Decades of banking apprentices learned how to calculate the monthly payment rate of a loan like so: (see Wikipedia) or translated to Javascript code: Java Performance Through the Ages Stephan Rauh — Wed, 18 Dec 2013 00:00:00 +0100 Inspired by Charles Nutter's talk on the JIT's optimizations I mentioned a couple of days ago, I designed a little benchmark to learn more about the JIT optimizations. Being curious if the Java performance improved in the last years, I ran the benchmark with every major JDK version since JDK 1.2. Groovy's Tiny O-R-Mapper Stephan Rauh — Mon, 02 Dec 2013 00:00:00 +0100 Do you like Hibernate or EclipseLink because of it's simplicity? It's true, JPA is very simple once you've got it up and running, but it's not the most simple way to access a database. The easiest way to access a database I know is SQLWindows (aka Centura), with Groovy a close second. Native Groovy, that is. I'm not speaking of Grails. Groovy uses some clever meta-programming to do its magic. The result almost resembles a simple O-R-mapper - although it's not an O-R-mapper at all. A Simple Class Parser Stephan Rauh — Fri, 15 Nov 2013 00:00:00 +0100 If you want to parse a java class, it is a clever idea to fetch a java grammar and let JavaCC do the work for you. However, I didn't find a grammar for Java 7, so I decided to write my own parser. This parser can also read Groovy source code and most of the Java 8 source code (apart from defender methods). Another reason to write the parser was to show how simple file and text manipulations can be. Groovy is optimized for programming these tasks (at the cost of being a little slower). The parser consists of merely 263 lines, including a couple of comments and blank lines. I guess the Java version is a lot more verbose. License Feel free to use the source code if you need it. Please note that I provide it to you on a "as-is" basis: if you use the source code, you use it at your own risk. You can download it here. The regular expressions The most important file of the project contains the regular expressions I use to extract classes, variable, methods, assignments and annotations: The Future of JavaScript: an Assembler Language? Stephan Rauh — Tue, 05 Nov 2013 00:00:00 +0100 Behind the scenes, widely unnoticed, there's an interesting development going on. The role Javascript plays in the computer industry is starting to change. The first time I got aware of the new role was when I learned about GWT. The heart of GWT is a cross-compiler translating Java code to Javascript. Then I learned about Dart. Extending a Java Class That's Not Meant To Be Extended Stephan Rauh — Fri, 18 Oct 2013 00:00:00 +0200 Patching a foreign class Chances are you already stumbled about bugs or shortcomings of a library you can't easily modify. Maybe you even know which class to patch, but it since isn't your class you're stuck. The last time this happened to me was when I worked on AngularFaces. A couple of weeks ago I discovered Thomas Andraschko's Search Expression Framework. It came to me several important expressions were missing: @next, @previous and @surrounds. It wasn't difficult to implement @next and @previous. After that I published an article about it. As it happens, Thomas found the article within two days and implemented the search expressions in the official Primefaces 4.0 release. He even changed the API by adding a register method allowing people like me to invent and register new search expressions. The interesting part is what I did until Thomas came to help me. The Search Expression Framework had been designed with extension in mind, but the corresponding methods and attributes were private. It looked roughly Similarities between JSF and AngularJS Stephan Rauh — Fri, 04 Oct 2013 00:00:00 +0200 Sometimes it's interesting how your brain works. My subconsciousness recognized the astonishing similarity between AngularJS code and JSF code long before I got fully aware of it. I had to read a blog post to become conscious of the common pattern. Before that, all I knew was I immediately liked with Angular. "What a cool framework", I thought, beginning to look for an opportunity to use it. But I didn't ponder about why AngularJS attracted me. I suppose the familiarity of the concepts played a big role. To a certain extent, Angular code looks just the same as JSF code I use every day at work. Does Abstraction Change Perception of Programming Concepts? Stephan Rauh — Wed, 18 Sep 2013 00:00:00 +0200 One of these days I tried to teach my co-workers one of the more exotic features of the Java language: bitwise operations on integers. It took me quite a while to explain the concept. At the end of the lesson my co-workers simply decided to avoid the feature. It seemed useless to them. That's fine be me. You don't need bitwise integer operators in everyday programming, possibly with the (almost) sole exception of computer graphics. But it made me think: How do the tremendous gains in computer science change the perception of concepts? Does the high level of abstraction modern programming languages affect the depth of understanding of computer programming concepts? Maybe negatively? And while we're at it: is Java a high level language at all, by today's standards? The Hidden JavaEE Gem: Lambda Expressions With Java 7 Stephan Rauh — Fri, 13 Sep 2013 00:00:00 +0200 This morning Adam Bien has a surprising story: While the majority of the Java world is impatiently waiting for Java 8's closures, JSF programmers can use lambda even today. All you need is EL 3.0. Even more, every Java 7 programmer can use lambda expressions by simply including the class EL library to the classpath: Does Your Programming Language Influence Software Quality? Stephan Rauh — Sat, 07 Sep 2013 00:00:00 +0200 This morning Heise published an article I found exciting at first glance. They claim Python has a superior software quality. At second sight thing look a little different. According to the comments, the article contains a number of mistakes. Maybe even worse, it's utterly misleading. The study they cite says Python is high-quality software. They don't talk about programs written in Python. Python itself is written in C. The JVM version of Python is written in Java How to Write a Dynamic JSF 2.x Component Stephan Rauh — Fri, 16 Aug 2013 00:00:00 +0200 I'm trying another approach to simplify my team's JSF pages. The verbosity of JSF always puzzles me. My favorite example is the component. In most cases you have to add a label and an component, and you have to make sure every id is correct (read my blog post on this topic). JSF has been designed to make it simple to write your own component. That's what I did, and I stumbled across some unexpected difficulties. JSF Cross Field Validation Stephan Rauh — Fri, 02 Aug 2013 00:00:00 +0200 JSF 2.0 introduced support for the Bean Validation API, aka JSR 303. Nowadays we can use the same annotations in JSF controllers and database entities to define constraints: Browser Market Shares 07/2013: The Americas Are All Green Now Stephan Rauh — Sat, 27 Jul 2013 00:00:00 +0200 Roughly three months passed since my last compilation of browser market shares. To my surprise Google Chrome managed to become the leading browser in the USA. If the trend is going to continue like this, the map will soon pretty boring. The Americas already shine in uniform green color. According to StatCounter Internet Explorer's market share dropped to a meager 25% by the end of June. Firefox seems to have a fidel community - roughly 20% - while Chrome jumped above the 40% line. On the other hand I saw my companies statistics a couple of days ago. They differ significantly from StatCounter's figures. Many companies do not address the general public, but smaller user groups. Big companies are far more conservative than smaller companies or individuals. Internet Explorer still dominates the enterprise market, for instance. How to Write a Simple Javascript Slide Show: A Step-by-Step Tutorial Stephan Rauh — Sat, 27 Jul 2013 00:00:00 +0200 Introduction It's time to see some source code on this blog again! During the last couple of weeks, I've been preparing a relaunch of my second blog, 11pictures.com, which shows some photographies of mine. If you're interested in western Europe, you may want to have a look at it. After reading this post, that is :). I'd like to explain how I did this blog's slide show - or at least the Javascript portion of it. Make or buy? Most people tend to use an existing framework instead of writing one. So did I. Why I chose to write my own framework is valid question. I found it interesting enough to dedicate an entire article on the make-or-buy topic. Design goals I wanted to reach a number of design goals: I wanted my slide show to load fast. A key point to achieve this was loading the images lazily. I wanted to optimize the images for search engines. This isn't that easy if you want to do lazy loading at the same time. I wanted to add both touch (or rather: swipe) and keyboard support. I wanted to display the images in full screen mode. I wanted to create a simple and flexible framework. I want to be able to modify it at any time. I'll explain how I reached each of the goals later. Let's start with the basics. Make your web site secure I won't go much into details at this point, but it's the most important task to do: if you're going to publish your web site in the internet, please make it secure. As a rule of thumb, every visitor of beyondjava.net is accompanied by a hacker. If you're optimistically hoping to be visited by, say, 1 million visitors a year, that's one million hackers to deal with! Selecting a Javascript framework I chose the Prototype framework to do my 11pictures.com rela Adding Lazy Image Loading to Your Javascript Slide Show (Part 2) Stephan Rauh — Sat, 27 Jul 2013 00:00:00 +0200 Let's continue the tutorial I began with the previous post. The code I show here builds on the code of the first part, so make sure you read the first part first. Adding lazy loading All right, we've achieved a lot already. We've got a slide show, and it even displays texts. But wait - it's slow like hell. You can't use it with large pictures or low bandwidth. A partial solution is lazy loading. Loading the images lazily won't make your slide show faster. But it helps to make it feel faster by loading the pictures just in time. As far as I know it helps a lot to get a better Google ranking, by the way. Google is said to care a lot about load times. Preparing the HTML-Code for lazy loading The images are loaded immediately when the rendering engine reads the src tag. So we simply replace it by another tag. I chose srclazy. But it's important the first image is still loaded regularly because I hid the lazy loading magic in the method addImage() which is called after loading an image. So we ought to make sure at least the first image is loaded regularly. To help the browser render the page before the image has been loaded, add a style attribute indicating the expected height and width of the picture. If you fail to do so, the browser will be forced to show ugly redraws when it loads the images. Finishing the Advanced Javascript Slide Show (Part 3) Stephan Rauh — Sat, 27 Jul 2013 00:00:00 +0200 Let's continue the tutorial I began with the two previous posts. The code I show here builds on the code of the first and second part, so make sure you read the first two part first. We've already come a long way. We've got a decent slide show, and it's super fast due to lazy loading. We even made sure it's Google-friendly. There's not much missing - but from the user's point of view it's just the other way round: he doesn't know about the technical miracles we did. He's just seeing a dull slide show. Wouldn't it be nice to be able to influence it? Add buttons to control the page Let's add some buttons to the slide show. They should allow the user to jump to the next image, to the previous image, to the first image and to the last one. First let's provide the HTML code. Apache MyFaces ExtVal: Full JSR 303 Support in JSF 2.x Pages Stephan Rauh — Sat, 27 Jul 2013 00:00:00 +0200 Beginning with version 2.0, JSF supports Bean Validation (aka JSR 303). However, it does not support every JSR 303 feature. Putting it in a nutshell, only attribute validation is supported, and it's limited to the controller class. A particularly annoying shortcoming is there's no cross-field-validation (aka class validation). Fortunately it's easy to fix the deficiencies. Just add Apaches MyFaces ExtVal jar to the classpath, restart the server and you're done. Make sure you download the ExtVal examples, too. At the time of writing, the library is badly documented, so you need them. The examples are short and simple, so you should get along without documentation as well. JSF bears a little surprise: It validates only the fields on the current page. If your page displays only a few of your beans attributes, the bean may be invalid (some attributes contain invalid values) but JSF doesn't show any error. JSF evaluates Bean Validation annotations when it's calling one of the bean's setters - and it considers the annotations associated with the setter or it's underlying attribute only. But then, it's no use to show error messages referring to fields that aren't displayed. Think of a multi-page wizard to see the wisdom of this approach. For the sake of completeness I should mention that JSF 2.x doesn't deliver JSR 303 support out of the box. You have to add a JSR 303 implementation to the classpath. There are several implementations to choose from. Up to now, I'm happy with Hibernate Validator (which doesn't say neither good nor bad about the alternative implementations - I just didn't try them yet). You don't have to configure anything. JSF finds the JSR 303 implementation "automagically" without further ado. The Apache MyFaces ExtVal project page On Languages, VMs and Optimization Stephan Rauh — Sat, 27 Jul 2013 00:00:00 +0200 Charles Nutter published a post on how various languages can be optimized on various virtual machines. He's one of the few people knowing a lot about compilers and about how to compile a language to different virtual machines. If you like to learn about the low-level stuff (you can almost hear the CPU registers working while reading the article :)), it's an interesting article about the influence of a language's type system to the optimization the JVM can perform. In other words, how fast the program can run. Follow the link to read Charles Nutter's article: On Languages, VMs and Optimization CDI Compatible With JSF-Portlets at Last! Stephan Rauh — Sat, 27 Jul 2013 00:00:00 +0200 I just got word of exciting good news: the long-lasting bug preventing Liferay users to utilize CDI in their JSF 2.0 portlets has been solved. More precisely, you can use Weld. I do not know yet whether you can use OpenWebBeans My Computer's Too Fast! Stephan Rauh — Fri, 26 Jul 2013 00:00:00 +0200 Programmers need fast computers to work efficiently. Give them the fastest gear you can get, and they'll give you a lot of bang for the buck. It's not only their motivation elevated by being flattered Why "Eclipse Generates it Automatically" is a Bad Answer Stephan Rauh — Thu, 04 Jul 2013 00:00:00 +0200 A plead for conciseness I want my code to be simple, short and concise. I hate silly boiler plate code. Code that doesn't add business value is code I don't want to see. Welcome to the Java world. Well-educated Java classes - and beans in particular - consist almost entirely of boiler plate code: Constructors or factory methods serialVersionUID Getters and setters toString(), equals(), hashcode() What about business code? Sometimes it's hard to spot it among all the boiler plate code. The fascinating thing is virtually nobody actually sees this boiler plate code. Experienced Java programmers are experts in masking out getters, setters and the like. It's almost like the code wasn't there in the first place. And whenever I complain about it, the answer typically is: "It generated by Eclipse, so what's the matter?". Code that ain't there is code you ain't have to understand Obviously most of the people I talk to are concerned primarily with writing code. However, most source codes are read far more often than they are written. The Influence of CPU Caches on Java or Scala Programs Stephan Rauh — Thu, 04 Jul 2013 00:00:00 +0200 Today, I've listened to a pretty astonishing talk held by Jamie Allen. Both Java and Scala have become fast enough that some guys begin to care about CPU caches. The JVM's JIT compiler does such a good job it's possible to feel the impact of the CPU's cache on your Java programming. Sometimes, it pays to rearrange your variables to get a performance boost. Incredible, isn't it? On Goroutines, Coroutines and How to Simulate Them in Java 8 Stephan Rauh — Wed, 12 Jun 2013 00:00:00 +0200 Google's Go language offers a nice idea how to run processes concurrently. They called it "goroutine" - clearly an allusion to coroutine, but they felt they made something new, so they gave it a new name. The idea is very simple. Every method preceded by the word "go" is run concurrently. The Go language adds an elegant concept to define and run anonymous functions (similar to the way Javascript does). The last building block is the possibility to define variables that can roughly compared to futures at stock exchange: They don't exist when you define them, but they are guaranteed to exist when you need them. Real world futures (if they can be called like this, given modern stock exchange is run almost entirely in its own virtual reality) can become very expensive for the seller. They are forced to deliver in time, no matter what the costs are. In contrast, the Go language simply blocks the access to the future until it's there. If you've already used Java's Futures, you know the idea. Java 8 Lambdas Seem to be Allowed to Contain Defender Methods Stephan Rauh — Wed, 05 Jun 2013 00:00:00 +0200 I just got aware how much Java 8's lambda expressions differ from closures. Traditionally, closures are very short pieces of code. In many aspects closures are a short-hand notation for methods (plus the extended variable scope). Java 8 lambdas are full-blown classes - including inheritance, methods and everything else. A SAM with a defender method To illustrate the point, I wrote a simple function that scans a directory and collects the Java source code files in an ArrayList: A Glance into the Crystal Ball: Target Typing in Java 8 Stephan Rauh — Wed, 05 Jun 2013 00:00:00 +0200 Introduction The efforts to introduce closures to the Java language go way back to 2006 or maybe even earlier, and no doubt about it, there is still a lot of work to be done. The work on closures in Java has become JSR 335, aka project Lambda. Both syntax and semantics of project Lambda are pretty stable by now, and these days there's even an IDE that can deal with Java 8's new features. That's pretty early if you bear in mind that Oracle's roadmap says the Java 8 is still almost a year ahead. This series of articles looks into the crystal ball to see what Java will bring to us when Java 8 is finally going to be shipped. My bet is that it's going to look different - and it's going to be fun. Among other things, Java 8 is going to allow you to be lazy and productive at the same time. Target typing is a key to that, and that's why it's the topic of the first article of the series. The other articles are more hands-on. They will show you Java's lambda expressions in depth, and they will show you what functional programming is going to look like in Java. By the way, this is not a tutorial on closures. There is a lot of literature, so this article's focus is on what is special about the Java variety of closures. Or rather: on lambda expressions. Java's closures are somewhat limited, so it's better not to call them closures. More on that later. Maybe you remember the Java 8 article I wrote during this years JAX conference. Back then, I enthusiastically wrote about the all-new type inference of the Java version to come. Experienced Scala or Groovy programmers may have been puzzled when they looked at the examples: they know type inference ever since, but Java's type inference is not the kind of type inference they are used to. Type inference in Scala To a Scala programmer, type inference means that you don't have to specify the type of a variable if it can be derived from the asm.js - A Reduced Instruction Set Makes Javascript Run Faster Stephan Rauh — Fri, 31 May 2013 00:00:00 +0200 The day after I finished my article claiming Javascript to be the new assembler language I heard about the asm.js project. This project strongly supports my previous article's theory. Even the project's name alleges asm.js programs are sort of assembler programs. The goal of asm.js is to define a subset of Javascript that can be executed very efficiently. The idea is to identify expensive operations and to replace them with cheaper ones. But there's a catch: you don't really want to write an asm.js program. It looks a little weird, and it's requires a lot of additional key strokes ordinary Javascript doesn't require. So why should we bother? You Don't Seriously Want To Write Your JUnit Test in Groovy, Do You? Stephan Rauh — Wed, 22 May 2013 00:00:00 +0200 Why - yes, I do! Limited CDI-Compatibility with JSF Portlets Confirmed Stephan Rauh — Tue, 21 May 2013 00:00:00 +0200 A couple of weeks ago I wrote a short note mentioning you can use CDI and JSF in Liferay portlets at last. The good news And it's true! It's hard to believe for someone like me who has been waiting two years for it. But every CDI core feature my team and I tried works flawlessly in the Liferay portal server. Named Parameters in Scala Stephan Rauh — Wed, 08 May 2013 00:00:00 +0200 When I wrote my article about parameter passing mechanisms, I believed the Call by Name to be an old fashioned idea. However, it can be pretty useful if you know what you are doing, so the Scala language (collecting clever ideas like a vacuum cleaner :)) knows it as well. JAX Conference 2013 Roundup Stephan Rauh — Tue, 30 Apr 2013 00:00:00 +0200 During the last years the annual JAX conference served as a good gauge for the trends and hypes of the Java world. This year's JAX conference felt almost boring by this measure. As far as I can see, most of the conference was about evolution. If there was any revolution I missed it. Maybe it was hiding in the dark, but the conference generally felt a lot like steady but constant progress. Actually, consolidation's not a bad thing - apart from that it's boring to write a blog article about it :). Nonetheless there were a few exciting topics: the renewed GUI battle, the arrival of the mobile platforms as major players in the Java word and the sobering after getting drunk with agile programming. As for languages, Javascript was by far the language most talked about (second to Java, of course). To my disappointment most of the other languages were hardly mentioned. Starting External Programs Without the Pain Stephan Rauh — Fri, 26 Apr 2013 00:00:00 +0200 Today, I've found a nice description why Java's RunTime.exec() method feels to clumsy. Since Java 5 there's a major improvement - the ProcessBuilder class - but still, it could be done better. AdiGuba offers an library to do so (see Runtime.ecec() n'est pas de plus simple). If you're able to read an article written in french, you will find a nice API. A problem that hasn't been solved by this API is that you can't influence a process you didn't start. Sometimes it happens that your Java applications starts an external process, crashing before the external process stops. You can restart your Java application, but it cannot kill the process its predecessor called into life. If you want to to things like that, you have to use JNI and to do some native C coding. Overview of ECMAScript 5 (aka modern Javascript) Stephan Rauh — Wed, 17 Apr 2013 00:00:00 +0200 As you probably know, Javascript used to be an an underdog among programming languages. But chances are you also may know by now it's an interesting full-blown language of its own. It isn't object oriented the way Java is. Or rather, it doesn't know classes; all it knows is objects. You can add methods and fields to objects, and you can use objects as prototypes to create other objects. This makes Javascript program look very alien to Java programmers, but you shouldn't mind: ECMAScript may take a slightly different approach than Java does, but at the end of the day it is just as powerful. These days, OIO's blog gave an interesting overview of the new features of ECMAScript 5. Java 8: PermGen Space Errors Abolished - But... Stephan Rauh — Wed, 17 Apr 2013 00:00:00 +0200 One of the nice things about Java 8 is the end of the OutOfMemoryError caused by depleted PermGen Space. These errors are especially nasty, and you can't avoid them. Once your using one of the more interesting libraries - be it a database driver or Log4J - your program is infested (see me article on the topic). But... well, if Pierre-Hugues Charbonneau is right, little is won. The error has simply been replaced by another OutOfMemoryError. The problem itself has yet to be solved. Read the full story at Pierre-Hugues Charbonneau's web site. By the way, if you're still using Tomcat 6, there is a partial solution: I'm told Tomcat 7 does a much better job on freeing PermGen space than its predecessor. Google Drops WebKit as Chrome's Rendering Engine Stephan Rauh — Fri, 12 Apr 2013 00:00:00 +0200 There are astonishing news: Google is about to drop WebKit as the rendering engine of its browser Chrome. Even more astonishing is Opera's announcement to adopt Google's new rendering engine Blink instead of WebKit (see Hello Blink). This comes as a surprise as Opera announced to adopt WebKit just a couple of weeks ago. JavaFX and GroovyFX: One Program, Two Flavors Stephan Rauh — Fri, 12 Apr 2013 00:00:00 +0200 Tiles are popular. Not only are they ubiquitous in our modern smart phones, picturesque tiles are a part of portuguese and spanish culture since countless Aparapi: Run Java Applications on Your Graphics Accelerator Card Stephan Rauh — Fri, 12 Apr 2013 00:00:00 +0200 Daydreaming of performance In the old day Java used to have a bad reputation for being slow. Nowadays, Java has become pretty fast - roughly as fast as a C++ program, and only a couple of times slower than a carefully optimized C program. But still, performance is always a hot topic. Wouldn't it be nice to have ten times the power? Actually, your computer does have that much power - if only you were able to run your application on the graphics accelerator card. Aparapi You can do so, and it's fairly simple. Aparapi's a library originally developed by AMD that has been made open source source some time ago. It analyzes the byte code of your program and compiles it to native C code that can be run on the graphics accelerator card. Java 8 Links Stephan Rauh — Thu, 28 Feb 2013 00:00:00 +0100 Recently I've read quite a few interesting articles on Java 8. This a a small collection of links to articles I consider remarkable. Feel free to leave a comment to add articles I've missed. I'd like to begin with articles written by the Java 8 programming team: Brian Goetz on the state of the lambda project Lambda extensions to the collections API Maybe you're even interested in my articles on Java 8 and lambda expressions. I also enjoyed reading these articles: User experience of early Java 8 students Feature comparison of Scala and Java Far side look at Java 8 Maurice Naftalin's Lambda FAQ The JSF Code That's Just a Bit Too Clever Stephan Rauh — Fri, 22 Feb 2013 00:00:00 +0100 Miraculous code? Today I've been studying some lines of code that obviously should have done - well, they should have done nothing at all. I read the code, and judging from what I saw at first glance, the implementation was missing. Luckily the program didn't know that. So it didn't care about the missing implementation, working just fine. It took me a couple of minutes to realize that the algorithm at hand was sort of obfuscated. The implementation was there, no doubt about it. But it was hidden where I didn't expect it to be, and it used a variable without accessing it, so I failed to recognize that the variable was used indeed. Liferay Hooks Stephan Rauh — Sun, 10 Feb 2013 00:00:00 +0100 Liferay has a nice feature to influence the behavior of the portal by deployable items. Among other things, you can use these "hooks" to call a java method if the user logs in or logs off again. My particular use case was to show different pages to different user groups. Hooks are described nicely at their wiki. Unfortunately, this description is a little outdated. For the sake of convenience, I jot down the basic steps to write a hook. Primefaces RemoteCommand: Lazy Loading Revisited Stephan Rauh — Tue, 29 Jan 2013 00:00:00 +0100 Last year I published an article on lazy loading in JSF pages. This article became one of this blog's most popular articles. Obviously I'm not the only developer suffering from slow back ends. Most likely you already know what lazy loading is about: it's about slow back ends. If you have to deal with a slow back end you shouldn't call it when initializing your bean. Your JSF page is shown after your bean has been initialized completely and after every bean property displayed by the page has been read. So you'd rather have a bean that's constructed and initialized quickly, and your getters shouldn't waste time. But what if it takes - say - 30 seconds to initialize the bean? How to use Primeface's poll component to do lazy loading Stephan Rauh — Fri, 18 Jan 2013 00:00:00 +0100 This is a nice little trick a colleague of mine found out. Consider a JSF page that uses a major backing bean. Suppose it takes a long time to initialize this bean (e.g., because a huge amount of data have to be loaded from the database). The JSF page is shown when the backing bean has been initialized completely. We were looking for a way to decouple the JSF page rending and the initialization. The idea was to show a rudimentary JSF page at once (e.g. the page is shown completely, but some data tables are empty). Once the backing bean has finished it's initialization the missing data is inserted. To do so you can use Primefaces poll component. Put the long-lasting initialization into a public method that is not called by a constructor, a getter or a @PostConstruct method. Put a poll element behind the data table. The poll component calls your new public method. To make sure the method is called only once, add an onstart="myPoll.stop()". To make sure your method is called early add interval="1". There is a drawback to this approach: the client initiates the initialization, and it is delayed by at least a second. You can avoid this by starting a new thread doing the initialization in the backing bean's constructor. You save a second, but this approach is far more complex, especially when you try to debug your code. If you can afford to wait an extra second, better keep your code simple. Update You can also use Primefaces remoteCommand to implement a better and simpler version to do lazy loading. Update February 26, 2019 It goes without saying you can do the same trick with BootsFaces, using either or . A close look at AspectJ code Stephan Rauh — Wed, 16 Jan 2013 00:00:00 +0100 Many people claim AspectJ is slow. Rumors have it AspectJ is copying the aspects code into every method that uses the aspect. Eclipse's debugger also behaved strangely at my office PC, indicating that this theory might be true. These days I had a closer look at the byte code to verify or falsify this. A Java Approach to Duck Typing Makes Reflection Easy Stephan Rauh — Sun, 06 Jan 2013 00:00:00 +0100 Explaining Duck Typing in a nutshell Traditionally, Duck Typing allows you to call methods in a relaxed way. Java restricts you to call method if (and only if) the compiler knows it's there. Duck Typing removes this restriction. You can call a method if it's there. Wether you can call the method or not isn't decided by the compiler, it's decided at run time. Let's have a look at a valid Groovy code snippet to see the difference to Java: Third Glance into the Crystal Ball: Functional Programming in Java 8 Stephan Rauh — Sat, 05 Jan 2013 00:00:00 +0100 Introduction This article shows why lambda expressions will change Java programming style considerable, and it shows you what it looks like. For the sake of convenience I'd like to repeat the introduction of the previous article. A simple example Every once in a while I want to know how many lines of code my project has. Ad-hoc-statistics like this are a lot of fun in Groovy: Fourth Glance into the Crystal Ball: Advantages of the Java Approach Stephan Rauh — Sat, 05 Jan 2013 00:00:00 +0100 The first three articles of this series showed you how Java 8 programming is going to look like. Now it's time to compare the Java approach to the Groovy or Scala approach. Why did Java chose limited lambda expressions instead of full-blown closures? How to Evaluate JSF Expression Language (EL) Expressions in a Bean Stephan Rauh — Sat, 05 Jan 2013 00:00:00 +0100 Sometimes you want to use JSF expressions in your Java code. For example you can use EL expressions to access another bean you don't have a reference to Java Editors Display Anonymous Inner Classes as Java 8 Lambdas Stephan Rauh — Sun, 30 Dec 2012 00:00:00 +0100 Folding editors allow you to hide information you are currently not interested in. Most folding editors can collapse methods, loops and if-statements, showing the merely the first line and a "plus" sign to expand the collapsed region again. IntelliJ 12 and the Eclipse plugin Lambda4jdt take this idea to another level: Actually, this is a shorter version of the real source code: Stack Traces Tales Stephan Rauh — Sun, 30 Dec 2012 00:00:00 +0100 Did you ever look where a stack trace really comes from? You might say it is created where an error occurs. Or you might say the stack trace printout shows the precise line where the exception is thrown. Surprisingly, this is not the case. Simplify CSS with LESS Stephan Rauh — Sun, 30 Dec 2012 00:00:00 +0100 Maintaining major CSS files can be a challenging task. If you use nested CSS commands, there are so many combinations that it is easy to get lost. LESS is a DSL that comes to the rescue. It allows you to write the nested CSS instructions in a tree-like way. The Art of Refactoring: Removing Code Duplications Stephan Rauh — Sun, 30 Dec 2012 00:00:00 +0100 In most cases I start refactoring when I recognize the code has begun to smell badly (as a collegue of mine uses to call it). In the past week I frequently refactored duplicated code. Eclipse provides you with excellent tools to do so, but sometimes the code needs to be prepared to enable Eclipse to perform its magic. The pattern recognition of Eclipse is far less flexible than any human beings pattern recognition. Frequently Eclipse misses repetitions that are completely obvious to you. There are some tricks to help Eclipse. By the way, this article is about concepts. It is not about using a particular tool, nor is it about a particular language. This article provides you with screen shots of Eclipse and Java, but of course the ideas are applicable to any procedural language and to any IDE capable of refactoring. I suppose this includes Netbeans and IntelliJ's IdeaJ, just to name a few tools in the java world. Consider the following code: Renaming Threads Stephan Rauh — Tue, 11 Dec 2012 00:00:00 +0100 JEE servers tend to create quite a few threads. Sometimes you are looking for a very slow algorithm, maybe even an infinite loop. You don't know where to find it beforehand, so chances are you didn't set a breakpoint. At other times the situation is even worse: the infinite loop occurred in a production environment, and you are sent a trace dump. Wouldn't it be nice to know which thread had been working on the infinite loop? Groovy Rocks! Most of the Time :) Stephan Rauh — Tue, 11 Dec 2012 00:00:00 +0100 Let's have a look at the JSF magician I presented a couple of days ago. Writing this program was a lot of fun. It felt like the Groovy designers had my JSF magician in mind when they invented the Groovy language. It contains a lot of code that make Groovy shine. Or rather, it contains little code that makes Groovy shine: There simply isn't much code that can shine. Groovy allows for some very compact syntax. When I wrote the predecessor of the JSF magician, I wrote it in Java, and it was a lot more verbose. Early Glimpses into Java 8 Programming Stephan Rauh — Tue, 11 Dec 2012 00:00:00 +0100 From my point of view, the most important feature of the coming Java 8 language is functional programming. In other words, closures, method references, default methods and the improved collections API that enables you to use these features. You can see a number of code samples here. Of course, languages like Scala and Groovy know these features since ages. So it's an obvious idea to explain functional programming in Java 8 by comparing Scala and Java 8. This blog provides you with a lot of explanations and code snippets in both languages. PermGen Tales: Weird Ways to Run Out of Memory Stephan Rauh — Tue, 11 Dec 2012 00:00:00 +0100 Imagine a web server that runs out of memory. Even without running an application. Sounds absurd? Well, that's exactly what my team and I observe since a couple of weeks. Java Renaissance - Closures and Multiple Inheritance in Java 8 Stephan Rauh — Thu, 29 Nov 2012 00:00:00 +0100 The rise of alternative JVM languages like Groovy, Ruby or Scala has been made possible by the growing conservatism, if not stagnation, in the java world. In particular, the Java language itself hasn't evolved that much since September 2004, when Java 5 had been released. Eclipse Breakpoints Unleashed Stephan Rauh — Thu, 18 Oct 2012 00:00:00 +0200 Have a look at the code snippet without looking at the code. Today it's not the code I'm interested in. Just look at the left margin Where Am I? Stephan Rauh — Wed, 17 Oct 2012 00:00:00 +0200 A particularly nice feature of the Java language is Introspection. Chances are you are familiar with reflection, being the most popular API that allows a program to analyze itself. But Java doesn't stop there. This article shows you how easy it is to find out where you are - or rather, where your JVM's program counter points to. Debugging Code Using AspectJ: Surprises and Caveats Stephan Rauh — Wed, 17 Oct 2012 00:00:00 +0200 This article is intended to be a collection of hints concerning AspectJ. Currently, this list is pretty short, but I'm going to add new hints whenever I stumble into a caveat. You can add to the list yourself: Please feel free to add your own experiences using the comment function. Don't set a breakpoint on the first line This example applies to Eclipse without the AJDT plugin. Chances are that AJDT fixes the bug (I didn't verify this). I suspect other IDE suffer from the same bug, but I didn't check this, either. If you set a breakpoint on the first line of a methods that is woven into an @around or @before aspect, the debugger will stop at the breakpoint twice. Set it at the line below, and the debugger will stop only once. In my particular use case this behavior puzzled me completely because I didn't expect the debugger to stop at all - thus making me believe the weaving mechanism didn't work: JSon and GSON Stephan Rauh — Sat, 07 Jul 2012 00:00:00 +0200 There is a nice library that makes creating and reading Json objects fun: Google GSon. I use it in every class of mine to implement a toString() method. You can even use to to implement the clone() method (if you don't care about performance): Got a prepaid sim card for your IPhone w/out internet access? Stephan Rauh — Thu, 21 Jun 2012 00:00:00 +0200 During my last trip to France, I bought a french prepaid sim card to reduce costs. However, it didn't pay. The Evolution of Programming Languages Stephan Rauh — Thu, 10 May 2012 00:00:00 +0200 I'm fascinated by languages. This includes both programming languages and spoken languages. So I decided start a series of articles comparing computer languages. Sometimes different languages have remarkable and instructive differences. There are also interesting similarities - maybe I manage to show them, too. Let's start with some general thoughts on programming languages. Combining lombok and AspectJ Stephan Rauh — Thu, 10 May 2012 00:00:00 +0200 Both lombok and AspectJ can simplify your java code by removing or reducing mindless code repetitions. The first one allows you to get rid of most of the getters and setters (and other methods), whereas the latter makes it easier to include cross cutting concerns to your code. Unfortunately, the corresponding Eclipse plugins are incompatible. Is AspectJ really slow? Stephan Rauh — Thu, 10 May 2012 00:00:00 +0200 These days, I've been asked about my experiences with AspectJ. What about your application's performance, they asked me. Isn't it bogged down by AspectJ? Slow JNDI lookups Stephan Rauh — Mon, 02 Apr 2012 00:00:00 +0200 Today I stumbled over an unexpected performance leak. Looking up for simple variables in the JNDI context sometimes seems to consume some 20 ms. At other times, the lookup takes only a few microseconds. Zipping a file (Java 6 style) Stephan Rauh — Mon, 19 Mar 2012 00:00:00 +0100 Zipping a file in Java is a rather trivial task you can find in many tutorials. However, I'd like to use it in a subsequent article, so I publish it anyways. By the way, it is another example of (almost) correct resource handling before Java 7. Templates for Java 6 style resource management Stephan Rauh — Mon, 19 Mar 2012 00:00:00 +0100 I've seen so many questionable solutions of Java file and database IO that I decided to offer a template you can freely copy. By the way, being a hurried (and lazy) programmer, I frequently do Java IO wrong myself, so I will copy this template, too :). A sad story of spam and ham Stephan Rauh — Sat, 17 Mar 2012 00:00:00 +0100 Dear Readers, your comments are important to me. They help me a lot to improve this blog - and they show me there are people who read this blog, and, judging from your comments, even enjoy it. Thank you very much! An easy-to-use Java 5 parser Stephan Rauh — Sat, 10 Mar 2012 00:00:00 +0100 Sometimes it can be useful to read and analyse a java class. This can be a tedious task; the classical approach is to write a grammar for the language and to generate a parser. This is exactly what Júlio Vilmar Gesser did. His parser has a simple interface, allows both reading and modifying java code and is available under the LGPL.