This is an x.264 video, shown here initially with a Flash-only player (FV Wordpress Flowplayer). The video file is served by Amazon’s CloudFront CDN, which is trivial to sign up for without any sales process or minimum service cost. Later I’ll replace this Flash-only widget with one that offers HTML5 video (for iPad use, in particular), when I find one that works sufficiently well.

That’s the easy part, though. Getting this video to you here was an adventure, and not in a good way. Three recordings were made of the talk:

1. We hired a professional videographer to record the talk. When I say professional, I mean it only in the most literal way, i.e. the videographer charged money. They showed up with a nice camera and a wireless lapel mic… but somehow produced a broken video recording (the first 10-15 minutes were intermittant video noise). In addition, the mic gain was turned up way too high and thus the audio is awful.
2. Dave Blankenship recorded the talk on his consumer camcoder; he was not paid for this, and he did a much better job. This video is usable all the way through, but arrived in an oddball format produced mostly by some models of JVC camcorders. The audio was not so hot, because he used the mic built in to the camcorder from the back of the room.
3. I recorded the audio using a $5 microphone plugged in to an iPod Nano, sitting on a table at the front of the room. It’s a bit noisy, but with a few minutes of work with Audacity (Noise Removal and Normalization), the results are much better than either video attempt.

Armed with this, I set about to somehow combine the video from #2 with the audio from #3. I send emails describing this mess to several videographers I found on Craigslist. Most of them didn’t reply at all. I finally got a cost estimate from one, of many hundreds of dollars or more, and not much assurance of results.

Now I’m willing to spend some money to get good results, but spending it without confidence of results is less appealing; so I set about trying myself instead.

First, I cleaned the audio in Audacity as mentioned above.

Second, I watched the video and listened to the audio a few times, to get the approximate starting timestamp in each one of the moment the talk actually started; each recording had a different amount of lead-in time

Third, I grabbed ffmpeg, the swiss army knife of command line video and audio processing. After reading a dozen web pages of ffmpeg advice, and a number of experiments (with short -t settings, to quickly see how well it works without waiting to transcode the whole thing), I ended up with this command to produce the encoded video:

ffmpeg -y -ss 40.0 -i Recording-3-audio-only-clean.wav -ss 95 -i Recording-2-video-ok-audio-bad.mod -shortest -t 18000 -vcodec libx264 -vpre normal -b 700k -threads 2 Cordes-2010-SaaS.m4v


I then noticed that the MacPorts installation of ffmpeg omits the important qt-faststart tool, and found this helpful version of qt-faststart and used it instead, on my Mac; later I switched to a Linux machine with an ffmpeg install including qt-faststart. Without the faststart step, the metadata in the m4v file is arranged in a way that prevent progressive/streaming play-while-downloading.

The results are good but not great:

• The video has some motion/interlace artifacts; these were present in the original recording, and I’m not aware offhand of what to do about them
• The video camera used rectangular pixels; the pixel aspect ratio is 3:2 while it is intended for display at 16:9. I wasn’t able (at least in 20 minutes of learning and experimentation) to get the 16:9 output working correctly, so if you grab the underlying m4v file you can see the aspect ratio a bit off in the shape of the clock on the wall, for example.
• The audio-video sync is adequate (and plenty good enough to follow along) but not perfect. Clearly using the audio track on a video recording is much better than putting them together in post-processing.
• The audio is not as good as if I used a lav or headset mic, though I think it’s quite remarkably good for a $5 mic plugged in to iPod.
• I’ve no idea if ffmpeg complies with any of the relevant copyrights/patents/whatever in video production, though it seems hopefully safe to use for a one-off non-commercial video like this. (Normally I use Apple’s iMovie for my videos, and I assume Apple has taken care of such things.)

A few morals of this story:

• Get some powerful tools, and learn how to use them.
• Be willing to pay for professional work, but be skeptical. Just because you pay, doesn’t mean it will be quality work.
• Have a plan B. If I had assumed that at least one of the two videos would get decent audio, and skipped my own audio recording, I’d not have been able to deliver the acceptable audio here. If Dave had assumed that my professional videographer would produce results, and turned off his camera, we’d have no video here at all.

• The SaaS talk handout as a PDF
• The SaaS talk slides as a PDF (also shown below)
• Transcript of the Talk, with slides, as a PDF
• Audio recording of the SaaS talk
• A video recording, which I finally got online in June.

or for download as a PDF.

Appistry again provided space and pizza – thanks guys! (Appistry is our locally-grown but widely-known cloud infrastructure software maker – they’d been cloudy for years before the term entered wide use.)

The talk appeared to go over well. There were many important things about factor that I’d love to talk about but didn’t have time. Nonetheless, I think 45 minutes is a good talk length, and I think the format (short talks) is a key part to the Lambda Lounge’s success so far.

Speaking of the Lambda Lounge,  next month there is a “language shootout” – if you want to participate, be sure to join the mailing list and look over the participants. (You need to join the list, to be able to get to the wiki with that page.) I might submit an entry myself, using Factor or another language.

Introduction and Agenda

Linus Torvalds wanted a replacement for BitKeeper. He wrote the first version of Git in a few weeks. A few years later, Git is now the leading contender among distributed source control tools: http://git.or.cz/

This will not be a typical “introduction” talk; there are ample introductions to Git on the WWW. Instead, I’ll wander through some source control use cases, pointing out Git features, strengths, and weaknesses along the way.

I use Git on both Linux and Windows, and I use both the command line and GUI tools. For this presentation, I will show how it works on Windows, and mostly use the included GUI tools.

We’ll end a bit early, to leave time for questions and ah doc demos.

Why Git?

Git promises to keep your files exactly as they are, and uses hashes to make it happen.

Git is very fast; speed matters a lot more than you might think.

Git is distributed and local, it works very well offline as well as online.

Git handles the realities of branching and merging.

Git has an enormous set of very useful features.

Git is clearly a tool made by people who love great tools.

Get Git

Deb/Ubuntu:   apt-get install git-core

Windows:        http://code.google.com/p/msysgit/

Version Some Files, Look at Them

git init                      git add                    git-gui

git commit                .gitignore                                gitk

Use Git with Eclipse

There is a git-Eclipse project in development:

