Lasso, there's another one, and her name is Python

In any long-term relationship, whether it is with people or technology and the tools of the trade, it is practical to periodically evaluate the situation. For the last several years I have been looking at how I got here, where I am now, and where I see myself going with my business.

Writing helps me gain clarity with murky and complicated situations. With the (long overdue) relaunch of my website, I felt that I needed to put my thoughts in writing regarding my past relationship with Lasso and my present inclination toward Python, a language that I think is better in most ways.

Lasso is great for "non-programming designers and DIY'ers"

Lasso originated in 1993 as a way to serve FileMaker Pro databases over the web. It has since evolved into an application server and a general-purpose, high-level programming language. It has some "batteries included"—database and web server connectors, PDF and image processing, file I/O, networking—all in a downloadable point-and-click installer or via apt or yum. Lasso runs on major operating systems, including Mac OS X, Windows, and a limited set of Linux distributions, Ubuntu and Red Hat/CentOS. It is relatively easy for developers to get started with writing simple applications in Lasso compared to many other languages.

FileMaker Pro is a desktop database application that provides non-technical people with an easy way to interact with data through a friendly graphical user interface. Users of FileMaker Pro became the first adopters of Lasso.

I've been using Lasso since version 3.6 in 2000, and it was my first web application-oriented language. My first database-driven web application allowed people to register for an entry level soccer referee clinic, served from my Macintosh Performa 6116CD over a painfully slow DSL connection at home. I started a small user group, LassoSFO, that included a handful of Lasso developers, but never more than a half-dozen at any given meeting. We were small, close, and content. Over the years members of the Lasso community have helped me gain clients in my business to the point where I could transition from a part-time freelancer to a full-time self-employed web application developer.

But as we entered a new millennium, grumblings became louder amidst the community of Lasso developers. We began to broaden our views of web programming languages—including Ruby, PHP, and Python—and noticed significant problems with Lasso as a product and how that impacted the Lasso community itself.

Hit by a bus and bottlenecks

The Lasso language is developed by a single person. If that person leaves, then there is no one who can continue its development. This is a significant risk to those who depend on stability and bug fixes to the product.

Hypothetical situation aside, one person can only do so much at a time. This places an unnecessary constraint on the rate of development of the Lasso language. It takes too long for bugs to get fixed, new features to get implemented, and documentation to emit from the sole developer.

Python has a very large group of core developers.

Commercial versus open source

Lasso is a commercial product owned by a private company. Development of Lasso is founded on making financial profit. I don't fault the developers of Lasso for making a living, yet this foundation prevents a free and open exchange of ideas. The future of the Lasso product is not openly discussed and debated in the context of available resources to implement changes for the good of its existing users, but for increasing the company's own profit.

In contrast the course of Python is directed by the Python Software Foundation and its Benevolent Dictator for Life, Guido Van Rossum. Python's development follows a rigorous and open process called the Python Enhancement Proposal. It is a process driven by the community and steered by committee, with veto power granted to the BDFL.

With an open source structure, Python attracts kindred souls, folks who tend to pay good will forward.

Burning bridges

Lasso floundered from mismanagement and unmet promises of delivering products. The original owner of Lasso masqueraded as the Blueworld evangelist Cathy Cunningham on Lasso Talk, introducing a bad kind of weird and mistrust. Some members of the Lasso Talk email list were banned from the list for criticizing the Lasso product. In response, a significant number of developers became alienated by the owners of Lasso, forming a secret email discussion group where core members of the Lasso community could openly and freely discuss the Lasso product without fear of reprisals.

However no written discussion remains secret or private, and word eventually reached management of the Lasso product. In some extreme cases, a few owners and managers of Lasso publicly insulted, derided, and mocked persons who dared to criticize their precious baby, the Lasso product.

These issues could have been easily dismissed as "isolated incidents" or someone "having a bad day". But the criticisms were entirely valid and born from bugs, instability, and other shortcomings of the Lasso product.

