An Architect's View

Forta Blogging

Ben Forta has finally given in to the inevitable and started blogging. Ben pretty much always has something insightful to say so this ought to be a killer blog.

Fusebox MX Renamed Mach II

Ben Edwards announced in the Fusebox MX forums that work on FBMX continues under a new name - Mach II. There will be a new website up shortly with more information. I'll post here as I know more!

Safari Goes Golden

Nothing up on Apple's site yet but it seems that Safari 1.0 is upon us. Excellent news!

---

Apple's site now has the 1.0 download available!

BART to SFO

Hurrah! After something like fifteen years of planning and construction, the Bay Area Rapid Transit system now runs all the way round to San Francisco International Airport! An hour on BART for about $6 instead of fighting with the Bay Area traffic and paying through the nose for parking - sounds like a bargain to me.

OpenOffice.org Announces Mac OS X

The official release of OpenOffice.org 1.0.3 for Mac OS X has been announced. This is a major milestone for both OpenOffice.org and for Mac OS X - congratulations!

Fusebox MX & Nested Layouts

I continue to work on a version of my personal site using Fusebox MX. For most of the display fuses, it's been really easy to copy the dsp_xxx.php file to dsp_xxx.cfm and change references to <?= $self ?> to index.cfm.
One change that has caught me out is that FBMX no longer has the layout wrapping mechanism of FB3. I used to set the page title in the display fuse and the layout would run after the display fuse and wrap its output, including being able to use the title variable I just set in the display fuse. FBMX advocates "plug-ins" for layout so the preView() and postView() are called as the wrappers for your display fuse. Since I want to use the title variable in the pre-view plug-in, I've taken the approach of adding setTitle() to my circuit CFCs and invoking that in the fuseaction section of fusebox.xml. It uses request.title to pass the title around and I'm not sure how I feel about that from an encapsulation point of view.
Then there's nested layouts. In FB3, I used nested layouts to create the left nav in the technical section of the site but FBMX has no such concept and at the moment I'm still pondering the cleanest way to achieve something similar since there's also no longer the concept of 'executing a circuit' to which layouts can be attached. It's proving to be an interesting experiment.

ColdFusion MX Wins Jolt Productivity Award

This one went past under my radar: Macromedia Products Win Awards. The press release starts out with Flash and FlashCom but also mentions CFMX won a Productivity Award in the 13th Annual Jolt Awards. Software Development Magazine announced the Jolt awards in their June 2003 issue.

On Vacation!

I'm taking a well-earned (and much needed) vacation for the next two weeks. I may or may not be blogging during that time - so I'll apologize in advance for any lack of new posts because I'm probably going to spend time away from my laptop (once it has been surgically parted from hands!)...
The only thing planned during my vacation is the Salt Lake City cat show where we will be showing some of our darling fur kids.
I expect I'll also have a little party to celebrate my 41st birthday before I return to work (even though I actually come back to work on my birthday - 7/7).

Fusebox MX

I'm starting to build a version of my personal website using Fusebox MX as an experiment. Fusebox MX is a radically different beast to 'regular' Fusebox but it's still proving to be much simpler than I expected to take the fuses from my PHP site and drop them into this ColdFusion MX prototype - although I'm still figuring out how to organize the site in the FBMX model (or rather in the FBMX view - since FBMX is MVC and most of my site is V!). I'll write this all up in due course, as I did eventually for the move from unstructured PHP to FB3 PHP.

MacLorem

A colleague just pointed me at this great Mac utility: MacLorem. Everyone knows the "Lorem ipsum..." text but this provides random text generation in a variety of pseudo-languages. It's great for building page layouts and the languages provide a nice bit of visual variety.

Dri morvit sernag srung la clum, erk — menardis velar flim vusp brul la re gra srung er la? Thung rhull lamax; obrikt ik vo, qi morvit ewayf delm ma zeuhl yiphras korsa. Furng rintax yiphras whik harle; morvit, nalista gronk erk flim delm galph ik wynlarce velar gen groum tharn erc zeuhl dri. Rhull prinquis vo su whik er relnag irpsa, teng helk erk galph fli, gen srung vo lamax. Arka tharn ma epp menardis urfa dri; teng epp, urfa vo gronk frimba fli rintax ma harle athran clum ik.

The RSS Aggregator in DRK3

