On walkabout in life and technology

BBEdit Lives Long and Prospers

On Twitter today:

Celebrating back to school? Most of today's undergraduates have never lived in a world without BBEdit.

All our attention is focussed on the race-to-the-bottom, in-app purchase rip-offs or the current fad app, but we forget that software, well-built and well-maintained software, has no shelf life.

I still use BBEdit every day. It still doesn’t suck!

Kudos to Rich Siegel (@siegel) and his team at BareBones for consistently making such an amazing and useful application.

FYI: The long, stable history of BBEdit is on it’s Wikipedia page. Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

Intentional Complexity

John Duns Scotus' (1265-1308) book Ordinatio: “Pluralitas non est ponenda sine necessitate”, i.e., “Plurality is not to be posited without necessity”

William of Ockham’s Razor, modern science version: “The simplest solution is often the best.”

Intentional Complexity is a manufactured situation where product configuration and operation are intentionally made difficult. It occurs when a software vendor exposes all the innards of their products to systems operators and end users.

It’s great for marketing to Managers and sales to CTO’s, but it’s rubbish for operations and business. In this post I will talk about what this is, why this is, how it comes to be, how this is bad for you and the fleeting signs of improvement that I am seeing.

But first, how does one detect it?

How is Intentional Complexity Presented?

Just look any marketing for enterprise systems and you will see some classic CIO friendly phrases (which I shall translate for you):

  • Fully Configurable - there are hundreds of settings you can change, but only a few combinations really work, we just don’t know which.
  • Fully Customizable - you can change how the system works using code (or pay us lots of money to ‘mod’ the system) and then you’ll have to wait for us on each upgrade to create the ‘mod’ for that too.
  • Fully Featured - we have so many features that you can use (and very likely will never need) in the product that we need lots of menus, toolbars, icons, fields and wizards just to get our heads around it, we have no idea how you will.
  • Integrates with any Product - even more settings and parameters to enable you to integrate this system with others, where settings are visible for all potential integrations, and only a few settings really work.
  • Supports -INSERT LIST HERE- protocols - if you think we have a lot of settings now, just wait until you see all the settings for all the protocols we support that you will never need or use but some small firm in Botswana needs.
  • Installation included - The product is so complex that we could not create a setup program for it. You need specialists just to install it and to create the initial settings.

If you buy a piece of software that can do anything, expect it to be able to do nothing out-the-box. You will need to configure it, customize it, choose the features to use, set up your integrations and choose your protocols, and then, only then, will it start working.

Software that can do anything is made intentionally that way, and is therefore intentionally complex to set up and use.

What is Intentional Complexity?

So what does this really mean? Well, lets take something as simple as setting up a Wi-Fi network. All you really need is to set the network name, the access user name and a password. That’s not complex at all.

But nooooooo, almost all Wi-Fi router setups also involve choosing frequencies (2.5GHz or 5GHz), channels (0-11), choosing protocols (B, G, N or a combination thereof), choosing the type of encryption of the password (WPA, WPA2, WP-SEC) and choosing the IP network range. That is some serious complexity. The router is fully capable of knowing which frequencies are better, which channels are less crowded, supporting the necessary protocols as and when they crop up, choosing the best encryption and making sure the network range does not conflict.

But the designers of the router have chosen not to make these decisions for the user, they have made it intentionally complex to force the user to make these decisions.

I am not saying these decisions should be taken away from users, just that they should not be forced on users. An advanced user should still have the ability to access the complexity and change things. But a regular user, or lazy advanced user like me, should be able to do the least amount of work and still get it up and running quickly.

Why create Intentionally Complex Products?

There are a lot of reasons for complexity in products, including:

  • Customers have different needs and if a vendor wants to sell its product to them, it needs to support those needs.
  • Customers have different workflows and processes which require configurable flows within the product.
  • Customers run different product mixes which requires complex integrations to be created.
  • The problem the product solves may be complex, requiring complex interfaces.
  • There may be thousands of users or millions of transactions, requiring complex webs of software and hardware to keep it all flowing.

Complexity in itself is not a bad thing when the problem space is, in fact, complex.