http://repo.or.cz/w/egit.git

However, I will show how to use Git and Eclipse without any integration. This turns out to be much less problematic than you might initially guess, and has advantages:

If you use git with multiple IDEs, you only need to learn one interface.

You can use the tool in ways that the IDE does not anticipate, such as by versioning a whole workspace as a unit.

Branch and Merge

git branch                                git checkout -b newbranch

git diff                                     git merge

Rebase

The best thing in the world, a great capability.

The world thing in the world, never do this.

My advice: Have it in your toolbox, but be careful.

Review and Search History

The sample repos from tonight’s demo don’t have much history to show; but with git, and without relying on a network connection, we can see git’s review and search capabilities on projects “in the wild”.

Rearranging Files

Git tracks content, and will follow that content as it moves around, without you telling it about the moves. This is extremely helpful if you have a pile of files to rearrange.

http://kylecordes.com/2008/07/18/rearrange-file-svn-git/

Blame!

Poll: Do you use Blame? How often? Does it help?

Blaming is a terrible way to interact with other people… but get over the name, because “blame” is a fantastic source control feature.

Host Your Repo on Your Server

Git has a built in ability to host repos, and also includes gitweb.

Gitosis is also a great tool: http://eagain.net/gitweb/?p=gitosis.git

GitHub

Don’t want to mess with hosting?  http://github.com/

Enterpriseynessility

Git does not have all the same feature as whatever enterprisey tool you may be using. It has a different set of features. YMMV, but in my opinion it is a “disruptive innovation”.

Git-SVN

Git makes a great front end for SVN; I use it this way regularly on Linux. Msysgit does not currently include git-svn, so no demo.

Tips

Initial Setup:

git config –global color.diff auto

git config –global color.status auto

git config –global color.branch auto

export PS1=”\u@\h \W\$(git-branch 2> /dev/null | grep -e ‘\* ‘ | sed ’s/^..\(.*\)/ {\1}/’)\$ ”

Remove from source control, the files you have removed from the file system:

git ls-files -z –deleted | git update-index -z –remove –stdin

Using Git in a Closed Team

There are many ways to use Git; you can think of it as mostly a superset of what other systems do. You can use Git to achieve many possible workflows. Here is one way to use it effectively:

Set up a server everyone can pull from and push to.

Use Gitosis or similar.

Have one(+) repo per developer, and one(+) for leads to all push to.

Everyone pushes to their repo.

Leads pull from others’ repos, and push to the main repo.

Server performance is not important, a slow machine can serve many users.

Backup is not all that important, you will not actually lose anything if the machine dies.

Make your initial repo fork for each person, on the server, for speed and space sharing.

Using Git for Open Source

Clone the project’s repo.

Hack.

Push your changes to your public repo (perhaps on Github)

Get someone to pull them.

git format-patch, if you want to send them.

Problems in the Git World

On Linux, things are going very well. But on Windows, not so well: the Windows port itself  is advancing nicely, but it appears to suffer somewhat badly from the “I am just doing this for fun, if you want it fix, make a patch” problem.

My opinion: to really thrive on Windows, Git needs a firm to create a commercial offering around it, and feed lots of core fixes back to the project.

Unfortunately I didn’t get an audio recording of this talk, so no transcript either.

About 30 people were in attendance. Nearly 100% were familiar with CVS and SVN, and perhaps 20% with other tools (ClearCase, SourceSafe, and others). Only 4 had ever used branch/merge in any project or tool!

A Brief Introduction to Distributed Version Control

You Branch and Merge.

A fundamental truth: every time you edit a file you are branching, and every time you reconcile with another developer you are merging. In most tools you get one easy branch and merge locus: your local working directory. All other branching is a Big Deal.

It does not have to be this way.

A Short Tour of 3 tools

bzr: http://bazaar-vcs.org/

hg: http://www.selenic.com/mercurial/

git: http://git.or.cz/

Also, check your distro’s package system.

(At this point in the talk I demonstrated the basic features of each)

What is a DVCS? Why Use a DVCS?

Peer-to-peer design

Everyone gets all the features, rather than the interesting features limited to a high priest class.

Make use of the massive CPU and disk capacity on dev machines.

No central server needed, though many projects nominate a machine for this purpose.

Use a “dumb” storage location for a repository, if desired. Or a “smart server” for performance and security.

Work offline, with full history, branches, merges.

No central administrator is needed, potentially a cost savings.

Very cheap branching, in some cases immediate, even for large projects.

Very good merging, because you merge all the time.

Commit-then-merge, not merge-then-commit.

Repeated merge without havoc.

Merge keeps both sides of history, which is important because you merge a lot. This varies by tools, for example apparently bzr keeps this history less effectively than some others.

Depending on what you are coming from and which tool you choose, the speed gain can be so remarkable that it help every developer every day.

Some SVN Nitpicks

It is easy and tempting to pick on SVN. Linus does so vigorously in his online talk. I don’t hate it as much as he does but, these things bother me:

SVN is slow for large projects.

Branching in SVN sounds clever as you read its cheap copy story. It’s a great story. But actually using it is ridiculous; both in the URL-crazy syntax and utter lack of merge history.

We don’t need a better CVS, we need something much better than CVS.

.svn directories scattered all over are a pointless pain.

.svn directories are enormous, sometimes larger than the entire project history in git or hg!

Security

Security is a weak area in terms of out-of-the-box features and tutorials, because these tools come from the open source world where the default is for everyone to be able to see all code. However, with a little effort you can set up whatever security you like:

If you’re serving over HTTP, you can use Apache mod_whatever to control access.

Tunnel over SSH (in the box, in most cases) to avoid ever sending code in the clear.

Even a “dumb” storage location can be secured with SFTP.

Scripts can be used for per-branch and other fine grained access control, akin to what you can do with svn-access.conf. There are examples online.

I Can’t Use a DVCS Because:

SOX/HIPPA/CMM/etc. requires a centralized tool.

SOX/HIPPA/CMM/etc, is the standard reason why anyone can’t do anything. Some of these tools facilitate much stronger guarantees about the provenance of the source code than you get from a centralized tool, because they have credible and straightforward ways to verify that centralized store has not been compromized.

We are all in one place, therefore a DVCS makes no sense.