Josh and Daniel Dura go under the hood of the XML news aggregator - one of the sample applications from the DevNet Resource Kit Volume 3. It's a good example of OO-style ActionScript and shows the power of Flash MX.

ColdFusion & Flash Data Connection Kit

Ben Forta has just published an in-depth article showing how to build a complete Rich Internet Application using ColdFusion and the Flash Data Connection Kit. It's a good read and it shows just how powerful these two products are when used together.

Patterns != Best Practice

I was entertained and heartened by Jesse Ezell's post about MVC code examples, proving that using patterns is not sufficient to ensure you end up with good code. Patterns are just another tool in your programming toolkit, they are no silver bullet. Best practice is about a combination of things.

Globalizing ColdFusion

Paul Hastings has created a blog dedicated to globalization issues in ColdFusion. This should be a great resource for anyone considering multi-lingual applications as Paul really knows his stuff! [seen on the Daemonite blog]

ColdFusion Administration Breez-o

Geoff Bowers has created a great presentation using Macromedia Breeze that covers a lot of useful ColdFusion MX administration hints & tips. Big thanx to Geoff for doing this and sharing with the community!
My only quibble would be that Geoff recommends not using J2EE Session Variables - I would definitely recommend enabling those so you can take advantage of the underlying application servers session management. Not sure why Geoff disagrees - he doesn't give any reason in the preso.

JavaOne - Friday

The sessions were a bit poor on Friday and attendance was definitely dropping off. The sessions I picked were either very dry and boring or too entry-level to be useful. Even Sun's Blueprints for Web Services session had little more than some basic common sense recommendations in it (tiered architecture, avoid fine-grained calls, avoid session aware clients).
Overall JavaOne had some good sessions, some very good sessions and some bad sessions. I'm glad I went but didn't get as much out of it as I'd hoped - Thursday was definitely the best day.
Compuware's "hippies" were great, protesting outside the Moscone Center each morning, wanting faster Java development and demanding OptimalJ. I never did get to the Compuware booth tho' (sorry Katie!).
The concession stands were outrageous - $9.50 for a small fruit salad! Where was the free coffee and snacks? A few lousy bags of pretzels don't cut it.
This was definitely the year of Mobile Java and, to some extent, Web Services although I somehow got the impression that many presenters already think Web Services are a bit "last year"... Perhaps next year will be Desktop Java or Corporate Java? That seemed to be where Sun think it's going, with the new brand etc. Will that change JavaOne and make it less technical? I hope not.

JavaOne - Final General Session

Scott McNealy gave his thoughts on the state of the union in Java and where we might be going. He mentioned the Java Verified program and welcomed Oracle and Macromedia (ColdFusion MX) to the list of "Java Verified" products. He mentioned the J2EE certification program and again mentioned Macromedia (JRun). He also commented on Dean Takahashi's piece in the San Jose Mercury News as a "party pooper" for the negative write up of Sun.
Scott spent quite a while comparising Java to .NET, starting from the position that we mostly buy "plastic-wrapped" software (cell phones, cars etc) and Microsoft has said their biggest innovation was separating hardware from software. Do you buy your cell phone O/S separately? Do you buy a car and then go online to download the turn signal software? No, you buy complete systems! He went on to say that customizing software packages or writing custom software is past - we'll be buying devices and services and adapting our way of working to those. I'm not sure how ready businesses are to adapt their processes to some arbitrary third-party system but it's an interesting comment - customizing software is expensive and mostly done to support business practices that could do with an overhaul themselves!
Verizon demo'd their "Digital Companion" which is a Java-based platform that integrates and aggregates your communication channels - a virtual PBX. He showed a Java client that manages all your phone calls to all the phone numbers you have registered with the system, including showing it notifying him of a call to his office via his Blackberry and then choosing to redirect the call to the Blackberry itself, in real-time. Very cool! JXTA is key in the architecture, which also does drag'n'drop file sharing.

JavaOne - Forthcoming Language Features

Java 1.0 was introduced in 1995. Java 1.1 appeared in 1997 and added nested clases. There have really been no major changes since, although 1.4 (2001) added assertions. Java 1.5 "Tiger" will likely go into beta late this year and brings the biggest ever changes to the language. There are seven new features:

1. generics
2. enhanced for loop "foreach"
3. auto-boxing / -unboxing
4. type safe enum
5. varargs
6. static import
7. metadata

