Volume Number: 22 (2006)
Issue Number: 7
Column Tag: White Paper

Lasso & PHP

A Closer Look at Two OS X Scripting Languages

by Chris Tracewell

When the World Wide Web first opened its doors to the public in 1994, most web pages were static text files. A new breed of programmers, called web masters, toiled away at their text editors, hour after hour, churning out HTML documents one at a time. Since then, a lot has changed. The vast majority of websites utilize server-side scripting languages to dynamically generate pages on the fly. The result is that web masters can now build a framework for their site out of just a few scripted files. The most common task for these scripted files is to "pull" information from a data source such as a database, to populate themselves with relevant data. Thus, a single scripted file, such as a product page, can be used to serve a unique page for each record in a product's database.

Over the last decade, there has been a proliferation of server-side scripting languages, and the debate over which is the best can be found in blogs and forums throughout the web. This article is a look at two such scripting languages, PHP and Lasso. Both of these languages have unique histories that can be traced back to a single programmer that just wanted to create a better way of doing things. While the similarities are many between the two, so are the differences.

Both of these languages have unique histories that can be traced back to a single programmer that just wanted to create a better way of doing things.

PHP, which originally stood for Personal Home Page Tools, and now stands for Hypertext Preprocessor, is the most popular server-side scripting language in the world, largely due to the fact that it is free. Originally written as a small set of Perl scripts, PHP evolved through several iterations, and is now a very fast and feature-rich language written in C. PHP is an open source project, and is highly visible throughout the web. PHP currently stands at version 5.0 and gained a whole host of upgrades when it stepped from 4 to 5. One of the major changes was a new Object Model that brings object-oriented programming, as well as, better speed and functionality. Also included are a good smattering of new functions, including a set of new array commands and XML improvements. Besides plenty of nifty functions for working with your HTML files, you also have the ability to create PDF files, manipulate images, send emails, and work with XML, among other things.

Lasso is a server-side scripting language that was originally developed in 1995 as a means to connect Filemaker databases to web servers. While its roots began in the Mac and Filemaker, Lasso has evolved into a multi-platform object-oriented scripting language that fully supports inheritance, sub-classing, and tag-overloading. Lasso has been object-oriented since version 5.0, and thus has had several revisions to refine its OOP model, allowing coders to painlessly write custom types, tags and data sources in plain old Lassoscript. While Lasso has been around for nearly the same amount of time as PHP, it is a lesser known technology; however, it does have a very strong and active community of developers that continues to grow. Lasso is used in nearly every sector of the Internet from e-commerce to banking applications to blogs, education and corporate sites.

OmniPilot announced Lasso 8.5 in February, and many new features were detailed. Among the more interesting new features announced, were a set of AJAX tags and advanced charting capabilities. The Lasso AJAX tags, called LJAX, make basic AJAX functions possible by just setting a few tags and parameters. To do advanced charting functions you'll be able to buy Chart FX, an advanced enterprise-level graphing solution. Like PHP, Lasso can also create and manipulate images and PDF. In addition, Lasso has a full array of email tags for not only composing and sending emails, but also opening connections to mail servers to receive email messages - thus giving you the ability to program your own mail clients in Lasso.

If you're a PHP or Lasso junkie, or for that matter someone who is just getting into server-scripting languages, you'd probably want to know how these two languages differ. I will tell you that I'm not here to drill down to every last technical detail, and declare one the supreme champion over the other. Rather, I hope to highlight the unique characteristics and capabilities of each language, as I see them, and then let you decide how they might fit your needs. I'll also confess that I'm not the ultimate guru in either language, and I still spend a good amount of time chunking through language guides and looking for web tutorials in order to solve tough problems.

Now that I have hopefully squelched the possibility of starting any technical flame wars, let me tell you that I have scripted several websites in both languages over the last 5 years, and currently maintain several websites in both languages. I have built full blown e-commerce, order tracking, inventory management solutions in both, used both to connect with third party data services like UPS and credit card gateways, and used both to generate and read XML data, as well as reading and writing files to and from the system. Now that you know where I am coming from, let's jump in and give these two products a good looking over.

It would be nice if we were able to simply compare Lasso and PHP based on speed, price, and a few functions. However, out-of-the-box, we are talking apples and oranges. Beyond comparative functions, Lasso's standard feature set differs quite a bit from PHP's. So, to get off on the right foot, let's look at the major "out-of-the-box" differences between PHP and Lasso.