Actually many of the features in these tools are as useful in the same building as in a worldwide team.

Tool ZZZ is our corporate standard.

Then you should use it, don’t get fired. However, many people are using a DVCS in front of their corporate standard tool.

DVCS vs DVCS:

Many DVCS tools treat each repo/workspace as a branch and vice versa, so if you use many branches you will have many workspaces.

bzr can use shared files to reduce the bloat from this.

git handles many branches much better, with arbitrarily many per repo/workspace.

My feeling is that hg and git are more mature than bzr.

git does not work well on windows yet.

Other DVCS to Consider

Monotone – has some slick features, but does not appear to scale well to large projects. It stores information in a SQLite DB. Monotone, unlike any others I’ve seen, replicates all branches by default, which is nice.

An aside — there are fascinating thoughts on how to a data synchronization system can work, in the Monotone docs / presentations.

arch / tla — one of the early DVCSs that started all this. I have heard it is mystifying to use.

darcs — everyone loves its “cherry picking”, but I have not triedit.

SVK — optimized for being a better svn client, with offline history and merging that works. Stores merge history in SVN attribute.

More git Merging

Depending on time, I will show more of the branch / merge facilities in git, as well as its gitk GUI.

Other Resources

http://wiki.sourcemage.org/Git_Guide

http://www.adeal.eu/

Update: the following appeared a few days after my talk, it is very good, aside from slightly bogus listings in the “disadvantages” section:
http://betterexplained.com/articles/intro-to-distributed-version-control-illustrated/

The 1 hour audio recording (Olympus WS-100 digital voice recorder, Audacity cleanup) is available here: SAASTalk.mp3

A transcript of the talk is available. In the talk I mentioned Paul Graham’s The Other Road Ahead, which is shorter and easier to read the my talk transcript.

A couple of people at Code Camp asked if I could come give a similar talk in-house at their firms. Yes – please contact me with the contact form to arrange a date.

The handout contents follow.

Selling your Software as a Service

Kyle Cordes
May 5, 2007

An Encouraging Idea

When you open up an IDE/editor at home, on your own time, you have a remarkable power in your hands: you can create something that you own (modulo some employment agreements). It is yours to sell, to give away, or to decline to do either, on your own terms. Likewise a company has this on a larger scale.

For the last few years my firm has been selling access to an application we wrote (and continue to write) as a service, charging a monthly fee for use, hosting, and support. I won’t name names or describe our product in detail (this talk is not spam), but I will share some things we’ve learned along the way.

What is SAAS?

Delivering a software product (especially a complex “enterprise” system, less so with consumer products) involves more than just bits in a file / on a CD-ROM:

1. Delivery of the deployable code

2. License (legal right to use it)

3. Hosting: hardware, deployment, and management thereof

4. Support for the server(s) / software on the servers

5. Support for the end users / software on their PCs or other devices

In a consulting or in-house project, the most common type of project for the audience here at Code Camp, you sell hours of labor to do the things above.

In a commercial software product company, you bundle #1 and #2 for a price, then perhaps sell a service contract for #4 and possibly #5.

With Software as a Service (SAAS) you bundle #1, #2, #3, #4, and possibly #5, then sell the result for a yearly / monthly fee times some measure of volume (per computer, per user, per transaction, per site, etc.). A company selling their software in this way is sometimes called an Application Service Provider.

The Business Model

From a business perspective, SAAS offers a recurring revenue stream rather than “spiky” up front sales. In the short term this can make higher investment demands (since the revenue arrives more slowly). In the long term, though, recurring revenues are very amenable to a sustainable ongoing business.

On the downside, as a SAAS vendor you are at greater risk of ongoing payments stopping, vs. up-front payments in full when the sale is made.

Collections are typically much less of a problem with SAAS: you will generally be paid by customers in a timely way (as they would pay for electricity, bandwidth, and other ongoing utility services).

This gradual arrive of revenues will shape your company’s financial decisions: you need to meter expenses to match.

Hosting

With SAAS, your customer stays out of the “hosting business”, but you get in to it. One way to offer reliable hosting is to put your servers in a colo facility; you can typically get a full rack (with power and bandwidth) for less than $1000 per month. This will provide redundancy in the power, air conditioning, and connectivity, which would be much more costly to provide in-house.

You will become experts in hosting, by experience. You will host more instances of your software than any one customer would, so you are in a better position to do a good job doing so.

Another route, for a smaller operation, is to rent a single dedicated server or even a “virtual” dedicated server. Or, go utterly virtual and use Amazon EC2 and S3 as your infrastructure.

Support / Operations

As an SAAS firm you can offer much more hands-on support than a traditional software vendor, because you have direct and immediate access to the production systems serving your customers.

At the same time, this access will expose your team to the customer’s pain points, making it more likely those problems are fixed soon.

With SAAS you can readily deploy updates regularly (weekly / monthly) at low cost, enable end-to-end agility. Paul Graham wrote about this in “The Other Road Ahead”.

What do customers like about SAAS?

Customer love not paying for unproven software up front, even if they have abundant cash and even if the software is in use elsewhere. They avoid making an unrecoverable investment in case their needs change or the software turns out to be inadequate.

Customers generally like not running a hosting operation: not operating a data center, not hiring employees for it, etc.

Customers benefit with SAAS’s easy scaling up or down as their needs grow and shrink. Financial decision makers often prefer costs that scale smoothly with business volume.

What do customers not like about SAAS?

Customer may be concerned that they have less direct control over an application supplied SAAS, than one hosted in-house, with less ability to persuade an operator/developer to drop everything and fix it now.

Eventually a customer may spend more with SAAS (at least in terms of the checks written to the software vendor, though perhaps not in total cost) than they would have spent buying a license up-front; thus they are prone to regret that they didn’t buy an up front license.

A customer may want to customize the software in a way the vendor does not offer.

Start Fast

SAAS provides considerable flexibility in delaying software work past the product launch; “admin” features can be less complete and more rough, if they are used primarily by the vendor’s staff instead of by the customer, and can require deeper system knowledge.

There is also a risk that the ability to get by with rough edges will too easily allow you to never truly finish the product.

What’s it like to sell software this way?