Fool me once

Then in 2007, whispers about a new Lasso 9 release began to circulate. Speed, stability, security, and simplicity were touted as characteristics of Lasso 9. In 2008, pre-sales of Lasso 9 were being taken. Lasso 8 code would "just run" in Lasso 9 and many other promises of an imminent release strung along the hopes of many developers.

A private, then a public, beta were released in 2009. However, without any new sales of Lasso licenses, development of the Lasso line stalled. In early 2010, Lasso 9.0 was released, but with very little documentation. LassoSoft moved documentation to Zoho, but the effort depended on the goodwill of the community to freely donate time and effort. Worse, many developers were disappointed to learn that "backwards compatibility with Lasso 8 code" had a very different interpretation by the owners of Lasso. This angered many developers. Others were deterred from migrating their solutions from 8 to 9 because of the immense effort required and almost no guidance or documentation of how to do so.

This upgrade from Lasso 8 to 9 should take only 30 minutes, I reckon.

"This upgrade from Lasso 8 to 9 should take only 30 minutes, I reckon."

That summer an effort by a small group of developers entered discussion with the owners of Lasso to form a foundation to raise funds for completing the Lasso 9 product and bringing it to market. Toward the end of the year, it was announced that Treefrog Interactive, Inc., acquired LassoSoft, LLC, and the Lasso product line.

Unfortunately this life line was too little, too late. Many Lasso developers had moved on to other languages that could better provide what they needed, like a fully documented, tested, fast, and stable product. I was a big fish in a small pond heading toward a severe drought.

Import antigravity

By this time, I had already made a decision to explore Python, and made a commitment to learn about it. I attended my first PyCon in 2011 and have attended each year since. At PyCon 2011, I took a tutorial from Brandon Rhodes on using Sphinx, a learned skill that paid for my next 3 PyCons. I fell into a fantastic community of developers who have tremendous knowledge and experience, and are generous with sharing it. I attend many SFPython, PyLadiesSF, and BayPIGgies meetups and hack nights. I meet engineers from Yelp, Twitter, Mozilla, Disqus, Twilio, LinkedIn, Heroku, and many others who are building really cool things. Once I typed import antigravity, I have never looked at Lasso with the same optimism and joy.

Import antigravity

Along my journey through Python, I gravitated toward a heavy metal group with awesome T-shirts, the Pyramid web framework. There's something about taking what you know and learn along the way, then giving it all back to the community, that gives me a sense of purpose and belonging. What I lost in Lasso, I found again in Pyramid and the broader Python community.

More than a feeling

There's more than emotional, cultural, and social motivations that have attracted me to Python. More important to me are technical, statistical, and analytical reasons, as I will now elaborate.

Documentation

Python is documented extremely well. Pyramid goes farther in its own philosophy, "If it's not tested and documented, it's broken." When the Python Software Foundation released Python 3, it provided documentation and tools that would help developers migrate their systems from Python 2. There are thousands of books, videos, presentations, articles, curricula, and podcasts.

Lasso 9 had virtually no documentation except in docstrings and whatever could be culled while subscribed to the now extinct (and never archived) Lasso 9 Beta List. The community Zoho debacle had no dedicated resources. In 2011 after the community made it abundantly clear, LassoSoft hired a few experienced members from the community (I was one of them) to write documentation items for the Language Reference, which is the equivalent of an API reference. The process was slow, inefficient, and underfunded. The quality of some contributions was poor, often incomplete or with untested and unverified code samples, and spelling and grammar mistakes. The process required posting content through a web interface that often reformatted and double-encoded entries.

Although the contributions to the Language Reference mitigated the lack of documentation, much more work needed to be performed. At the 2012 Lasso Developer Conference, the community once again made it abundantly clear that it needed narrative documentation. Thanks to Brandon Rhodes' Sphinx tutorial and my contributions to the Pylons Project documentation, LassoSoft hired me to bring my experience into the project. I helped migrate content from the community Zoho wiki and other sources into reStructuredText using pandoc. From there we could automate output of documentation to almost any format—including HTML, PDF, and epub—using Sphinx. The initial release was in March 2013, with a nice PDF and printed version later in the fall.

