Internet Archive WayBack Machine: Valuable Technical Reference

Have you ever bookmarked a really good technical resource, but were disappointed when you tried to access that page later and it was gone? Have you ever seen what looks like the perfect linked resource in a blog post, article, or book, but then found the referenced URL to not work? In short term cases such as an intermittent server issue or network problem, Google Cache can be an indispensable tool to see a cached version of the page. When a page has been completely removed for a long time, a web page archiving site is more helpful.

A particularly easy site archive tool to use is Internet Archive's WayBack Machine. This free online tool is very easy to use if you know the URL of the page you care about (which you would if the URL was part of a bookmark or if you clicked on a link to a site that was no longer present). You can enter the URL in the form field at the Wayback Machine page, click on the button saying "Take Me Back."



After doing the above, you see a detailed history of changes to the page at that location. This is demonstrated in the following screen snapshot.



The above screen snapshot demonstrates use of Internet Archive Wayback Machine to see a history of my page on Common Struts Errors and Their Causes that was originally posted on GeoCities, but is no longer available due to the demise of GeoCities.

Even though the page is no longer available at the GeoCities URL, its archived versions can still be viewed via the Internet Archive WayBack Machine. The following two images show what happens when one tries to access the page at its former GeoCities address and then what happens when using one of the Internet Archive WayBack Machine's archived versions.





As the screen snapshots above indicate, the page that is no longer available on GeoCities is still available via Internet Archive WayBack Machine. In my case, I have hosted this page at Google Sites and there are many other mirrored copies of it on the web, but the Internet Archive can be useful for finding pages that don't get copied or hosted on alternative sites. Because Internet Archive WayBack Machine also provides various versions of the same page, a history of a particular page can be seen.

The recent loss of GeoCities-hosted pages only one of many examples of original content being removed from the web. A relatively recent well-known example of loss of original content was the sudden and somewhat surprising online disappearance of why the lucky stiff. The next two screen snapshots show a page from the popular Why's (poignant) Guide to Ruby. The first snapshot indicates that the original page is no longer available at its original URL (http://www.poignantguide.net/ruby/chapter-1.html), but the second snapshot indicates that it is archived and accessible with WayBack Machine (at http://web.archive.org/web/20080526095452/www.poignantguide.net/ruby/chapter-1.html).





So far, I've only discussed the simple search implemented by providing the URL and clicking on the "Take Me Back" button. There are many advanced search options as well. If you have an e-mail or bookmark with a URL that no longer works, you'll often have a date on the e-mail or a date on the bookmark property of when it was created. You can use that date with WayBack Machine to find the page as of that date. This is especially useful for an easy way to recollect history.

What was big in the world of Java in late 2004? To find this out, I could look at archives for some major players in the Java world. For example, the java.sun.com page on the last day of 2004 looked like that shown in the next screen snapshot:



We can see from the above screen snapshot (I had entered http://web.archive.org/web/20041231/java.sun.com/ with a day but no time, but it resolved to http://web.archive.org/web/20041231092116/java.sun.com/ with a day and appropriate time) that big topics at the end of 2004 included early access to binaries and source of Java SE 6 (then still called as J2SE 6 or Mustang) and NetBeans 4.0.

As a final example, I'll look at something from the very early days of Java. The URL http://web.archive.org/web/19970211220056/www.sun.com/sunworldonline/swol-10-1995/swol-10-javadigest.html provides an interesting article from SunWorld Online called Java users reveal their habit. This makes for very interesting historical perspective for those of us in the Java community. For those of us who have been around since the public inception of Java, it is a reminder that applets were once the "big thing" in the Java world. For those who are not familiar with the early days of Java, it can provide an interesting perspective on how far things have come (and how much some things are still the same).

Assuming that the deal for Oracle to acquire Sun Microsystems goes through, there is some question about what will happen to the wealth of Java resources available online at domains such as http://java.sun.com/ (such as the JDK 6 Documentation). These articles and other documents will almost assuredly continue to exist (even if at a different URL that includes "oracle" in its name), but it is still comforting to know that the archived versions should also be available via the WayBack Machine.

There are many valuable benefits to having old web pages still available after their deletion and having the ability to see older versions of a particular web page. When one runs into the all-too-common frustration of finding a bookmark or link that is no longer valid, the Internet Archive WayBack Machine is a very welcome tool. However, such power can also be abused. Some articles that talk about people who are not too happy with the power of the WayBack Machine include Internet Archive Sued Over WayBack Machine and Internet Archive Settles Suit Against WayBack Machine.

As an interesting side note, there is a Java-based, open source implementation of the WayBack Machine called wayback.


Conclusion

There is no question that the ability to link documents via hyperlinks is one of the main reasons for the success of HTTP and the World Wide Web. It is very convenient to click on links in bookmarks, e-mail messages, articles, blogs, and even type in URLs from books and go directly to the referenced site. On the other hand, one of the greatest disappointments when using the web is when a hyperlink is no longer valid. Although a search engine might be able to tell you a page's new location (or the location of a mirror or copy), or Google Cache might be used to see a cached version of a page that is temporarily down, a tool like the Internet Archive WayBack Machine is sometimes what is needed to see a page that is no longer otherwise available. In cases where the page still exists, but information that was previously available has been removed, WayBack Machine's ability to see historical versions of that particular page is very useful. In many ways, using WayBack machine definitely feels like time travel.

Reocities: GeoCities Rising from the Ashes

I previously wrote about the potential loss of historical technical details as a result of the demise of Yahoo! GeoCities. I listed several useful technical pages hosted on GeoCities that might be lost. Others have also pointed out that GeoCities provided a perspective of the early days of personal web pages with profound value for those interested in studying the history of the web.

I read with interest Jennifer Van Grove's post One Man's Quest to Bring GeoCities Back from the Dead. The endeavor she highlights, instantiated as the ReoCities site, is interesting enough because of the salvaged data of potentially significant value. Perhaps even more interesting, though, is the technical challenge associated with this and the approach being used. More details on this can be found in The Making Of, a story of stress and scripting.

According to the Wikipedia entry for GeoCities, other efforts to archive potentially valuable data hosted on GeoCities include Internet Archive and InternetArchaeology.

Maintaining a Software Development Library (Books)

For as long as I can remember, I have always loved books. When I was growing up and my parents would offer to buy my brothers and me something at the store, I'd almost always select some fictional book while my brothers would select toys. As an adult, I don't read as much fiction as I'd like, but I do buy and read (at least portions) of a lot of technical books. I've got technical books strewn around the house in several different book cases in several different rooms. My wife asks me to take more of them to work, but I have my two long book shelves at work filled as well. In this blog post, I look at why I value these books (versus the information freely available on the web), how I get many of them for really low prices, and how I finally determine when a book has gone beyond usefulness to uselessness and often even to being a hindrance.


Why Books?

With the prevalence of blogs and online articles, why do we even need technical books? I have found that blogs and articles can be superior to books in terms of cutting-edge knowledge and in terms of strange corner cases. However, books are typically better at providing "big picture" introduction to a topic and at providing in-depth thorough coverage of a topic. Books can also be taken just about anywhere, though e-books are becoming more portable with devices such as the Amazon Kindle. I still prefer the ability to write notes in my book and I find that my memory of a certain concept or description seems to be better with physical associations I make mentally. Books often provide more consistent and thorough coverage of a topic than can be covered in a collection of blog posts and articles, even when written by the same individual or team.


Acquiring the Technical Book

I have purchased some real stinkers when I have not adequately researched what I was purchasing. Fortunately, I have gotten better at picking better technical books. There are several factors that aid in this process. Reviews on sites like Amazon.com can be insightful, especially when reviewers express why they like or dislike a particular book. There are also many bloggers who post reviews of technical books. Furthermore, many users groups also provide book reviews. Asking fellow developers and colleagues about the books they own and/or have read can also be enlightening. It is best to consider a wide set of reviews rather than a single review when trying to determine whether to purchase a particular book.

I have sometimes made a decision to purchase a book after borrowing it from a colleague or from the library. This was the case with the Second Edition of Effective Java. I was "on the fence" about purchasing the Second Edition (until it fell in price on the Amazon Marketplace at least) until I borrowed a colleague's Second Edition and realized how much was added in that edition. I have also found several highly useful books and some not-so-useful books after borrowing them from the library and evaluating them. In a few cases, I have gotten the tip or piece of knowledge I needed from a particular book during the period I had it borrowed from the library and did not need to purchase it after borrowing it.

Many publishers offer sample chapters that allow one to preview a portion of a technical book and this can provide insight to the author's writing style and level of detail. Entire older editions of some books are available online. For example, Bruce Eckel makes old editions of some of his books available online. O'Reilly has its Open Books Project with online editions of books that can be reviewed (and sometimes this is the only way to easily access out of print books). If you like what you read there, you can purchase the latest edition to get up-to-date information.

Speaking of older editions, there can be times when acquiring an older edition of a particular book is satisfactory. An older edition can be much less expensive than the latest edition. Traditional and online bookstores will deeply discount the older editions before the new editions come out. Depending on how important the information in the new edition is, considering an older edition can be a useful approach.

When I purchase a technical book, I often first consider Amazon Marketplace. The Amazon Marketplace has the advantage of being hosted directly on Amazon.com and allowing the purchase to be made via Amazon using one's Amazon account. This implies no need for a special account and means that Amazon handles the financial transaction. I am more comfortable trusting my credit card information with a single vendor (Amazon) than with each individual third-party vendor that sells on Amazon Marketplace. My experience is that the new or used books purchased through Amazon Marketplace often arrive quickly and in outstanding shape.

There are a couple things to be aware of when using Amazon Marketplace. For one, shipping and handling is added to the price and typically purchasing $25 worth of merchandise does not mean free shipping when purchasing through the Marketplace. There are times when the fulfillment is through Amazon on a Marketplace purchase and in some of those cases the purchase can use the free shipping with $25 purchase option or Amazon's other prime shipping deals. There are times, especially for newer and more popular technical books, when it costs almost as much or even more to purchase the Marketplace book and pay the shipping (often $3.99 per book) as it costs to buy the book new directly from Amazon with free shipping.

A second consideration with purchasing books on Amazon Marketplace is that the third-party vendor typically arranges the actual administration of the order fulfillment. This can mean a delay in delivery, though it varies widely from very quick vendors to very slow vendors. If you need the book in the next several days, you might want to consider another option.


Using the Technical Book

Although I love books in general and technical books in particular, I rarely read technical books cover to cover. I have only read portions of most of my technical books. In some cases, I have read the entire book several times, but never cover-to-cover. I have read a few technical books cover-to-cover, but that is the exception rather than the norm.

I like to read portions of many of these books during small amounts of available free time. This can include waiting for a car to be serviced, waiting at a doctor's office, waiting for a train on railroad tracks, etc. I almost always have a book with me in the car for such situations. I also read portions of books directly related to whatever I'm working on at the time.

A technical book is often used as a reference and, in such cases, a good index is highly valuable. I have found that a really good index can turn a mediocre book into a trusted resource. Even the best indexes often lack every term I find myself frequently looking up in the book. Because of this, I have gotten in the habit of adding my own index entries in my most-used books for terms and pages that I expect I may want to look up again in the future.

Besides writing in my own index entries, I also often write notes in my books referencing other sections of the book that are related. I like to record any substantive changes on relevant pages in the book to help address obsolescence that is unavoidable with technical books. For example, the Spring Framework Reference is almost always going to be more current than a printed book can ever hope to be. Therefore, my favorite Spring book has many notes in it adding new or changed features in the Spring Framework that I have found out about via blogs, articles, or reading the Spring reference.


Saying Goodbye

Because I enjoy books so much, it can be difficult to part with one, even when it has lost its usefulness. For one thing, there is always the possibility that I might need it again. It can be difficult to admit that I probably won't. Another hindrance to getting rid of a particular book occurs when it is outdated, but I hesitate to invest in a newer edition or improved version. There are also logistical issues such as how to determine when a book has lost its usefulness and deciding on the best way to get rid of it (paper recycling, book use recycling, trash, etc.).

When a book gets so old that it actually contains information that is no longer accurate, it can be risky to use. This is because it can teach incorrect principles that have to be unlearned and can waste a lot of time trying to figure out why something doesn't work as described in the book. In a worst-case scenario, one might even be dissuaded from using a particular technology because of frustrations that are a direct result of using an obsolete and/or incorrect book.

Some books are easier to get rid of because the covered technologies are obviously obsolete. For example, I shouldn't have much trouble getting rid of my book on J# because it is extremely unlikely at this point that I'll ever need that book. Even better examples are books on specific versions of products or implementations that are no longer available or are no longer regularly used.

With some still-popular languages and frameworks it can be more difficult to determine when a book on the subject has passed its useful life. For example, it is my opinion (assuming one is developing in JDK 1.4, J2SE 5, or Java SE 6) that any book on Java that was written before JDK 1.1 is not worth reading or using. Although a book on JDK 1.2 or JDK 1.3 might be a little better, I really don't think most Java books focused on a version of Java prior to JDK 1.4.2 are worth keeping (or at least regularly referencing). JDK 1.4 was a "game changer" in the world of Java development and it is my opinion that any Java book with real usefulness must address at least that version. Similarly, any Flex book covering Flex 2 or Flex 3 might be fine, but any book addressing Flex before Flex 2 (Flex 1.0 or Flex 1.5) is generally not worth keeping or using.

I typically am too much of a cheapskate to purchase a newer edition of the same book unless the new edition offers enough to justify its purchase. An example of when this has been the case is Effective Java. What makes this example interesting is that even after purchasing the Second Edition, I have retained my First Edition copy. The reason for this is that the First Edition is still largely valid and I like to have it around when I have loaned my Second Edition to someone else or have left it somewhere other than my work desk. The point of this is that even purchasing a newer edition of a particular book may not necessarily mean it is time to get rid of the older edition.

When the time comes to part with a technical book, there are several options. If the book is still relevant (not usually the case for me because I wait until the book is completely useless to anyone to part with it), it can be sold online (such as through the previously mentioned Amazon Marketplace, eBay, or other used book selling venue). A book with some remaining relevance might also be donated to a library, a school, or to fellow developers who are working with the language or technology and don't have a better book (especially if they are using an older version to which the book is more applicable). If a book has become so obsolete that it has no value to anyone, the best remaining option is to have its materials recycled.

There are several good blog posts on getting rid of technical books. These include Don Demsak's Recycling Technical Books, Book Recycling, and How Can I Reuse or Recycle Old Books? (see feedback comments as well), and How Book Recycling Can Help the Environment.


Ideas for Good Technical Books

Looking for ideas for some good technical books to add to your personal library? Here are some lists of others' favorite technical books:
• StackOverflow: 'Must Have' Books on Your Bookshelf (2009)
• What Is The Single Most Influential Book Every Programmer Should Read? (2008)
• Top 100 Best Software Engineering Books, Ever (2008)
• The Best Books Every Programmer Should Read (2006)
• Coding Horror: Recommended Reading for Developers (2004)
• Elliotte Rusty Harold's Ten Must-Have Technical Books (2003)


Conclusion

A technical book can be a valuable resource in improving one's skills. However, most of us want to be careful without our money and (perhaps even more careful) with our time. We want to spend our money and time as efficiently as possible. In this blog post, I have recorded some of the things I have learned to improve the efficiency of money and time I invest in acquiring, using, and finally retiring of technical books.

Firefox 3.6 Requires Java SE 6 Update 10

Java SE 6 Update 10 was a significant release despite its version numbering indicating a minor release. Among other advancements, Java SE 6 Update 10 introduced the Next-Generation Java Plug-in for a better Java applet experience. It has now been announced that Firefox 3.6 (Namoroka) will require this next-generation plug-in. Users can access the web page at http://java.com/en/download/help/testvm.xml to test the version of Java supported on a particular machine. The Firefox 3.6 for Developers page specifies advancements in support for Cascading Style Sheets, HTML, JavaScript, DOM, and XPath.

RMOUG Training Days 2010 Abstracts: Groovy, REST, and Better UIs

As I noted in my previous post, my two abstracts have been accepted by the Rocky Mountain Oracle Users Group (RMOUG) for presentation at Training Days 2010. I have also learned that Bill Jackson's abstract for "Ten Easy Ways To Build a Better GUI" has been accepted as well. I will include the abstracts for my two presentations and for Bill's presentation later in this post.

I am eager to present these two presentations because they are inspired by the presentations that I had planned to present at Colorado Software Summit 2009. Incidentally, that conference would have started tonight with the annual Sunday evening reception famous for its good food and interesting conversation. It was a great way to casually and comfortably kick off an absolutely terrific conference. I was sad to hear about the end of this conference and don't like thinking about what I am missing this week. It certainly would have been nice to be getting my brain crammed full of software development concepts and ideas this week in beautiful Keystone, Colorado. As I stated, however, the opportunity to present presentations at RMOUG Training Days 2010 similar to what I had planned for CSS 2009 is a positive one.

My two abstracts that were accepted for RMOUG Training Days 2010 are "Applied Groovy: Scripting for Java Development" and "RESTful Java." The abstracts for these two presentations are (may differ slightly from what will appear in the conference materials):


Applied Groovy: Scripting for Java Development

As a dynamic language that runs on the JVM and can be used anywhere the Java programming language is used, Groovy is a great choice for building, testing, and maintaining Java SE and EE applications. This presentation briefly summarizes some basics of Groovy and advantages of using Groovy before moving onto demonstrating how to use Groovy to improve the ability to build and test standard and enterprise Java applications. Although the basics of Groovy will be covered initially in the presentation for those who have not used Groovy previously, most of the syntax and other features of Groovy covered in this presentation will be presented in conjunction with use of Groovy in the building and testing of applications for the Java platform.


RESTful Java

The Java platform provides many types of support for building REST-based web services and REST-compliant clients. This presentation will briefly summarize the main principles of the Representational State Transfer style of web services before covering several of the most popular Java-based approaches for working with REST. The presentation will focus on JSR 311 (“JAX-RS: The Java API for RESTful Web Services”), Jersey (the JSR 311 reference implementation), Restlet, and Enunciate while also covering other useful tools related to REST-oriented development with Java.


Bill Jackson's abstract is called "Ten Easy Ways to Build a Better GUI." His abstract is shown next and, as its name implies, focuses on Graphical User Interfaces (GUIs).


10 Easy Ways to Build a Better GUI

In the world of graphic user interfaces, form nearly always follows function. From Dilbert jokes about GUIs designed by engineers to MySpace’s reputation for ugly pages it’s clear that designing attractive, useful, and well thought-out GUIs is much easier said than done.

However, positive examples in the commercial world such as Apple’s well-earned reputation for stylish products show just how much impact a well designed user interface can have. This presentation will cover 10 basic steps for building more intuitive, attractive, and useful user interfaces. The discussion will include issues such as usability, data presentation, form layout, color selection, icon acquisition, and a host of other issues that will help attendees to understand the basic steps to making programs that users actually like. The benefits of these skills go beyond the aesthetic issues to help raise user productivity and product longevity. The presentation will not require any specific programming knowledge and will apply to desktop applications and web pages alike



My presentations planned for RMOUG Training Days 2010 will be changed to some degree because of the different venue and different audience characteristics. The Groovy presentation is conceptually almost exactly what I planned for Colorado Software Summit except that I was going to speak on JRuby there. The RESTful Java presentation will be 60 minutes at RMOUG Training Days 2010 rather than the 90 minutes it would have been at Colorado Software Summit 2009. Because of the shorter duration, it will necessarily be less detailed at Training Days, but I think that may fit the different audience better anyway. I will focus on basics of REST and then cover at a high level (with some API details) how to apply Java tools and frameworks to build REST-based applications.

Rocky Mountain Oracle Users Group Training Days 2010 will take place February 16-18, 2010, at the Colorado Convention Center in Denver, Colorado.

Java SourceVersion and Character

The SourceVersion class provides information on Java source versions and can provide some interesting details, including demonstration of terminology covered in the Java Language Specification. In this blog posting, I look briefly at some of the more interesting observations one can make using this class that was introduced with Java SE 6 in conjunction with the Java long-timer class Character.

The SourceVersion class provides several handy static methods for ascertaining details about the source version of the current Java runtime. The methods SourceVersion.latest() and SourceVersion.latestSupported() provide details regarding the latest source versions that can be "modeled" and "fully supported" respectively.

The following code snippet demonstrates these two methods in action.

out.println("Latest source version that can be modeled: ");
out.println("\tSourceVersion.latest(): " + SourceVersion.latest());
out.println("Latest source version fully supported by current execution environment ");
out.println("\tSourceVersion.latestSupported(): " + SourceVersion.latestSupported());

The output from running this code is shown next.



As the code example and corresponding output above indicate, the currently supported modeled version and currently fully supported versions are easily accessible. Although the SourceVersion class was introduced with Java SE 6, it has been built to be support future versions of Java. Not only does the Javadoc documentation state that "additional source version constants will be added to model future releases of the language," but the SourceVersion.values() method also provides all supported version enums. A code example and associated output are shown next to demonstrate this method in action.

out.println("SourceVersion enum Values:");
final SourceVersion[] versions = SourceVersion.values();
for (final SourceVersion version : versions)
{
   out.println("\t" + version);
}

The Javadoc documentation tells us the meanings of the various enum values shown in the above output. Each represents a different "source version of the Java programming language" and the platform version it is associated with. As shown earlier, the RELEASE_6 is associated with Java SE 6, RELEASE_5 is associated with J2SE 5, RELEASE_4 is associated with JDK 1.4, RELEASE_3 is associated with JDK 1.3, RELEASE_2 is associated with JDK 1.2, RELEASE_1 is associated with JDK 1.1 and RELEASE_0 is associated with "the original version." The Javadoc documentation for Java SE 7 indicates that SourceVersion.RELEASE_7 is supported in Java SE 7.

The SourceVersion class provides three static methods that each indicate whether a provided CharSequence is an identifier, keyword, or name. The three methods that allow one to dynamically determine if a particular CharSequence fits one or more of the types identifier, name, or keyword are (respectively) SourceVersion.isIdentifier(), SourceVersion.isName(), and SourceVersion.isKeyword().

Using these methods allows one to determine if a particular string is reserved as a keyword, is even considered a valid identifier, and if a string that is a valid identifier is not a keyword and is thus a valid name. The isName() method returns true for a "syntactically valid name" that is not also a keyword or literal. The isKeyword() method indicates if the provided string is one of the keywords listed here.

I have run many different strings of various combinations of these three types in the following code.

   public static void printIdentifierTest(final String stringToBeTested)
   {
      out.println(
           "Is '" + stringToBeTested + "' an identifier? "
         + SourceVersion.isIdentifier(stringToBeTested));
   }

   public static void printKeywordTest(final String stringToBeTested)
   {
      out.println(
           "Is '" + stringToBeTested + "' a keyword? "
         + SourceVersion.isKeyword(stringToBeTested));
   }

   public static void printNameTest(final String stringToBeTested)
   {
      out.println(
           "Can '" + stringToBeTested + "' be used as a name? "
         + SourceVersion.isName(stringToBeTested));
   }

   public static void printTests(final String stringToBeTested)
   {
      out.println("\n===============  " + stringToBeTested + "  ===============");
      printIdentifierTest(stringToBeTested);
      printKeywordTest(stringToBeTested);
      printNameTest(stringToBeTested);
   }

   public static void printTests(
      final String stringToBeTested,
      final String alternateHeaderString)
   {
      out.println("\n===============  " + alternateHeaderString + "  ===============");
      printIdentifierTest(stringToBeTested);
      printKeywordTest(stringToBeTested);
      printNameTest(stringToBeTested);
   }

   /**
    * Main function for demonstrating SourceVersion enum.
    *
    * @param arguments Command-line arguments: none expected.
    */
   public static void main(final String[] arguments)
   {
      final String dustinStr = "Dustin";
      printTests(dustinStr);
      final String dustinLowerStr = "dustin";
      printTests(dustinLowerStr);
      final String instanceOfStr = "instanceof";
      printTests(instanceOfStr);
      final String constStr = "const";
      printTests(constStr);
      final String gotoStr = "goto";
      printTests(gotoStr);
      final String trueStr = "true";
      printTests(trueStr);
      final String nullStr = "null";
      printTests(nullStr);
      final String weirdStr = "/#";
      printTests(weirdStr);
      final String tabStr = "\t";
      printTests(tabStr, "TAB (\\t)");
      final String classStr = "class";
      printTests(classStr);
      final String enumStr = "enum";
      printTests(enumStr);
      final String assertStr = "assert";
      printTests(assertStr);
      final String intStr = "int";
      printTests(intStr);
      final String numeralStartStr = "1abc";
      printTests(numeralStartStr);
      final String numeralEmbeddedStr = "abc1";
      printTests(numeralEmbeddedStr);
      final String dollarStartStr = "$dustin";
      printTests(dollarStartStr);
      final String underscoreStartStr = "_dustin";
      printTests(underscoreStartStr);
      final String spacesStartStr = " dustin";
      printTests(spacesStartStr, " dustin (space in front)");
      final String spacesInStr = "to be";
      printTests(spacesInStr);
   }

When the above code is executed the output shown next is generated.

===============  Dustin  ===============
Is 'Dustin' an identifier? true
Is 'Dustin' a keyword? false
Can 'Dustin' be used as a name? true

===============  dustin  ===============
Is 'dustin' an identifier? true
Is 'dustin' a keyword? false
Can 'dustin' be used as a name? true

===============  instanceof  ===============
Is 'instanceof' an identifier? true
Is 'instanceof' a keyword? true
Can 'instanceof' be used as a name? false

===============  const  ===============
Is 'const' an identifier? true
Is 'const' a keyword? true
Can 'const' be used as a name? false

===============  goto  ===============
Is 'goto' an identifier? true
Is 'goto' a keyword? true
Can 'goto' be used as a name? false

===============  true  ===============
Is 'true' an identifier? true
Is 'true' a keyword? true
Can 'true' be used as a name? false

===============  null  ===============
Is 'null' an identifier? true
Is 'null' a keyword? true
Can 'null' be used as a name? false

===============  /#  ===============
Is '/#' an identifier? false
Is '/#' a keyword? false
Can '/#' be used as a name? false

===============  TAB (\t)  ===============
Is ' ' an identifier? false
Is ' ' a keyword? false
Can ' ' be used as a name? false

===============  class  ===============
Is 'class' an identifier? true
Is 'class' a keyword? true
Can 'class' be used as a name? false

===============  enum  ===============
Is 'enum' an identifier? true
Is 'enum' a keyword? true
Can 'enum' be used as a name? false

===============  assert  ===============
Is 'assert' an identifier? true
Is 'assert' a keyword? true
Can 'assert' be used as a name? false

===============  int  ===============
Is 'int' an identifier? true
Is 'int' a keyword? true
Can 'int' be used as a name? false

===============  1abc  ===============
Is '1abc' an identifier? false
Is '1abc' a keyword? false
Can '1abc' be used as a name? false

===============  abc1  ===============
Is 'abc1' an identifier? true
Is 'abc1' a keyword? false
Can 'abc1' be used as a name? true

===============  $dustin  ===============
Is '$dustin' an identifier? true
Is '$dustin' a keyword? false
Can '$dustin' be used as a name? true

===============  _dustin  ===============
Is '_dustin' an identifier? true
Is '_dustin' a keyword? false
Can '_dustin' be used as a name? true

===============   dustin (space in front)  ===============
Is ' dustin' an identifier? false
Is ' dustin' a keyword? false
Can ' dustin' be used as a name? false

===============  to be  ===============
Is 'to be' an identifier? false
Is 'to be' a keyword? false
Can 'to be' be used as a name? false

The above output demonstrates that a valid name must be a valid identifier without being a keyword. A keyword must be a valid identifier, but not all identifiers are keywords. Some string values that are not keywords or reserved words are not even identifiers because they don't meet the rules of Java identifiers.

The examples above indicate that we cannot use a name for a variable or other construct that begins with a numeral, but we can use $ and _ for the first character in a name. Another way to determine this is through use of the static method Character.isJavaIdentifierStart(char). The following code snippet demonstrates this along with the similar method Character.isJavaIdentifierPart(char), which returns true if the provided character can be in the name anywhere other than the first character.

   public static void printTestForValidIdentifierCharacter(
      final char characterToBeTested)
   {
      out.println(
           "Character '" + characterToBeTested
         + (  Character.isJavaIdentifierStart(characterToBeTested)
            ? "': VALID "
            : "': NOT VALID ")
         + "FIRST character and "
         + (  Character.isJavaIdentifierPart(characterToBeTested)
            ? "VALID "
            : "NOT VALID ")
         + "OTHER character in a Java name.");
      out.println(  "\tType of '" + characterToBeTested + "': "
                  + Character.getType(characterToBeTested));
   }

   public static void demonstrateCharacterJavaIdentifierStart()
   {
      out.println("\nTEST FOR FIRST AND OTHER CHARACTERS IN A VALID JAVA NAME");
      printTestForValidIdentifierCharacter('A');
      printTestForValidIdentifierCharacter('a');
      printTestForValidIdentifierCharacter('1');
      printTestForValidIdentifierCharacter('\\');
      printTestForValidIdentifierCharacter('_');
      printTestForValidIdentifierCharacter('$');
      printTestForValidIdentifierCharacter('#');
      printTestForValidIdentifierCharacter('\n');
      printTestForValidIdentifierCharacter('\t');
   }

The output from the above appears below.

TEST FOR FIRST AND OTHER CHARACTERS IN A VALID JAVA NAME
Character 'A': VALID FIRST character and VALID OTHER character in a Java name.
 Type of 'A': 1
Character 'a': VALID FIRST character and VALID OTHER character in a Java name.
 Type of 'a': 2
Character '1': NOT VALID FIRST character and VALID OTHER character in a Java name.
 Type of '1': 9
Character '\': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of '\': 24
Character '_': VALID FIRST character and VALID OTHER character in a Java name.
 Type of '_': 23
Character '$': VALID FIRST character and VALID OTHER character in a Java name.
 Type of '$': 26
Character '#': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of '#': 24
Character '
': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of '
': 15
Character ' ': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of ' ': 15

Because the Character.getType(char) method has been with us for quite a while and predates the J2SE 5-introduced enum construct, this method returns primitives integers. One can refer to Java's Constant Field Values to determine what each of these constants stand for.

To make the above example's output a little more readable, I have added a simple "converter" method that converts the returned int to a more readable String. I have only added switch cases for the integers returned from my example, but one could add cases for all supported types represented by different integers.

   public static String extractReadableStringFromJavaCharacterTypeInt(
      final int characterTypeInt)
   {
      String characterType;
      switch (characterTypeInt)
      {
         case Character.CONNECTOR_PUNCTUATION :
            characterType = "Connector Punctuation";
            break;
         case Character.CONTROL :
            characterType = "Control";
            break;
         case Character.CURRENCY_SYMBOL :
            characterType = "Currency Symbol";
            break;
         case Character.DECIMAL_DIGIT_NUMBER :
            characterType = "Decimal Digit Number";
            break;
         case Character.LETTER_NUMBER :
            characterType = "Letter/Number";
            break;
         case Character.LOWERCASE_LETTER :
            characterType = "Lowercase Letter";
            break;
         case Character.OTHER_PUNCTUATION :
            characterType = "Other Punctuation";
            break;
         case Character.UPPERCASE_LETTER :
            characterType = "Uppercase Letter";
            break;
         default : characterType = "Unknown Character Type Integer: " + characterTypeInt; 
      }
      return characterType;
   }

When the integers returned from Character.getType(char) in the example two listings ago are run through this switch statement, the revised output appears as shown next.

TEST FOR FIRST AND OTHER CHARACTERS IN A VALID JAVA NAME
Character 'A': VALID FIRST character and VALID OTHER character in a Java name.
 Type of 'A': Uppercase Letter
Character 'a': VALID FIRST character and VALID OTHER character in a Java name.
 Type of 'a': Lowercase Letter
Character '1': NOT VALID FIRST character and VALID OTHER character in a Java name.
 Type of '1': Decimal Digit Number
Character '\': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of '\': Other Punctuation
Character '_': VALID FIRST character and VALID OTHER character in a Java name.
 Type of '_': Connector Punctuation
Character '$': VALID FIRST character and VALID OTHER character in a Java name.
 Type of '$': Currency Symbol
Character '#': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of '#': Other Punctuation
Character '
': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of '
': Control
Character ' ': NOT VALID FIRST character and NOT VALID OTHER character in a Java name.
 Type of ' ': Control

The SourceVersion class is useful for dynamically determining information about the Java source code version and the keywords and valid names applicable for that version. The Character class also provides useful information on what a particular character's type is and whether or not that character can be used as the first character of a name or as any other character in a valid name.

Who Should Oracle Sell MySQL To?

There is no shortage of people calling for Oracle to sell MySQL. I keep reading that Oracle should sell MySQL to "a suitable third-party" or to a "neutral third party." I understand why these people feel passionate about this, but "loose" terminology like this is always dangerous. It implies that this is an easy thing to do and that there is a line of suitors out there waiting to snap up MySQL for a fair market price.

I wonder if there is a line of potential MySQL purchasers out there just waiting for an opportunity to bid on MySQL. Should Oracle have to shed MySQL even for a low-ball price in the name of market competitiveness? Can a company make significant money off of MySQL? Did Sun make money off of MySQL? Should Oracle or Sun take a loss on MySQL in the name of community betterment? Should another company purchase MySQL even if they don't believe they can ever earn back their investment (without even considering a desired profit margin) in the name of community betterment? Is eminent domain a consideration here?

Some companies make money related to shepherding open source projects; many do not. Ironically, at the time it seemed that Sun's purchase of MySQL overshadowed Oracle's purchase of BEA. Sun purchased MySQL for roughly one billion U.S. dollars ($800 million cash plus $200 million debt assumption). Can Oracle expect to get at least that for MySQL? Or, is MySQL worth more or less than that now? One could argue its only worth what someone else will pay for it. Is someone willing to pay more than $1 billion for MySQL? Should Oracle be forced to sell MySQL to the highest bidder regardless of the amount bid?

I have no idea what the fate of MySQL would be under Oracle, but I am almost as curious and uncertain about what price Oracle could get for MySQL. It is probably much like my most trusted old cars have been: they have been worth quite a bit more to me because they are cheap to own and operate and I know they are in good condition. However, they are not worth nearly as much to anyone else. I wonder if this is a similar case: is MySQL worth much more to Oracle than it is to anyone else? One could make an argument that "the community" values MySQL more, but it is nearly impossible for "the community" to purchase something like this for any reasonable price. What would be required in that case is either Oracle donating MySQL or selling it at significant discount or a "representative" of the community stepping forward to purchase it. Is there any organization out there ready to step up and be that representative? Does any organization have sufficient selfish motivation to do this?

It's easy to suggest that Oracle should sell to a "suitable third party?" That's just talk. The potentially significantly more difficult thing might be to actually find a buyer that meets the definition of "suitable" to all involved. I would love to hear those who state that Oracle should sell MySQL do more than state things as though if are as easily implemented as they are stated. I'd like to see who is willing to bid for MySQL and how much they're willing to bid. Of course, even those organizations interested in bidding on MySQL are not likely going to share their offers publicly. So, we're left wondering if there are any buyers out there willing to pay anything close to what Oracle feels the value of MySQL is.

MySQL may be one of the best examples one can think of where its value to the overall community is tremendous (perhaps many times more than $1 billion in this case), but it is much more difficult for any single organization to see enough individual value to justify purchasing it (in this case for anywhere close to $1 billion). There is no question that MySQL brings significant value to its users, but does it carry enough value to whoever owns it to justify its purchase? Or, is this another example of the problems of the commons? For my part, I can see how MySQL might be of more value to Oracle than it is to any other single party. This makes a sale difficult because Oracle wants more than any individual organization is willing to pay. MySQL is almost certainly more valuable to the collective community, but the collective community is not structured to make the purchase.

If someone is to purchase MySQL without a deep discount from what Oracle likely thinks it is worth, that "someone" will need to have a plan how they will make money from their ownership of MySQL. The more they pay for MySQL, the more revenue they need to be able to directly trace back to ownership of MySQL. Which organizations are in a position to profit from owning MySQL? How can these organizations most readily make money off ownership of MySQL? I don't know the answers to all of these questions, but I'd love to hear others' ideas.

RMOUG Training Days 2010 Presentations

I received word today that my two abstracts were accepted for Rocky Mountain Oracle Users Group (RMOUG) Training Days 2010, which will be held February 16-18, 2010, at the Colorado Convention Center in Denver, Colorado. The abstracts that I submitted for RMOUG Training Days 2010 were heavily influenced by the abstracts that had been accepted by Colorado Software Summit 2009 prior to the cancellation of that conference.

The two abstracts that have been accepted are Applied Groovy: Scripting for Java Development and RESTful Java. For the Groovy presentation, I plan to focus on using Groovy to improve the efficiency of development and deployment tasks. Although I'll briefly talk about using Groovy (and Grails) to develop applications, the emphasis will be on how Groovy helps with development and deployment of traditional Java applications. Because of this, it is also likely to be of more interest to those developing applications in other languages who still would like to take advantage of a nice scripting language and JVM features.

In the "RESTful Java" presentation, my current plan is to briefly introduce REST (quick summary of my RMOUG Training Days 2008 presentation REST from Web Services Frustrations) and then introduce some tools and frameworks that are Java-based to make developing RESTful web services easier.

By the time the Rocky Mountain Oracle Users Group Training Days 2010 conference is held in February 2010, it is highly possible that we'll know the fate of the Oracle bid to acquire Sun Microsystems. That is likely to be a topic that gets some mention during the conference.

I am looking forward to seeing other presentations that will be at this conference in coming days through presenters' blogs and tweets. I'm especially looking forward to the release of the conference agenda to get a more complete picture of the types of presentations that I can attend at Rocky Mountain Oracle Users Group Training Days 2010.

Being Critical is Easier Than Being Creative

I have learned in life in general and in software development in particular that it is far easier to be critical of a proposed idea than it is to be creative in coming up with a new or different idea. We see this in politics all the time when one ideological side seems to be better at attacking the other side than at coming up with real and creative solutions of their own.

There are numerous times when the ability to be critical and question others' judgment is necessary. For example, in the business management classic On the Folly of Rewarding A, While Hoping for B, Steven Kerr outlines how well-intentioned decisions often end in unanticipated and often conflicting consequences. In many of these cases, significant unintended harm could be avoided by more considering more critically the actions being taken and their unintended consequences and side effects.

There are times when brainstorming can be the best approach for coming up with new ideas. However, sometimes it seems to stall or people seem reluctant to participate fully. Other times, brainstorming may not be as useful because of the relatively narrow scope of possibilities involved. I have found repeatedly, through my own experience and the observation of others around me, that in such cases it is often best to simply "throw an idea out there" and allow the group of affected stakeholders to criticize it and build upon it. In other words, when individuals are having a difficult time being creative, it might be best to take advantage of their ability to be critical and criticize.

In many cases, putting any idea or potential solution "on the table" is just what is needed to get critical thinking flowing. There are reasons why I believe this to be true and there are reasons we don't take advantage of this approach more often. In the remainder of this post, I look at why this is often a useful approach, why we don't use it more often, and how we can apply it more frequently to solve our difficult design and other problems.


The Virtues of Being Critical

There are several advantages that can be gained from encouraging critical discussion regarding an idea. First, it is almost always the case that the different backgrounds and experiences of multiple people will lead to more identification of "deal breaking" problems and challenges for a proposed approach than a single person could come up with.

A second advantage of putting out an idea to be criticized is that the very proposal of a solution often more clearly conveys the nature of the problem being solved. When the others involved see what the proposed solution is trying to accomplish, they may being to better understand the problem at hand.

Throwing out an idea for critical consideration has a third advantage of giving folks a starting point. It really is often easier to find faults with the proposed scheme than to come up with one's own. Similarly, others may find it easier to propose an alteration to the proposed idea than to propose a completely new idea.

Partly related to the just mentioned three advantages, the initial idea is often useful because it helps to overcome the equivalent of writer's block. Even when writing this blog, I sometimes find the most difficult part being putting something down. In refactoring of difficult code, I have often found even starting refactoring simple things helps a lot. In so many things, doing something, even anything, helps us get going on what needs to be accomplished.


Why Don't We Do This More Often?

It is not difficult to understand why we don't "throw an idea out there" more often. It takes a thick skin to be the first one to throw an idea out. If this approach is going to be at all useful, one must be prepared to have one's idea roundly criticized. It is never fun to see one's ideas publicly torn apart. But it can lead to great results.

Besides the fact that one's idea is going to be criticized, it can also be difficult to be the one to put out the initial idea if the problem is not well understood. This is because the initially proposed solution will almost certainly expose lack of knowledge of the problem or the problem domain. Of course, that is often the reason coming up with a solution is so difficult; perhaps no one in the group truly understands the entire complexity of the issue. This is where putting out something to start with and allowing different people work out its details can be so helpful.


Overcoming the Obstacles

The most important step to overcoming obstacles that prevent us from putting out the initial idea that we hope to refine via critical thinking is overcoming one's own self doubts and worry about one's image. Often, the one who is able to do this ends up looking better for his or her work rather than worse because he or she is able to steer the critical discussion of the initial idea to a well-developed solution.

Ironically, just as brainstorming requires the ability to allow people to contribute without fear of ridicule, the process of fostering criticism of a proposed initial idea requires allowing people to feel free to criticize without fear of retribution. If this is not allowed and even encouraged, the process will not be as productive.

I have generally found that most software developers can be professional and the criticism is often easier to take than we might have feared. In many ways, this approach is the same we should welcome for design and code reviews. Also, it is often the case that the things we don't understand when building the initial solution are not understood by other members of the group. In other words, even if the person comes up with a solution that demonstrates he or she did not know something that he or she probably should have known, it is likely that others did not know it either.


Conclusion

It is definitely true that is often easier to be critical than to be creative. Although this is sometimes a frustrating negative characteristic of human behavior, we can turn it to our advantage when faced with particularly difficult problems that require the collective experience and insight of a group of people to solve appropriately. By being willing to put out an initial solution with known flaws and shortcomings, we can often encourage the development of a superior solution based on the combined knowledge and experience of those we work with.

Comments on the Future of IntelliJ IDEA

In the blog post Why I Think IDEA Going Open Source is Not a Good Sign, Cedric Otaku articulates why he believes that the open sourcing of IntelliJ IDEA Community Edition is not a good sign for that IDE's future. He makes several points that are very difficult to argue with and many of which I thought myself.

There are three stated reasons in the IntelliJ IDEA Community Edition FAQ for providing an open source Community Edition of the IDE and the platform upon which it is built. The first stated reason is to "significantly grow the number of users of IntelliJ IDEA." I have no doubt that this will be the case, especially in the short-term. The second stated reason is to encourage the "growth of ecosystem around IntelliJ IDEA." The final stated reason is to improve both the open source Community Edition and the premium Ultimate Edition via expected increase in user feedback.

Ceki Gülcü has written a response to Otaku's blog post called IDEA open sourced and points out that this may be a "strategic decision" that turns out okay for JetBeans in the end. However, Gülcü also concedes that Otaku is probably correct that "Jetbrains is unlikely to be flooded with patches and additions from the community."

In Hybridizing Java, Bruce Eckel pointed out that "Cost was one of the main things that originally held me back from using Flex, primarily because of readers who were unwilling or unable to pay it." When Adobe made large chunks of Flex 2 SDK and compiler freely available and later open sourced Flex 3, they opened the doors for Eckel and numerous others to adopt Flex. The Flex user base has grown tremendously since then. There have been more users contributing bug reports, more third-party frameworks and libraries for Flex development, more books on Flex, and so forth.

One indicator of popularity of a particular product is the number of books covering the topic. A simple search on Amazon.com for "Eclipse IDE" (IDE portion is important to avoid the Twilight book getting in the way) returns numerous books on Eclipse including, but not limited to, Eclipse, Eclipse Cookbook, Eclipse for Dummies, Professional Eclipse 3 for Java Developers, and Eclipse: Step-by-Step. Additional Eclipse books are listed in Eclipse Resources.

Amazon shows many books on NetBeans as well: NetBeans: The Definitive Guide, The Definitive Guide to NetBeans Platform, Pro NetBeans IDE 6 Rich Client Platform Edition, 100 NetBeans IDE Tips and Tricks, and many more. Additional NetBeans books can be found on the Netbeans Books page.

If you want to see a ton of books on the same IDE, try placing "JDeveloper" in the Amazon.com search. A listing of a small sample of these books is available at JDeveloper Books and Courses.

There are numerous books on Eclipse, NetBeans, and JDeveloper. For IntelliJ IDEA, however, an Amazon.com search only lists one book devoted to the topic: IntelliJ IDEA in Action. The Community Edition FAQ states that this book covers IntelliJ IDEA 4 and IntelliJ IDEA 5 (IDEA 9 will have the Community Edition), but adds that there are negotiations underway for a new book. Technical books are not known for being financially lucrative in general, but it does help encourage a publisher to publish a book on a certain technical subject when it is anticipated that there will be high demand. Perhaps open sourcing the Community Edition of IntelliJ IDEA will help stimulate this demand.

Intellij IDEA has an almost cult-like following of die hard enthusiasts and that speaks well of it as a product. This recent announcement of a Community Edition of the product may be just what is needed to increase the number of loyal users. In some cases, developers new to the IDE may even decide they want to pay the license fee to move to the Ultimate Edition for use with the Enterprise Java needs, Flex development needs, or other needs above and beyond what the Community Edition provides.

Of course, IntelliJ IDEA's future is not in a vacuum. As I wrote in a recent blog post, the Java IDE market has other forces at work. Another major external force is what Oracle decides to do with NetBeans once its (Oracle's) deal with Sun concludes.