These are covered by JSR-14 (generics), JSR-175 (metadata) and JSR-201 - visit the JCP website for more information. All of these changes are intended to make programming in Java easier, providing shorthand for many common code idioms.
Generics were covered in depth by Gilad Bracha's talk. One key issue noted here is that the parameter for a generic type must be a reference type (i.e., a sub-class of Object).
The enhanced for loop (for (T t : c) reads "for each t in c") allows simple, consistent iteration over collections, arrays and strings. It removes the need for explicit use of Iterators in many cases.
Auto-boxing and auto-unboxing removes the need to wrap primitive types (e.g., int) in reference types (e.g., Integer) and the need to extract the primitive value from the reference object (e.g., calling intValue()).
Type safe enums seem - on the surface - to introduce a mechanism very much like C, C++ has for defining distinct named symbolic values. However, it's a much more expressive change that actually allows enums to have constructors and methods etc, just like classes. The compiler in turn generates a lot of code behind the scenes. I think this is too big a change to solve the problem at hand - C++ enums would have been enough, in my opinion.
"varargs" is not, despite its name, the ghastly C-style machinery for supporting variable numbers of arguments. Java varargs is quite simply a convenience to allow the compiler to auto-box multiple arguments into an array so that, for example, format("string", a1, a2, a3); becomes shorthand for (something like) Object[] args = new Object[] { a1, a2, a3 }; format("string", args); - so my initial objections to this are melting away somewhat...
Static import is probably the simplest change: it allows you to 'import' the static members of a class (or enum) so that they can be accessed without being qualified by the class name (e.g., cos(1) instead of Math.cos(1)).
Metadata is another big change - at least potentially. The idea is to provide a standard, general purpose way to annotate code so that developer tools can all agree to process the annotations the same way. One possible annotation is to put @remote on methods in a class that are intended to be available via RMI and then have tools that generate the interface that extends java.rmi.Remote with the methods declared to throw the remote exception and then have the original class implement that interface. This is probably the change that still needs the most work to decide exactly how it should work.
A prototype implementation that supports all of the above except for metadata can be found on the Java Developer website.

JavaOne - Generics

JSR-14 (generics) has been a long time coming and is probably the biggest language change since nested classes were introduced back in '97. Generics provide the ability to parameterize types so that instead of just List (of Objects), you can say List<String> to state that your list only contains strings. This allows the compiler to perform additional type checking - instead of waiting until runtime - and removes those ugly downcasts from your code. The speaker, Gilad Bracha, took great pains to explain that Java generics are not like C++ templates - the generic is compiled just once to a single class file and there is no notion of instantiation. Essentially, generics provide a source code annotation that the compiler uses to transform your code as it compiles it, performing type checking and cast insertion automatically.
The key for the generics team is to introduce the change without breaking existing code. If you continue to use plain List, your code will still work although you'll get a warning that the compiler cannot fully check your code.
An interesting issue (for language lawyers like me, at least) is the concept of "reification" - where the type parameter information is encoded into the object for runtime checking. C++ has some notion of this through Run-Time Type Identification and the fact that templates really do cause multiple distinct types to be generated (so List<String> can be distinguished from List<Integer> at runtime). At present, they do not intend to reify the types since the whole point of generics is to provide compile-time checking rather than run-time checking. If you do mixed-mode programming (mixing List<String> and plain List, for example) you will already be relying on the dynamic type-checking that already happens in Java today (without reification) - so there appears to be no benefit to reification for generics. Gilad referred people to his home page for more information about generics.

JavaOne - Garbage Collection

