Adobe GoLive CS

I'll freely admit that I'm doing this review for somewhat impure reasons. You see, I started my second flirtation with Adobe GoLive only because my usual visual page editor (you know, the one named after that cheeseball Gary Wright song) got the equivalent of some really bad plastic surgery that left it laughably buggy and ultimately unusable. So in my desperate time of need, I turned to the proverbial "other woman" I had only gazed at briefly before (and then, only for the QuickTime editor) in the hopes of finding aid and comfort. How did GoLive CS do? Read on to find out...

The basics

In a nutshell, GoLive is a visual page editor (or "WYSIWYG" editor, in the vernacular of the mid-1990's). But we've come quite a ways from those long-ago PageMill days. GoLive, now at version 7 (OK, OK, Adobe marketing folk - "CS"), is a complete, integrated environment for designing, authoring, and publishing Web content. And maybe I was a victim of lowered expectations here, but GoLive simply impressed the expletive out of me. And it's not often that I get the expletive impressed out of me, especially not by a program that spits out Web pages, of all things.

The first thing you'll notice when firing up GoLive is that the interface is a little more in tune with the rest of the Adobe product line, especially those products that share the CS moniker (fig. 1). That's intentional, of course, as Adobe would like nothing better than to have you pony up for the entire Creative Suite Premium Edition and never touch any product from any other vendor again. But I digress. If you're familiar with Photoshop or Illustrator, it's not hard to get the hang of how things are set up in GoLive.

Figure 1: GoLive's interface is a little more Adobe-esque these days.

Once you're in, you can basically work as you would in a word processor. Type stuff in, drag and drop images, create tables, etc. Nothing too groundbreaking there. The real fun comes once you move past the basics. For example, GoLive CS gives you the ability to resize and/or crop images on the fly (fig. 2), meaning that once you've got a source image, you don't have to go to another program to tweak it. This is a huge timesaver, and becomes especially cool once you start factoring GoLive's Smart Objects (more on those later, though).

Figure 2: Resizing and cropping existing images can be done directly in GoLive, while still retaining excellent image quality.

Newbie to expert

In addition to being an easy tool for HTML novices, GoLive CS really reaches out to those who are decidedly on the other end of the spectrum. I realize that it may be taboo in certain circles for any self-respecting HTML expert to effectively "slum it" by using a program like GoLive instead of hand-coding in a text editor, but for those who throw pride out the window (as I routinely do), GoLive presents a pretty tight environment for the more geeky among us.

For the newbies, it might as well be the PageMill days again, albeit with a lot more options. You never have to see a single character of HTML code if you so desire, since, as I mentioned, you can use GoLive as you would a word processor and be done with it. Adding HTML tags is as easy as drag and drop (fig. 3), and the Inspector palette makes it simple to edit the attributes of your code without having to know syntax or other such nonsense (fig. 4). GoLive CS also ships with a ton of ready-made page templates (fig. 5) as well as a pretty sizable library of CSS styles, code snippets, and even section 508-compliant designs that make accessible pages a snap. Even adding content designed for plug-ins such as Flash or QuickTime is ridiculously easy—drag the object from the toolbar to the page, set a few properties, and all that nasty Object and Embed code is inserted for you (fig. 6). The bottom line here is whether you're genuinely code-adverse or just like shortcuts to make things easier when writing HTML, you're set.

Figure 3: Drag from the toolbar, drop in the Layout. Code inserted.

Figure 4: The Inspector lets you add attributes to your code without really having to know what you're doing.

Figure 5: If you need help getting started, GoLive ships with a ton of page templates.

Figure 6: Here's some ActiveX code you don't have to know about, since GoLive lets you drag and drop plug-in objects right into the Layout.

Now, for the more HTML-savvy users out there, you're in great shape as well. To borrow from Tom Cruise in Magnolia, GoLive "respects the code." First and foremost, GoLive generally codes the way you want it to, not the way it wants you to. Except for GoLive-only things like Smart Objects, you're not going to get garbage tags thrown around for no apparent reason like some programs inexplicably do. You're going to get pretty clean code from the start, which stays untouched. Sure, you can set GoLive to rewrite tags in pre-existing pages if you want (fig. 7), but it will do so only when you tell it to. Otherwise, whether code was written by hand or spit out via some other editor, GoLive leaves it alone, which is very good.

Figure 7: GoLive only rewrites code when and how you tell it to.

But what about tags that GoLive generates itself? This is a big issue for hand coders, as over time everyone comes to write in a certain style (preferred tabbing, insertion of carriage returns, amount of whitespace, etc.) and it's often difficult to "eye parse" code that's been written in an unfamiliar manner. Rest easy, because again GoLive puts you in charge, from how the code is formatted to the way specific tags are written (fig. 8), meaning that it's quite possible to make GoLive-generated code appear exactly as you would have coded it.

Figure 8: You can customize the way each tag is written, if you're into that sort of thing.

Now, I've always been partial to the minimalist way of coding using only a text editor, especially in these days of cleaner markup and CSS, so I was a little wary about whether GoLive's Source Editor would be up to snuff. But to my surprise (which is pretty much a running theme here), the Source Editor is a thing of beauty (fig. 9), in that it gets out of your way when you want it to and is there to help when you need it. It's really all about the little things. Of course, there's syntax highlighting, but GoLive lets you switch highlighting themes on the fly (highlighting only the actual text inside of a page, for example), which is a big help with the all important eye parsing I spoke of earlier. Dragging and dropping from the toolbar also works in the Source Editor (fig. 10), so you don't have to be in layout mode to enjoy some of the timesaving features that the newbies do. GoLive also packs a context-sensitive tag library—just start typing and likely matches pop up right under the insertion point for quick access. It's also got an integrated syntax checker (fig. 11), so you can verify whether you forgot to close a tag or misspelled something or are kosher with whatever standard you're coding to. And finally, the Source Editor features are also extended to various other specialized editors, such as those for JavaScript, CSS, and XML (fig. 12).

Figure 9: GoLive's Source Editor, in all its splendor.

Figure 10: Dragging and dropping ain't just for the code-phobics.

Figure 11: You can check the integrity of your code against any number of Web standards.

Figure 12: GoLive sports numerous other task-specific editors; the JavaScript editor is shown here. You may recognize this code if you're a Flash user.

While I'll cover some more geek stuff a little later, for now I'll leave this section by saying that if you're a source code nerd (or even an occasional source code nerd like myself), GoLive is a surprisingly nice environment for source-only editing. Now there's a sentence I never thought I'd read myself writing when I first started messing with GoLive.

Site planning and maintenance

GoLive CS also sports an array of tools to aid in planning, prototyping, and maintaining your sites. First up is the site feature (fig. 13), which consolidates all of your site's assets, from files and images to Smart Objects and even external links, into a single place. Of course, everything is accessible through double-clicking in the site window, and, as you might expect, you can drag/drop/point at things like images and links in a snap (fig. 14) should you opt to manage your site this way. GoLive is equally capable of just messing with pages on an individual basis as well, so if you're just working with a page or two at a time you'll still be in good shape.

Figure 13: GoLive's Site window.

Figure 14: The ubiquitous Adobe pickwhip comes in handy here as well.

Another feature that might come in handy is GoLive's diagramming capabilities (fig. 15). You can plan out site maps, information architecture, and technology requirements right from within GoLive, add annotations, notes, etc., and then save the results out as a PDF or SVG document to pass around. Once you've got your site set, you can then submit the diagram to GoLive, which will actually create all the pages and elements for your site. Complicated, but also pretty powerful and kinda sorta cool to boot, if you're into that kind of planning stuff.

Figure 15: A fascinating diagram, as generated by the diagramming feature.

The last thing I'll mention here is that GoLive CS adds a new Co-Author mode, which is a publishing workflow that allows designers to create site templates with editable sections that, in a nutshell, don't permit content editors to break the design when trying to update the site. The designer uses GoLive CS to set up the pages and their editable regions, and then the editor uses a stripped-down version of GoLive (called, ingeniously, GoLive Co-Author) to create or edit pages based on the approved template(s) and then publish them to a Web server.

Standards-friendly

A lot of Web designers have caught the standards bug, and it's not hard to see why. There's a whole heckuva lot to like about standards-based site design, which I've written a whole 'nother column on earlier so we don't have to rehash that now. The bottom line is that if you're into standards, you'll be generally pleased with what GoLive has to offer in that department.

GoLive embraces a boatload of W3C-approved standards, including regular ol' HTML, XHTML, XML, and even SVG, for cripes' sake (fig. 16), but CSS is the "big one" here. GoLive integrates CSS authoring in a variety of ways, starting with the CSS Editor (fig. 17). The CSS Editor lets you manage both internal and external style sheets, and it's super-easy for novices and pros alike. If you're new to CSS, GoLive provides a complete GUI interface to the CSS spec, all the while giving you live previewing of your current style (fig. 18). For those already familiar with CSS, it's still nice to have a GUI to save you from syntax and property "dis-remembrances" while still having one-click access to the source code for tweaks (fig. 19). And, like the Source Editor, GoLive's CSS Editor lets you choose how the CSS gets formatted so it's in tune with any existing formatting style you may be used to.

Figure 16: So many standards to choose from, and even more that you don't see here.

Figure 17: Making CSS simple: GoLive's CSS Editor.

Figure 18: Editing a CSS document is done through a simple GUI, with a live preview thrown in for kicks.

Figure 19: Or, code by hand in the source view.

Once you have some styles built into or attached to your document, you can then use the uber-handy contextual CSS style checkbox. Just select some text, pop up the panel, and check away (fig. 20). It makes changing text styles super-easy and incredibly quick.

Figure 20: The styles panel lets you preview font styles and apply them with simple checkboxes.

"Superior Adobe integration"

I'll admit that I had somewhat of a "gimme a freaking break" moment while reading Adobe's marketing copy regarding GoLive's support for the other Adobe CS products. "Superior Adobe integration?" Whatever, dude. But, considering how a big part of why I was curious about GoLive in the first place was to see how Adobe managed to make everything play nice together, I was willing to give the marketing mavens the benefit of the doubt for once. Anyway, the BS detector did not serve me well this time, because it's really cool how the other CS products fit together here. GoLive makes extensive use of what it calls Smart Objects, which allow you to place native files from other CS applications directly into GoLive. The main advantage of using Smart Objects is that once you've placed another Adobe file type into GoLive, it keeps track of the source file and automatically generates out Web-ready images based on your defined export options. Here's a quick rundown of how each CS app fits into the picture:

Photoshop/ImageReady

Place a Photoshop Smart Object in the layout, and you're instantly presented with the familiar ImageReady Save for Web dialog box (fig. 21), where you specify what format and settings you want in the Web version of your image. The crop and resize features, of course, apply to Photoshop files as well. Additionally, you can also exchange rollover states and HTML code with ImageReady.

Figure 21: Look familiar?

Illustrator

The Illustrator Smart Object allows you to convert AI files to normal images, or as vector-intact SWF or SVG files (fig. 22). Again, if the source file changes, GoLive will automatically re-save the image in the target format.

Figure 22: GoLive auto-converts Illustrator Smart Objects to several Web-friendly formats.

Acrobat

If it's an Adobe product, you can imagine that there is some PDF capability built in. GoLive CS makes use of PDFs in a couple of different ways. In addition to being able to view diagrams in PDF format (as discussed earlier), you can easily create a PDF preview of whatever page you're working on (fig. 23). You can even open existing PDF files and edit links within them without having to have Acrobat handy (fig. 24).

Figure 23: Any page can be saved as a PDF.

Figure 24: Need to switch a link in an existing PDF? No problem with GoLive.

InDesign

This is such a cool feature, it almost makes me wish 1) that I knew anything about print design and 2) if I did, that I was an InDesign user. InDesign CS sports a "Package for GoLive" function that bundles up all of your print document's assets and allows you to create sites from them just by dragging and dropping in GoLive (fig. 25). It's one of those things that I played with a lot longer than maybe I should have, considering I have no real use for it. But just imagine how useful it would be for folks who are actually looking for an integrated print-to-web workflow.