To this date, there is insufficient documentation for Lasso 8 developers to migrate their solutions to Lasso 9.

Books, videos, podcasts, blogs, and other publications

A quick search on Amazon for "Python programming" returns 1,862 results. But for Lasso, only 18 results are returned, only one of which is an actual book on programming Lasso, and that is for the antique version Lasso Professional 5.

Official videos are available from LassoSoft and LassoSoft LassoTube, with one almost impossible to understand yahoo ripping off the LassoTube brand.

Python hosts official PyCon and related videos. Most of these videos are presentations and tutorial sessions.

I created a few video screencasts and tutorials for the Pyramid web framework and using Lasso in Lasso Lab.

Blogs for Lasso that are still updated are hard to find. Most get updated every once in a while. The most prolific blogger is Tami Williams. Other notable blogs are published by Chris Wik who is also my awesome Lasso ISP, Jono Guthrie of LassoSoft, Inc., and Jason Huck.

Bug tracker

A bug tracker is an essential piece of communicating with a user base. When things go wrong, users need to be able to report problems in a system that facilitates communication and the issue's progress and eventual resolution.

At the 2013 Lasso Developer Conference, a public bug tracker RhinoTrac (named after cat herpes) was finally announced. At long last, developers could file a bug report without sending an email, and know that the issue had been registered in a system. Additionally, other developers would now be able to search one place to see whether a bug had already been filed and avoid a lot of frustration. RhinoTrac uses Trac, which is written in Python as the underlying system.

Python has a public bug tracker, and it's been around for a very long time. Its detail of bugs is comprehensive, including status and assignment.

Testing

Python has hundreds of testing packages, and a few of the most popular are nose, unittest, and pytest. There are also tools to control a web browser and mobile devices through Python using webdriver.

Lasso has L-Unit.

Debugging

Just a few of the Python tools available for debugging include pdb and its derivatives, as well as debuggers in PyCharm, PyDev, and other IDEs.

Lasso has L-Debug and the debugger in LassoLab.

Speed

LassoSoft makes misleading claims about its performance compared to Python. Unfortunately LassoSoft does not publish its code samples for others to try and reproduce their results. Not being one to take pretty graphs for granted, here are some reproducible tests using the latest versions available at this time, Lasso 9.2.7 and Python 3.4.1.

All code samples were executed from the command line. They were not compiled nor were they run through a web stack. As time allows, I may update my test results to reflect those environments. I intend to run the Python tests in PyPy through the web application framework Pyramid and its web stack, and use Lasso's web stack, too. Both of these environments will compile the code and both should have significant speed improvements.

Code samples are derived from Rosetta Code, LassoTalk, LassoChat, and other sources.

I welcome any reproducible comparisons in PHP and Ruby, too.

First 40 Fibonacci Numbers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import time

start_time = time.time()

def fibIter(n):
    if n < 2:
        return n
    fibPrev = 1
    fib = 1
    for num in range(2, n):
        fibPrev, fib = fib, fib + fibPrev
    return fib

for n in range(40):
    print(fibIter(n))

end_time = time.time()
print("Elapsed time was %g milliseconds" % ((end_time - start_time)*1000))