The biggest difference in selling SAAS is a more substantial long term relationship with the customer, both operationally and financially. This can be a great advantage – with a close customer relationship you will be in a position to understand their needs more fully, and innovate in your software to meet those needs better.

Customizations

The purest SAAS way to offer customizations is to not charge hourly / project fees for the changes, but rather to invest in the desired enhancements then charge a higher ongoing price for the enhanced system. Hybrid customization payments are also possible, combinations of customization fees and monthly costs. Be sure your customer understands that paying for a customization, does not grant ownership of the underlying system.

Intellectual Property

While an SAAS firm usually owns (or licenses) its software, customers should own their data (and have access to a copy of the raw data, if they ask for it). Hire a lawyer to work out the details.

Go to great lengths to keep customer data separate: you must make sure to never, even briefly or accidentally, give one customer access to another customer’s data. For small, cheap services, WHERE clauses are OK for this, but for large expensive services, use (at minimum) separate databases and server code instances, and perhaps even separate hardware.

I’m in for two sessions this year, assuming enough slots are available for both:

Flying Boxes

It’s surprisingly easy, with Java and Swing, to build animated drag-and-drop “direct manipulation” user interfaces. I covered the overall topic in a talk at the Java User Group, and found that my “flying boxes” demo and code walk-through were by far the most interesting part. I’ll repeat that demo and explanation here, with more careful (and thus helpful) coverage of the issues involved in getting good results. As “filthy rich” GUIs become more popular, the ability to build such interfaces has become important in commercial business applications, not only in demos and games. The code can be downloaded from my web site.

Selling your Software as a Hosted Service

For the last few years my (other) firm has been selling an application as an Application Service Provider, charging a monthly fee for use of software that we develop, host, and support. (This is sometimes called the “Salesforce.com” model, but it predates them by decades.) Of course we have much still to learn, but in this talk I’ll share some experiences, tips, and advice on how (and whether) to use this business model for your own ventures. The last portion of the session will be a roundtable discussion, I’d like to learn from you too.

I also recorded audio of the talk with my Olympus WS-100 digital voice recorder, then used Audacity to clean it up; Audacity’s “Remove Noise” feature worked surprisingly well. The recording lasts 1 hour 23 minutes, is 49 MB in size: RubyGUIToolkitTalk.mp3

A transcript of the talk is also available.

In the audio I mention screen shots and demos; you can find those at the respective toolkits’ web sites (linked below). I also briefly discuss and demo some code from a 2005 talk about Swing.

The handout contents follow below.

Ruby GUI Toolkits

St. Louis Ruby UG – http://stlruby.org – March 27, 2007

Kyle Cordes – http://kylecordes.com – Contact me via my web site

These notes will on my web site sometime this week.

Agenda

1. Review the myriad options

2. Let’s see some code

Ruby is quite popular for web applications (mostly with Rails) and for utility scripting. But there is a world of GUIs beyond web applications, a world which is not going away. To build such applications in Ruby, we must choose a GUI toolkit and Ruby bindings. My criteria for a rich client application toolkit (or the resulting application) are perhaps harsh:

• Polished, rich set of widgets (My experience is with the enormous wealth of free and inexpensive widgets available for Delphi)

• Consistent, comprehensible API, with both API reference and “how-to-use-this” narrative

• Robust, production-grade: No beta, no pre-1.0.

• Features beyond what’s readily possible in a web application

• Look like 2007, not 1997

• Look and feel, if desired, like a mainstream GUI application

• Actively developed and updated

• Ideally cross-platform; at minimum, great results on Windows, where most of the customers are.

• Sufficiently popular that programmers and community resources are available

In summary: it must be suitable for creating applications that people will pay for. Not merely pay for in a vacuum or an internal-project-single-bid situation, but pay for in a competitive environment where I am trying to outmatch others who are using Java Swing, Java SWT, MFC, Visual Basic, Delphi, etc.

I investigated each option enough to form an opinion of its suitability according to the criteria above. With some of them this took only a short while. Here they are, alphabetically:

Cocoa

Sadly, I don’t have a Mac. If I did (and was targeting that platform only), the Ruby-Cocoa bridge would be very appealing, as it produces applications with a completely native Mac look&feel, and appears to be a joy to program.

http://www.rubycocoa.com/

http://rubycocoa.sourceforge.net/doc/

Fox

The Fox GUI toolkit was somewhat weak when I first learned of it a few years ago, but appears to have improved considerably since then. It uses non-native widgets (which resemble “vintage”, pre-XP-Themeing Windows controls), and has a somewhat limited selection of them. http://www.fox-toolkit.org/

FXRuby, the Ruby binding, is in the “one click installer” box. The benefit of being in the box is hard to overstate.

http://www.fxruby.org/

http://fox-tool.rubyforge.org/

Gtk

Gtk, the graphic toolkit from the GIMP and Gnome problems, is a strong candidate. Gtk is stable and well documented, and thoroughly proven by the large number of polished Gtk applications for Gnome. Gtk feels most at home on Linux, but also works on MacOS and Windows. I didn’t try MacOS, but I found it works and looks good on Windows.

Glade, the Gtk GUI design tool, treats GUI layout as data rather than code. (NeXT did this in the 1980s, and MS has recently reinvented it in the form of XAML.)