Figure 25: Adding InDesign assets to a Web page is, yet again, as simple as dragging and dropping.

The bottom line here is other than the fact that the Smart Object feature adds a tiny bit of garbage code to your pages (fig. 26), the integration with other Adobe CS programs is pretty excellent. Maybe not "superior," but it's definitely not just hype.

Figure 26: The proprietary "livesrc" tag—a small price to pay for the flexibility of Smart Objects.

But wait, there's more

I'd be remiss if I didn't at least give token mention to GoLive's built-in QuickTime editor. I'm not going to go into too much detail here, as I've already done an entire feature on GoLive's QuickTime authoring environment a while back. Not a lot has changed between GoLive 6 and CS in this regard, but it's still a pretty useful tool to have if you need to wire up some interactive QuickTime. It's still no LiveStage Professional, but it'll do if your interactive QuickTime needs are, shall we say, more modest.

Disappointments

Even with all the good stuff GoLive CS hands you on a silver tray with a lovely garnish of parsley, there are a few glaring disappointments. The first one is a biggee, and may be enough to send a few of you packing right now. Rarely have I seen a software product completely remove a pretty large feature from existence, but GoLive CS has managed that rather dubious feat. I'm talking about the complete and utter disappearance of all dynamic content features. No database connectivity, no nothing. It's just gone. Of course, the competition continues to offer this feature, so if your bag is dynamic site management, you'd best look elsewhere.