I can only speak for myself, but I can say that it is likely (at least it's in my current plans) that I will start using IntelliJ IDEA Community Edition in much of my Groovy development. I will be likely to blog on things I learn as I do this and possibly use screen snapshots of IntelliJ IDEA with Groovy code and support. This is just one small example of how exposure for IntelliJ IDEA might be increased as a result of the move to an open source Community Edition. The question of if additional users and more coverage will translate to more revenues can only be answered in the future.

A Big Week for the Java Development Community

This past week featured some significant news for the general Java development community. Many of us looked to this week's OpenWorld 2009 as an opportunity to learn more about the potential future of Java and the Java "ecosystem" under Oracle's stewardship. There was also exciting news of the forthcoming Version 9 of IntelliJ IDEA being made available in two editions, including a Community Edition that would be open source and freely available.


Oracle OpenWorld 2009

Although many of us in the Java development community have worked with Oracle products for years, others are just starting to become familiar with Oracle products since the announcement of Oracle's acquisition of Sun. In particular, this past week's Oracle OpenWorld has received more attention from the general Java development community than ever before. In his blog post A Big Fat Thanks/Things I Learned At Oracle OpenWorld (#oow09), Oracle Technology Network Editor-in-Chief/Community Evangelist Justin Kestelyn summarizes where things are at in terms of OpenWorld and the future of JavaOne:

The Java technologist community is very nervous about OpenWorld serving as a substitute for JavaOne; the cultural and content differences are stark. The sooner we can communicate our plans there, the better. (Unfortunately, nothing can be said until deal close. And contrary to some of the rumors out there, no announcements have been made on this subject at all.)

JavaOne's future is not the only future we're thinking about in the Java development community. We still have to wonder about the future of Sun-supported products such as GlassFish, NetBeansm, MySQL, and JavaFX.

For more information on Oracle OpenWorld, see sites such as OpenWorld Wrap-Up: The Best and Worst from San Francisco, Reporter's Notebook: Oracle OpenWorld 2009, The Guide to Oracle OpenWorld 2009, and Blogs about Oracle OpenWorld.



Community Edition of IntelliJ Idea

The announcement this week regarding the release of IntelliJ IDEA Version 9 in two editions (including a freely available open source Community Edition) has caused quite a stir in the Java development community (three of the top four links currently on DZone discuss this announcement [here and here and here]).

The IntelliJ Platform will be completely open sourced while the IDEA IDE will only have certain select portions open sourced. Both the platform and the IDE will be open sourced under the Apache 2 license.

The IntelliJ IDEA 9 Editions Comparison Matrix indicates the differences between the freely available, open source Community Edition and the Ultimate Edition. The Community Edition lacks some nice features of the Ultimate Edition, but the Community Edition still contains many powerful features, especially for those developing applications with Java SE, Groovy, and Scala. For those developing Java EE and web applications, the upgrade to the Ultimate Edition or use of an alternative IDE would probably be a better bet.

The landscape of the Java IDEs is going to get even more interesting in coming months. In Intellij Idea IDE OpenSourced - The current state of the Java IDE's, Anshu Mishra compares and contrasts Eclipse, NetBeans, and IntelliJ IDEA Community Edition. However, another freely available (albeit not open source) Java IDE is not mentioned: JDeveloper. With Oracle obviously behind JDeveloper and likely soon-to-be the primary steward of Java, that IDE cannot be discounted.


Conclusion

It is going to be interesting to watch the progress that occurs within the Java development community over the next several months. Both Oracle's handling of Java and the effect of the release of IntelliJ IDEA Community Edition will likely impact to some degree Java development for many in our community.

Java in First Days of Oracle OpenWorld 2009

In Oracle OpenWorld for the Java Developer, I looked at the relationship between Sun and Oracle and considered how Java might be covered at Oracle OpenWorld. In this blog post, I point to and summarize some of the blog posts starting to come out along these same themes based in Sunday and Monday at OpenWorld.

In Sun Shines at Oracle OpenWorld (on the Oracle OpenWorld Blog), Stephen Fox summarizes the closing keynote of Day 1 (Sunday). It sounds as if the anticipated mutual compliments between Sun and Oracle leadership did occur. Fox briefly describes James Gosling's gushing over Oracle's involvement in the Java community.

Cay Horstmann, in Oracle OpenWorld Day Zero, writes that "Oracle OpenWorld seems bigger" than JavaOne. Like Fox, he writes about Gosling's coverage of Oracle and Java. Horstmann also writes about a "culture difference" he senses between Java and Oracle user groups and wonders if a single conference can really appeal to both the usual JavaOne attendees and the usual OpenWorld attendees.

Arun Gupta has a very thorough blog post titled Oracle Open World 2009 - Day 1 Report. Gupta provides Scott McNealy's "ten reasons engineers have gone wild" and "top ten innovations from Sun" (Java is #6). Gupta also provides links to a list of Sun bloggers at OpenWorld.

In the post OOW 2009: Too many sub titles - the Scott and Larry show (keynote on SUNday), Lucas Jellema presents a lengthy list of sub-titles gleaned from the "SUNday" keynote. Jellema's post is thorough, but one of the things I like about it best is that it challenges the assertion that the active Oracle user community might be significantly smaller than the active Java user community. Jellema cites numbers related to Oracle Technology Network membership in addressing this. I have found my local Oracle users group, Rocky Mountain Oracle Users Group, to be very active. This AMIS Technology Blog already features several very specific reviews of Oracle OpenWorld 2009.

In Oracle OpenWorld: Getting down to business, Sam Diaz comments that OpenWorld appears to remain a "vibrant show" despite other technical conferences suffering lower attendance in recent months than they normally enjoy.

For the most part, there have not been many surprises so far related to Java and Oracle. This is not unexpected because there are certain legal limitations imposed on both parties in the acquisition. Overall, most principal players still seem to be saying the right things to soothe the Java development community regarding Oracle's acquisition of Sun.

Impact of Demise of GeoCities on Online Software Development References

On 9 July 2009, I received an e-mail message from Yahoo! GeoCities stating, "GeoCities is closing." I received these because I have had, for many years, a simple static homepage on Geocities (http://geocities.com/Colosseum/Field/7217/SW/index.html or http://geocities.com/dustinmarx/). I did not provide a link to it because, two weeks from today on 26 October 2009, that page will no longer be accessible. As I have been archiving content on that page in preparation for its demise, I have noted that much of its content has been overcome by events. In this blog posting, I'll look briefly at why the GeoCities era is coming to an end and will ponder the fate of some potentially valuable resources that have been available on GeoCities-hosed sites.

In Now closing: GeoCities, a relic of Web's Early Days, Stephen Shankland does a nice job of covering the likely reasons why Yahoo! is closing GeoCities and how GeoCities has lost interest and favor over the years. Perhaps most importantly, Shankland also brings up a very good point: "it seems likely that a lot of amateur Web sites soon will vanish without a trace, a casualty of business priorities and the Internet's rapid changes."

As I archived files I might possibly want in the future and removed some files that I doubt I'll ever miss, I realized that my own use of a service like GeoCities had changed dramatically. When I first started using GeoCities over ten years ago, a large proportion of the web was static, there were still significant portions of people who did not have consistent web access or e-mail addresses, and the search engines were nowhere near as powerful as they are today.

Although there are still many largely static pages on the web today, the ability to have others respond interactively to what one has posted has been largely facilitated by blog software (such as Blogger.com) and by social sites (such as Facebook.com).

Today, a much larger percentage of people has decent web and e-mail access, often high-speed. Nearly everyone in the United States has access, even if it means they must visit the local library.

Several of the pages I had hosted on GeoCities were really glorified bookmarks. I had pages on topics such as Unix, Java, and C++ with links to resources that were more difficult to find in those days. Today, I still use my browser's bookmark feature and even use my blog for bookmarks, but the truth is that I can usually find what I am looking for again and again, quickly and as needed, with today's powerful serach engines.

Although it is not surprising that Yahoo! is closing down GeoCities given current conditions and the changing landscape of the individual's preferred online presence, it is still concerning to think about the vast amount of potentially valuable information that may be more difficult to locate in the future when GeoCities-hosted pages go away. Although GeoCities users can either move to a premium (non-free) plan or can manually archive their files one at a time to move to another host, I am sure there will be some percentage of GeoCities-hosted sites that will simply disappear. Many of the most useful pages out there have been copied multiple times over and there are features like Google Cache, but even these don't guarantee some information will not be lost. Because GeoCities sites will be completely unavailable after 26 October 2009, it will not even be possible to have forwarding information to the new location.

In the remainder of this blog post, I look at some examples of useful pages hosted on GeoCities that may be considered "at risk" of being lost in two weeks. Thanks to the power of the search engine, I also am able to point out secondary sources (copies of the same information). These are not intended to be the most valuable sites on GeoCities, but rather are intended to provide a sampling of the types of sites that may be lost forever.


Common Struts Errors
http://geocities.com/dustinmarx/SW/struts/errors.html
http://www.geocities.com/Colosseum/Field/7217/SW/struts/errors.html

I started with one of my own. This page on "Common Struts Errors" might be useful to those using Struts and running into an unfamiliar error. I think it is especially useful for those new to Struts. This version will be gone in two weeks. I do plan to rehost it on Google Sites at http://sites.google.com/site/dustinmarx/home/struts_errors-html. Other copies of this page are available on docstoc, Scribd, ZetaBoards, and Aext.net.


TechnoFundo Site
http://us.geocities.com/technofundo/home.html

This site contains links to articles on equals and hashCode and Java certification. By the way, there are numerous sites hosted on GeoCities that provide hints, mock exams, and other resources related to Java certification.


The GUI Toolkit, Framework
http://www.geocities.com/SiliconValley/Vista/7184/guitool.html

Fortunately, a mirror for this appears to exist at http://www.atai.org/guitool/.


Pascal to Java
Easy Transformation, Part 1 - http://www.geocities.com/siliconvalley/park/3230/pas/pas2java.html
Easy Transformation, Part 2 - http://www.geocities.com/siliconvalley/park/3230/pas/pas2java2.html

We probably don't have a lot of developers moving from Pascal to Java anymore, but it does seem like a waste to lose information like this for the relatively few who might fall into the category as well as for historical intellectual curiosity.


Java Fractals
http://www.geocities.com/CapeCanaveral/Hangar/7959/fractalapplet.html

To be sure, there are many other pages out there (such as this one and that one) that demonstrate fractals with Java applets. However, it is always helpful to have different perspectives on the same general issue.


Bumper Sticker Computer Science
http://www.geocities.com/krishna_kunchith/misc/bscs.html

There are many references and reviews of More Programming Pearls: Confessions of a Coder, but losing any one of them means less information available.


Windows/DOS Commands Cheat Sheet
http://www.geocities.com/tlawlessrr/dos.htm

This convenient page prints the DOS commands on a single page.


A Brief Introduction to Java Native Interface
http://www.geocities.com/kongwenyu/jni.html

There are many resources on the web about JNI, but this is a nice introduction.


OpenLaszlo - Basics
http://www.geocities.com/rs.ramaswamy/laszlo.htm

Again, there are multiple resources on the web regarding OpenLaszlo, but this is another introductory level one that could be gone soon.


On the Folly of Rewarding A, While Hoping for B
http://www.geocities.com/athens/forum/1650/rewardinga.html

This article is a classic on human behavior and how ill-conceived incentive programs often motivate different consequences than intended. Often these unintended consequences are opposed to some degree to the intended consequence. This GeoCities version of the article is the first returned article for many Google searches on related topics, but fortunately the article appears to also exist at sites such as Oakland University, Sacramento State University, and NYU Stern. Although this article is not strictly a technical article, it is most assuredly highly relevant.


So How Many GeoCities Sites are There?

I don't know of an exact count of the number of GeoCities sites out there, but the searching in Google on the expression "site:geocities.com" reports that there are "about 7.53 million" matches. Running the same query on Google for "site:geocities.com java" returns nearly 86 thousand matches. A query on C++ links ("site:geocities.com c++") returns over 16 thousand matches. Querying on "object orientation" with "site:geocities.com object orientation" returns over 6500 matches. Nearly 6300 matches are found for the query "site:geocities.com c#" (C#) and over 10 thousand matches are found for Perl ("site:geocities.com perl").

With the technically-focused GeoCities articles counted in the thousands, the is almost certainly going to be some useful technical information lost when all the free GeoCities sites go down in two weeks.


What Types of Sites Will Be Lost?

From the sample of sites I displayed above, there are certain characteristics of the GeoCities pages that may be gone before the end of the month. Many of them tend to be older, some are even obsolete. Some of the older ones are still applicable and useful. Some of the GeoCities sites are for projects that are no longer progressing (or have been migrated to a site like SourceForge), but even in their current state may be of interest to some people. Many of the GeoCities sites have not seen any updates in recent years because their authors have moved onto blogs, but the authors have not moved the old information to the blog. Even for subjects that are widely covered, we will lose some perspectives on these subjects and will lose things such as book and product reviews.

In my own case, I found that about half of my content on my GeoCities site was not worth archiving and about half was worth it (to me at least) to archive. Only a few pages were worth migrating to a publicly accessible site.

This would be much more damaging, to me in terms of personal loss, and to the community in general if BlogSpot was the one going away. Of course, several years ago, GeoCities was that popular hosting site.


Alternative Free Web Hosting

For those who do maintain GeoCities sites and do not plan to transition to GeoCities's premium plans, the article GeoCities Shuts It Doors and Thousands of Sites Could be Lost,But There Are Other Options lists several other free web hosting options: Webs, Weebly, and UCOZ. Google Sites and AngelFire/Tripod are alternatives as well.


Conclusion

There is little question that GeoCities no longer is as trendy or current as it once was. That stated, many hours of person time has been invested into pages and sites hosted on GeoCities. With many of these pages and sites likely to be inaccessible two weeks from now, it seems that the interconnected world community will be the loser.


Addendum (25 October 2009)

GeoCities is scheduled to go away tomorrow. See GeoCities Going Away, And My Thoughts On It for an interesting discussion (including feedback comments) on why the disappearance of GeoCities is a valuable loss of information and of web/internet historical perspective.