Wizard dialogs are a very common design pattern for user interfaces, e.g. for the GUI of software installation tools. However, although wizard dialogs are so ubiquitious these days, component frameworks such as Swing or JSF do not provide any support for them, so you have to turn to a third party library or roll your own. In this blog posting, I am modeling an abstraction for internationalized wizard dialogs which is independent of the particular user interface technology and easy to implement and use, e.g. in Swing based desktop applications or JSF based server applications.
I just created a demo for Guice, Google’s popular dependency injection framework. The Guice Demo is somewhat more complex and realistic than the samples in the Guice Wiki. The documentation discusses some general aspects of applying the Dependency Inversion Principle.
As an aftermath of this demo, I’ve also created Guicer, an alternative Domain Specific Language (DSL) for configuring a Guice
Injector which is simpler and more concise than the original Guice DSL. The documentation introduces you to the DSL.
Enjoy the Guice!
At current, there is very little information about how to use Markdown syntax to author pages for a project site with the maven-site-plugin. With this blog posting, I am going to change this – at least a little bit.
In this final part of the series I am going to look into the Lambda Expressions pattern to define an internal DSL for constructing object graphs. I am also going to provide some conclusions for the three patterns.
In this second part of the series I am going to look into the Nested Functions pattern to define an internal DSL for constructing object graphs.
I just came along a very interesting blog posting about Domain Specific Languages (DSL) in Java. In his posting, Mohamed Sanaulla nicely discusses three different patterns to define an internal DSL for constructing object graphs: Method Chaining, Nested Functions and Lambda Expressions. In this series, I am going to look into each of them. In this first posting of the series, I am going to look into the Method Chaining pattern.
In part one of this series, I’ve introduced you to the
Transformation interface, which applies or unapplies a function to a
Sink. In this posting, I’ll show you how to write a general-purpose composed
In the second part of this series, I’ve covered caveats when using the
Sink interfaces. This time, I’ll look into another useful abstraction, the
In the first part of this series, I’ve introduced you to the
Transformation interfaces. This time, I’ll look into a caveat and provide some more useful implementations.
Pretty much any program needs to do I/O to process some data. Sure, in Java we have
OutputStream (or its modern day cousin,
Channel) to do this with relative ease. However, this is not the end of the story. In everyday programming, I often need some higher level abstractions. Actually, I need them so often that I wonder why there are no abstractions like the following in the JSE API.