Installing Pharo on the Server

Table of Contents:

Step 1: Set up your hosting server / OS – Ubuntu 12.04 LTS x64

For hosting, I went with a Digital Ocean VPS instance. The amount of RAM, disk space, bandwidth and processing power you can get for $5 to $10 US a month can’t be beat.

With this host, you select your operating system up front, and they create it from a ready image in a very short amount of time (with my previous host, it booted up to “bare” hardware with an Ubuntu install CD in the emulated disk drive, and so installation took a while).

OS-wise, I went with Ubuntu 12.04 LTS x64. Ubuntu because of familiarity and ease of dev tool installation, 12.04 LTS (Long Term Support) for its mix of newness, stability and long term security patch support, and the 64-bit version because the Riak db only runs on 64 bit systems, and that’s what I want to use for my Smalltalk persistence layer (via the Phriak library).

I’m pretty sure you can make all of this work on CentOS / RedHat, but I’m less familiar with those distros, and plus going with Ubuntu meant I could make use of the nice pre-packaged Pharo VMs, as you’ll see below.

Step 2: Install the Pharo VM

There are several ways of installing Pharo on a Linux server — see the Installing Pharo in Many Flavors post for a discussion.

However, the apt-get install method on Ubuntu is the most straightforward for beginners. (A huge Thank You to Damien Cassou and Nicolas Petton for making available the Pharo Ubuntu packages! These make server-side installation much easier.)

For instructions, I went with the recommendations from the Pharo on Ubuntu guide.

Enable the add-apt-repository command:

sudo apt-get install python-software-properties

Add the Pharo PPA (custom package archive):

sudo add-apt-repository ppa:pharo/stable
sudo apt-get update

Install the server-side version of Pharo. (Meaning, only pharo-vm-core, not the pharo-launcher:i386 package).

sudo apt-get install pharo-vm-core

You can see all of the files installed by pharo-vm-core via:

sudo dpkg -L pharo-vm-core:i386

The binary that you will be executing will be in:

/usr/bin/pharo-vm-nox

Note: -nox means “No X Windows”. Meaning, this is a server-side pharo, without any GUI components.
Also, you can view the help files from the command line:

man pharo-vm-nox

Step 3: Upload Your Seaside Image

Now that Pharo is ready to go on your server, it’s time to upload your deployment image.

First, locate your deployment image on your development machine.
On Mac OS X, the image is located in:

[Seaside install/download folder]/Seaside-3.0.7.app/Contents/Resources

Copy the image to the server using scp. For example, I would use:

scp ~/Seaside-3.0.7.app/Contents/Resources/Seaside.1.image my-username@xx.xx.xx.xx:/home/my-username/

Step 4: Start Pharo

Finally, to launch the Pharo VM and point it to your image:

pharo-vm-nox ~/Seaside.1.image

This will load the image from my user home, and start the Seaside web stack listening on port 8080, by default.

Of course, this is merely the basic concept of launching Pharo, for tutorial purposes. For a production application you would want to ensure that Pharo is started via a system service. In addition, you would want to put a web server such as Apache or Nginx in front of it, for security and load balancing purposes.

Advertisements

Packaging Your Squeak/Pharo Image for Deployment

Table of Contents:

There are two schools of thought, as far as preparing a Smalltalk image for deployment to a remote server:
1) Start with a minimal clean image, and only load the libraries and classes that you’re actually using to run your application.
2) Take your development image, and strip out unnecessary applications, GUIs, and the development environment itself

The first method is slightly more difficult but very rewarding, especially if you’re going to go the Continuous Integration route (via Hudson/Jenkins), because it requires you to know exactly which packages you’re using, what they depend on, the load order, and so on. We will explore this approach in later posts.

For this tutorial, though, we’ll use method #2, with help from the Preparing for Deployment chapter of the Seaside book.

Things to Remove for Deployment

  1. The Developer Toolbar
  2. All the default applications (except our Hello World one).

First off, what is the Developer Toolbar? It’s the dev mode menu that Seaside automatically inserts at the bottom of your applications, to help you with configuration, session resetting, and so on, and it looks like this:

seaside_dev_toolbar

You definitely want to disable it when deploying your application to a production type server. Fortunately, the code that unregisters all of the extraneous default applications (see below) also removes the dev toolbar.

First, unregister all applications with Seaside (to view the list of the applications that are installed, pull up http://localhost:8080/browse)

WADispatcher default handlers do: [ :each | 
   WADispatcher default unregister: each ]. 

Next, re-register our Hello World app, since that’s what we actually want to deploy:

WAAdmin register: RHelloWorldComponent 
  asApplicationAt: 'helloworld'

Now, double-check that our application is running on our localhost server at http://localhost:8080/helloworld, and that the others (such as /config or /browse, aren’t).

The last step is to save the image. I recommend the Save As route, so as not to overwrite your development image — left-click on the Pharo desktop to bring up the World menu, select Save As:

seaside_world_menu
And pick a name for the new image, such as:

seaside_save_image_as

Now your image is ready to be shipped to a remote server for deployment.

Interlude: How to get a remote server (for Seaside deployment)

Table of Contents:

For the purposes of this tutorial, I’m going to walk you through setting up Pharo on a remote Ubuntu Linux server. This, of course, requires first getting such a server. The easiest (and cheapest) option that I’ve found is to get Squeak/Pharo running on a low-cost Virtual Private Server (VPS).

Here’s what I want you to come away with: Hosting for Seaside is fairly easy, and within your reach.
And, it is no different than hosting options for other (non-PHP) languages, such as Ruby, Python or Java. If you’re a hobbyist developer, or just want to test it out, there’s free options available. If you’re a pro, you can get a (virtual) remote server with full shell access for very little, for just $5-20/month, USD, or an actual physical server for about a hundred a month. Pair that with basic Linux sysadmin skills, and you’re good to go.

Low Cost Options – Virtual Private Servers

Getting yourself a Virtual Private Server hosting account is the easiest and cheapest way to get started with deploying your apps (in any sort of dynamic language). This is what I use, myself, at the moment.
Advantage: Low cost, you have full root access to the OS
Disadvantage: Self-managed (you have to provide the system administration), low disk space (compared to dedicated servers — VPSs have from 10-50Gb of disk space), slower (than dedicated physical servers)

For hosting, I went with a Digital Ocean VPS instance. The amount of RAM, disk space, bandwidth and processing power you can get for $5 to $10 US a month can’t be beat.

I polled my web app developer friends recently, as to what sort of hosting service they use (they are mostly Ruby and Python developers). They also use VPS hosting, with either Digital Ocean, or Linode (there was one person using Slicehost, but they were switching to Linode). Out of those, Digital Ocean has the best value, although Linode has is more established and highly regarded for business use.

Low Cost Options – Cloud Hosting

Pharocloud looks very promising. They are attempting to provide the same level of ease and convenience for Smalltalk developers as Heroku does for Ruby/Rails developers. The important feature here is that they also provide persistence services (Postgres, etc) for your Pharo/Seaside/whatever images.

Amazon Elastic Compute Cloud (EC2) For not much more cost per month than a medium-size VPS, you can also deploy your Seaside application to the cloud, which gets you load balancing, unlimited scaling capability, and more.
Deployment to EC2 – Resources:

Medium Cost Option – Dedicated Servers

If you need fast performance, and lots of memory and disk space (and you’re a professional developer or a small company), you have to go with an actual dedicated physical server at a colocation facility.
Fortunately, these are still fairly inexpensive (compared to what they used to cost even a few years ago). You have two options:
Unmanaged Servers (they give you a physcal box and remote access, just like with a VPS, and you provide the system administration). DedicatedNow has unmanaged servers for $99 USD/month (this includes a 2-core CPU with 2Gb RAM and 2Tb disk space), and Westhost has a slightly less beefy server (with 500Mb ram) for $95/month.

You can also choose Managed Servers, where the host provides you with a box and performs system administration for you, guarantees your uptime and manages your security. DedicatedNow has a managed server (with 4Gb RAM!) for $200 USD/month.

Free Options

If you just want to try out the Smalltalk/Seaside deployment process and you do not want to pay, or if you’re developing a free service, you have a number of free options.

Seaside Hosting offers free 256MB hosting partitions for non-commercial Seaside applications (see the chapter on deploying to SeasideHosting of the Seaside book, and the Seaside hosting Pharocast). This is where the official Seaside site is hosted, for instance.
Advantage: It’s free, and they’re knowledgeable about Seaside.
Disadvantage: For non-commercial apps only, 256MB disk limit, no shell access or access to databases (so, you basically store your data in the image). See also this StackOverflow question, Can I host a SandstoneDB on SeasideHosting.st? – and the upshot is, no, you can’t at this point.

Free Shell Access
There is also a number of places that provide you with free hosting accounts that you can SSH into — see the Free Shells List or just google for ‘free shell’ access. For free, these are obviously going to be small and underpowered hosting accounts, with not much memory, diskspace or bandwidth provided. But, they are full on development environments, with database access and everything and you can get Squeak/Pharo to run on most of them.
The only one of these free shell services I have experience with is the SDF Lonestar organization – and hey, it does what it says on the box.
Advantage: Free. Full SSH access, databases
Disadvantage: Slow, resource restrictions (RAM, disk space, bandwidth), and there may be issues with Terms of Service restrictions

Open Source/Community Applications
One more thing. If you have no budget, but you’re developing a free and helpful service that might benefit other people, don’t despair. Develop it, and put it up on a free hosting service above for beta testing. When you outgrow free hosting and need more power (or disk space, or bandwidth)… you should just ask. Seriously, if you’ve come up with really good software that benefits people, the community can probably find hosting for you. Ask on the mailing lists (Seaside, Squeak, Pharo), ask individual developers or universities… Doors will be opened to you.

Creating a Seaside “Hello World”, localhost

Table of Contents:

Note: This section assumes that you’ve mastered the basics of creating new classes and methods in Pharo Smalltalk. If not, I recommend you glance through the Paro By Example, or my own previous post on Creating Classes and Methods in Pharo.

Note 2: See also the Getting Started (Pharo and Squeak) section of Dynamic Web Development with Seaside for a similar “getting started” tutorial, with screenshots.

Time to create our first “Hello World” app in Smalltalk/Seaside. Here’s the plan:

  1. Create a new Category and component (read: class) for our app.
  2. Create a method to output ‘Hello World’
  3. Register the component with Seaside, so it can start routing requests
  4. Profit! (That is, load up the page in the browser, and behold Hello World)

1.a. Creating a Seaside Component – The How

Creating a Seaside component is easy. First, create a Category for this tutorial – something like ‘RHelloWorld-Core’. Now, inside it, create a class (a subclass of WAComponent) called, for example, RHelloWorldComponent. Like this:

WAComponent subclass: #RHelloWorldComponent
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'RHelloWorld-Core'

That’s it. You’re a third of the way done (now we just need to create a method to output ‘Hello World’, and register the component with the framework, so it can start routing).

1.b. Creating a Seaside Component – The Why

So, what is a component? A Seaside component is a subclass of WAComponent (the “WA” stands for “Web Application”, incidentally). Great, but what is it really? To answer that, we need to briefly discuss how you write web apps in Seaside.

Think of a component as a “smart view”. What about Models, though? And Controllers? Well, components that are complex enough to need models, have models. That is, Models are also a concept that Seaside uses. Since we’re just writing a static “Hello World” app, we don’t need a model, we’re just going to output a literal string directly. What about Controllers, though? Don’t we need a Controller? Well, no. Not as such. Part of the answer is – Seaside (and the programming language itself) IS the Controller. It takes on the traditional role of the controller (routing requests, calling the right objects and methods, managing sessions and marshalling parameters). Seaside also has Tasks (subclasses of WATask), which are view-less control and routing objects that manipulate other components, a job traditionally reserved for Controllers in the MVC paradigm. But again, we don’t need Tasks for a Hello World tutorial.

The easiest way to understand Seaside web development is to think of it in terms of traditional desktop GUI development. Say you open up a desktop application, like Firefox or Outlook Express. You see a window, and within it, panes and toolbars, and within those, buttons and lists and other GUI widgets. In Seaside, the application/”window” is a top-level Component, which displays sub-components (toolbars, navigation menus, panes). In a desktop app, the components keep track of their own states (and have models if need be), and have Events/Actions defined for when you interact with them (click on a button, scroll the scrollbar, and so on). Same thing in Seaside. So a Seaside app is “just” a nested collection of components, which keep track of their own states, and which register events or actions that are performed when a user clicks on a link or selects a value from a pulldown, and so on.

If that’s too confusing, or if you haven’t done desktop GUI programming, don’t worry about it. In Seaside, you’ll be dealing with Views, Models when you need them, and occasionally view-less controller-like Tasks.

2. Create a method to output ‘Hello World’

Ok, let’s create a method in our RHelloWorldComponent class. (You can either put it in the default --all-- method category, or, more correctly, create a rendering method category, and add the method there).

renderContentOn: html
	html text: 'Hello World!'.

3. Register RHelloWorldComponent with Seaside

Lastly, we need to register our component with Seaside (specifically, the Web Application Admin class), so it can start routing requests to it.

Execute the following snippet of code:

WAAdmin register: RHelloWorldComponent 
	asApplicationAt: 'helloworld'

Hold up. How do I execute code in Squeak/Pharo?
You can execute code from any code editor or workspace in the Pharo image. Traditionally, snippets of code (or “incantations”) are executed from a Workspace window, which just looks like a blank text editor window. To open one, click anywhere in the background of the Pharo window to bring the the World Menu, and select Workspace. You’ll see a blank text window. Now you can type arbitrary code in here, select it with your mouse, right-click on it and select Do It (d). The keyboard shortcut is Meta-d, of course.

Ok! Now, when you access the /helloworld url on your web server (in our case, running it by default on the desktop, it will be http://localhost:8080/helloworld), Seaside is going to locate the RHelloWorldComponent (since that’s what we registered as the top-level component of our application up above) and execute the renderContentOn: method.

Test it out – load it up in your browser, and you should see

Hello World!

displayed on a plain white html page.

Coming up next: Obtaining access to a remote server, installing Pharo on it, and packaging up your app for deployment.

Deployed Hello World – Installing Seaside and Squeak/Pharo Basics

Table of Contents:

Time to install Seaside. If you go to Seaside Download page (and click on the Seaside for Pharo Download link), you’ll see that there are several options. The easiest one is the Seaside One-click Experience — as I mentioned in the last post, this comes with a VM for your operating system, sources, and an image that comes with Seaside installed, and a web server started and ready to go as soon as you open up Pharo. This is the option you should go with — click on the latest one (at the time of this writing, it’s Seaside One-Click Experience 3.0.3).

Where should I unzip the download file? Squeak/Pharo is self-contained, so it doesn’t matter where you install it, it’s not going to make any Windows Registry entries or anything like that. I usually place it in C:\Pharo on Windows, or in my user directory on Linux.

To Launch Seaside: (after unzipping it into a Pharo folder) click on the folder, then on Seaside.app, then on Contents, then on the folder appropriate to your operating system, then on the executable.

If the VM is in Contents\Windows\, where is the image that I’ll be launching? The image lives in Contents\Resources. The default one that launches when you double-click on the executable is Contents\Resources\Seaside.image.

Go ahead and double-click on the executable and open Pharo. (On Windows, you will likely be prompted by the OS to permit the application to open a port — that’s the web server starting up). You will see three things — a server control panel, conveniently started for you, a code browser window, and what looks like a text file but is actually a full-fledged Workspace in which you can execute code (more on those later).

Where is the menu bar? File, Edit, Windows, Help, etc? Squeak/Pharo does not have the traditional menu bar running across the top that you see on most applications on Windows, Linux or Mac. It’s kind of like Emacs in that it tries to be its own universe (although even Emacs has menu bars on most latest versions). However, what you do have is the World Menu — click on any empty spot within the Squeak window (the squeak “desktop”, if you will), that is, anywhere not on the code browser or workspace, and you will see a popup menu titled “World”. This is essentially your menu bar, and contains the items you’d expect, Help and Windows commands, preferences, and so on.

Now the vi/Emacs question – how do I save and exit? Easy enough – click on an empty space on the Squeak desktop to bring up the World Menu >, then Save or Save and quit.

Wait, if I hit World Menu > Save, and then World Menu > Quit, why does it ask me if I want to exit without saving? Didn’t I just save? Yes, you did just save, so everything’s ok. It’s just being extra paranoid. If this disturbs you, then use the ‘Save and quit’ option to do both in one step, and then it won’t prompt you with that question.

When I click on the X icon to Close Window and exit, why does the prompt say ‘Quit Croquet without saving’, instead of Quit Pharo? That’s minor bug in the current release that I’m sure is left over from merging some of the code from Croquet into Pharo, ignore it. Actually, the Croquet Project is a fascinating VR/realtime collaboration project that’s implemented in Squeak, and is worth checking out.

OK, so how do I edit code? The last basic thing you need to know is how to actually edit code from within Pharo. Click over to the code browser window (it’ll say WACounter on the title bar — that’s the name of the class it’s browsing). Now click anywhere on the code and add an extra space or a return somewhere, just to have edited it. (Btw, see how the upper right corner of the code window turns orange? That’s how you know this method has been modified). Now, to save edited code, press Alt-S (I think it’s Cmd-S on Mac). (Why does Squeak use Alt-S instead of the more traditional Ctrl-S to save a window/buffer? I’m not entirely sure, but you can change this behavior in preferences (switch how Squeak handles Alt and Ctrl keys) to be more familiar for Windows/Linux users — I’ll explain how in the next post).

When you hit Alt-S (Squeak documentation will refer to this as Meta-S (Emacs users will find this familiar), so as to be consistent across operating systems), an Information Required prompt will pop up and ask for your name. Why does it do this? Because all code edits get saved in a version log (you can see this by clicking on the Versions button above the code editing area), and entering your name allows you to identify the code edits as yours. (When you start using source control tools like Monticello, this name will be used to sign your code changes). Think of it as the @author tag in the JavaDoc tool.

Important note: Meta-S just saves the code changes to a single method within the live image, it does not save the image itself. You still have to go World Menu > Save to save the whole image to disk, before you exit (or commit your changes to a version control system, once you start using one).

How do I open another code browser window? Go to World Menu > System Browser and that opens up a code browser window (incidentally, you can switch between the open windows in Squeak by pressing Meta-Left or Meta-Right keys, kind of like switching tabs in Eclipse or Firefox).

Ok, you now know enough to be dangerous to write code. Next up, a quick note on customization, and the on to the Hello World web app in Seaside.

Which Smalltalk?

[Edit: Updated February 2014]

When starting any project, a developer has to navigate a tree of choices. Which programming language do I choose? Which distribution? Which editor or IDE should I use with it? Which operating system should I target? Sometimes, the decision is easy since the environment is dictated by management: we’re a C# shop, so fire up VisualStudio on Windows and go. Or, we’re using Ruby, so pick your favorite code editor (TextMate, vim, Emacs, Eclipse) and you’re off, since you’re limited to pretty much one official Ruby distribution. Same with Python, or Perl — pick an editor and your favorite *nix OS (Windows support is more shaky for all these scripting languages), and you’re set. Sure, there are often experimental or alternate VMs and interpreters, but the mainstream production choice is clear.

Not so with Smalltalk. Much like with Lisp, a casual user first approaching the Smalltalk world is faced with a bewildering variety of Smalltalk versions. Which distribution and virtual machine (and therefore a slightly incompatible dialect and set of libraries) should you choose?

Fortunately, a bit of research narrows down the choices. Especially if you want to use the Seaside web development framework. Your options are:

Commercial Smalltalk Vendors

Open Source Smalltalk Projects

  • Squeak Smalltalk
  • Pharo (forked from Squeak in 2008, to take the project in a more Enterprise direction, and still under very active development)

Let’s run down the choices that I made in starting this project.

Q: Which programming language? A: Smalltalk
I have worked with Smalltalk for over 9 years, both as my day job (writing desktop applications in Visual Smalltalk and Cincom’s VisualWorks), and as a hobby (exploring Squeak Smalltalk). Though I have also worked on commercial projects using Java, Perl, PHP, Python and Ruby/Rails, I have not found anything in those worlds resembling Smalltalk’s powerful IDE and ease of debugging. Though the other languages enjoy a wider base of developers, open source projects, and third-party library support, the experience of working with Smalltalk (and Seaside) is profound, freeing and satisfying.

Q: Which Smalltalk? A: Pharo Smalltalk
Although the GLASS platform intrigues me, I don’t have much experience with it. And, given a choice, I always prefer to work with open-source technology rather than commercial distributions, hence the choice of Pharo (which I feel has more long-term longevity and openness) over VisualWorks (even though that has better commercial support, I don’t want to deal with license fees at this stage in the project).

So why Pharo and not Squeak? Although I’ve worked with “plain Squeak” for a number of years, the Pharo fork seemed like a reasonable choice, since it was chosen to be the reference implementation for the Seaside platform (perfect, exactly what I need it for). While I originally made this choice around 2009, having watched the Pharo community grow and blossom over the years, I do feel that currently (as of 2014) Pharo is the overwhelmingly correct choice (for web development).

Edit: The original reasons that I posted for choosing Pharo were:

a) removing unessential code from Squeak (Squeak, having started as a children’s education project, has accumulated a fair amount of cruft over the years), b) clearer licensing (MIT license), c) more frequent updates (think Ubuntu versus Debian), and d) being a reference implementation for the Seaside platform (perfect, exactly what I need it for).

