I'm a little afraid of posting this blog, thinking that it could resulting in either
- So many and varied requests that it will be difficult to address them all
No responses at all. (If a blog falls in the forest and noone reads it, does
it still make a sound?)
Nevertheless, I'll forge ahead. After all, the whole point in my blogs/articles
is to talk about stuff that developers want or need to know more about.
So, in the words of the unforgettable sourthern rock band and Java desktop client developers Lynyrd Skynyrd:
What is it you want to hear?
In other words, what would you like to see articles on? I have a few ideas kicking
around in my head that I'd like to cover, and people have suggested a few more. But
if you have other ideas that you would like to have considered, please tell me in the
feedback section below.
Here are a few topics that I would like to cover sometime soon, to give you a feel
for where things are headed. If you have opinions on these, feel free to post those
below as well:
Managed Images: I've written about Managed Images in various forums so far (such as the
BufferedImage (Part 1 and
Part 2), VolatileImage (Part 1 and Part 2), and Image Strategies articles). But maybe managed images deserve their
own dedicated article.
Old vs New: I believe that some of the confusion and performance problems in Java graphics
usage comes from the difference between the old Java graphics APIs (those written in the
jdk 1.x days, e.g. ImageProducer, ImageConsumer, PixelGrabber) and the new ones
(starting from jdk 1.2, e.g. BufferedImage). I would like to write an article (or maybe
a series of articles) on the differences between these APIs and their implementations.
Specifically, I would like to examine how developers would do things (such as
image pixel manipulation) on the old graphics APIs and how they would do things
using the newer APIs (hopefully better, faster, and more efficiently).
Server-based graphics: This is also probably a series of articles. One thread is a
discussion of how to do graphics operations (such as image creation and manipulation)
in server apps (when you are not displaying to screen, but rather to/from images
only). Another thread involves rich clients for server-based applications (such as
Web Services); how can we make it easier to write clients that interact on the
network and with servers? These are all pretty complex topics, so understanding and
explaining the issues may take some time. But in this increasingly connected world,
this seems like a useful topic in graphics development.
ImageIO Utilities: While ImageIO simplified many things in image reading/writing and
manipulation, it complicated some operations that are simpler in older APIs. For
example, displaying an animated GIF is simple when loaded through some of the old
1.x APIs such as
Toolkit.getImage(). But when using ImageIO, the developer
needs to do much more work to display the images correctly. It's that whole "with great
power comes great responsibility" thing; the power of the ImageIO APIs and the
information that it exposes to the developer also (for now) necessitates more
work to make some operations succeed. I would like to explore some of these issues
to see if we can derive some simple frameworks or approaches that developers can
reuse in their work to simplify their applications.
Image Scaling: This is related to the "Old vs. New" topic above; some operations
in our APIs are not obvious. Also, even when there are obvious methods in the API
for accomplishing tasks, sometimes it is not clear how these methods work, or that
the best ways of accomplishing the tasks are perhaps not related to the most obvious
means. For example,
Image.getScaledInstance()is not, in general, the
best way to scale an image, either performance- or quality-wise. The
Graphics.drawImage()methods are much better in general, but they are
not necessarily obvious to developers new to the
I would like to cover some of these areas and discuss the merits of the different
Rendering Hints: Wouldn't it be nice to have the hints discussed in a single area
where it is more clear (than in the current javadocs) what happens when various
hints are enabled?
Transform Tips & Tricks: There are always questions about how to go about transforming
things correctly or most efficiently. We could explore some of these topics in
an article or series of articles.
Animation: Some of the *Image* articles have touched on this topic, but perhaps an
article dedicated to animation would be helpful. This article could cover everything
from performance tips to timer usage.
Done! I've just posted an article entitled Timing is Everything on java.net. It doesn't cover animation as a whole, but has some information about timers and utility code I developed to add higher-level functionality to the existing Java timers.
Intermediate Images: This topic comes out of something we've discussed in our JavaOne
talks before: using images to cache complex rendering. This can be a huge win for
animation or performance-sensitive graphics apps. Some sample code and implementation
details here might help people take advantage of this high-performance approach to
Java graphics development.
Done! An article on Intermediate Images is now up on java.sun.com.
That's all I can think of for now, although I tend to add to my internal list of blog TODOs frequently.