Important note: Effective with the release of Adobe LiveCycle ES, the Adobe Flex Data Services 2 server product has been rebranded as a Solution Component of LiveCycle ES. This article was written based on Flex Data Services but will likely work as is with LiveCycle Data Services ES. Any articles referring to or using ColdFusion and Flex Data Services are not compatible with LiveCycle Data Services ES. To learn about the new capabilities of LiveCycle Data Services ES, see the tutorials in the LiveCycle Developer Center and read about Adobe LiveCycle Data Services ES.

In October 2005, Macromedia (now Adobe) provided the developer community with the first look at Adobe® Flex™ 2—a new lineup of developer tools, libraries and runtime services that will enable developers everywhere to build and deploy rich Internet applications that take advantage of the Flash® Player runtime. Since then, tens of thousands of developers have started to build applications with Flex and provide their feedback to us. Additionally, Macromedia became part of Adobe, opening up a whole new world of opportunities for improving the future of Internet applications.

With the announcement of the Flex 2, we're proud to show the results of the development cycle between October 2005 and June 2006. By combining an intuitive programming model, a powerful Eclipse-based IDE, and a rich set of J2EE-based runtime services, we believe that the Flex 2 product line provides developers the most comprehensive solution for delivering cross-platform rich Internet applications available today. The recently announced pricing structure allows developers to build and deploy many kinds of applications for free without needing to install anything on their servers. And recent releases of technologies like the Flex-Ajax Bridge and Ajax Client for Flex Data Services under open source licenses allow developers to incrementally add Flex components to existing websites and applications, whether they are based on static HTML or Ajax technologies.

If you regularly use floating DIVs to help your web pages look consistent in a variety of browsers, you'll be very interested in this technique. Instead of using positive margins, it involves using negative margins to help position your DIVs. This article is the first part of a four-part series.

Introduction

When web designers started building web page layouts using now-venerable DIVs, a considerable number of approaches emerged quickly. These different techniques demonstrated the numerous advantages of the table-less paradigm.

Among many crucial things, you've no doubt learned that DIVs could be easily floated to the left and the right of a web document. This facilitates the creation of consistent web page layouts by mean of only a few floating boxes. And to be frank, this technique has proven to be quite successful, particularly in those cases when it's necessary to build web-based front-ends that must be displayed consistently across different browsers.

In most cases, when floating DIVs are used to build the layout of a web document, they're simply positioned to the left or right side of the pertinent document, according to the number of containing columns that need to be created. Eventually, positive margins are also specified for each of them when this is applicable.

However, as you probably know, it's also possible to build robust web page layouts that use negative margins to accommodate the containing DIVs within the corresponding web document. This CSS-driven approach was introduced initially by Ryan Brill in his insightful article, and it bases its functionality on pulling out DIVs to the left and the right of a web page by specifying negative values for their respective margins.

Even though this concept may sound quite easy to understand, the truth is that it can be a bit tricky when it's time to put it into practice. Therefore, assuming that you're interested in expanding your existing background in building DIV-based web page layouts and learning how to use negative margins to position your DIVs, in this group of articles, I'm going to show you numerous code samples regarding the implementation of this useful CSS technique.

Now, let's get rid of the preliminaries and start learning the key concepts of creating consistent web page layouts using negative margins. Let's get going!

It's not unusual for the layout of a Web page to feature multiple columns. Unfortunately, when creating this layout while using general <div> containers, you can end up with columns of uneven height, depending on their content. This looks very unprofessional. Alejandro Gervasio explains a way to keep your column heights even using CSS and JavaScript.

Introduction

CSS based design is really a powerful approach for most Web developers who consciously keep a website's contents separated from their visual presentation, which improves the site's overall maintenance and flexibility. Without a doubt, these virtues have provided designers with new possibilities for styling and positioning elements within Web documents very easily.