To install Gtk-Ruby on Debian (from http://ruby-gnome2.sourceforge.jp/hiki.cgi?Install+Guide+for+Windows):

sudo apt-get install ruby-gnome2

Then to try it out:

ruby -r gtk2 -e ‘Gtk.init ; Gtk::Window.new.show ; Gtk.main’

Unfortunately the simple invocations above didn’t work for me; but with a bit more work the samples run well.

JRuby + Swing, JRuby + SWT

Java Swing or Eclipse’s SWT can be used with JRuby. I didn’t investigate these much (aside from running the samples), because JRuby was not yet “ready for prime time” yet, as of around the end of 2006. It looks like there has been a lot of progress since then, so if you are reading this in mid-2007 or later, give it a close look.

require ‘java’

JFrame = javax.swing.JFrame

frame = JFrame.new(“Hello Swing”)

frame.getContentPane.add javax.swing.JLabel.new(“Hello World”)

frame.setDefaultCloseOperation JFrame::EXIT_ON_CLOSE

frame.pack

frame.visible = true

Local Web Application

Ship a “local” web application: install Rails + Mongrel + etc., and launch a web browser pointed at http://localhost:port. AJAX or Flash can be used to build a richer GUI than you can get with plain HTML. Aside from the local install process (which is not difficult), the tools are mature and powerful, and programmers are abundant. Because of these advantages, and because of the various problems with the GUI toolkits, I would consider this strongly if I needed to build a local Ruby GUI app today.

.NET

There is a Ruby-.NET bridge which can use WinForms (in .NET 1.x), but it hasn’t been updated since 2004.:

http://www.saltypickle.com/rubydotnet

There is at least one Ruby compiler in development which targets .NET (analogous to JRuby). When that is ready, it will be possible to use WinForms and WPF (the new “Vista” era .NET GUI toolkit).

http://www.plas.fit.qut.edu.au/Ruby.NET/

OpenGL / SDL

There are Ruby bindings for OpenGL and SDL; I didn’t investigate these because they are most suited for producing graphical / game software rather than application GUIs. However, as application GUIs become richer, I expect the two categories to merge to some extent, so don’t rule out this approach completely.

http://ruby-opengl.rubyforge.org/

Qt

Qt is mature, stable, and of high quality. It is used for many commercial applications on Windows and Linux. The documentation is extensive and GUI layout tools are available. Qt uses native widgets on each platform. Qt is available for free for use on open source software (including KDE and the many KDE applications). For commercial use, it is less free:

$2000 per dev, for the “desktop light” edition (one platform)

$5000 per dev, for the “full” edition on 2 platforms

$more for various other packages

The QtRuby bindings are free, and described as “very complete”:

http://developer.kde.org/language-bindings/ruby/index.html

There is a book from the Pragmatic Press about QtRuby:

“Rapid GUI Development with QtRuby”

http://www.pragmaticprogrammer.com/titles/ctrubyqt/

Qt/QtRuby is very appealing, probably the most polished of all the options, except for the price. I believe the price will prevent large scale adoption. For those large corporate Ruby GUI projects, go with Qt.

Tk

Tk is in the Ruby “box” (installed by the installer, though I also saw instructions to install it separately), and has a complete, documented API. Unfortunately, it is also quite old and generally ugly; it seems more suitable for simple GUIs for utility programs, than for large, rich applications. However, this seems to be changing – the “Tile” theme engine for Tk greatly improves the appearance.

require ‘tk’

root = TkRoot.new

button = TkButton.new(root) {

text “Hello, World!”

command proc { puts “I said, Hello!” }

}

button.pack

Tk.mainloop

Win32

Also included in the Ruby installers are SWin and VRuby. SWin is a low level Win32 API binding, with VRuby is a GUI toolkit (OO wrapper) on top of that. VRuby appears to be inspired by Visual Basic or the Delphi VCL. Its controls are the Windows controls (including the TreeView and ListView), and are of course 100% native and 0% cross-platform. It uses a clever implicit event-binding technique, requiring generally 0 lines of code to bind an event to a method.

The documentation, while detailed, is in Japanese, and this is a relatively low-level toolkit, so it may be quite hard to adopt for non-Japanese speakers.

Update, January 2008: Anthony Leotta wrote in to point out that there is now good VRuby documentation, in English.

WxRuby / WxSugar

WxWidgets itself is stable, featureful, free, and used in many commercial applications. The most common way to use Wx appear to be with its native C++ API, and with WxPython. Wx uses native widgets for each platforms, and with a little work can have a modern slick look and feel.

http://www.wxwidgets.org

Unfortunately, the WxRuby bindings are incomplete and unstable – even the demo application crashed several times.

http://wxruby.rubyforge.org/

WxSugar adds a layer of “syntactic sugar” on top of WxRuby, to enable a more expressive, compact coding style.

http://wxruby.rubyforge.org/wiki/wiki.pl?WxSugar

Ruby Scripting for a non-Ruby GUI

Ruby can be used as an embedded scripting language; to do this, you’d write your application “core” in something else, then use Ruby for instance-specific business rules, plugins, etc. I demonstrated this last year at Code Camp with Lua, the same approach works well with other languages.

So What Do We Do?

I don’t have a single answer as to which of these to use; none of them has impressed me as a compelling replacement to the mature toolkits I’ve used, such as Java Swing (in the Java language, which for all its issues, is a good language to use for interacting with massive Java APIs).

Other References

Jeff Barczewski pointed out that the “Ruby Developer’s Guide” (a 2002 book by Michael Neumann), which features a free sample chapter on Ruby GUIs.

http://wiki.rubygarden.org/Ruby/page/show/ComparingGuiToolkits/TakeTwo

http://groups.google.com/group/comp.lang.ruby/msg/58504a6e39e6a1c7

http://www.trug.ca/Ruby_GUI_Toolkits

http://www.arachnoid.com/ruby/RubyGUIProject/index.html

http://www.trug.ca/VRuby

Ruby/TK tutorial: http://members.chello.nl/~k.vangelder/ruby/learntk/hello.html

]]> http://kylecordes.com/2007/ruby-gui-toolkits/feed 8 http://kylecordes.com/2006/java-scripting http://kylecordes.com/2006/java-scripting#comments Fri, 10 Nov 2006 15:09:26 +0000 Kyle Cordes http://kylecordes.com/2006/11/10/java-scripting-talk-%e2%80%93-code-notes-and-audio/ Last night (9 Nov 2006) at the St. Louis Java User Group, I gave a talk on “Scripting Your Java Application”. As I mentioned, there were no slides, but rather a handout, the text of which is pasted below. You can download the handout (a tight, one page PDF), the code, audio of the talk (WMA), and audio of the talk (MP3, larger). The audio was recorded with my Olympus WS100 Digital Voice Recorder, so the quality is bearable but not great.

Update: As an experiment, I also had CastingWords prepare a transcript of the talk. It’s somewhat tedious to read (I didn’t edit it at all), but it is available as Google fodder rather than trapped only in audio.

Beans Scripting Framework

http://jakarta.apache.org/bsf/projects.html