Lasso is commercial and costs money for a deployment license (developer software is free), whereas PHP is free. The problem is you get vastly differing features and abilities at those two price points, and thus you really can't make price point comparisons on a feature for feature basis. Lasso, for example, comes with the ability to compile standalone LassoApps that allow you to obscure your source code, and distribute your solution in a nicely contained package all the while speeding up your solutions overall performance. To do this with PHP you'll need Zend's Zend Guard product, which costs $995 for an annual subscription [Ed. Note: there are a few completely open source optimizers that will also protect your PHP code, such as the Turck MMCache]. As we'll see later, Lasso also includes a full-blown administrative interface as part of its standard install. For PHP, you'll again need to look at something like Zend's Zend Platform to achieve similar functionality. Further, by default Lasso parses LassoScript down to byte code and caches compiled pages for excellent speed improvements. With PHP, you'll need to locate and install a third party solution, of which there are both free and commercial solutions, to realize these speed gains. If you own multiple Lasso licenses, you can scale your solution through server clustering and shared session management. PHP can do the same with Zend's Zend Platform product.

Hopefully, you can see that both technologies have some default differences that need consideration when comparing the two. For the purpose of this article, we will only be comparing standard features, sans third-party add-on solutions that might give one or the other similar abilities. For the sake of this article, we'll assume that you can scale either with such options at relative prices. The goal is to see the core functionality of both as they are packaged and priced.

Right out of the gate PHP has one clear advantage - it's free. Lasso, on the other hand, is a commercial product - it costs money... sometimes. What do I mean? Until recently developers had to purchase their own license to develop in Lasso, and then either find a Lasso ISP or host their own solution, which, if you were running your server on a box other than the one you were developing on, meant you needed another license. With the latest release of Lasso 8.5 (due out this summer), that all changes. OmniPilot Software, the makers of Lasso, now offer Lasso Developer, free to anyone who wants it. This is not a crippled version of Lasso that can't do all of the tricks of Lasso Professional Server, it is the exact same thing. In fact, when you install and run Lasso Professional Server 8.5 without a serial number, it simply defaults to Lasso Developer mode. The difference is that Lasso Developer limits the number of client connections to 5 IP addresses at any one time, and also limits the number of page requests to 1000 per minute. That's more than enough for a development team to do their work, let alone a single programmer.

So you have your masterpiece coded. It's ready for prime time, you're ready to "go-live" - what's it gonna cost you? If you're hosting your own solution, you're going to have to put down some dollars and buy a license for Lasso Professional Server, and that will cost you $649 ($399 typical upgrade). PHP, on the other hand, is free. A big difference, but if you're paying for the hardware and rack space or data line for your own server anyway, $649 is not likely the deciding factor.

If your deployment plan, like many, is to host with an ISP, the monetary gap narrows considerably. PHP hosting packages are numerous and simple plans can get really cheap, downwards of $3, but I have found that spending between $6 and $10 is the more common scenario. While Lasso hosting is not as widespread, there are still a lot of options. You'll spend around $10 to $25 for basic plans with a couple of emails, a single MySQL database, and domain name.

True, this is a Mac magazine, but in today's IT world, it goes without saying that any technology that is landlocked to a single platform, with the exception maybe of Microsoft products, is likely to become not only irrelevant but obsolete as well. So, if you develop a solution and a year later want to move it to a different OS or IT wants to transition to a new data source, your life will be a lot easier, if the scripting language you use can accommodate your needs.

Luckily, both Lasso and PHP play nicely with others. Lasso can be installed on OS X, Red Hat Linux, and Windows. PHP comes pre-installed on OS X, and can also be installed on various flavors of Unix and Windows.