Another thing that's off is just the overall unwieldiness of the Site feature. I appreciate the fact that GoLive is designed to handle potentially enormous sites, but with the rats nest of tabs and data folders and all the other ways that GoLive organizes things, for smaller sites it's just not worth it. For all the emphasis GoLive puts on keeping your code clean and organized, it all seems to get thrown out the window once you create a site structure. I'd like to see some measure of control given back to the developer for site organization, rather than GoLive taking over and organizing things the way it wants to.

I'm also a little disappointed at how more complex CSS appears (or, more accurately, doesn't appear) in GoLive's layout window. You get nothing but a lot of muddled garbage once you start precise positioning in CSS, which kind of defeats the purpose of even having a layout window in those situations. Of course, all is right once you switch over to the preview tab, but that's not the issue, is it?

And speaking of GoLive's previews, I have a couple of nits. One, is there any good reason that the integrated preview on the Mac is based on Opera? No offense to Opera, which is a fine standards-compliant browser, but isn't it ridiculously easy to access WebKit from Mac OS X and use the Safari engine? If text editors like SubEthaEdit can give you a live Safari-based preview window, GoLive should at least be as hip. In Windows, you get Internet Explorer, which is sucky just on moral grounds, but pretty decent considering that's what 95% or so of folks are running anyway.