But why intentionally create complexity?

  • One reason is the expectation that enterprise software needs to look and feel complex. Selling what looks like a simple product against a what-looks-like-complex product is hard.
  • If you are selling your software for a lot of money, you want the customer to perceive they are getting value for that money. Intentional complexity makes your product look just that more expensive because it has just that more visible stuff in it.
  • If you sell your software to professionals or experts, you think you need to give them all the power you can, which means exposing the innards of the product. That decision to expose the guts of the product intentionally creates intentional complexity.
  • To encourage the vicious circle of training and sales. If you can train professionals to use your complex product, when they consult or change jobs, they will want to leverage that training for more money, leading to more sales. And customers who buy these products need these trained professionals to use these products. Cisco was very successful with this strategy with its IOS routers and certifications. So is Microsoft and Oracle and SAP. Their intentionally complex software requires certified professionals, and their certified professionals push their products.
  • Simple image and exclusivity. People who understand and use intentionally complex software feel smug compared to the rest of us who do not. Just try getting a SAP or Certified Network Engineer to speak in normal, it just does not happen.

How does Intentional Complexity even happen?

This is where is starts:

  • Marketing wants to compete feature-for-feature with a competitor which means the developers need to intentionally add features just for marketing.
  • Sales wants to sell to the largest audience which means selling the product to customers who have different needs, or may be in even different industries, requiring additional complexity in the product.
  • Product design has no idea what they are creating so they create a product that does everything and hope something sells.
  • Management hears an idea at the golf course and wants that added to the product.
  • Customers who have no intention of buying say they just have to have a feature, so that gets squeezed into the product, just for a sale that will never happen.
  • New business partners and vendors enter the market, requiring developers to create new interfaces for them, just in case a customer one day, someday, maybe needs them.
  • Customers want new features to mod the product for their needs, leading to more and more settings and changes to the core product. And as they upgrade, these mods become core.
  • Technology changes, protocols change and to remain relevant, the software has to support these new changes, while not losing support for old technologies and protocols.

But the main reason Intentional Complexity remains is this: nothing gets removed. Excuses range from the difficulty in removal to backwards compatibility to just-in-case to some random customer still uses this feature. Which means all current and future customers have to intentionally bypass this feature every time they use the system.

And then there is the straw-man argument that users should be able to use the product their way and systems operators should be able to set the product up they way they want, so the product should support that. The software should be un-opinionated. Just because users can set something up some way does not mean that they should.

There is an army of certified professionals who run around setting things up the most complex way because they can, not because they should and not because that’s the best way for the business. Staff and consultants want to create job security and Intentional Complexity used just right can guarantee that.

Why is Intentional Complexity Bad?

Once again, in this post, I am not arguing that complexity is good or bad, just that Intentional Complexity is.

  • Companies need certified and trained personnel to do what they need on the product. These people usually cost more and are harder to find.
  • It takes a lot more time to set things up because systems operators have to go through all this complexity just to get it started.
  • It takes an even longer time to figure out when things go wrong because the fault may lie in any of a hundred places or with different people or vendors.
  • Once it’s working, it encourages people to resist change because the complexity of the system makes change difficult or risky.
  • It’s confusing as anything as to how to get things done, how things are done, how things have been done and how things should be done. The too many choices that Intentional Complexity leads to difficulties in deciding what to do and how to set things up.
  • It enables customers to continue to run their businesses using inefficient workflows and protocols which are supported by the intentional complexity of the system, instead of running optimized better workflows supported by a simpler, best-practices system.
  • It requires a lot of time and effort to train staff to use the product.
  • Users use a small portion of the product because it’s too hard and complex to use other features, or the user simply has no idea the feature exists, it gets lost in all the Intentional Complexity. Consider something like MS Word which is an intentionally complex word processor where 99% of users use less than 5% of its features yet have to wade through 100% of its features to do so.
  • And people start to base software and implementation decisions on myths and on institutional knowledge (which is basically just a memory of what worked at least once before) because these intentionally complex products do not indicate in any way what is better.

Is anyone trying to be less Intentionally Complex?

Fortunately, there is light at the end of this tunnel. Cisco’s incomprehensible iOS and CNE’s have been replaced at the bottom and medium ends with very easy to use web interfaces on their routers. SAP has created a significantly simpler version of their product for smaller and medium businesses by removing thousands of unnecessary settings and complexities. Citrix has created an easier to use GUI for their Xen virtualization servers, hiding the complexity of their maddening command-lines.

