I attended this session and left it feeling very inspired. It was amazing to see what this small crew did with such a behemoth of a site. Just the thought of having to migrate a 1.66GB Oracle DB into a Drupal site makes me sweat. All things considered, I felt like this was probably the best session I attended at DrupalCon 2008. It wasn’t the nerdiest, or the geekiest, and it didn’t have lots of slides of code…but for our line of work, it was incredibly valuable. Not only did they go into the “nuts-n-bolts” of how they built the site, they also touched on the project management side, and also managing client expectations with such a large project.

Check it out to see how one of the best Drupal sites out there came to fruition.

Now, as you can probably tell, implementing a context for your site can sometimes be just as difficult as explaining what it is. In Drupal, there are several methods available to determine a context, but there are many pitfalls to look out for, especially if you are wanting to maintain a long-term context. Typically, we most often see context’s in use when setting what “section” of a site the user is on. We do this with either a thought out navigation structure (i.e. /galleries/album1, /galleries/album2). You will almost invariably find yourself resorting to looking at $node->type, arg(n), or using node_load() to determine what content to render. These can be handy for small, simple structured sites, but can quickly become a scalability issue on larger sites. You’ll find yourself having to return to append some more context to a switch statement in your template everytime a new section is added to the site.

So, that brings us around to Panels 2. At the presentation, Panels was suggested as a possible way to easily implement context and maintain it throughout a user’s experience. To clear up any confusion you may still have, sirkitree.net has posted this screencast about using Panels 2 Context.

You can read more about the session here and here.

If you missed the Boston DrupalCon 2008, don’t miss out on this wonderful session.
Files can be downloaded here…

This presentation was targeted primarily at the Drupal newbie, and was mostly a “tips & tricks” session. Here are my notes from the session:

We begin with a basic look at how Drupal works beneath the hood, so to speak. He talks about modules for core and contrib, and what module hooks are and what they do (take actions from Drupal, return info to other modules, alter info before returning it to Drupal, etc…). The first example we looked at was hook_menu(). hook_menu, in a nutshell, maps a URI to the code needed to build that specific page at the specified URI. It determines if the URI is accessible to the user, and records the URI for breadcrumb generation. We then looked at some specific examples of hook_menu() used in a module. Chad identified the main components of the hook_menu() function, including the $items[] array, access, callbacks, and callback arguments.

Next, we looked at hook_form_alter(), which is certainly one of the most powerful (and probably underused) functions available to modules in Drupal. In Drupal, forms are represented as nested arrays. Drupal core builds a form, and passes this array around to other modules. Modules can then alter parts of this array using the hook_form_alter() function, by either adding to it, modifying it, or deleting form elements all together from within the array. Basically, when you call the function, one of its parameters is $form_id. This represents the unique identifier for all forms generated by Drupal. You can check for this id, and thus, modify any form inside of Drupal before it is rendered to the end user. Pretty powerful stuff right there.

There was a good question from an audience member at this point: At which point does hook_form_alter() actually get called in the page rendering process? Drupal core builds the form first, then inside includes/form.inc, there is a function called drupal_process_form(). In this function there is a foreach loop that calls module_implements() to check for all modules that implement hook_form_alter(). It is at this point that the form(s) get modified by modules. After this, the form is rendered and returned to the user.

You can read the official Drupal API documentation on both of these hook functions here:
http://api.drupal.org/api/function/hook_menu/5
http://api.drupal.org/api/function/hook_form_alter/5

Next, we briefly touched on how content does not equate to presentation in Drupal. Content is stored in the database, and run through the theming system to separate content from presentation. It is loosely based on the MVC pattern.

The next topic involved what it takes to get Drupal up and running. The first thing, obviously, is a web server and a development environment. The easiest method of getting a development environment up and running is to download and install a pre-packaged Apache, PHP, and mySQL stack such as LAMP, MAMP, or WAMP. He briefly talks about other tools included in those packages such as phpmyadmin. Drupal has some video tutorials on getting your own environment up and running at http://drupal.org/node/159534.

There was another question from the audience at this point: What about migrating to a “secure” environment from your local (localhost) development environment. Use rsync or something of the like. There was an emphasis on keeping your development environment very separate from the production environment. Of course, in our line of work, this is absolutely necessary and imperative for many reasons. Basically, use localhost or your dev environment for testing out functionality and breaking your sites.