However, as this thread on Pharo-Project mailing list pointed out, most of them are incorrect. My apologies for misunderstanding — I got those reasons from the Pharo Wikipedia entry when I came across the Pharo fork, and was trying to figure out whether to switch or not.

Q: Which version of Pharo? A: Pharo 2.0 (with testing on 3.0)
As of Feb 2014, Pharo 2.0 is the “current/stable” version, and 3.0 is undergoing active development. So far, I have not seen too many problems with interoperability, so I generally develop on 2.0, and make sure the tests pass on 3.0.

Q: Which IDE? A: Pharo
Unlike most programming languages, the code editor and IDE is often built into the distribution/VM (though the IDE code can be stripped out when getting a VM image ready for deployment). This may sound strange, but it buys you incredible debugging and refactoring powers. Like in Lisp, both the source code and the (on-the-fly) compiled methods and classes are first-class objects, so with a single keystroke, you can do things like “Show me a list of all the methods called from this method” or “Give me a list of all the other places in the code this function is called from” — something that has to be approximated with full-text searches in other IDEs and environments.

Q: Which operating system? A: Doesn’t matter, actually
Most of the main Smalltalk distributions are cross-platform, with the virtual machine and IDE working almost identically on Windows, Linux and MacOS X. Currently, I do development on Mac OS X or Ubuntu Linux (depending on which machine I’m working on), and deploy to a web server running Ubuntu.

I hope this sheds some light on this very individual set of decisions. One last thing I’d like to reiterate: If you’re new to Smalltalk and Seaside, you essentially can’t go wrong with the main distributions (VisualWorks, VA Smalltalk, GLASS or Pharo). All are excellent cross-platform environments, and the choice between them comes down to commercial support, licensing fees (and, in the case of Gemstone, whether or not you need a first class object-oriented database).

Welcome – Seaside Thoughts and Tutorials

Welcome. Over the course of this blog, I would like to share my thoughts and experiences on web development on the Seaside framework using the Smalltalk programming language.

My current project is to implement a Web MUD (an excellent example of this genre is Kingdom of Loathing), a text-based persistent online game with a web interface, using Riak as a persistence engine. But specifically, this blog focuses on general areas of interest to current Seaside users, and those interested in learning more about this amazing and flexible framework.