But some have not. Microsoft continues to add Intentional Complexity to Windows server and management infrastructure. ISP’s and colocation firms still need CNE’s to get things going. Accounting products get more and more intentionally complex by the day. And the ultimate in intentional complexity, Bloomberg, remains the grand master.

What can we do?

We, the users and the buyers and the writers of checks, have to start to demand simpler, easier to use systems and products. We need to demand routers that are self configuring, we need to demand the removal or hiding of unnecessary features in products, we need to adjust our own workflows and choose the simpler products that support those flows. We need to push our vendors into making the 5% of the product we do use into the best 5% of the product and to hide the rest. We need to standardize our interfaces and all write to the same integration formats.

We need to break the mindset that Intentionally Complex software is better than complex software where the complexity is hidden behind intelligent defaults or unnecessary complexity is removed.

We need to realize that we do not do things that much differently to everyone else and that all this intentional complexity required to support our perceived uniqueness is unnecessary in the product, bad for business and bad for all our users and partners.

Unlike Occam’s Razor, the simplest solution may not be the best, but the most intentionally complex one is certainly always the worst.

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

ChronoSync Back to My Mac

TL;DR: You can use ChronoSync to access a remote ChronoAgent if Back to My Mac is turned on for both computers. Which means you can sync from anywhere!

I have been using the excellent ChronoSync for years to ensure that the Documents and Projects folders on my personal laptop are kept in sync, and therefore backed up, with my home OS X server.

These days I have two laptops, the personal one that lives at home and is used for Noverse work, and the work one for my day job at the fund. But sometimes when a Noverse Client calls, I’m at the office and do not have access to my personal laptop which contains their software and files.

When this happens, I use Back to My Mac to access my home server, download their files, do the work, and then manually upload them back (see below how to do this, it’s pretty easy).

But it takes time, time away from real work to do this upload and download every time. It would be better for them – and me – if my Noverse files were also kept in sync on my work laptop. And it would be even better if I could do this when not at home.

So a few days ago, I brought the work laptop home and set up ChronoSync on my work laptop. The plan was to sync at home in the evenings and if any Noverse work needed to be done, I’d have close-to-the-latest files to work with.

I started to enable the sync of Documents and Projects folder on the server to a Noverse sub-folder … and stumbled across an interesting feature. Since I use ChronoAgent on my server to speed up syncs, it turns out that the work laptop “saw” the server ChronoAgent both on the LAN and on Back to My Mac. Which means it can sync from anywhere!

How cool is this.

Here is how to set it up.

Note: You do need ChronoAgent set up on the destination computer for this to work!.

In ChronoSync, go to Preferences and choose the Connections tab. While on the home LAN, click Add:

As you can see, there are two references for Kepler (the name of my home server):

  • ChronoAgent@Kepler, the usual LAN ChronoAgent, and
  • Another ChronoAgent@Kepler with XXXXXXX.members.btmm.icloud.com as its domain. That’s the Back to My Mac one. I set this up as a new connection called KeplerRemote.

Then in the sync documents, I simply used the new KeplerRemote agent connection instead of the regular Kepler agent connection:

Now I can sit at the office, or in a coffee shop, and use ChronoSync to sync files between my work or home laptop and the home server via Back to My Mac! No more wasting time downloading and uploading when a client calls!

Top Tip: Use ChronoSync’s built-in scheduler to schedule these syncs regularly and you can forget about worrying whether you have the latest files again.

Aside: Finding your Back to my Mac ID

In order to use this, you will need a home Mac that remains turned on with:

  • Back to My Mac enabled on the home computer. Make sure System Preferences / iCloud has Back to My Mac checked and that there are no warnings.
  • Both computers (home and laptop) are signed in to the same iCloud account.
  • You also need Back to My Mac enabled on the laptop.

ChronoSync automatically finds the Back to My Mac address for you. But if you just want to ssh in or mount your shared folder remotely, you will need your unique iCloud URL. To find out what your unique address is, open up the Terminal.app and type

$ dns-sd -E

You should get something like this:

DATE: ---Thu 15 Aug 2013---
23:22:04.315  ...STARTING...
Timestamp     Recommended Registration domain
23:22:04.315  Added     (More)               local
23:22:04.316  Added                          icloud.com
                                             - > btmm
                                                - - > members
                                                - - - > XXXXXXXXX

