Skip to main content

"Freebird!"

Posted by chet on August 23, 2004 at 11:13 AM PDT

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


or

  • 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.

Related Topics >>