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 Graphics class. I would like to cover some of these areas and discuss the merits of the different approaches.
• 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.