Where XXXXXXXX is your unique ID.

Your home computer name is then:

<computer name>.XXXXXXXXX.members.btmm.icloud.com

To mount a drive, launch Finder and press ⌘K to bring up the Connect to Server dialog and type in your computer’s URL. Note that you must have File Sharing checked in System Preferences / Sharing on the remote computer for this to work.

Click Connect to see your shares at home.

For ssh, make sure the home computer has Remote Login enabled and the command is:

# ssh user@<computer name>.XXXXXXXXX.members.btmm.icloud.com

Happy remoting.

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

The Little Touches

It’s the little touches that turn ordinary products into great products.

For years I have been using Power2000 NiMH batteries and their chargers that I get in Japan for use in my camera’s Flash. I use these because they really hold a charge and can handle the burst heat from a Nikon flash unit. And they store a lot of energy so they keep on flashing.

So when I moved to an Apple Wireless Keyboard and Magic Trackpad, I naturally pulled one of these sets out to use. I loaded a fully charged set of 4 and off I went.

Unfortunately, the trackpad and the keyboard discharge at wildly different rates. Which means that the trackpad ran out far sooner than keyboard did. Since I did not have any spare batteries, I either had to wait the several hours to recharge the two from the trackpad, or raid some out the camera (which meant the flash was unusable).

Most chargers come with 4 batteries.

The Apple Battery Charger comes with six.

Yep, six.

Two for the keyboard.

Two for the trackpad.

And two to be charged while the in-use ones discharge.

The simple act of adding two more batteries to the set means we no longer need to scavenge batteries when recharging or worry when one device runs out of power. There is always a charged set available to swap in.

Two additional batteries. Such a little touch. Such amazing benefit.

Only $29.99 on the Apple Store (not affiliate link).

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

Gist TextMate 2 Bundle Updates

New updates to the Gist.tmbundle for TextMate 2:

  • Changed the launch key from ⌃⌘G to ⇧⌃⌘J as it interferes with the Find and Replace All (the TextMate 2 defaults changed)
  • Am now having GitHub guess the language of a “Gist from Selection” by taking the file extension from the source file you copied from and using that in the pushed file name. Was hoping to use the scope language but could not figure how to get that and map the right extensions for GitHub. This works though.

The update should flow through the TextMate 2 updates process in due time.

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.


There are two ways to deal with “the ways things are” in an environment where one can change them:

  • Find some way to justify or meekly accept them, however twisted and delusional they may be; and try to get on with things within those perceived constraints. They call this being reasonable as if it were a good thing.

  • Or find a better, considered, simpler way for things, which requires effort, argument, time, and sometimes blood; enabling one to actually get on with things with fewer constraints. They call this being unreasonable is if it were a bad thing.

The reasonable person in this context makes up, believes and is required to publicly support their own justifications. The reasonable person believes “The boss is always right.”, or “They pay me to do, not to think.” or “I’m sure there is a reason why I have to perform this mind-numbing process.” or “We’ve always done it that why, so if it ain’t broke, don’t fix it.” They assume that they cannot change “the ways things are”.

Sounds pretty unreasonable to me. It’s a cop-out. Bad for the person, bad for the business. I am a boss, and I am most certainly not always right! And many many processes have no purpose at all.

Progress, innovation, change, joy and great software depend on being unreasonable. They depend on thinking about what one does, questioning it, challenging it. They depend on identifying the underlying assumptions and justifications and then tearing them apart, regularly. If the “way things are” stack up after that tremendous attack, then maybe, just maybe, they can stay, for now. But the “way things are” rarely do.

Thanks to the unreasonable people out there we have an Internet and mobile phones and rovers on Mars. Thanks to the reasonable people out there we have bureaucracies and paper forms and religions and borders.

In my case, it was not reasonable to strive to gain an education that got me out into the world, it was not reasonable to go and live and work and experience life on three continents after leaving my original one, and it was not reasonable to design and create innovative hedge-fund systems for my bosses. The reasonable thing to do was to stay where I was, live where I was and do what I was told.

Boring. Sad. What a waste of a life it would have been.