Elapsed time was 0.339031 milliseconds

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
[
local(start) = date_msec

define_tag("fibonacci", -required="n", -type="integer");
    if(#n < 1);
        return false;
    /if;
    local("swap") = 0;
    local("n1") = 0;
    local("n2") = 1;
    loop(#n);
        #swap = #n1 + #n2;
        #n2 = #n1;
        #n1 = #swap;
    /loop;
    return(#n1);
/define_tag;

loop(-from=0, -to=39);
    fibonacci(loop_count);
    '\n';
/loop;

'Elapsed time was ' + (date_msec - #start) + ' milliseconds';
]

Elapsed time was 64 milliseconds

Python is 188 times faster than Lasso.

Updated July 24, 2014

Jolle Carlestam and Ke Carlton provided some improvements to the code example above, and I've adopted their optimizations. Although there is an improvement, it still falls short in comparison to Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
[
local(start) = micros
define fibonacci(n::integer) => {
    #n < 2 ? return #n
    local(swap) = 1
    local(fibPrev) = 1
    local(fib) = 1
    with item in 2 to #n do {
        #swap = #fibPrev + #fib
        #fib = #fibPrev
        #fibPrev = #swap
    }
    return #fib
}

with item in 0 to 39 do => {^
    fibonacci(#item)
    '\n'
^}
'Elapsed time was ' + ((micros - #start) / 1000.0)->asstring(-precision=3) + ' milliseconds'
]

Elapsed time was 26.521 milliseconds

Python is 78 times faster than Lasso.

Count occurrences of a substring

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import time

start_time = time.time()

def count_sub(str, sub):
    return str.count(sub)

print(count_sub('the three truths','th'))
print(count_sub('ababababab','abab'))

end_time = time.time()
print("Elapsed time was %g milliseconds" % ((end_time - start_time)*1000))

Elapsed time was 0.056982 milliseconds

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
[
local(start) = date_msec

define countSubstring(str::string, substr::string)::integer => {
    local(i = 1, foundpos = -1, found = 0)
    while(#i < #str->size && #foundpos != 0) => {
        protect => {
            handle_error => { #foundpos = 0 }
            #foundpos = #str->find(#substr, -offset=#i)
        }
        if(#foundpos > 0) => {
            #found += 1
            #i = #foundpos + #substr->size
        else
            #i++
        }
    }
    return #found
}
define countSubstring_bothways(str::string, substr::string)::integer => {
    local(found = countSubstring(#str,#substr))
    #str->reverse
    local(found2 = countSubstring(#str,#substr))
    #found > #found2 ? return #found | return #found2
}
countSubstring_bothways('the three truths','th')
'\n'
countSubstring_bothways('ababababab','abab')
'\n'

'Elapsed time was ' + (date_msec - #start) + ' milliseconds';
]

Elapsed time was 30 milliseconds

Python is 526 times faster than Lasso.

Count to a million

1
2
3
4
5
6
7
8
9
import time

start_time = time.time()

for n in range(0, 1000000):
    print(n)

end_time = time.time()
print("Elapsed time was %g milliseconds" % ((end_time - start_time)*1000))

Elapsed time was 6404.57 milliseconds

1
2
3
4
5
6
7
8
[
local(start) = date_msec

loop(-from=0, -to=1000000) => {^
    loop_count +'\n'
^}
'Elapsed time was ' + (date_msec - #start) + ' milliseconds';
]

Elapsed time was 2866 milliseconds

However that didn't smell right to me. Instead let's remove the print and capture methods so that we can see the true speed of a looping structure by itself.

1
2
3
4
5
6
7
8
9
import time

start_time = time.time()

for n in range(0, 1000000):
    print

end_time = time.time()
print("Elapsed time was %g milliseconds" % ((end_time - start_time)*1000))

Elapsed time was 92.241 milliseconds

1
2
3
4
5
6
7
[
local(start) = date_msec

loop(-from=0, -to=1000000) => {
}
'Elapsed time was ' + (date_msec - #start) + ' milliseconds';
]

Elapsed time was 402 milliseconds

Python is 4 times faster than Lasso.

JSON de/encoding

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import time

start_time = time.time()

import json

j = json.loads('[ { "id": "0001", "type": "donut", "name": "Cake", "ppu": 0.55, "batters": { "batter": [ { "id": "1001", "type": "Regular" }, { "id": "1002", "type": "Chocolate" }, { "id": "1003", "type": "Blueberry" }, { "id": "1004", "type": "Devil\'s Food" } ] }, "topping": [ { "id": "5001", "type": "None" }, { "id": "5002", "type": "Glazed" }, { "id": "5005", "type": "Sugar" }, { "id": "5007", "type": "Powdered Sugar" }, { "id": "5006", "type": "Chocolate with Sprinkles" }, { "id": "5003", "type": "Chocolate" }, { "id": "5004", "type": "Maple" } ] }, { "id": "0002", "type": "donut", "name": "Raised", "ppu": 0.55, "batters": { "batter": [ { "id": "1001", "type": "Regular" } ] }, "topping": [ { "id": "5001", "type": "None" }, { "id": "5002", "type": "Glazed" }, { "id": "5005", "type": "Sugar" }, { "id": "5003", "type": "Chocolate" }, { "id": "5004", "type": "Maple" } ] }, { "id": "0003", "type": "donut", "name": "Old Fashioned", "ppu": 0.55, "batters": { "batter": [ { "id": "1001", "type": "Regular" }, { "id": "1002", "type": "Chocolate" } ] }, "topping": [ { "id": "5001", "type": "None" }, { "id": "5002", "type": "Glazed" }, { "id": "5003", "type": "Chocolate" }, { "id": "5004", "type": "Maple" } ] }]')
print(json.dumps(j))

end_time = time.time()
print("Elapsed time was %g milliseconds" % ((end_time - start_time)*1000))

Elapsed time was 4.09102 milliseconds

1
2
3
4
5
6
7
8
[
local(start) = date_msec

local(j) = json_deserialize('[ { "id": "0001", "type": "donut", "name": "Cake", "ppu": 0.55, "batters": { "batter": [ { "id": "1001", "type": "Regular" }, { "id": "1002", "type": "Chocolate" }, { "id": "1003", "type": "Blueberry" }, { "id": "1004", "type": "Devil\'s Food" } ] }, "topping": [ { "id": "5001", "type": "None" }, { "id": "5002", "type": "Glazed" }, { "id": "5005", "type": "Sugar" }, { "id": "5007", "type": "Powdered Sugar" }, { "id": "5006", "type": "Chocolate with Sprinkles" }, { "id": "5003", "type": "Chocolate" }, { "id": "5004", "type": "Maple" } ] }, { "id": "0002", "type": "donut", "name": "Raised", "ppu": 0.55, "batters": { "batter": [ { "id": "1001", "type": "Regular" } ] }, "topping": [ { "id": "5001", "type": "None" }, { "id": "5002", "type": "Glazed" }, { "id": "5005", "type": "Sugar" }, { "id": "5003", "type": "Chocolate" }, { "id": "5004", "type": "Maple" } ] }, { "id": "0003", "type": "donut", "name": "Old Fashioned", "ppu": 0.55, "batters": { "batter": [ { "id": "1001", "type": "Regular" }, { "id": "1002", "type": "Chocolate" } ] }, "topping": [ { "id": "5001", "type": "None" }, { "id": "5002", "type": "Glazed" }, { "id": "5003", "type": "Chocolate" }, { "id": "5004", "type": "Maple" } ] }]')
json_serialize(#j)

'Elapsed time was ' + (date_msec - #start) + ' milliseconds';
]

Elapsed time was 194 milliseconds

Python is 47 times faster than Lasso.

See the bug report Ticket #7750: Encode_JSON slow.

Summary of speed tests

These tests were executed from the command line, without precompiling or loading them into memory. That would be another exercise, but only if code in both Lasso and Python were compiled. The point is to compare raw code execution not its compilation.

As you can see in the counting to one million test, speed tests can be easily manipulated to achieve a desired result. But with these examples, at least you can reproduce these tests and do your own analysis.

The cost of legacy code

Lasso 8 works. It's good enough for most of my clients. My clients depend on me, and I depend on Lasso, even though Lasso continues to disappoint me. I have a great deal of legacy code written in Lasso 8. Clients do not want to pay to upgrade because they will receive no perceivable benefit, despite what Lasso 9 cheerleaders claim.

I've accepted a few projects to rewrite Lasso 8 legacy code to Lasso 9, and it is a very painful process, which is worsened by the lack of a migration guide. In all previous versions of Lasso, there always existed in the Language Guide a list of incompatibilities and what developers needed to do to upgrade, but that never happened with Lasso 9.

In one of these projects, the goal was to use minimal effort to just get the code to run, never mind about optimization in Lasso 9 syntax and improvements. In one instance, I discovered that the xml_rpc method in Lasso 8 had not been migrated to Lasso 9. When I enquired with LassoSoft staff whether it would be migrated, I received a response of "nobody uses it anymore", even though it was obvious that my client was using it in Lasso 8. Debugging XML over RPC calls in Lasso is not fun, and I spent 10 hours of unexpected effort creating and releasing an open source version of xml_rpc for Lasso 9. The process was exacerbated because documentation for XML in Lasso 9 is feeble. When I finished my work, I submitted a pull request and filed a bug with LassoSoft to accept it into its product. There has no been no further action from LassoSoft.

Libraries and packages

Lasso provides TagSwap which currently contains 464 entries. On GitHub there are 20 Lasso repositories and BitBucket hosts 8 Lasso repositories.

Python provides the Python Package Index which currently contains 44,140 entries, almost 100 times more than Lasso. GitHub hosts 71,469 Python repositories and BitBucket hosts 5,751 repositories.

It should be noted that most repositories are forks of original projects.

Web frameworks

Of the 6 Lasso web frameworks listed on LassoSoft's website, only 1 is actively developed, Knop. Python has around 100 web frameworks, although many, too, have fallen off the face of the planet.

Applications

There is no killer application written in Lasso.

Python has too many killer applications to count, across dozens of industries. Django is a popular web application framework used mostly as a content management system. I've placed my bets on Substance D since it is based on Pyramid. It better work out, otherwise all my effort to design the Sphinx theme for its documentation would be for naught.

Internet service providers

Finding a web host for Lasso is a challenge. If you don't want to run your own virtual machine and want inexpensive shared web hosting for Lasso, your choices are extremely limited. For VMs and shared hosting, I recommend Anu.net. For FileMaker hosting with Lasso, I recommend Point in Space.

Options for hosting Python applications are plentiful. Some even offer a free service level, like Python Anywhere and Heroku. I cannot recommend any one over the other. Rackspace and Linode are popular, although not just specific to Python but for general VM hosting.

Deployment

Lasso is a pain in the ass to deploy. Installation is simple, but configuration of the Instance Manager, Instance Administration, and Datasource Setup require a buggy web GUI interface. A command line interface is sorely needed to make it easy to automate.

There are no tools that automate Lasso configuration or deployment. You must write your own tools. I use rsync with ssh keys and custom scripts for deployment.

Python has dozens of deployment tools and strategies, including tox, buildout, fabric, puppet, ansible, chef, and salt.

Keep an eye on Docker which makes deployment of Python applications extremely fast and lightweight because it does not need a VM or Hypervisor. Nothing like this exists in the Lasso ecosystem.

Licensing

Lasso requires a license key to be able to administer and configure its settings in a production environment. LassoSoft fails to send reminder notices of pending expiration, so you must keep track of your licenses and renew them accordingly. This very night, I tried to administer the settings for a site using a license that is valid for another 4 months, but the administration has locked me out. To remove the lock, one must send an email and wait for a human response during regular business hours.

Python is free and open source, so it never has this issue.

Virtual environments

Lasso sort of has virtual environments, but not really. It has "instances" (previously called "Lasso sites" in Lasso 8), or isolated lassoserver processes each running within their own environment. However these environments are bound to the version of Lasso, and, as mentioned in the previous section, are a pain in the ass to deploy.

Python has a different concept of a virtual environment through virtualenv. It isolates not just the packages (much like a Lasso instance) but to any version of Python installed on the machine. Thus you can write an application and run automated test suites against multiple versions of Python. It also makes it easier to package your application.

Monitoring and profiling

Monitoring Lasso performance has always been a challenge. If you've ever had a Lasso server that had high load or crashed, trying to determine the cause is usually next to impossible. Often the solution is to just restart the instance or lassoserver. Lasso has no toolset that allows for monitoring or profiling other than what is available for the host operating system.

Python has a couple of tools in the standard library so you can examine things like memory usage of specific parts of your code, not just the entire system process. RunSnakeRun is an open source tool for drilling down into your code. New Relic provides an amazing live interface for web applications on production environments. New Relic allows you to drill down into your code functions, SQL queries, and timings and resource usage.

Conferences

There is one conference held on an irregular annual basis, Lasso Developer Conference, with a couple dozen attendees, and a smattering of sponsors and events. The registration cost was CDN$799 in 2013.

PyCon US is the king of programming conferences. Just go to one, and you'll be amazed and overwhelmed. Tutorials, presentations, lightning talks, sprints, poster sessions, exhibit hall, and a job fair are the main attractions. In recent years, they've added a 5K fun run and PyLadies auction fundraisers, sponsored dinners and parties, social activities around town, and even child care. With over 2000 attendees, there is no end to the opportunities to meet other developers that share your interests. The registration cost for an individual was $350 in 2014.

Then there are PyCons across the United States and dozens of other countries.

Employment opportunities

I have not heard of or seen any employer hiring programmers to write Lasso code for several years.

For a general idea of language popularity, take a look at LangPop. Yes, Lasso does show up, but just barely.

Compare the list of Lasso Customers at the bottom of the LassoSoft home page to the list of success stories on the Python website. The Python Software Foundation has dozens of sponsor members, as well as individual members, that fund the development of the Python language. Job boards for Python are plentiful.

If I had equivalent skill and experience in Python as I have with Lasso, I could easily command a salary over $100,000. Obviously I prefer my independence, the commute from my bed to my home office, and a snoring labrador curled up by my side to the hectic life in Silicon Valley. But if I ever want to shift careers into another area, such as training instead of writing code, I would be better qualified if what I taught was something in demand. Python and its tremendous and diverse communities of users is in very high demand, and that demand is increasing exponentially.

What's in a name?

GitHub incorrectly identifies many repositories as Lasso that have nothing to do with the Lasso language. BitBucket at least correctly classifies repositories, but the pickings are slim.

The tag "Lasso" on StackOverflow returns more results for statistics and numerical analysis than the language.

Searching Freelancer for "Lasso" yields results where the skill Lasso is for the lasso tool in Photoshop.

With Python, it's difficult to confuse a reptile with a programming language, although it did derive its name from the comedy show "Monty Python's Flying Circus".

Everyone's two favorite words after a long presentation

In closing, not much is changing for me. I am still traveling along the path of web application development, but I'll be spending gradually more time with Python at my side than Lasso.

As a commercial product, Lasso will never grow the size of its user base as rapidly as open source languages. Under the latest management by LassoSoft, Inc., the Lasso product line has a future, where previously it was in dire straits. I attribute that turnaround to management because they have engaged with its user base in honest, open, and sometimes brutal discussion. Even though criticism of "your baby" may seem harsh, they must be commended for listening, setting a course, and delivering on promises.

Did you like this article? Please send me a Gratipay, as little as 25¢ per week!

Updates, suggestions and comments regarding this article may be sent to Steve Piercy, [email protected] or comment using Disqus.


Written by Steve Piercy in Lasso on Wed, May 21, 2014.
Last modified: Thu, Jul 24, 2014
Tags: Lasso, Python, open source

Comments

comments powered by Disqus