We discussed the various editors and IDE’s available next, including VI/VIM, Emacs, TextMate, TextWrangler, etc… For the record, Chad uses Zend. We really didn’t get into any specific details on any editor or IDE, he just gave some examples.

Next up: coding standards. First and foremost, if you have any desire to code for Drupal, whether it be to contribute to core, or write a custom module, read this first:
http://drupal.org/writing-secure-code
or, better yet, if your up here in Boston with us at the conference, there will be this session:
http://boston2008.drupalcon.org/session/drupal-security-best-practices
Chad talked about why it is important to have coding standards:

• For consistency among projects and codebases.
• For improved readability of your code.
• For automated documentation of your code (well written code = self-documenting code
• For security
• And, it is critical if you ever want your contribution to Drupal’s core to get accepted.

Next topic: What to do when your stuck??? This was mostly a series of links and resources to help you out when your at your wits end with an issue. Here’s the shortlist:

• http://drupal.org/support
• http://drupal.org/handbooks
• IRC channels: #drupal, #drupal-dev, #drupal-support, #drupal-themes, #drupal-dojo
• Full IRC chatroom list: http://drupal.org/node/108355
• IRC tutorial: http://www.irchelp.org/irchelp/irctutorial.html
• Support Forum: http://drupal.org/forum/18
• Module development support: http://drupal.org/forum/4
• Theme development support: http://drupal.org/forum/3
• Videocasts: http://drupal.org/videocasts

Next we looked at some available helper modules. These are aimed at the Drupal developer. Chad covered the API module, for locally installing a copy of Drupal’s API documentation (and also, allowing you to view the documentation of contributed modules, which isn’t available at the official API documentation website). The Devel module, which is the holy grail of development assistance modules for Drupal. The Coder module, which reviews module code for standards, as well as aiding in upgrading Drupal 5 modules to Drupal 6. And last was the SimpleTest module which brings the SimpleTest framework to Drupal. You can find these modules and more information in the links below:

• http://drupal.org/project/api
• http://drupal.org/project/devel
• http://drupal.org/project/coder
• http://drupal.org/project/simpletest

Lastly, Chad gave us some tips on what we can do to become a Drupal ninja. They are:

1. Master CVS and Project Management. Checkout the CVS handbook. Documentation for Project Managemetn is available at http://drupal.org/handbook/cvs/projects.
   There was an question from the audience about integrating SVN into Drupal. The short answer: it would take more resources than are currently available to make this happen, and so much has been invested into CVS for Drupal. Too bad.
2. Use test scripts. One helpful example was copying and pasting the first two lines from index.php in your Drupal web root. These two lines alone fully bootstrap Drupal and will give you a fully functional Drupal site without any of the other bloat. It is very useful for quickly trying out a snippet of code. We also talked about using debug functions such as print_r(), var_dump(), var_export(), and exit().
3. And speaking of exit(), it was next on the tip list: exit() is your friend. Indeed it is. Use exit() to bisect your code flow until you locate the source of your problem
4. Study core’s code. Seriously, learn from the people who wrote Drupal. If it made it into core, it is generally assumed to be good quality code. And it definitely follows the coding standards. Also, this code is reviewed extensively by the community before it can make it in.
5. Clear your cache. You can use the Devel module to make this trivial, or you can use the mySQL TRUNCATE command on the cache tables in the database. Nevertheless, at some point in your Drupal development life, you will run into a moment where caching will make you want to pull your hair out when your wondering why your code changes aren’t taking effect.
6. Learn vi/vim. Basically, because it may be the only available editor on some environments you encounter. Fair enough.
7. Install the API documentation locally with the API module. See above notes.
8. Document your work. Good comments and documentation not only help your fellow developers, but help you understand why your making the decisions you are making with your code. It gives you a chance to stop and really think about what your code is doing (or supposed to be doing)
9. Finally: if your at the conference, attend the Zen and the Art of Drupal session

You can view the slide presentation here: http://drupal5.xcarnated.com/node/22/s5

Also of note: this slide presentation was done using the s5 module for Drupal. Pretty neat.

Current state of browser market shares:
http://www.w3counter.com/globalstats.php?date=2007-05-20

Good and Bad PHP Code: An employer’s perspective
http://www.sitepoint.com/blogs/2007/05/25/good-and-bad-php-code/

How to use Firebug to debug PHP
http://ajax.phpmagazine.net/2007/02/how_to_use_firebug_to_debug_ph.html

Comprehensive guide to .htaccess
http://www.wsabstract.com/howto/htaccess.shtml

Prettier accessibly forms w/ CSS
http://www.alistapart.com/articles/prettyaccessibleforms/

TypeTester: Compare different fonts web output
http://typetester.maratz.com/

MicroFormats blog: From the man who wrote the book on microformats
http://microformatique.com/

15 Days of JQuery
http://15daysofjquery.com/

Simply Google. Simply put.
http://lloydi.com/blog/simplygoogleoriginal.htm

Along the same lines as simple google: FaganFinder
http://www.faganfinder.com/

Hacking DNS for faster web browsing
http://www.computerworld.com/action/article.do?command=printArticleBasic&articleId=9019951

First, I recommend you head on over to Yahoo Develper Network. The good people there have already taken most of the hard work out of browser normalization for you. There are two stylesheets you can download. The first is called reset.css. It sets defaults values for paragraph margins, body tag margins and padding, and headings among other things. The next stylesheet you need to download is fonts.css. This does the same thing as reset.css, but for fonts.

These two files should be the first stylesheets you call in your html. This way, you are provided with a relatively clean slate across all browsers to begin working on your own stylesheet. The first time I tried this technique out, I started without the normalizing stylesheets and viewed my page in Firefox, IE 7, IE 6, and Opera. I rapidly switched between the browsers to spot the differences. Some were very noticable, others not so much. I then applied my reset.css and fonts.css and repeated the same process. The result was very pleasing. Now, I was hard pressed to spot any differences.

BTW - While your visiting Yahoo, be sure to peek around. There are a ton of web designer and developer goodies up for grabs, as well as lots of literature to peruse.

The next thing I would recommend is getting in the habit of always using a DOCTYPE in your html. This is not only a good practice, but it is the standards compliant way of writing markup. Having a DOCTYPE tells your browser how to parse your markup. Without it, the browser reverts to it’s own methods. In IE 6, it goes into what is known as ‘quirks’ mode. Not only is this non-standard, but who wants IE acting any more quirky than it already does? When you add a DOCTYPE, IE goes in to “strict” mode, which is more predictable for web design and development.

Of equal importance, is that when you have a DOCTYPE, you can now run your markup through a validator. If you are not familiar with validating your markup, you should start to consider making it one of the most utilized tools in your web development arsenal. Running your markup through a validator allows you to quickly catch syntax errors you would have otherwise spent hours looking for. It also insures that your markup is keeping up to standards. There are several types of DOCTYPES to choose from, the most common today being XHTML Transitional, and the holy grail of all - XHTML Strict. Having markup that validates XHTML Strict is not only a badge of pride, but it also means that your markup is accessible and well formed. As with everything, the caveat here is that the validator is not smart enough to analyze your content, just the markup. So, once your html is validating, it is your job to make sure your markup is meaningful and the content is ordered properly to be accessible to those with text-only browsers, screen readers, and mobile devices.

Resources:

Yahoo Developer Network:
http://developer.yahoo.com

reset.css:
http://developer.yahoo.com/yui/reset/

font.css:
http://developer.yahoo.com/yui/fonts/

W3C HTML validator:
http://validator.w3.org/

W3C CSS validator:
http://jigsaw.w3.org/css-validator/

IE - quirks and strict modes:
http://www.quirksmode.org/css/quirksmode.html

Other good resources for DOCTYPES:
http://www.w3.org/QA/2002/04/valid-dtd-list.html
http://alistapart.com/stories/doctype/
http://www.oreillynet.com/pub/a/javascript/synd/2001/08/28/doctype.html

If you have ever attempted to implement rounded corners in your markup and css, you’ll find that your markup quickly becomes riddled with presentational divs, loads of images, and the css seems to be playing the role of a bar bouncer. It’s even worse if the content box you have rounded needs to be fluid in any direction.

Nifty Corners Cube solves this for us in just a few lines of Javascript. Here’s how easy it is to get it going:

In our example, we assign a window.onload function that will ensure our boxes get rounded every time the page loads/refreshes. The function Nifty(), is where all the work takes place. It takes two parameters. The first parameter points to the id of the element we wish to round (any block level element that takes up space on the page will work). This can be a comma separated list of multiple elements, and it can accept certain CSS selectors. The second parameter is a space delimited list of options that tell Nifty Corners how to round the box. In this example, we used the options ‘big’, which says to make the corner radius 10 pixels (there is also small(2px), and the default normal(5px)), and we used ‘top’, which will only round off the top two corners of the box.

There are several other options that allow you to fine tune your boxes. You can assign only one corner of a box to be rounded, and it even has built in support to create columns of rounded boxes. Also, you can call the Nifty() function as many times as you would like for as many elements as you need to. Just be sure to wrap them all in a window.onload (or the included NiftyLoad function).

Recently, we had a design to breakdown that made heavy use of rounded corners. For the first pass, we didn’t use Nifty Corners. The markup was laced with tons of nested divs, and the CSS file was accordingly huge. Though the design was functional, it was fragile. Any future redesigns would have required alot of work. We went back and implemented the same design using Nifty Corners, and found that we were able to easily keep the markup lean (and validate XHTML strict), and the CSS file was reduced by nearly 800 lines. This means alot when time is money, and even more should the day come to redesign the site.

There are a couple of improvements I would like to see in future versions of Nifty Corners. Currently, Nifty Corners cannot support borders around your box. You can have a border set, but it will not round off with the rest of the box. Second, I would like to see better support for Safari. We found that it would work on Safari for nearly all applications, but when we attempted to round off a grouping of list elements (which worked in every other browser we tested), it just wasn’t happening. Reading up on his site, it seems that support for Safari is new to Nifty Corners, so perhaps it won’t be long before all the kinks are worked out.
We tested Nifty Corners on Firefox 2, IE 7, IE 6, Opera 9, and Safari 2. It faired very well in all browsers (floats and padding couldn’t even break it in IE 6!).

I’ve noticed over the years, that everyone has a different approach to tackling this issue. Some prefer to use multiple stylesheets, one always for IE, the other for everyone else. Some code one stylesheet, but forsake uniformity for subtle, sometimes unnoticable, differences. I myself have used both of these techniques in the past. Not that there is anything wrong with either method; the end goal is to have a webpage that looks roughly the same in all the major browsers (IE 5-6, Firefox, Opera, Safari), and most importantly, without using tables for layout.

Recently, I discovered a technique that takes a little bit off the edge of that crossbrowser headache. It allows you to use a single stylesheet for the two big browsers (IE, Firefox), and not have to resort to ‘hacks’ to get IE to cooperate. I’ve noticed that the standard is starting to lean towards a ‘design in Firefox - tweak for IE’ mentality. This technique allows us to handle both browsers at the same time, without having to go back later and run in to the inevitable issues that crop up.

Enough talk. Let’s see some code.

We’ll start with an HTML snippet:

<div id="green">What color is this?</div>

Simple enough. Now, let’s style it so that our text is actually green on the page.

#green { color: #00ff00; }

Ok. Now, if we viewed this in any browser, the text ‘What color is this?’ will be green. But what if we wanted the text to be blue in Internet Explorer, but stay green in Firefox? Hmm…do we use two stylesheets? Not anymore. Check this CSS out:

#green { color: #0000ff; } /* make it blue for internet explorer */

body>#green { color: #00ff00; }  /* make it green for firefox */

What’s happening here? Well, when Internet Explorer is parsing through this stylesheet, it comes to the first #green tag. Nothing out of the ordinary here, so it parses it just fine. Then it comes to the next tag, body>#green. Internet Explorer 6 and below does not recognize the ‘>’ selector (which is referred to as the child selector), so it doesn’t parse it. But Firefox and Opera support the child selector, so following the rules of cascading, Firefox would render the tag correctly, while IE only renders the first tag. Cool, huh?

Of course, my example is trivial. This really comes in handy when dealing with positioning issues such as the differences between how IE and Firefox handle the box model, padding, margins, and floats.

There are some rules to follow when using this technique:

1- The IE element should come first in the stylesheet (they don’t call it cascading stylesheets for nothing!)

2- There should be no white space surrounding the child selector:

#container > #green { color: #00ff00; } /* This won't work! */

#container>#green { color: #00ff00; } /* This will! */

3- When using the child selector (>), the element on the left should be the direct parent of the element you wish to effect.

For example, if we had had the following html in our earlier example:

<div id="container">

<div id="green">What color is this?</div>

</div>

We would have wanted our stylesheet to look like this:

#green { color: #0000ff; }  /* blue for IE */
#container>#green { color: #00ff00; } /* #container is the direct parent of #green */

That’s it. No other rules needed. I find that this technique really saves me time now when it comes to doing css layout. I can handle positioning an element in both browsers at the same time, instead of coming back to it later to tweak.Of note: IE7 now supports the use of child selectors. So, when your coding your css, keep in mind that IE6 and below won’t understand the selector, but IE7 will. Also, IE7 won’t support the old “star hack” that many a css designer have used in the past to hide styles from IE.

For more information on crossbrowser CSS, as well as the discussed techniques and ’star hack’ visit these links:

http://www.quirksmode.org/css/contents.html

http://www.webcredible.co.uk/user-friendly-resources/css/internet-explorer-7.shtml

Virtuemart:

• <5 minutes (if you have a working installation of Joomla, <10 minutes otherwise).
• Installs as a module for Joomla. Click upload & install from module installer pane, and viola!
• Package comes with two Joomla components, two mambots, and several plug-in modules that offer added functionality (i.e. minicart, top 10 products list).
• Includes sample data for a demo store.
• Uses Joomla’s admin interface for store administration

osCommerce:

• <10 minutes.
• Includes sample data for a demo store.
• Comes with admin interface.

Features

(as stated on the websites for each product)

Virtuemart:
Products/Categories:

Add as many Products and Categories as you want
Can also be used just as a catalogue (without cart features)
Unlimited Category/Subcategory depth, products can be assigned to multiple categories
Sort your Categories the way you like
Sell downloadable Products like MP3s, Templates, Videos or Software
Add a Thumbnail and a full size Image to every Product via your Browser
Add Attributes like Size or Color to your Products to offer product variations
Use Product Discounts (percantage/total, time limited or not)
Show Details & images for every Item
CSV Upload, (CSV Import & Export)
Manage the Stock Level for Products and Items
Automatically Notify Shoppers when a Product is back in Stock
Feature specific products by setting them “on special”

Shopper Groups / User Management

Add Shoppers and assign them to different shopper groups
global Shopper Group Discounts
multiple prices can be added to a Product, each for an own shopper group or a quantity range
Restrict “Display prices” to specific user groups
Access Management: assign users to user groups like “admin”, “storeadmin”, “shopper” or “demo” to allow the administration by other users

(assign products to vendors and allow those vendors to maintain only their products)
Easy Configuration / Customization

Manage your shop through an easy and completely Joomla/Mambo-integrated interface
A “Welcome Screen” shows your daily Shop Statistics: A Summary with “number of customers”, “number of orders”, “5 newest customers” and so on
capable of Frontend Administration (without having to login into the Backend of Joomla/Mambo)
global Price/Currency Display Formatting
Templates for Product Display Pages
Extend the Shop with other Modules and Functions
Manage different Currencies, Countries

Shipping Addresses / Rates

Shoppers can add individual Shipping Addresses
Fetch Shipping rates live from Intershipper, USPS, UPS, Canada Post, …
Write your own Shipping Modules using the Shipping API

Tax Rates

Product prices can be displayed “including tax” or not (set for each shopper group)
Choose between Shipping-Address-based tax calculation (city/state & country/region)

OR

Store-Owner-based tax calculation (e.g. in european countries)
Add your own shipping carriers and shipping rates

Payment

Use safe SSL encryption (128-bit) and Shared SSL
Capable of live credit card processing
Supported Payment Providers:

o authorize.net online Credit Card Processing (AIM)

o 2Checkout
o PayPal (with IPN gateway)
o Paymate
o NoChex
o WorldPay “IPN”
o PayMeNow
o eCheck.net
o eWay (XML transactions)
o eProcessingNetwork
o and more…
* Payment Module API for custom payment modules…

Order Management

Complete Order Management
Automatically notify your customers when the Order Status changes
See who has ordered: IP address storing
Extend the pre-defined order statuses with your own ones

“Nice” Features for Customers…

Let your customers easily search for products through a search form
Shoppers can see, in what time a product will usually ship, on product-details page (with nice images!)
Shoppers can manage their user accounts
Shopper can view all their orders (and order details)
Order Confirmation mail (customizable!) is sent to shopper and store owner

Joomla! / Mambo Integration

Registration while checkout automatically registers the user to the global user table (registration is necessary for purchasing items)
Complete integration of the layout using Joomla!’s standard CSS styles
Easy installation / uninstallation using the Joomla/Mambo Installer

Free VirtueMart hacks/tweaks/modules

(made vailable from the community, and growing daily!)

Zone Shipping Module from Zephware.com
Flypage Admin Link for phpShop
Latest Products for phpShop (as a seperate module)
Mini Cart for phpShop (also available as a separate module)
Random Products for phpShop (as a seperate module)
Featured Products for phpShop (as a seperate module)
Special Products Manager for phpShop
Report Basic (for statistical purposes)

osCommerce:

General Functionality

• Compatible with all PHP 4 versions
• All features enabled by default for a complete out-of-the-box solution
• Object oriented backend (MS3)
• Completely multilingual with English, German, and Spanish provided by default

Setup / Installation

• Automatic web-browser based installation and upgrade procedure

Design / Layout

• Template struture implementation to:
  • allow layout changes to be adaptive, easy, and quickly to make (MS3)
  • allow easy integration into an existing site (MS3)
• Support for dynamic images

Administration / Backend Functionality

• Supports unlimited products and categories
• Products-to-categories structure
• Categories-to-categories structure
• Add/Edit/Remove categories, products, manufacturers, customers, and reviews
• Support for physical (shippable) and virtual (downloadable) products
• Administration area secured with a username and password defined during installation (MS3)
• Contact customers directly via email or newsletters
• Easily backup and restore the database
• Print invoices and packaging lists from the order screen
• Statistics for products and customers
• Multilingual support
• Multicurrency support
• Automatically update currency exchange rates
• Select what to display, and in what order, in the product listing page
• Support for static and dynamic banners with full statistics

Customer / Frontend Functionality

• All orders stored in the database for fast and efficient retrieval
• Customers can view their order history and order statuses
• Customers can maintain their accounts
• Addressbook for multiple shipping and billing addresses
• Temporary shopping cart for guests and permanent shopping cart for customers
• Fast and friendly quick search and advanced search features
• Product reviews for an interactive shopping experience
• Forseen checkout procedure
• Secure transactions with SSL
• Number of products in each category can be shown or hidden
• Global and per-category bestseller lists
• Display what other customers have ordered with the current product shown
• Breadcrumb trail for easy site navigation

Product Functionality

• Dynamic product attributes relationship
• HTML based product descriptions
• Automated display of specials
• Control if out of stock products can still be shown and are available for purchase
• Customers can subscribe to products to receive related emails/newsletters

Payment Functionality

• Accept numerous offline payment processing (cheque, money orders, offline credit care processing, ..)
• Accept numerous online payment processing (2CheckOut, PayPal, Authorize.net, iPayment, ..)
• Disable certain payment services based on a zone basis

Shipping Functionality

• Weight, price, and destination based shipping modules
• Real-time quotes available (UPS, USPS, FedEx, ..)
• Free shipping based on amount and destination
• Disable certain shipping services based on a zone basis

Tax Functionality

• Flexible tax implementation on a state and country basis
• Set different tax rates for different products
• Charge tax on shipping on a per shipping service basis

Thoughts:
Both products support alot of the same features. Customizable products, carts, shopper account administration, reports, etc… Virtuemart definitely benefits over osCommerce when it comes to extensibility. If you are familiar with Joomla’s framework and templating system, then the sky’s the limit when it comes to extending virtuemart. osCommerce, while certaintly popular, is difficult for the developer wade through, lacking meaningful comments and a having a code structure that is haphazard at best. osCommerce and Virtuemart are both easy to administrate from each others’ respective admin interfaces.

Virtuemart Pros:

• Fast and easy installation and configuration.
• Easy to customize and extend.
• Shopper groups (vendors, guests, whatever your heart desires. Product prices and descriptions can vary from group to group).
• Small codebase, easy to develop for. (it’s just a Joomla module)
• Easy to adminstrate.

Cons:

• Still quite a bit on the CVS to-do list. (some functionality could require development if needed immediately)
• Not stand-alone. Requires Joomla to function.
• Must learn Joomla framework (or at least how to write Joomla modules and templates) to develop custom functionality.

osCommerce Pros:

• Fast and easy installation and configuration.
• Vetted. Though still a development release, it is widely popular and thus has a larger support base.
• Lots of plug-ins. Chances are, any feature you need, has already been written by someone else.
• Supports most e-commerce standard features out-of-box.

Cons:

• Large and overly complex code base. Difficult to extend or modify.

Final thoughts:
Still waiting for the “holy grail” e-commerce solution. osCommerce comes close in functionality, but from the developer’s perspective, the code could really benefit from a reorganization and some general TLC. Better comments, cleaner code layout, and a more thought out class structure would definitely boost osCommerce’s standing among developers. If Joomla continues to grow as (probably) the best web CMS out there, Virtuemart could give osCommerce a run for its money. Having the advantage of being fully integrated into a very rich CMS, managing Virtuemart becomes almost trivial.