Now is not the time to get all reasonable again and protect the status quo. It’s time to get more unreasonable, to accelerate the rate of change and innovation. It’s time to rethink everything, challenge all assumptions, tear down all rote justifications. We have the technology, the knowledge and the ability.

And I for one look forward to what we unreasonable people can come up with. There is nothing we unreasonable people cannot change, improve or fix if we set our minds to it.

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

Quick Process Search

I am forever starting and running background UNIX tasks, either manually or via cron jobs. And I am forever checking to see if they are running or not.

The usual command I used to use see if a process was running is

ps ax | grep bash

Where bash is the process that may or may not be running. It gives (headers added):

  PID TTY         TIME    CMD
  411 ttys000    0:00.04 -/bin/bash
  615 ttys001    0:00.04 -/bin/bash
  773 ttys001    0:00.00 grep bash

There are some issues with this:

  1. For long commands with redirections in them, it truncates the command at the width of the terminal (80 columns).
  2. I invariably then go looking at other utilities for memory or CPU usage, so there’s not enough information.
  3. The grep itself is found, adding another line to the output.
  4. Too much to type all the time, I am lazy.

A better version is:

ps auxwww | grep bash

This gives user, pid, memory and CPU as well as the full command line (headers added):

hiltmon          411   0.0  0.0  2433436   1600 s000  Ss    7:44PM   0:00.04 -/bin/bash
hiltmon          768   0.0  0.0  2432768    596 s001  R+    7:52PM   0:00.00 grep bash
hiltmon          615   0.0  0.0  2433436   1604 s001  Ss    7:48PM   0:00.04 -/bin/bash

Much better. But even harder to type. And it still contains the grep line.

So I created a bash function in my .bash_profile to make it easier:

# PS with a grep
function psax() {
    ps auxwww | grep "$@"  | grep -v grep

Now I just type:

psax bash

to get a nice clean result:

hiltmon          411   0.0  0.0  2433436   1600 s000  Ss    7:44PM   0:00.04 -/bin/bash
hiltmon          615   0.0  0.0  2433436   1604 s001  Ss    7:48PM   0:00.04 -/bin/bash

Top tip: A lot of people use this to get the pid’s of processes in order to kill them. All distributions now come with the killall command, so it is even easier:

killall stunnel

Kills all known instances of stunnel that you can kill.

The psax function has been added to all my logins, and I use it a lot!

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

Laravel 4 Blade TextMate Bundle

In the comments of My TextMate 2 Setup, reader Bob Rockerfeller wondered if the Sublime Text Laravel 4 Blade bundle could be ported to TextMate 2. So I did.

It was easy because Sublime Text uses TextMate’s .tmLanguage file format for syntax highlighting. I just created a new bundle using the Bundle Editor, created a new Syntax file and pasted in Eric Percifield’s (@medalink7) code. Then tested it with the example in his repo.

You can download the bundle here: Laravel Blade.tmbundle.

To Install: Unzip the file and double-click the Laravel Blade.tmBundle icon to have TextMate install it for you. Alternatively, drag and drop the Laravel Blade.tmBundle to ~/Library/Application Support/Avian/Bundles/ folder.


Disclaimer: I don’t use Laravel, I just use TextMate 2. All the good work in this bundle was done by @medalink7, thank you, I just packaged it into a TextMate bundle format.

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

The Work Computer Software Loadout

I got Back in the Saddle over three weeks ago and purchased a new Haswell 13-inch MacBook Air as my primary work computer. I plan to write more about it after at least 30 days use. But with the new computer, my plan was to only install that which I needed as and when I needed it. It turns out, I use a lot of different tools for work activities.

Note: No affiliate links were hurt in the creation of this post, all links are to the vendor’s sites, so it’s safe to click through to learn more about each product.

Primary Uses

The primary uses for this work computer are:

  • Programming new systems using a myriad of languages and tools, mostly via terminal, TextMate 2 and Xcode, to be run on Centos Servers against many different database servers. See A Simple C++ Project Structure.
  • Designing the new systems, from mind mapping, through diagramming, through wire-framing and artwork creation and, of course, writing documentation.
  • Maintaining a bunch of older web applications and moving them to newer technologies (and creating a bunch of new ones)
  • Systems administration of the servers, databases and routers of the business
  • The usual work-like things such as emails, contacts, calendaring and communications

Launchpad Pages

Page 1 of my Launchpad contains all the default Apple applications, with the addition of iWork and Xcode:

Quick notes:

  • Safari is my primary web browser
  • Mail is where I run all my email accounts
  • iMessage is running for chats and IM
  • Contacts manages my address book
  • Calendar stores my calendar, but I use Fantastical on the menu bar to manage it
  • Keynote is the only iWork app I have used so far on this new machine

Page 2 and 3 contain all my third party applications. Yes, in alphabetical order of course!

Dock and Menu Bar

For the apps I like to drop things on or click to launch, and really because they have just habitually been on the dock:

  • Finder, always first
  • LaunchPad, because I forget what I have installed
  • Mail, for all accounts
  • Safari, for all web browsing
  • Google Chrome, for when I need flash or an alternate login to the same site
  • iTerm 2, for all my local and remote terminal needs
  • BBEdit, for notes and text manipulation
  • TextMate 2, for programming
  • Tweetbot
  • Kiwi
  • iMessage
  • System Preferences, because I always forget they are on the Apple menu
  • OmniFocus, to see what to do next

I could, and will, remove PixelMator, VoodooPad and the Qt system as I am not using them anymore (replaced by Photoshop, BBEdit files and new code). I’d also would dearly like to toss Microsoft Office, but the finance industry runs on it and there are some files only it can open.

The two things that I am missing natively is a a copy of XenCenter that runs on OS X to manage server virtualization, I need to run that on a VMWare VM; and a native SQL Server database access tool. If I find a good one then Xamarin and Mono can go as well. Too bad SQL Grinder died with the Objective-C/Java bridge.

Using all these tools, I have been able to launch straight into the work at the new firm, and start off very productively. There is not much I cannot do with this loadout and laptop.

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.

Fast SSH Windows With iTerm 2

I have a bunch of Linux boxes that I need to access via SSH, whether to install things, start or stop processes or browse log files.

But it is a pain to have to launch a new terminal window and type in the whole SSH command line:

$ ssh hiltmon@servername.domainname.local

Yep, I am that lazy. Or really, I do this so often I needed a faster way to do this.

Enter iTerm 2 profiles with shortcut keys. You can SSH to any of your servers by pressing a single keystroke, cool huh? For example, to access my Farragut server in a new iTerm 2 tab, I press ⌃⌘F, to access Hipper, ⌃⌘H. Here’s how to set it up.

Using iTerm 2 Profiles

In iTerm 2 preferences, access profiles and add a new profile. I name these after the my server colloquial names (because who can remember those IT names like XYZZYDEVDBWX907.domainname.local).

Set the shortcut key you want to use, and input the full SSH command:

ssh -R 52698:localhost:52698 hiltmon@servername.domainname.local

The -R port mapping enables me to use rmate from these terminals.

And that’s it.

To activate a new terminal tab and SSH into that server, just press the shortcut key.

Bonus Top Tips

I change the PS1 on each server to show the colloquial name, so at a glance you can see which server the terminal window represents. Add the following to .bash_profile or whichever file configures your shell (In this case, the colloquial name is Farragut):

# \u -> user, \W is basename, the rest are terminal colors
PS1='\[\e[0;35m\]\u\[\e[0;33m\]@\[\e[1;34m\]Farragut:\[\e[0;33m\]\W \[\e[0m\]\$ '

Which gives us this:

I also slightly change the terminal background color and the colors used in the prompt, not enough to make it garish, but enough to tint the black and change the look. That way my eye can sense different terminals by the slight color variances as well.

Other Options

You could use TextExpander macros, but that requires you to create a new terminal first, more keystrokes. I used to do this until I found these profiles.

If you have Keyboard Maestro, you could create AppleScripts to create new terminal windows and launch SSH sessions.

If you have Alfred 2 you could use scripts in workflows to launch a new SSH terminal.

Or you could even use the free Shuttle app that puts your list of SSH sites in your menu bar.

Or just use iTerm 2’s profiles.

Is it not wonderful that we can each find our own way out of an unlimited number of ways to do the same thing, and all be cool about it.

Related Reading: Make iTerm 2 more Mac-like

Follow the author as @hiltmon on Twitter and @hiltmon on App.Net. Mute #xpost on one.