The BSF came from IBM in the late 1990s, and was the first major multi-scripting-language plugin API. It supports many languages (BeanShell, Groovy, Jacl (Tcl), Rhino/JavaScript, Jython, etc.), with a focus on embedding script in HTML/XML. BSF is now an Apache project and supports non-web scripting as well.

BeanShell (JSR 274)

http://beanshell.org/

BeanShell supports a superset of the Java syntax; as a result you can use it as a more-pleasant-than-Java scripting language, or use it as a Java interpreter. BeanShell was written by Pat Niemeyer here in St. Louis.

Because of the Java syntax, BeanShell can be used to get code working in an interpreted way, or as part of a script plugin/extenstion, then very easily move that code in to your core application, unlike code written in a non-Java scripting language.

Another, more extreme use of BeanShell is to use it instead of javac for an entire application, to reduce the deployment size – with Java, compressed source code is often smaller than the equivalent compressed compiled classes!

Groovy (JSR 241)

Groovy is a relatively new language, whose specific syntax and semantics are being worked out in the JSR process. Its key advantage is that its design is much more compatible with how the JVM works than other non-Java languages: it is less dynamic. Thus it is likely to achieve better performance and more straightforward access to Java features, until some future JRE adds better dynamic language support.

Java 6.0 Scripting (JSR 223)

http://jcp.org/en/jsr/detail?id=223

https://scripting.dev.java.net/

It appears that starting with Java 6.0 / 1.6, a scripting API and implementation will arrive “in the box” in the form of the javax.script package and bundled JavaScript (Rhino) implementation (as the “js” language). The API is similar to the BSF API, though more refined. The API makes it easy for a host application to support multiple script languages and integrate only once. Java 6 will be released Dec. 7, 2006.

“It’s pretty hard to defend a delayed project when you are using Billy’s Scripting Language. As a project manager or IT manager you could get fired for making that decision. However, if you build an application using MegaStandard Scripting Language X, you won’t because you followed the recommendation of a standards body. Its not your fault it doesn’t work as expected.” (Richard Monson-Haefel’s blog)

Other JSR 223 compliant scripting engines: AWK, BeanShell, Groovy, UGNL, Python, Ruby, Scheme, Tcl, many more.

Rhino (JavaScript)

You probably deploy with Java 5/1.5 or 1.4 now. Use JavaScript (the Rhino engine) today via its API and 693K js.jar file; you are prepared for the future, you will be able to use the JSR 223 API and in-the-box Rhino with little effort. All existing scripts should still work.

Experience Report

We have a large “enterprisey” product; as with many such products, there are some aspects of behavior that are inevitably customer-specific and hard to accommodate through a data-driven configuration mechanism. We use Rhino / JS scripting to add customer-specific behavior, for example in the form “if fields A and B have values C and D, then field E is required”. It was surprisingly easy to add scripting support – perhaps a few pages of code to add plug points and invoke the script engine. Recommended.

What’s a scripting language anyway?

Common answers, none of which are absolute, include “duck typing”, the lack of a complex type system, interpreted execution, ability to “just load some text and eval() it”, lack of binary compatibility concerns, and sandboxed execution.

Why script?

Scripting can provide more flexible configuration than the typical data-centric configuration approach; use it whenever you feel the temptation to invent just a little bit of an programming language, particularly in XML. (A rule to live by: do not write code in XML.)

Scripting is more important in commercial systems (which serve many customers) than in internal system; be wary of over-engineering, do not add a scripting language when a lookup table will do. Yet in a commercial system scripting provide a path to make your application “done”, in spite of ever-shifting customer-specific needs.

Scripting serves as a “soft layer” in the “Alternate Hard and Soft Layers” design approach, which I illustrated with Lua at a talk last year; there are notes about the topic on my web site.

A scriptable application is generally also a testable, modular application.

Scripting opens the door to user-generated procedure content – witness the amazing proliferation of user-written scripts in Second Life.

What should my API look like?

With rules scripting, the user configures a logic behavior for a situation the application encounters, such as a “billing rule”. Provide a carefully “shaped” (but not too complex) API, such as an entry point / script per product-type. The shaped API provides good isolation between scripts, important since rules are often filled in by users with very little programming experience.

Plugin scripting is more general, allowing the user to add capabilities and features to the application, within limits. Impose much less structure on the script; exposing very few entries points (perhaps just one), then let the script register interest in events as they require. This will make it possible for a scripter with some experience, to use an intentional design for their plugin, rather than contort it to meet your API. An end-to-end plugin spans the tiers (client/server/etc.) of the application; if your mechanism assists the script by carrying ad hoc attributes along with predefined data, such a plugin can be quite powerful. For example, it could define the entry of additional data, rules for the processing of that data, billing based on that data, etc.

External scripting, common in large desktop applications like Excel, steers the operation of the application with an API that resembles the model of a user manipulating the UI, with mild additional abstraction.

Be wary of what primitives you expose to the scripts; you may inadvertently expose your entire class structure – a large and complex “surface area” for which it will be very challenging to maintain future compatibility. Sandbox your scripts as much as feasible.

Alternate Hard and Soft Layers

This is a Pattern from the C2 Wiki: http://c2.com/cgi/wiki?AlternateHardAndSoftLayers

In a system built with “hard” code (not in the sense of difficulty, rather in the sense of statically typed, statically compiled languages), organize that code in to layers, and between those hard layers, put “soft” layers in the form of scripts written in a dynamic, runtime modifying languages. AHSL is closely related to the idea of scriptable applications, with the additional notion of layering, rather than ad hoc extension.

“hard layer” languages:

• C
• C#
• C++
• Delphi (*)
• Java

“soft layer” languages:

• bash
• BeanShell
• Emacs Lisp
• Groovy
• JavaScript
• Lua (*)
• Python
• Ruby
• Tcl

This talks’ examples are in Delphi (hard) and Lua (soft). Delphi is a mostly static language, essentially similar in certain ways to C, C++, and Java, but with a Pascalish syntax.

Key Points about Lua:

• An easily learned, dynamic programming language
• Small, highly embeddable (~ 100 KB)
• Multi-platform (highly portable C code)
• Well suited to “Alternate Hard and Soft Layers”
• Free and open source
• Stable and mature
• Safe and Sandboxed
• Actively developed and maintained

Recommendation on Scripting:

• If you’re building a Java system, the most appealing scripting language is JavaScript, because it will be “in the box” in Java 6.
• If you’re building a .NET system, use a .NET-centric scripting mechanism
• If you’re building a Win32 system with a lot of COM in it, use the Windows Scripting Host and expose your system’s feature to the scripts via COM.
• If you’re building a system with a “hard” (very static) language, and want to keep your options open for cross-platform development / deployment, than Lua is an excellent choice, it is small, fast, proven, COM-free, and cross-platform.

Slides: sd04_disconnected.ppt

Source Code: disc-data-ex.zip

Details are here

Talk in Powerpoint format

The plain text of the slides (which is, frankly, plenty good enough) follows:

Objects without Classes – JavaScript

An Alternative Object Model

Kyle Cordes

Oasis Digital Solutions Inc.

St. Louis OOSIG

Oct. 16, 2003

Yet Another “About Me” Slide

* Developer, Architect, Consultant, PM, etc.

* Learned OO in C++, early 1990s

* Many other OO languages since: Java, Delphi, C#, Python, Ruby,
JavaScript, etc.)

* Oasis Digital Solutions Inc.

¨ Outsourced development

¨ Services to help teams write better software

* kylecordes.com

Assumptions

* You write software

¨ Not necessarily a lot of software

* You use an OO language

¨ It’s hard to find one that isn’t nowadays

* (More technical than some OOSIG talks)

Agenda

* Objects and Classes

* Classless OO

* Very Brief Introduction to JavaScript / ECMAScript

* Examples

The Point

* Object Oriented does not necessarily mean Classes.

* Classless OO is a useful model, in surprisingly widespread
use, though not in mainstream enterprise development.

* Nonetheless, understanding classless OO can help you create
better designs in the language you use now.

Class-based OO

* C++, Java, C#, Smalltalk, Eiffel, Delphi, many more.

* Objects are divided into types, and don’t change type

* The properties of a set of objects of the same class
are specified in a class definition

* Classes are abstract thing, instances are specific

* Class relationship is static

* This is the only way it can be done, right?

Classless Objects

* Some OO langages don’t have classes

¨ Called Classless or Prototype-based

* Objects share behavior by sharing a common prototype object.

* All objects are instances

* “Class” relationship is dynamic

* Classless OO can be used to build class-based OO, it is more
inclusive

For Example…

* A few years ago, this would be of academic interest only

* But…

* JavaScript (ECMAScript) is in widespread use, and has classless
OO

¨ “Dice Index” of 964

¨ That’s more than C#, for example

Intro to Javascript

* Not much to do with Java

¨ Name came about from Netscape cashing in on initial Java excitement

* Standardized as ECMAScript

* Current spec version is 1.5.

Where is JavaScript Used?

* Most commonly, in client-side web scripting

* Web server implementations

* Very interesting Web Services toolkit from IBM

* In .NET, ships “in the box”

JavaScript Implementations

* Initial Netscape Implementation

* Rhino (written in Java)

¨ Easy to add script scripting to Java apps

* Mozilla

* IE (JScript)

* Opera etc.

* JScript.NET

JavaScript Features

* Dynamic typing, “duck typing”

* Type-safe (dynamic != unsafe)

* Single Inheritance

* Compiled to intermediate representation

¨ Can JIT to machine code, Jscript.NET

* No Classes, Prototype-based

* Functions are first-class objects

A Constructor is just a Function

* function Employee () {
this.name = “”;
this.dept = “general”;
}

* var x = new Employee; // instance

Constructor Parameters

* function Employee (name, dept) {
this.name = name;
this.dept = dept;
}

Methods

* function WFW() {
return this.wage * weeks;
}

* Employee.WageForWeeks = WFW;

Tighter Syntax for Methods

* function Employee () {
this.name = “”;
this.dept = “general”;

this.WageForWeeks =
function (weeks) {
return this.wage * weeks;
}
}

Subclasses

* function Manager () {
this.reports = [];
}
Manager.prototype = new Employee;

* function WorkerBee () {
this.projects = [];
}
WorkerBee.prototype = new Employee;

Subclasses (deeper)

* function SalesPerson () {
this.dept = “sales”;
this.quota = 100;
}
SalesPerson.prototype = new WorkerBee;

* It dynamic, we can change it later (example)

Add A Property

* Add to an instance:
var jim = new Employee;
jim.years_of_service = 12;

* Add to all instances:
Employee.prototype.phone = “”;

* (example)

AOP

* Aspect Oriented Programming

* With a prototype-based, dynamic language, we can add wrapper
/ “advice” etc. without needing new language features or compilers.

Singletons etc.

* There are many times in class based languages where you define
many of classes and create 0 or 1 instances of each, to hold some bit of code.

* With prototype-based OO, many of these situations get much
simpler.

OK, So It’s Different, So What?

* Classless teaches us to think about objects first, then classes
later

¨ Behavior, not just data

¨ Sequence Diagrams before Class Diagrams

* I have been building better designs sooner, since learning
JavaScript, even though I don’t use it much.

Back to The Point

* Object Oriented does not necessarily mean Classes.

* Classless OO is a useful model, in surprisingly widespread
use, though not in mainstream enterprise development.

* Nonetheless, understanding classless OO can help you create
better designs in the language you use now

Links

*
xhref=”http://devedge.netscape.com/central/javascript/” mce_href=”http://devedge.netscape.com/central/javascript/”>http://devedge.netscape.com/central/javascript/

Talk Offer

* I need practice giving talks!

* I’ve give this talk, or one like it

¨ In your organization

¨ For Developers, For Managers

¨ No Cost (in town), No Obligation

The End

Slides will be on my site:

* http://kylecordes.com

Wiki PowerPoint Presentation: WikiCCSL.ppt

Or read the text of it:

Wiki: Low Threshold Online Collaboration

Kyle Cordes

Oasis Digital Solutions Inc.

CCSL

Oct. 14, 2003

Yet Another “About Me” Slide

* Developer, “Architect”, Consultant, Trainer, Project
Manager, etc.

* Java, EJB, Oracle, SQL Server, Delphi, C++, Python,
Ruby, EJB, XML, multi-tier, etc.

* Proponent of agile, iterative development

* Oasis Digital Solutions Inc.