While tables still remain, for good compatibility reasons, the most used technique to define the layout of Web pages, <div> elements have gained considerable territory because they efficiently perform the same task. However, div-based layout exposes some undesirable artifacts when it is applied. Certainly, one of the most common pitfalls encountered when building up a two or more column liquid layout is the inability to give each general <div> containers the same height. It is desirable to achieve a consistent look, but also difficult, because of the dynamic nature of contents to be included in general <div> containers.  Due to this issue, many websites present layout columns with uneven heights, which looks very inconsistent to the eyes of visitors.

However, we can do much more to solve this problem. Over the course of this article, I'll show you a simple but powerful approach to match heights for general layout divs, thus eliminating that ugly effect that makes some sites appear quite unprofessional. Using CSS and JavaScript, we'll find a nice solution without feeling a sense of doom. So, it's time to move on and tame those wild divs!

One of MySQL's strengths is its use of Binary Large Object (BLOB) columns. These columns store unprocessed binary data, typically files, that can be retrieved and manipulated like the other common datatypes. The difficulty comes in accessing the BLOB column in VB. Prior to ADO 2.5, the only way to move data in and out of a MySQL BLOB column using Visual Basic was to use the appendchunk and getchunk methods. With ADO 2.5, the stream object has been added, greatly simplifying the process of working with MySQL BLOBs. In this article, I will focus entirely on using the stream object.

I would recommend you begin by making sure you have the latest service pack for Visual Basic installed. Installing the service pack will ensure you have the latest version of ADO installed. In a new (or existing) Visual Basic project, make sure that the most recent version of the Microsoft ActiveX Data Objects Library is checked in the references section of your project (Version 2.8 as of this writing). I will also assume that you have MySQL installed, as well as the latest version of MyODBC (currently 3.51.06).

NOTE  Version 3.51.03 or higher is required to avoid errors.

MySQL Configuration

Now that ADO is installed and referenced, we can use it to access a MySQL BLOB column. Our first step is to create a table to be accessed. In my file tables, I usually have four columns: an AUTO_INCREMENT column of appropriate size (UNSIGNED SMALLINT) to serve as a primary key to identify the file, a VARCHAR column that stores the filename, an UNSIGNED MEDIUMINT column that stores the size of the file, and a MEDIUMBLOB column that stores the file itself. For this example, I will use the following table definition:

CREATE TABLE files(
file_id SMALLINT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
file_name VARCHAR(64) NOT NULL,
file_size MEDIUMINT UNSIGNED NOT NULL,
file MEDIUMBLOB NOT NULL);

While logged into MySQL, we should modify the max_allowed_packet system variable. This variable determines how large of a packet (i.e. a single row) can be sent to the MySQL server. By default, the server will only accept a maximum size of 1 meg from our client application. If you do not intend to exceed 1 meg, this should be fine. If you do intend to exceed 1 meg in your file transfers, this number has to be increased. I set my max_allowed_packet value to 15M, in MySQL 3.x, this limit is 16M, in 4.x, the size is limited only to your system memory, up to a theoretical 2G maximum. I personally find 15M to be more than enough, especially since my users connect remotely through DSL modems at best, and a 15 meg transfer tends to take upwards of 5 minutes as it is. If you do need to change this value, you can either set it in the my.cnf file (add a line that reads SET max_allowed_packet=15M;), or use the SET max_allowed_packet=15M; syntax from within MySQL.

Learn how to take advantage of polymorphism in VB.Net with William's quick tutorial. Learn how polymorphism can eleviate your OOP-related headaches!

This article explains and extends the know-how of implementing polymorphism in VB.Net.  Of course, polymorphism is a huge topic and I will only focus on the little known VB.Net keyword MyClass.

I would like to stress that VB.Net is a full compliant object-oriented language and thus, OOP should be practiced at all times within .NET Development, albeit with careful planning and design so as not to lose focus.

In the aforementioned article, the author stresses that polymorphism can lead to nightmares and headaches. I would like to stress that not implementing polymorphism can lead to much worse nightmares and headaches in terms of code maintenance and extensibility.

The above problem, as stated by the author, can essentially be solved with the VB.Net keyword: MyClass.