The bottom line

As with all my reviews, I've left out a lot. That's not entirely due to me being a worthless sack of garbage—it's also because if I mentioned everything, I'd still be writing by the time GoLive CS 2006 (or whatever the next one will be called) is shipping. Such is life when you're dealing with a mature product. That's OK, because I'm also going to do something I do in all my reviews, which is direct you to Adobe's Web site and download the tryout version of GoLive CS.

So what's the verdict here? I'm giving GoLive CS a Strong Buy rating. It's worth it all by itself, and especially so as part of the Creative Suite Premium product (which features Photoshop, Illustrator, InDesign, and Acrobat Pro). Considering that my view of GoLive went from adorable little Dreamweaver competitor desperately nipping at the big dog's heels to pretty much an equal over the course of a few weeks, that's a gigantic improvement. Plus, it didn't crash 937 times in a row or "forget" to actually write out all my finely-crafted CSS tags like a certain other MX 2004 version of a certain former favorite visual page editor of mine, as I consider actually getting something done a valid criteria.

GoLive CS is available now for Mac OS X and Windows. It'll run you $399.00 by itself, $169.00 for an upgrade, $1,229.00 as part of the Creative Suite Premium, or $749.00 as a CS Premium upgrade.

Filed under: Review on February 25th, 2004

^ Top of Page

Got Feedback? to send an email. I'll do my best to answer. Really.