¨ Outsourced development and other services

* kylecordes.com

Agenda

* What is a Wiki?

* Examples

¨ Instant Intranet

¨ Web Site

¨ Documentation

* Details and Implementations (the bits)

* Online Collaborative Communities

What is Wiki?

* “The simplest online database that could possibly
work.” – Ward Cunningham

* “Wiki is a piece of server software that allows users
to freely create and edit Web page content using any Web browser. … has a
simple text syntax for creating new pages and crosslinks between internal
pages on the fly.”

* Like a CMS, but simpler

Get To The Point

* Wiki is not the perfect solution to many problems, maybe none
at all

* Wiki is a good solution to many problems

* You can use Wiki to create lots of value for yourselves and
your customers, with tiny startup effort … and starting is often the hardest
thing to do.

Example 1 – Instant Intranet

* Vague, but strong need for a way to share information in a
team / company

¨ No Time

¨ No Budget

¨ No Person to assign to do a bunch of work

* Lots of miscellaneous information

¨ Knowledge Base / FAQs

¨ Developer Data Dump

Non-Solutions

* Lotus Notes?

¨ None of us knew how to use it

¨ Noone in our office had rights to do anything

¨ Hours of meetings to ask and get it

¨ Easier to just forget it

* Official Intranet?

¨ Each change required manual effort from IT

¨ IT too busy to do it, not cost-justified

¨ Easier to just forget it

Solution: a Wiki

* Install a Wiki

¨ 20 minutes, on my own PC, later on a server

* Learn something, type it, share it

¨ it was expensive to learn these things, and really cheap to save
the next person the effort

* Someone asks a question, answer it

¨ “It’s on the Wiki”

¨ “Here is the answer, I added it to the Wiki”

* Other people joined in after a couple weeks

¨ Grew to hundreds of pages

Example 2 – Need a Web Site

* No Time, No Budget, Noone to assign a bunch of work

* Multiple contributors with a few minutes here and there

* Not yet sophisticated enough for a real CMS

Solution: a Wiki

* XPSTL.org

* Can turn off public editing if desired

* Get the info online now

* Add and edit the content over time

¨ Discover the structure also

* Later, a web designer can make it in to a real web site

Example 3 – Documentation

* Our software / services / procedures need to be documented!

¨ No Time

¨ No Budget

¨ No Person to assign to do a bunch of work

* Open Word, start typing?

¨ I can do that, but it’s unlikely the next person will open and add to
it.

Solution: a Wiki

* Power users (and others) can contribute a bit at a time as
they work

* For internal apps, create Wiki links right in the software

* Eventually, hand the accumulated information over to a doc
writer

¨ But still keep a Wiki around to accumulate new information

Where Did Wiki Come From?

* Ward Cunningham created “The” Wiki

¨ “WikiWikiWeb”, Psuedo-Hawaiian for “Quick”

¨ First embryonic version ca. 1991

¨ Lots more broad use ca. 1995

¨ Portland Pattern Repository

¨ Community of Extreme Programming ideas

¨ The Wiki: c2.com/cgi/wiki

¨ Ward is a very, very smart guy.

Wiki Implementations

* Hundreds of them out there

¨ Mostly free

¨ Any language you can think of

¨ Some very easy to install

¨
xhref=”http://c2.com/cgi/wiki?WikiEngines” mce_href=”http://c2.com/cgi/wiki?WikiEngines”>http://c2.com/cgi/wiki?WikiEngines

* Try some out, decide which features you came about, choose
one that has them.

Wiki Implementations

* Ward’s Perl implementation

* UseMod – one Perl file, very easy setup

* TWiki – extremely featureful

* TikiWiki – part of a big package, like “____Nuke”

* ASP.Net Wiki

* PHPWiki

* Hundreds more, many homegrown also

¨ Creating a Wiki is a common “learn a new language” project

Text Formatting Rules

* Paragraphs:

¨ Do not indent, use blank line as separatorTab before

* Horizontal Lines: —-

* Lists: <tab>* item, use more tabs to nest

* Font: indent one space for fixed width font

* “”words”” “““words””” etc for various bold ital etc.

* Some wikis support tables, some HTML, etc.

Links: WikiWords

* PutWordsTogether to automatically create links

* Some users hate that, so some implementation lets you do this
instead: [Link Text Here]

Links

* URLs become links

* Image URLs are shown as the image

Inter Wiki Link

* Haven’t had much use for this myself

Community Issues

* Malicious Users

* Reluctant Contributors

¨ Many people who would be too shy to improve a public page in a CMS, do
so in a Wiki.

* “Mind Wipes”

Anyone Can Edit Anything!

* This can’t possibly work!

¨ But it does work surprisingly well

* Well suited in small groups

* Remarkably, often works well in larger communities

* Changes are recorded (many impls.)

* Plenty of security options in other implementations

¨ Choose the minimal level that works for you, to keep the usage threshold
low

The Wiki Mind Wipe

* Sometimes a user will decide to remove everything they’ve
ever said.

* If it was useful, someone else will probably put it back.

¨ Local Connection: Jeff Grigg

Wiki Vandals

* Some users will post lots of irrelevant, caustic, obscene,
etc. junk

* Others users will remove it

* Ban IPs

* If it happens a lot, use login security, or require changes
to be approved by a trusted user

Wiki Spam

* Users will post advertising as Wiki pages (or in existing
ones)

* Other users, who watch RecentChanges, will delete them

* Logs IPs. Ban them.

* If it happens a lot, use login security, or require
changes to be approved by a trusted user

Wiki Bots

* Malicious Users will write scripts to add lots of junk to
Wiki

* Many Wiki implementations throttle the rate of changes from
an IP to slow this.

¨ But an eager miscreant can get around that

* If it happens a lot, use the same solutions as before

Back To The Point

* Wiki is not the perfect solution to many problems, maybe none
at all

* Wiki is a good solution to many problems

* You can use Wiki to create lots of value for yourselves and
your customers, with tiny startup effort … and starting is often the hardest
thing to do.

Talk Offer

* I need practice giving talks!

* I’ve give this talk, or one like it

¨ In your organization

¨ For Developers, For Managers

¨ No Cost (in town), No Obligation

The End

* Kyle Cordes