This was a technical talk about how garbage collection works and how the different types of collectors (in JVM 1.4.1 and later) differ. Objects are allocated on the heap, which is split into two main sections: young generation, including the "nursery" where most new objects are created, and old generation where longer-lived objects are stored. The young generation heap contains new and short-lived objects and is usually fairly small in comparison to the overall heap space. Garbage collection runs frequently on the young generation heap, reclaiming a lot of objects each time (normally!). Objects that survive one or more collections are promoted into the old generation heap which steadily grows over time. The old generation heap is much larger and is swept much less frequently - collections take substantiatlly longer (1-2 seconds, compared to 100-200ms in the young generation heap).
You can enable parallel garbage collection on the young generation heap (-XX:+UseParallelGC) which provides benefits on multiprocessor machines.
You can also enable (mostly) concurrent mark and sweep garbage collection on the old generation heap (-XX:+UseConMarkSweepGC) which automatically enables parallel GC on the young generation heap in JVM 1.4.2.
The speakers demonstrated the performance improvements - on multiprocessor systems - that these collectors can provide but said that you really need to do extensive tuning of the JVM to get the best possible performance out of your application. In future, they hope to provide self-tuning features on the JVM but, for now, they suggest you read the HotSpot documentation and look at JSR-174 (monitoring and management) and JSR-163 (profiling).
Then they talked about how to be GC-friendly in your program: avoid finalize and avoid object pooling. The former causes unreachable objects to be queued for finalization (and not collected) and any referenced objects remain reachable. Once the finalizer runs, the objects may become reachable again so it takes another sweep of the GC to collect them. Note that you are not actually guaranteed that an object will ever be finalized - it could remain on the finalizer queue indefinitely! Object pooling is a technique to explicitly reuse objects in order to avoid the overhead of construction - for objects with expensive initialization, such as file I/O (see caching with caution in the Faster Code "Secrets" talk). Unfortunately, such pools can impact GC by keeping memory in use unnecessarily and by creating memory leaks (since objects in the pool remain reachable even if they are never actually reused!).

JavaOne - Five Secrets to Faster Code

Myth: Java is Slow. Premature (and unnecessary) optimization can cause many problems. Here's Blake Stone's five "secrets":