Lasso started out its commercial life as a plug-in to the once dominant Mac web server, WebStar. Since then, Lasso has gained the ability to integrate with Apache and Microsoft IIS, and also has a J2EE Java servlet connector that provides extended web server integration options. PHP also works with Apache, IIS and WebStar, and additionally supports a host of less prominent web servers like Sun, iPlanet and Netscape. Because the majority of pages on the Internet are served via Apache, and OS X comes with Apache installed (and IIS isn't an option on OS X), this article will assume an Apache configuration when referring to web servers.

Database connectivity for both Lasso and PHP are plentiful. Both speak to a broad range of SQL databases, including MySQL, Microsoft SQL Server, PostgreSQL, Oracle and SQLite. Both also support connecting to data sources through open standards such as XML, SOAP, ODBC, and JDBC, although PHP's Java integration seems to be a bit "experimental" at this point. Take a peek at php.net/manual/en/ref.java.php to see what I am talking about. The comments on that page seem to suggest that JDBC support isn't currently for the faint of heart.

Lasso also has the unique ability to connect seamlessly to FileMaker Pro databases right out of the box. While most would argue that launching a large e-commerce site using Filemaker as the backend data source is probably not the best idea, there is a whole gamut of usefulness here. First, many companies and developers have a legacy with Filemaker, and the need to access Filemaker databases on an intranet or on the web for various reasons does exist. Being able to keep your network clients' Filemaker, while also implementing access via a web browser is something many users need. Lasso excels beautifully here and makes connecting to Filemaker databases as easy as it's gonna get. I can already hear the PHP guys chattering "Hey, we can do that too." It is true that a PHP project called FX.php allows PHP to connect to Filemaker, but it isn't a part of the default install, and after Googling around, doesn't seem to have a ton of momentum behind it. If you need serious Filemaker support, you're gonna have a hard time not going with Lasso.

If you're a command line freak that knows every Emacs command without looking at a single man (manual) page, then you can skip this section because you'll be comfortable installing and administrating either PHP or Lasso. If, however, you're closer to a mere mortal like myself, who still stumbles through the docs when working in terminal, this section is vital.

It is likely no surprise that PHP and Lasso install and work "behind-the-scenes" in the various OSes and web server integration environments they operate in. What this means to you is that installing and controlling their settings and behavior is a little more in-depth than simply pulling up a preference pane and clicking a few check boxes.

Lasso has always enjoyed the comfort of having a Mac-friendly installer package. PHP on the other hand used to be somewhat of an adventure, often a treacherous one at that. Those days are mostly over now, for a couple of reasons. First, as of version 4.3, PHP is native to OS X, whereas before, it required a lot of shuffling and command line juggling to get things set up correctly. Second, PHP actually comes preinstalled on OS X. Finally, and most importantly, you can download simple installer packages from sites such as http://www.entropy.ch/software/macosx/php/ and http://www.serverlogistics.com/php4.php that take the pain out of installing versions of PHP that Apple hasn't released themselves.

When installing either language, you will need to pay attention to the install notes and instructions. It is vitally important that the installers have the ability to place various files and directories in specific places, and that Apache be where the installer thinks it should be, in order for things to go smoothly. This shouldn't be much of a problem for most fresh installs.

Okay, so you have Lasso or PHP installed, now what? Well, the first order of business would be to make any special tweaks, maybe install a custom PHP extension or Lasso module to add extended functionality. While both PHP and Lasso allow programmers to write their own functions (called custom tags in Lasso) directly in the script files themselves, you'll eventually need/want to write and/or install pre-compiled functionality that is available throughout your site, not just functions defined in scripts and associated include files. PHP and Lasso offer this functionality through different methods. PHP incorporates PHP extensions, written and compiled in C, that give programmers a robust set of extended functionality and customization options. Lasso lets you utilize C/C++, Java and LassoScript to create new tags, data sources and types.

Installing PHP extensions will require you to download or write the extension, compile it if it isn't already, and then modify one of your configuration files for PHP or Apache: php.ini, httpd.conf or .htaccess. It may often be required to also re-compile PHP itself to gain the functionality of a particular extension. Lasso will require you to write or download the tag, type or module, compile it if necessary (actually most downloaded Lasso solutions are pre-compiled) and then drag and drop it into the associated folder inside your server's Lasso Professional Server folder. PHP deprecated the ability to load PHP extensions on demand via the dl() function in version 5. As a result, you must now specify which dynamically loadable extensions you want loaded at startup in the php.ini file. Lasso offers on-demand loading when you drag LassoApps and custom tag libraries into certain folders inside the Lasso Professional Server folder, such items load on-demand when called from a script. Further, any Lasso custom tags (equivalent to PHP functions) and LassoApps that are placed in your server's LassoStartup folder will be automatically compiled and cached when the server starts up and available site wide, very nice.

When it comes to administering your server, Lasso really shines. As mentioned above, Lasso administrators can access the Lasso Administration pages (figure 1) on their web server and configure everything from database connections to security to file permissions, as well as monitor Lasso performance and even setup tasks on schedules. An administrator can even dictate which tags a user or group can or can't use. All of this is done through a nicely laid out web interface, and is included with the standard install. PHP's administration is confined solely to config files and server settings. That is by no means to say that administering PHP is limited or restricted, only that it does take a deeper technical understanding of your config file locations, layouts and parameters. It isn't for the easily intimidated.

Another area of interest is site administration. Both Lasso and PHP allow server administrators to assign certain control to site owners, so they can make configurations for their particular site on shared hosting solutions. PHP achieves this functionality primarily through the htaccess file, where web masters can mark up their Apache commands to control how PHP processes files. Lasso, on the other hand, allows server admins to grant administrative privileges to individual web masters to control their site(s) through the Lasso Admin interface. This is nice not only because users can make their own security settings, file permissions etc without bugging their ISP, but they can also check server logs for specific Lasso errors and setup their own events and LassoApps.

Through its "Lasso Admin" pages, Lasso offers an extra security layer to web applications. Administrators can set up groups and users, and also define which data sources those users and groups can access, and what they can do to them, such as updates, selects, and deletes. A common strategy here is to code your front end Lasso pages with queries using a user in your group that can only perform select statements; and at the same time it is using a separate group of users for your backend and intranet pages where trusted visitors access your site. This way, even if a username and password were compromised on a corporate web server, for example, the extent of any malicious activity would be greatly reduced.

Of course, it can be said that setting up your MySQL security properly can reach some of the same goals in PHP, but that is not completely the same, and here's why. If you setup a user in Lasso Admin, you not only designate what actions the user can take and what data sources they can connect to, including database names, tables, and even fields, you also specify the username and password for the databases, such as MySQL. This means the username and password for your database, as well as the database name itself, is never in a file on your server where web or FTP permissions may be compromised. Unlike the standard method in PHP of utilizing an include file for your database connection settings, the Lasso Admin pages store these permissions in its own secure internal database and controls database, and file executions on a per request basis.

One final thought in the area of security is that Lasso enjoys a somewhat "out-of-view" advantage in that not many hackers are really aware of the language. This is similar in many respects to how Mac users have enjoyed fairly virus free computing because of the fact that Microsoft is just so much bigger and thus an easier target. With obscurity comes a bit of safety. If you Google "PHP Hacking", you'll get around 25 million fairly relevant results whereas a "Lasso Hacking" search will return around 125 thousand mostly irrelevant results.

Both PHP and Lasso have language structures that are similar enough that someone who is comfortable with one would be able to learn the other in a short amount of time. For me, it took a day or two to feel comfortable with PHP after three years of using Lasso. That's not to say there weren't a lot of trips to php.net to find the right functions, but learning how to declare variables, perform loops and conditional statements was not a huge leap. Both languages open their script blocks with similar syntax. PHP can be opened with either <?php or <? while, Lasso uses <?lassoscript to identify its opening block. Both close with ?>. Lasso also offers the option of using the [ and ] brackets to execute its code in smaller bits, which can come in handy in some situations, but for this article we'll be using the Lassoscript syntax. Let's look at some simple code to see how the two compare. First let's look at a bit of Lasso code in LassoScript format.

<?lassoscript
// declare a variable
var:'the_variable' = 'some text';
// concatenate more text 
$the_variable += ' more text';
// conditional
if: ($the_variable == '');
   'Empty';
else;
   'Not Empty';
/if;
?>

The above code declares a variable, assigns a string value, concatenates more text onto the variable, and finally it does a test to see if the variable is empty and outputs a response to the HTML page. Now, let's look at how we would do this in PHP.

<?php
// declare a variable
$the_variable = 'some text';
// concatenate more text 
$the_variable .= 'more text';
// conditional
if ($the_variable == '')
   {
   echo 'Empty';
   }
else
   {
   echo 'Not Empty';
   }
?>

As you can see, the two languages have similar structures. The manner in which the two languages handle variables is probably the biggest difference. In Lasso, a variable must first be initialized with either var: or variable: and can from then on be called using $. PHP, in contrast, simply allows you to set your variables with just $. While the PHP method is quicker, it is not good practice and can encourage new programmers to pick up bad habits. For instance, Lasso will throw an error if a variable is called that has not been initialized, making it easier to debug and secure your code. On the other hand, by default, PHP will just act as if the variable is empty, thus making it difficult to debug why or where a solution is failing. In addition, if register_globals is not disabled in the PHP configuration file, and variables passed using POST or GET methods, it can set variables that have not been initialized, thus leaving a solution open to security risks. Lasso will only read POST and GET data through its Action_Param substitution tag, thus ensuring that such values are explicitly called for in the script.

Let's take a look at another common area of code in scripting languages, database queries. Lasso and PHP access databases differently. Lasso uses a database abstraction layer, while PHP utilizes database specific functions to directly access databases. Database abstraction layers provide the ability to code your scripted web pages while minimizing the dependence on one particular database vendor. Let's say, for example, your solution uses MySQL as your database today, but in a year your company decides to switch to Oracle. Perhaps you're developing a solution for a client who uses PostgreSQL, but your development box is MySQL. Without a database abstraction layer, you will have a little more work on your hands, as you'll need to re-engineer any database-specific functions.

Database abstraction has been at the heart of Lasso, since they began supporting multiple databases, beginning with version 5. PHP, currently has no abstraction layer built in. You can install and setup various third party database abstraction layers using PHP, but again, they are not a part of the standard install, and depending on which solution you implement, you may incur additional overhead as a result of additional script inclusion and processing. Lasso's implementation is native out of the box: It is a part of the compiled language, and thus has the advantage of consistency and low overhead, if any. Another great advantage is that you can use Lassoscript to code your own data source connection to, say a CSV text file, that you can then use an Inline to access - slick. One final Mac specific feature Lasso offers in 8.5 is the ability to use OS X's Spotlight feature as a data source. You can use an Inline to search your iTunes folder, for example, and return the artists, album names and durations of songs - all as a normal record set, how cool is that?

As mentioned above, Lasso's default database connection method is via a database abstraction layer, and the following is a typical example of that method.

<?lassoscript
// declare and set your SQL statement variable
var:'the_sql' = '
            SELECT
               first_name,
               last_name
            FROM
               customers
            WHERE last_name = "Smith"';
// run the query 
Inline: 
      -database='the_database',
      -username='any_user',
      -password='the_password',
      -sql=$the_sql;
      
      // loop through the found set   
      records;
         (field:'first_name')+' '+(field:'last_name')+'<br>';
      /records;
/Inline;
?>

In the above code, we are setting a single variable to hold our SQL statement, and then using Lasso's Inline function to connect to the database and retrieve the record set. The Inline function accepts parameters for the database name, which is not necessarily the actual name of the MySQL database, but the alias assigned to it through Lasso Admin. Likewise, the username and password parameters are not the username and password set in MySQL permissions, but are those of the user/group setup in Lasso Admin who have (or should have) access to the requested database. The -SQL parameter is obviously the SQL statement to be executed. Inside the records tags, each row of the found set is looped through, and the field tag is used to retrieve a particular field value for the current row. There are more than a few additional parameters you can include in your inline statements, and you can also name your inlines, so you can use the record set elsewhere in your script without needing to re-write your inline.

Now let's look at a typical PHP MySQL query. The overall logic is similar, but it requires a little more setup, and does require that you put your MySQL database name, username and password directly in your script. Permissions are handled via MySQL and as mentioned, it is often the best technique to utilize an include file with relevant file permissions for the purpose of code reuse and security.

<?php
// set connection parameters - usually this is an include file
$connect = mysql_connect ('localhost','un','pw') or
   die('cannot connect to database');
$db = 'the_database';
$db_select= mysql_select_db ($db, $connection) or 
   die ('Unable to select the database');
// declare and set your SQL statement variable
$the_sql = '
            SELECT
               first_name,
               last_name
            FROM
               customers
            WHERE last_name = "Smith"';
// run the query
$result = mysql_query($the_sql,$connect) or die ('Error');
// loop through the found set
while ($row = mysql_fetch_array ($result))
   {   
   echo $row['first_name'].' '.$row['last_name'];
   }
?>

You can see that the PHP method is similar to Lasso for querying a MySQL database. I have found that both PHP and Lasso MySQL queries require about the same amount of coding to perform, and that the advantage of Lasso's native abstraction layer is a nice insurance policy for the possibility of changing data sources down the road. In all reality, should one make such a transition in either language, you will still need to rewrite your SQL statements throughout your solution, and if you use an include file for your connection parameters in PHP, which you should, then the only other real bother is replacing the MySQL specific functions for mysql_query and mysql_fetch_array - something that is not too huge a task for most solutions, especially using find and replace.

Another area where the two languages differ is in the consistency of their function/tag names. Lasso has the upper hand in consistency in that all of their functions, called tags in Lasso, adhere to a strict structure that is conducive to learning, recognizing and remembering. Lasso substitution tags, for example, always take the form of Category_OperationBeingDone. PHP's naming conventions are now standardized, but once weren't and thus, for reasons of backward compatibility, many function names are inconsistent in that they may or may not use underscores, and may have the operation listed before the category or the other way around.

In the end, both languages utilize fairly similar structures. Lasso's is stricter, which forces you to write cleaner code by initializing your variables. PHP's more liberal parsing can make it easier for first timers to get going, but in the end is prone to encourage bad coding habits, if you aren't mindful.

An important aspect of any programming language are the tools available to author it in. Both PHP and Lasso can do well in the top environments including Dreamweaver, BBEdit, and Eclipse. Out of the box, Dreamweaver offers excellent PHP code coloring and function name recognition to make writing your code easier. A quick search on the Lasso list will score you links to downloadable Dreamweaver code coloring files that can do the same.

For those who are just venturing into Lasso programming, it is worth noting OmniPilot's Lasso Studio for Dreamweaver and Lasso Studio for GoLive products. These products integrate with Macromedia Dreamweaver and Adobe GoLive respectively. While they are by no means as deep as high octane hand coded solutions with all sorts of tricky custom tags, these products do make it a heck of a lot easier to get started for those just starting out. Eventually, you'll likely progress toward hand coded solutions, but these products do let you be productive in a short amount of time, and thus have their value.

If you prefer to work in an IDE, like the popular open source Eclipse solution, you again have options in both camps. You can obtain a free Eclipse plug-in for PHP called PHPEclipse. OmniPilot offers a product called Lasso Studio for Eclipse that allows you to code, debug, and preview your code via the Eclipse IDE for $199.

One of the most enticing aspects of using PHP is its widespread adoption in the online community. The result is that you can Google just about anything you want to, figure out how to do it in PHP, and find an answer fairly quickly. There are a lot of sites with sample code and tutorials, as well as free libraries of functions and forums to post to. In the same breath, Lasso, while smaller, also offers a very active developer community, as well as a good smattering of sites with free tutorial and code resources. The Lasso list is very active and new comers are warmly welcomed and helped along. LassoChat is also fairly active. You can IM LassoChat from iChat to meet some Lassoers. Books and magazines are everywhere for PHP, but I have found the best resources on the web. I will also say that I have never found a problem in either language that I couldn't get a pretty fast answer to by searching forums or visiting a discussion board.

I have always appreciated the documentation provided by OmniPilot with their Lasso products. It is really nice to have full manuals for all aspects of the language that are straight from the horse's mouth, so to speak. Lasso comes with a Setup Guide, Language Guide, and Extending Lasso Guide. PHP's official site, <php.net>, does offer setup instructions, but they are a little sparse and heavy on the technical aspects. You'll likely find yourself searching various websites and forum posts if you need extra help. Both PHP and Lasso have searchable online tag/function databases; however, Lasso's Language Guide, available in PDF and paperback, is really nice. The Language Guide goes through each and every Lasso Tag with clear instructions and code samples that really help you pickup the language with minimal effort. In addition, the guide is laid out in a manner that it allows you to find answers to common tasks such as "Searching and Updating Records" and "Conditional Logic." These sections walk you through not only the tags, but the logic and reason. If you're just getting started with programming, Lasso's Language Guide is an excellent resource that systematically trains you in all aspects of the language.

It was tempting, when I started in on this article, to try and compare PHP and Lasso feature for feature. I quickly realized that the massive amounts of technicalities, specifications, and alternative methodologies, hardware and software setups would make true speed and function comparisons near impossible. Instead, as I mentioned at the beginning, I decided to highlight my experiences with both languages, and hopefully give you a sense about my impressions.

In the end, I like PHP and I like Lasso. I like PHP because I can author a website and host it anywhere and Google answers to questions in the blink of an eye. I like Lasso because it is a tightly integrated, well thought-out product - something you'll come to appreciate once you use it. If you are just getting started with scripting languages, I'd highly recommend either of these technologies, but would give Lasso the edge in ease and cohesiveness. When it comes to price, you can't argue with PHP's - free. However, with OmniPilot now offering Lasso Developer for free, and shared hosting plans priced competitively in both languages, the entry to both languages can be considered, for all intents and purposes, equal.

Chris Tracewell is an entrepreneur and consultant living in Redmond, Oregon. He first programmed in BASIC on Apple IIe's and IIc's in 7th grade and bought his first Mac, a 128k, in 1984. Since then he has become proficient in JavaScript, AppleScript, RealBASIC, Lasso and PHP. After graduating with a degree in Marketing & Management from the University of Oregon, Chris worked for IBM, was a partner in an ISP, and started a successful media development company. Currently his focus is on growing his e-commerce business, TeamMASCOT.com and spending more time with his wife, Jennifer, and their four children.