1. maximize laziness: defer work - sometimes later means never (and not doing something is always faster than doing it!)
2. eliminate redundancy: a big surprise can be how many times something is executed - coalesce and defer processing
3. reuse optimal solutions (even better, reuse other people's optimal solutions!): collections are a good example in code, patterns are a good example in design
4. watch your footprint: if you hit swap space, your VM performance will tank, short-lived objects are OK (because the garbage collector is good at its job)
5. cache with caution: caching introduces complexity and can introduce memory leaks - only use them if object construction is very expensive, e.g., uses file system I/O

Above all, start with readable code - it's easier to maintain, it's easier to tune and HotSpot will do a better job of optimizing it. And measure performance before (and after) you apply any optimization. Also, remember to optimize your architecture, not just your code - most big savings come from architectural improvments. Document any of your assumptions - in case an optimization is based on some precept that may change.
Blake Stone is Chief Scientist at Borland.

JavaOne - Kawa: The JVM & "other" Languages

Per Bothner presented his 'pet' project Kawa which is an abstract language interpreter / compilation system that allows other languages to run on top of the JVM. He said there are three basic ways to implement a new language:

1. write an interpreter: quick and easy to implement but slow to run
2. compile to Java and then to .class: still fairly easy to write compiler, compiled Java is fast, big hit on first run (like CFMX)
3. compile to byte code: much harder to write a compiler, faster compilation process, opportunity to produce much more efficient code

Kawa supports a variety of languages to varying degrees. It can both interpret them and compile them - to a .class with a main method (a standalone program) or to a Servlet.
Two languages are well-supported and becoming widely used: Kawa-Scheme and Qexo (XQuery). There is also a working proof of concept for XSLT. More information about Kawa can be found on GNU's website.

ColdFusion MX - Java Verified

Already mentioned on Christian's blog but it bears repeating: today Macromedia announced that ColdFusion MX has achieved "Java Verified" status.

---

This also got a mention on The Server Side where they say a bit more about the Application Verification Kit. I'll keep watching that thread to see if any interesting comments appear.

JavaOne - An MVC Alternative

This was a bit of a strange session. Starting from the premise that the web is not a perfect match to the MVC idiom, the speakers showed how they constructed a CRUD / HTTP mapping that can be used for simple applications. Their solution was, in my opinion, an academic construction that overloaded the HTTP methods PUT and DELETE to produce a very literal create / read / update / delete mechanism.
The point about MVC not matching the stateless nature of HTTP-based web applications is worth examining, however. The traditional View in MVC performs direct state queries on the Model and initiates updates through the Controller. Changes to the Model can then be notified directly to the View. Since the "View" is transient in an HTML web application - it is constructed as HTML then sent to the user and at some later point the user then sends back some data (either an HTTP GET or an HTTP POST) - the change notification and the asynchronous updates are not possible. That's partly why we have such a clunky user experience on the web : click-wait-click. A Rich Internet Application can support traditional MVC using a Flash View and either ColdFusion MX and/or J2EE for the Model / Controller parts. And a Rich Internet Application provides a better user experience. This seems to be another case of picking the right tool(s) for the job instead of trying to shoehorn traditional MVC onto HTML web applications - or constructing artificial solutions to a simple problem.

JavaOne - The Black Art of Benchmarking

A lot of this talk built on yesterday's Platform Performance and today's Monitoring talks. Important points:

• make sure your benchmark is testing something real - code optimization can skew results
• data sets need to match production in size
• ensure your results are statistically significant
• change only one thing at a time
• use visualization tools to help you find bottlenecks
• test consistently with a harness

The same set of tools were recommended as for the Monitoring talk. Resources include hardware configuration and JVM tuning.

JavaOne - Performance Monitoring

This was a rather short session but it did at least provide some useful pointers to low-level monitoring tools. Working from a live example that had various memory-related problems, they showed how non-intrusive monitoring tools can help track down the problems. The tools they mentioned included: gcore (generate a core file from a running process), a Java tool (still in development) that can analyse core files intelligently, -verbose:gc (JVM option), the JVMPI and JVMDI profiling and debugging APIs (need more tools developed for these!), VisualGC (useful tool downloadable from Sun's site - it requires JVM 1.4.1+), pmstat, pstack, using SIGINT to get a thread dump, -Xprof compiler option, prstat, top. Also check out JSR-174 for a monitoring specification.

VAT - Coming to an eCommerce Site Near You!

The Washington Post has picked up on the impending VAT (Value Added Tax) changes in Europe that may affect U.S. eCommerce websites. I'm used to 17.5% sales tax, coming from England, so this move isn't much of a surprise to me. If anything, I'm surprised that the European Union allowed the current situation - where U.S. eCommerce sites could sell into Europe tax-free - to continue for as long as it has. Also, as far as I'm concerned, this is a completely separate discussion from whether the U.S. States should attempt to regulate sales tax online - the EU situation is very different in that EU companies already have to handle VAT for online sales.

MVCF Updated

Benoit Hedard has updated his MVCF website. He has made these updates:

There is the presentation "MX applications based on MVC" that I did at CF-Europe.
I've also updated all the best practices articles:

• no Hungarian notation anymore
• nothing in WEB-INF anymore
• CFC as controllers (with form remote invocation, it works wonderfully...)

I'm glad to see these changes - especially the removal of Hungarian notation! - and I'll check the site out when I get a chance.

JavaOne - Day 2 General Session

Started with a comedian telling engineering jokes. The best one was Linux : a Latin word meaning "I don't do Windows"...
Big announcements: both HP and Dell have signed agreements with Sun to ship Java on every PC and device - important given Microsoft's intention to drop Java from Windows on January 1st.
Tim O'Reilly talked about the importance of welcoming scripting languages into the Java fold and mentioned Macromedia's efforts in supporting scripting languages. See this InfoWorld story for more information about Macromedia's involvement.
Richard Green talked about moving Java into the corporate developer space and highlighted the changes that make developing easier (J2SE 1.5, JavaServer Faces, JDBC Rowsets, Metadata) and then looked at the industry activities in this area: Macromedia ColdFusion and Sun's Project Rave.
Demo'd Rave - very, very impressive visual IDE for Java that lets you drag'n'drop databases onto visual elements like drop-downs and data grids to create the relationships. Slick SQL using visual editor for joins etc. The demo actually crashed at one point so the guy rebuilt the entire application in about two minutes! Project Rave website.
Brief mention of service-based integration with WS-I support in J2EE 1.4, the Web Service Developer Pack and the Java Business Integration JSR-208.
The message was "growth through standards compliance".
Back to mobility again. Project Relator is a visual IDE for creating J2ME apps. Another drag'n'drop system but this has a ways to go yet before it's out in production. More on Sun's Wireless offerings.
Then SAP talked about NetWeaver which is a complete rewrite of SAP r3 to use Java alongside their existing ABAP language. SAP had 2,000 developers work on this for the last two or three years(!) and overall have 8,000 developers working on the SAP product. There are about 1m ABAP developers worldwide.

JavaOne - Platform Performance

This was a high-level overview of the issues involved in getting the best performance out of your Java systems which referred interested parties to several other sessions at JavaOne for more information. I'm hoping to attend most of those sessions and will blog them in due course.
One of the key principles is that benchmarking and performance monitoring should be part of your standard development process, not some post-QA afterthought. I agree.
The new garbage collectors were discussed in some detail, explaining how they can be used to tune the JVM for particular types of application. The throughput collector (enabled by the UseParallelGC and AggressiveHeap options) focuses on transaction speed. The concurrent collector (enabled by the UseConcMarkSweepGC and ParNewGC options) provides consistent response time and fewer pauses due to GC. The latter is probably what you want for a web application, providing more consistent response time.
The speakers noted that J2SE 1.5 ("Tiger") has "smart tuning" to dynamically optimize the JVM behavior at runtime, as well as some smarter self-configuration at startup. Then they talked about scalability, drawing the distinction between vertical (one instance, multi-CPU) and horizontal (multiple instances, each on a separate system). Usually your database layer is vertical (one application, one server, multi-CPU), your web layer is horizontal (multiple machines, each running one application - the web server) and your application layer is a hybrid (more than one machine, more than one instance per CPU - typical for Java systems... and ColdFusion MX for J2EE can work like this too). In fact, this is essentially how macromedia.com is architected: ten small servers running Apache, three big machines running multiple instances of ColdFusion MX on JRun and a big machine running Oracle.
The final takeaway was that the forthcoming J2SE 1.4.2 is highly optimized for Intel hardware and developers should see big, big performance improvements on those systems.

JavaOne - Web Services & Enterprise Service-Oriented Architecture

This sounded like it would be very interesting but it was a very dry presentation about the various layers of Web Service and XML standards. The take away was, essentially, coherent standards to support SOA are still years away but if you create a layered architecture and use whatever standards you can find today, you'll mitigate some of the risk of evolving standards.
Some specific points worth noting: J2EE 1.4 will support WS-I Basic Profile - although that is only one piece of the SOA framework; ebXML is probably the best set of standards for filling in the remaining XML pieces of the framework; security is still a tricky issue (with transport-level stuff still being the most appropriate solution for public systems); SWA-SOAP (SOAP With Attachments) is a useful step in the right direction to allow systems to pass around 'opaque' data.
In terms of architectural tiers, the speaker made an interesting recommendation of creating a Web Services Façade tier as the public-facing part that interacts with a 'choreography' tier which marshals and aggregates all the low-level component functionality. This produces a relatively dumb WS façade in front of a smart application logic tier - that's a good way to provide reuse of your application logic without tying it into your façade!

JavaOne - Technical Session

The Big Themes are "Ease of Development", "Scripting Languages" and "Mobility". Ease of Development is mostly being addressed through new language features - in particular the new metadata annotations and generics - and EJB 3.0 will also leverage metadata to dramatically simplify how to build EJBs. Scripting languages are Java's new best friend via JSR-223. The Reference Implementation will be on top of Tomcat and will use PHP. Then it was the mobility theme again with cell phones much to the fore. Lots of people began to drift out at this point.
I went for a walk around the Pavillion and the vendors. A lot of interesting applications on display. Macromedia were running a sneak peak of Royale (this preso is running several times throughout the conference), showing how a rich client application can be programmed using XML and some scripting and delivered via Royale on top of J2EE systems.

---

You can read more about Royal on macromedia.com.

JavaOne - General Session

The big message is "Java Everywhere" - Java on the server, on the desktop, on billions of connected devices. Performance and compatibility are key focus points and Vodafone showed their "Vodafone Live!" European cell phone service that offers games (in Java) and a myriad other services. Oracle and Borland both showed a peak into the future of their development tools and GE Medical Systems showed how they are using Java to improve efficiency in healthcare by empowering physicians and enabling them to take all of their data with them to their patients - impressive.
The other big news is the new Java brand - a tidier logo and a push into the consumer market with the consumer-focused http://www.java.com/ and the community-focused site http://www.java.net/

JavaOne[sf2003]

I'm going to be at JavaOne all week, starting tomorrow morning. My main focus will be on JVM performance issues (including garbage collection) but I'm also 'treating' myself to a couple of Mac OS X sessions and the new language feature stuff, as well as some ebXML sessions. It should be a good conference!
I went along and registered tonight while it was quiet and picked up my swag bag with T shirt, pin, notepage, program and hockey puck! Not quite sure about that. Nor are the cats... who think it ought to roll around a lot more than it does. Anyway, thank you Sun for an interesting cat toy.
While I was checking in, I opened my laptop and found three separate wireless networks active in the building ("onsite", "k3m", "javaone") but they all challenged for a password and not one member of staff onsite could tell me anything about the networks, nor whether there would be general delegate access (Macromedia provided free, open WiFi at DevCon 2002!).
I will try to blog live from the conference - WiFi permitting.

Font Tags - Just Say No! (Zeldman on Web Standards)

Meet The Makers continues its great "conversation" series with Jeffrey Zeldman on Web Standards, talking about why it's more than just being hip to be compliant - it can make you a faster web developer and it can also be easier.

Sun's Java Developer RSS Feeds

Sun has three RSS feeds covering Java, Wireless and Solaris technology themes.
The Java feed contains references to bugs fixed in 1.4.2, a chat transcript about 1.4.2 with the key developers, conversations with Joshua Bloch and Guy Steele about new language features and language evolution and a great article about best practices for Servlets and JSP.

CF Studio to HomeSite+

Todd Rafferty has some useful tips for setting up HomeSite+ so that it looks and behaves more like ColdFusion Studio 5.

A Taste of Shared Hosting

I finally have a CFMX hosted account! Right now, it's just a test account with an ISP that is asking folks to test their new 'control panel' and I don't know if it'll stay around once their test is complete, but it will give me a sense of what life is like on a shared server.
So far, the experience has been good: the control panel seems well-designed but, obviously, limited in functionality since you don't get a full CF Admin to play with. Not sure yet what I'll put up there by way of a test, probably a small DB-driven Fusebox MX application if I can think of something worthwhile to build.

CFMX for J2EE on WebSphere

IBM have a great article on their DeveloperWorks site about sharing sessions between ColdFusion MX and WebSphere. Even if you're not specifically using WebSphere, the article should provide you with an interesting insight into how the two technologies - ColdFusion and J2EE - interact.

CFUN-03

Don't forget: CFUN-03 is just $249 registration through the 14th of June (and then $299). CFUN-03 is June 21st & 22nd in Maryland.

Why is CFMX on Mac OS X so great?

Christian Cantrell waxes lyrical about why you should be excited about ColdFusion MX on Mac OS X! Christian talks about why Mac OS X provides the best of both worlds: robust, powerful Unix with an easy to use GUI and all the standard desktop software. The convenience of a PC with the power of a *nix server! Almost every week I see another member of my team has switched from Windows to Mac, with Powerbooks replacing Wintel laptops. Everyone seems very happy with their choice to switch.

CFMX for J2EE & Hardware Load Balancing

Brandon Purcell and Frank DeRienzo have just published a great article about setting up hardware load balancing for ColdFusion MX and J2EE application servers. This gives the background to how macromedia.com is set up as well as showing what other enterprise-class options you have with hardware load balancing.

Mono 1.0 - Later This Year

An interesting article in InfoWorld about the plans for Mono, which is currently at version 0.24 but is planning a 1.0 release this year. Mono is interesting for a variety of reasons and it's somewhat of a double-edged sword: it will both validate Microsoft's architecture and vision as well as providing a non-Microsoft alternative for development and deployment of .NET applications. It will be interesting to see how Microsoft reacts once .NET on Linux becomes a reality...

Macromedia & RSS

Mike Chambers has listed the various RSS offerings that Macromedia has produced so far (including the Press Release feed which I built in just a few lines of CFML!) and is asking for feedback on what else you'd like to see us offer. Go to his blog and offer your comments!

Red Sky / CFMX

Phil Costa talks about the next release of ColdFusion MX, a.k.a. red Sky. This is a maintenance release and will be a free upgrade for existing ColdFusion MX customers.

IE is Dead

Microsoft has stated that there will be no future standalone version of IE. It's interesting to hear this after all the work Microsoft put in to ensure dominance in the browser "market" (such as it is considering nearly all browsers are free!). As that "messy-78" blog entry suggests, Mozilla and Safari are probably the two best options for anyone wanting more from their browser (on Windows and Mac respectively).