In the end I’ve decided that in spirit of the FOSS ideals I don’t have the right to take away something people like and want to use(especially given the fact that they contributed most of the content there) and handed over the domain and the data to Jesse.

WikEmacs has been running for a couple of weeks now under his management and will continue to exist for a long time. If you liked the project I guess this is a good moment to show you love and spread the word.

• 15 new cops(checks)
• Support for disabling cops locally in a file with rubocop:disable comments
• Half a dozen bugs squashed
• Small improvements across the board

I guess the support for disabling cops locally deserves a bit of special treatment.

So here’s the basics - you’re now allowed to enable/disable certain cops (checks) and to alter their behavior if they accept any parameters.

One or more individual cops can be disabled locally in a section of a file by adding a comment such as:

1
2
3

# rubocop:disable LineLength, StringLiterals
[...]
# rubocop:enable LineLength, StringLiterals

You can also disable all cops with:

1
2
3

# rubocop:disable all
[...]
# rubocop:enable all

One or more cops can be disabled on a single line with an end-of-line comment:

1

for x in (0..19) # rubocop:disable AvoidFor

You can see all the gory details in the changelog. I hope you’ll enjoy RuboCop 0.6.0!

Today this tool is a reality - meet RuboCop. RuboCop already covers a significant portion of the Guide, supports both MRI 1.9 and MRI 2.0 and has pretty neat Emacs integration(via rubocop.el and flycheck).

I’d love to see more Ruby hackers check out RuboCop!

I’d love to thank all the great people who contributed code, issue reports and ideas to RuboCop’s development and I sincerely hope many Ruby hackers will find it useful!

There I’ll be sharing with you (hopefully) useful tips and tricks to make your experience with Emacs more productive and more enjoyable.

I hope you’ll like it!

It’s more than apparent at this point that the majority of the Emacs community is happy with EmacsWiki and that’s fine by me. I’ll be closing down WikEmacs after 2-3 months and I suggest that everyone who’s contributed significant chunks of content to it migrate them to EmacsWiki (I’ll personally move everything good I find). I don’t want the work people have done to just disappear.

Given the small interest in WikEmacs I doubt that many will miss it. I thank all the contributors and the supporters of the idea. In the long term it would be better for us to have a single repository of Emacs knowledge, that’s why I decided to terminate WikEmacs sooner rather than later.

I want to extend a big public apology to Alex Schroeder for my harsh criticism of EmacsWiki. One year later I see that stewarding documentation projects and nurturing a healthy community around them is much harder than writing software. I’m but a humble software engineer and you’ll have to forgive me for my misguided actions.

I hope that something good has(will) come up from all this drama. At the very least I urge everyone who cares for EmacsWiki to try and clean up, extend and improve at least a couple of articles on subjects that are of importance to him. I know that’s something I’ll be doing from now on.

See you on EmacsWiki!

WikEmacs is dead! Long live the one true EmacsWiki!

Looking at the official docs you’ll see that juxt takes a set of functions and returns a function that is the juxtaposition of those functions. The returned function takes a variable number of arguments, and returns a vector containing the result of applying each function to the arguments (from left to right). Basically:

1

((juxt a b c) x) => [(a x) (b x) (c x)]

At first glace that probably doesn’t seem particularly useful. Let’s see some practical applications of juxt. What if we wanted to split a sequence into two sequences - one with the values that satisfy some predicate and one with the values that don’t. While there are many ways to do so, juxt offers one particularly elegant:

1
2
3
4
5
6

;; illustration of the general idea
((juxt filter remove) pred coll)

;; separate the even from the odd numbers
((juxt filter remove) even? (range 1 10))
;; => [(2 4 6 8) (1 3 5 7 9)]

juxt is also quite helpful when dealing with multiple map keys:

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

;; extract the values of a couple of maps keys
((juxt :alias :name) {:alias "Batman" :name "Bruce Wayne"})
;; => ["Batman" "Bruce Wayne"]

;; sort a vector of maps by a composite criteria
(sort-by (juxt :alias :name)
         [{:alias "Batman" :name "Bruce Wayne"}
          {:alias "Robin" :name "Jason Todd"}
          {:alias "Robin" :name "Tim Drake"}
          {:alias "Robin" :name "Dick Grayson"}])

;; => ({:name "Bruce Wayne", :alias "Batman"} {:name "Dick Grayson", :alias "Robin"} {:name "Jason Todd", :alias "Robin"} {:name "Tim Drake", :alias "Robin"})

Hopefully this short article has whetted your appetite and you’ll find even more elegant uses for juxt in your code.

1
2
3
4
5
6

(defn drop-nth
  [n coll]
  (->> coll
       (map vector (iterate inc 1))
       (remove #(zero? (mod (first %) n)))
       (map second)))

Let’s try it out:

1
2
3
4
5
6

(drop-nth 3 (range 1 10))
;; => (1 2 4 5 7 8)
(drop-nth 5 (range 1 10))
;; => (1 2 3 4 6 7 8 9)
(drop-nth 5 (range 1 20))
;; => (1 2 3 4 6 7 8 9 11 12 13 14 16 17 18 19)

Looks good to me. Hopefully it will be of some use to someone.

Pressing M-c runs the command capitalize-word, which will capitalize the next word and move the cursor after it. Pressing M-- M-c will capitalize the previous word without moving the cursor.

Pressing M-l runs the command downcase-word, which will lowercase the next word and move the cursor after it. Pressing M-- M-l will lowercase the previous word without moving the cursor.

Pressing M-u runs the command upcase-word, which will uppercase the next word and move the cursor after it. Pressing M-- M-u will uppercase the previous word without moving the cursor.

The classic way to do so (introduced in Git 1.5) would be:

1

$ git push origin :branch-to-delete

So, if I were migrating an application from MySQL to PostgreSQL I might want to delete the postgres branch when I’m done:

1

$ git push origin :postgres

You have to agree this syntax is hardly something one can easily remember(and I’m extra certain nobody would have guessed it on their own). Fortunately in Git 1.7 a nicer alternative to the above command was introduced:

1

$ git push origin --delete branch-to-delete

That’s all from me for today. Now go ahead and delete those unneeded Git branches.

P.S. GitHub users might also want to take a look at this article describing recently added functionality to clean up after pull requests.

1

$ brew install emacs --cocoa --use-git-head --HEAD

Homebrew’s devs have even backported the full-screen patch to Emacs 24.2, so if you’re not very adventurous you can just do:

1

$ brew install emacs --cocoa

Alternatively you can install the Emacs 24.2.91 pretest (or a newer pretest/nightly build) from Emacs for Mac OSX. Personally I recommend this option, since cloning the Emacs git mirror (as homebrew does) takes like forever.

Here’s the beast in action:

This was a short article, but I do hope you’ll find it useful.

It’s time I resume what I started in my previous article documenting my first year as an OSX user a few months ago.

In this article I’ll focus primarily on the applications I’ve adopted during my short time being a Mac OSX user, after being a GNU/Linux user for quite some time before that. The focus of the article will be mostly desktop applications, since the command-line tools are more or less the same in both operating system. I will mention a couple of OSX specific command-line tools near the end of the article though.

Productivity

Office Suite

On Linux I was mostly using LibreOffice (chiefly its Impress module) and while it did get the job done I wasn’t particularly fond of it. At some point I was so frustrated with LibreOffice, that I started running Microsoft Office with CodeWeavers CrossOver for Linux. If you like LibreOffice - it’s available on OSX as well. If you don’t like it - you have some solid alternative available.

First, there is a native port of Microsoft Office for OSX. It’s a far cry from the Windows version of the app, but it does have a few advantages over LibreOffice. If you’re doing a lot of document authoring and editing it might be a good option for you.

The other office suite you might want to explore is Apple’s own iWorks. It has a few distinct advantages over Microsoft Office - you can buy only the apps you need (as opposed to the whole suite), it integrates great with the OS (but that’s hardly a suprise) and it’s much cheaper. I only bought Pages (Apple’s Word alternative) and Keynote (PowerPoint alternative). Pages is a so-so application, but Keynote is simply fantastic. I write a lot of presentations and for the first I actually enjoy the process.

Instant Messaging

Skype

Skype has a native client for OSX, that’s much more stable and featureful than the Linux one.

Pidgin/Kopete

OSX Mountain Lion ships with an app similar to Pidgin and Kopete called Messages (and iMessage in older OSX versions). It supports a plethora of chat protocols, but it kept constantly disconnecting and crashing for me, so I started looking for an alternative. Adium is a great free IM app that supports many protocols and works flawlessly (at least for me), so I’d recommend it to everyone.

IRC

If you’re in the market for an XChat replacement look no further than Colloquy. Personally I used Emacs’s ERC under Linux and continue to use it under OSX as well.

Twitter

Twitter has an official desktop app for OSX, that’s available for free in the Mac App store. It has one notable shortcoming - no retina support. Rumour has it Twitter will kill the app in the future, but it gets the job done for the time being and there are plenty of alternatives lying around.

Browser

The default OSX browser Safari is great and has some fairly unique features like pinch to zoom gesture support (smartphone users will appreciate those). Unfortunately it has a pretty small selection of plugins and might not be well suited for power users. I recommend the use of Google Chrome on OSX, since Firefox really seems to lag in terms of features there (the upcoming Firefox 18 will be the first with Retina support).

Email

OSX’s default application Mail is decent, but nothing more. Thunderbird is available for OSX, but I personally think it’s no better than Mail. My desktop email client of choice is the delightful Sparrow. It’s the first desktop email client I ever liked (I used to check my email with terminal clients and Emacs afterwards) and has great integration with GMail (it even supports GMail’s keyboard shortcuts), Dropbox, Facebook, etc. While it’s a doomed product since Google acquired Sparrow I plan to continue using it in the foreseeable future.

Keyboard remapping

By default you cannot remap that many things in OSX. The small utility KeyRemap4MacBook allows you to do much crazier remappings and despite its name the tool works on all recent Macs.

Virtualization Software

The go-to desktop virtualization solution favoured by most Linux users is VirtualBox and it’s available for OSX as well. VirtualBox gets the job done, but doesn’t even come close to Parallels in terms of performance, stability and integration with OSX. Parallels support for Windows guests is particularly good.

Software Development

Text Editing

Every major text editor has a port for OSX, so things are pretty much the same here. On OSX you’ll also get access to TextMate. My affection for Emacs is widely known though. Excellent Emacs builds are available here and the upcoming Emacs 24.3 will finally feature OSX Lion style full-screen support. If the mention of Emacs and vim scares you I’d recommend trying out Sublime Text 2.

IDEs

Eclipse, NetBeans and IntelliJ are available (no suprise since they are all Java apps) and look and perform great on OSX. There’s also Apple’s own XCode, which I found unwieldy.

Terminal Emulator

OSX comes with a pretty barebone terminal emulator called Terminal. I wouldn’t advice anyone to spent much time with it.

Install iTerm2. It redefines the meaning of insanely great.

Shells

OSX comes with Bash enabled by default, but Zsh is also preinstalled and you can easily enable it by typing:

1

$ chsh -s /bin/zsh

Media

Video player

As in Linux VLC is the king.

Audio player

iTunes fits the bill for a basic music player. I still haven’t found an OSX app which I like as much as Linux’s Amarok and Exaile.

UPnP server

Under Linux I used to use MediaTomb and it performed great. It’s available for OSX as well, but was causing a lot of problems for me, so I finally decided to go with a commercial solution. I heartily recommend Playback. Of course if your media player supports NFS you should go with it instead of UPnP.

File Transfer

FTP

Filezilla is extremely popular under Linux and has a native OSX version as well. Cyberduck seems to be the top choice of OSX users.

Bittorrent

There are plenty of great Bittorrent clients on Linux - Deluge, KTorrent, Transmission, etc. Transmission is the only with an OSX port and it seems that it’s also the only popular OSX torrent client.

Package Management

OSX has no official package managent tool but it has plenty of unofficial ones. Currently homebrew seems to be the most popular option. Its package selection is quite vast and I’ve rarely experienced problems with it. While regular users are unlikely to use anything from outside the Mac App store, developers and power users should definitely check homebrew out.

Command Line

Most of the command line applications that you know and love from Linux are available in OSX (by default or installable via homebrew) as well (but might be slightly different since Linux ships with GNU’s version of many tools and OSX with BSD’s). Here’s a few notable OSX specific commands:

• open - opens a file or directory in the appropriate desktop application

1

$ open doc.pdf

• pbcopy and pbpaste allow you to interact with OSX’s clipboard

• launchctl is a rough equivalent to the service and chkconfig commands on some Linux distros

• fs_usage allows you to monitor your filesystem usage statistics

• system_profiler gives you information about your hardware configuration (kind of like lshw)

Epilogue

This was a whirlwind tour of so many apps. I hope that my superficial treatment of many of them won’t stop you from trying them out. It seems to me that the app selection catalogue on OSX is not as vast as the one on Linux, but there’s also a tendency that established OSX apps are much more polished and reliable.

1

OpenSSL::SSL::SSLError: hostname was not match with the server certificate

when trying to deliver an email with Rails 3. How can I solve the problem?”

Obviously the best solution would be get a valid certificate for your hostname, but sometimes this is not possible or you simply don’t want to bother with this stuff (on your development machine for instance). The solution to the problem commonly suggested is to turn off encryption completely like this:

1
2
3
4
5
6
7
8
9

ActionMailer::Base.smtp_settings = {
  :address              => 'mail.foo.com',
  :port                 => 587,
  :domain               => 'foo.com',
  :user_name            => 'addy@foo.com',
  :password             => 'foofoo',
  :authentication       => 'plain',
  :enable_starttls_auto => true
}

This bit of code represent a portion of your ActionMailer configuration and you’d put it in application.rb or env.rb (where env is something like development, staging, production, etc).

While the solution is OK for development.rb you’d be crazy to use this code in production! Disabling encryption means that your username and password will traverse the Internet in plain text! A simple, but secure solution would be to just disable the certificate validation, without sacrificing the secure connection:

1
2
3
4
5
6
7
8
9
10

ActionMailer::Base.smtp_settings = {
  :address              => 'mail.foo.com',
  :port                 => 587,
  :domain               => 'foo.com',
  :user_name            => 'addy@foo.com',
  :password             => 'foofoo',
  :authentication       => 'plain',
  :enable_starttls_auto => true,
  :openssl_verify_mode  => 'none'
}

This code snippet is mostly the same as the one shown before. The crucial difference is the line :openssl_verify_mode => 'none'.

I hope someone will find this short article useful. Happy hacking!

The traditional solution to the problem is to use a tool like KeyRemap4MacBook to remap the right Option key to right Control and to use a snippet like this to make Command behave like Meta in Emacs:

1

(setq mac-command-modifier 'meta)

This works, but it’s hardly ideal since you’re remapping Option at fairly low level and you won’t be able to use it anywhere as Option.

A much better idea would be to leverage a little know capability of KeyRemap4MacBook (a great program which despite its name works with desktop Macs as well) and map the Return key to Control only when it’s held down (it will behave like a normal Return key in all other situations). The option you’ll have to find in KeyRemap4MacBook is in the Change Return section and it labeled Return to Control_R (+ When you type Return only, send Return).

This approach has several advantages. First and foremost you’re not sacrificing a valuable key like Option. Second - it’s much easier to hit Return with your right pinky than it is to hit Option (especially if you’re using a US layout keyboard - these have long single row Return keys, compared to the short 2 row Returns found on European keyboards). Lastly, if you’ve already remapped CapsLock to Control (like so many people do) you’re getting a pretty symmetrical mapping on the opposite side of your keyboard.

All in all - remapping Return to Control is a huge win if you’re using heavily one of Apple’s smaller keyboards. Of course, if you have the option to use an external keyboard you’d do yourself a solid if you obtained a good full size keyboard like the Das Keyboard.

1
2
3
4
5

;; this will make the symbol my-nasty-variable's value void
(makunbound 'my-nasty-variable)
;; this will make the symbol my-nasty-function's
;; function definition void
(fmakunbound 'my-nasty-function)

The names aren’t exactly intuitive and even I happen to forget them from time to time. Now at least I’ll now where to look for them if that happens again. :-)

In this article I’ll share with you a few tips and tricks about running Emacs under the Max OSX operating system.

Installation

While Emacs is available for installation from various sources I personally recommend you to use the Emacs for Mac OSX binary distribution.

Installation via Homebrew is also a decent option, although it more time consuming.

After the installation you might want to wipe out the ancient Emacs 22 that ships with OSX by default(its presence will only cause headaches, trust me):

1
2

$ sudo rm /usr/bin/emacs
$ sudo rm -rf /usr/share/emacs

Keep in mind that the OSX updates will (unfortunately) bring Emacs 22 back from the dead, so you might consider altering your PATH instead.

Alternatively you can just create an alias in your shell and when you invoke emacs it will run the newly installed version:

1

$ alias emacs="/Applications/Emacs.app/Contents/MacOS/Emacs"

If you installed via Homebrew that path might look like this:

1

$ alias emacs="/usr/local/Cellar/emacs/24.2/Emacs.app/Contents/MacOS/Emacs -nw"

To make it permanent, if using bash, add that line to ~/.bash_profile. zsh users will want to update ~/.zshrc instead.

Full-screen support

The Homebrew Emacs formula includes a patch providing the M-x ns-toggle-fullscreen command for switching between normal and full-screen modes. It works well, but does not provide the typical OS X Lion full-screen app experience. In particular, it remains on the desktop, obscuring non-full-screen applications, rather than moving to its own space. For OSX Lion style fullscreen support have a look at this article.

Another option that you might want to explore is the maximizer utility that brings full-screen support for all Cocoa apps under Lion.

Keybindings

I heartily recommend you to remap your Caps Lock key to Control. This can be easily done via Preferences -> Keyboard -> Modifier Keys. If you’re using a laptop keyboard or the bluetooth keyboard you’ll definitely want to remap your right Option key to Control as well. No one can use effectively Emacs without a right Control key. Remapping it is a bit more involved and requires the use of the third-party utility KeyRemap4MacBook.

On a regular Mac keyboard you’ll probably want to map Command to Meta and Option to Super. On an external Windows keyboard you’ll want to map Command to Super and Option to Meta (on Windows keyboard the Command and Option keys are swapped). Add this to your init.el (or .emacs) file:

1
2

(setq mac-command-modifier 'super)
(setq mac-option-modifier 'meta)

If you often switch between your laptop keyboard and an external Windows keyboard (like me) you might want to define this helper command and bind it to some key combo (C-c w in the example):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

(defun swap-meta-and-super ()
  "Swap the mapping of meta and super. Very useful for people using their Mac
with a Windows external keyboard from time to time."
  (interactive)
  (if (eq mac-command-modifier 'super)
      (progn
        (setq mac-command-modifier 'meta)
        (setq mac-option-modifier 'super)
        (message "Command is now bound to META and Option is bound to SUPER."))
    (progn
      (setq mac-command-modifier 'super)
      (setq mac-option-modifier 'meta)
      (message "Command is now bound to SUPER and Option is bound to META."))))

(global-set-key (kbd "C-c w") 'swap-meta-and-super)

Setting the PATH variable

Long story short - if you’re running Emacs from Spotlight (or any other launcher for that matter) your PATH and exec-path variables won’t be same as the ones in your shell (and that’s every nasty since you want be able to run some external programs from Emacs). The best way to handle this would be installing the package exec-path-from-shell by Steve Purcell.

Flyspell

For flyspell to work correctly you’ll need to install aspell plus a few dictionaries.

1

$ brew install aspell --lang=en

More goodies

If you want to spare yourself part of the headache of configuring Emacs on OSX and get a lot of extra firepower you might want to install Emacs Prelude - an enhanced Emacs 24.x configuration (developed by yours truly) that should make your experience with Emacs both more pleasant and more powerful.

So what are you waiting for? Go ahead, install the little sucker and enjoy your new pry-powered Rails console.

1
2
3
4
5

case object
when Fixnum then puts 'Object is an integer number'
when String then puts 'Object is a string'
when Hash then puts 'Object is a hash'
end

Behind the scenes this is transformed to:

1
2
3
4
5
6
7

if Fixnum === object
  puts 'Object is an integer number'
elsif String === object
  puts 'Object is a string'
elsif Hash === object
  puts 'Object is a hash'
end

A lot of people seem to make the following mistake, so beware:

1
2
3
4
5
6

# WRONG - Class === Class will return false
case object.class
when Fixnum then puts 'Object is an integer number'
when String then puts 'Object is a string'
when Hash then puts 'Object is a hash'
end

Hopefully you’ll find this small tip useful.

Ideally we’d have i18n-ed and localized everything perfectly, but that’s rarely the case. I’d rather have the users see things from another locale than error messages. So how do we do that in Rails 3? It’s pretty simple actually. There are three fallback options we can select and they all require small changes to the application.rb file.

• fallback to the default locale

1
2

# fallback to what's specified in config.i18n.default_locale
config.i18n.fallbacks = true

• fallback to a specified locale

1
2

# fallback to en, regardless of what's in config.i18n.default_locale
config.i18n.fallbacks = [:en]

• specify a fallback map (different fallback locales for different locales)

1
2
3

# missing translations of es and fr languages will fallback to english
# missing translations in german will fallback to french
config.i18n.fallbacks = {'es' => 'en', 'fr' => 'en', 'de' => 'fr'}

Well, that’s the gist of it. Happy coding!

A little more than an year ago I wrote my rant post The Linux Desktop Experience is Killing Linux on the Desktop and for the first time in 8 years I wasn’t a desktop Linux user anymore. I spent about a month wrestling with Windows 7, but let’s face it - Windows is ill suited for professional Ruby programmers like me (and it’s ill suited for most programmers, except maybe Java & .Net I guess).

Anyways, it was never my intention to stick with Windows - I was just doing my Mac due diligence. Now with 1+ year of OSX usage I’d like to share a few things about my experience thus far with you.

From Linux to OSX

The transition was initially painful - I felt very odd dragging app icons to the Applications folder to install them. To be honest I was quite puzzled what was I supposed to do the first time I had to install an app this way (it didn’t have those helpful hints with the arrows most apps do). The Linux distro package management is definitely infinitely better, or at least it seems so from where I’m standing. Luckily for me most of the tools I use are available from the third-party homebrew package manager for OSX. It’s like an extremely basic version of the mighty Gentoo portage, but it generally gets the job done.

On a more positive note - I was impressed with the quality and responsiveness of the OSX desktop and the fact that Emacs keybindings are used by default in its editor toolkit (and strangely puzzled by the lack of right control key - how is one supposed to hit Control + a I dare ask?). One app in particular - spotlight, blew me off the water, especially after having dealt on Linux with crappy clones like beagle in the past. Spotlight can truly find just about anything, was it’s own SQL-like query language and is blazingly fast.

I quickly found a good terminal emulator (that would be iterm2 - it’s actually the best terminal emulator in the world IMHO) and most of the command-line apps I used from day to day were already lying around (after all OSX is Unix) - to my great surprise even stuff like PostgreSQL (only on OSX Server) and zsh came preinstalled. Most of the other apps I really needed had native OSX ports; the others - worthy alternatives.

Having hated OpenOffice.org for many years I was very pleasantly surprised by quality of apps like Keynote & Words.

Being a keyboard chap preaching in the church of Das Keyboard I was a bit underwhelmed by the whole multi-touch mumbo-jumbo at first, but after a while I came to the conclusion that Apple have the only trackpads and mice that are actually worth using (even though I still like using the keyboard way more).

To sum it all up - I got up to speed fairly quickly, but it was a bumpy ride.

Here’s a bit more details…

The things I love about OSX

The Desktop

It’s pretty, it’s quick, it’s stable. It makes KDE4 and GNOME3 look like school projects in comparison. And did I mention that the fonts on OSX are even prettier than the ones in Windows?

The OSX flavored apps

Sparrow is the first desktop mail client I ever liked (shame on you Google for killing it).

iTerm2 is the ultimate terminal emulator. It alone warrants the purchase of a Mac.

Keynote is the best presentation program I’ve come to use thus far.

Parallels Desktop is light years ahead of VirtualBox and KVM (as far as desktop virtualization is concerned).

I could go on a lot like this, but I’ll stop now.

It’s obvious that Mac users have developed a taste in extremely refined software.

Hardware compatibility

If something is supposed to work with OSX - it works superbly out-of-the-box. I’ve almost forgotten now the days of constant battle with crappy hardware. Sleep & Wake just work. Battery life is exceptional (due to very advanced power management capabilities).

Certainly controlling all of the hardware an OS will run on helps a lot, but we still have to acknowledge Apple’s achievement.

Stability

One year, three Macs - only two or three system crashes. For a developer that likes to tinker a little bit more than he should - that’s impressive.

That having said I had some Linux desktops that used run for more than half an year without reboots (and the reboots were often caused by power outages or distro/kernel updates). Linux stability on a (fairly new) laptop? Well, that’s a whole different story…

The things that are OK

The default apps

The apps bundled with OSX are not bad at all, but they aren’t particularly great. Still - Safari is a very good browser, Mail is a much better desktop client than Evolution/Thunderbird, Calendar is a good organizer (but a bit buggy when it comes down to Google Calendar integration), Messages is so-so.

The bottom line is - you can go a long way with the bundled apps, but they aren’t exactly perfect. My advice - shop for alternatives (both open-source and proprietary).

Mac App Store

Decent way to distribute proprietary apps, but with all the restrictions on the app sandboxing there aren’t many interesting apps out there. Hopefully it’ll get better in time. The ability to upgrade your OSX by purchasing the new version from the App Store is very cool (for a proprietary OS of course).

Emacs

The Cocoa port of Emacs is a bit immature and there are some visual glitches here and there (try out M-x linum-mode for instance), but they are forgivable. I’m also missing the deep integration Emacs had with Linux. And who the fuck designed all the official Mac keyboards without a right control key? I finally understood why so many Mac users where on vim :-)

Btw, remapping the Caps to Control is not the answer. I do it now, I did it on Linux as well. You simply not supposed to hit Control + any other key with the same hand. It’s disruptive to your typing… But then again - you should probably do most of your typing will a full sized keyboard :-)

Software Development

OSX doesn’t nurture software development as much as Linux does, but it comes pretty close in second place. All the tools you know and love are available, but their installation & setup is a little bit more involved on OSX. There is a reason why the screenshots in most programming books show OSX.

System administration

Definitely a step back from Linux. Programs like launchctl (for instance) are not exactly fun to work with, but they do get the job done. I’d never use an OSX box for anything more than a desktop workstation. Setting up a sensible $PATH is not as trivial as it was on Linux either (/etc/paths and some plist I forgotten come to mind).

The things I hate

The special keys

Not exactly an OSX feature, but still…

One year and I still hate Command and Option - option is basically Alt on a strange location and Command is totally useless IMHO. I’d probably wouldn’t have hated them as much if there were room left on the Apple keyboards (expect of course the old wired Apple keyboard) for an addition control key. Luckily for me I use an external Das Keyboard Ultimate most of the time…

Command and Option do have some value, I’d probably would have appreciated it if they didn’t come at the cost of my beloved right control (which I guess only Emacs users are missing anyways).

No standard all mighty package manager

On Linux I had aptitude, yum, portage and pacman - all amazing at what they do. On OSX - homebrew is a decent option, but it’s a far cry from the might and magic of the Linux package managers. Still, homebrew is better than it’s alternative, so beware!

Ugly XML config files

Here and there in OSX you have to write some appalling XML config files. I thought I’d never see the likes of those again after I put Java development behind me :-)

XCode

You need to install a giant lame IDE just to get a bunch of command line development tools? That’s one of the most annoying things I’ve encountered up-to-date in OSX.

Yep, I know about the tools being available separately for couple of months now, but requesting an Apple developer registration just to get them seems a bit to much to me.

Epilogue

Am I happier now without Linux? Definitely! Is OSX a better OS than Linux? Absolutely not! It does have a much better desktop experience and since I spend most of the time on a computer interacting with the desktop - that’s a big win for me. Of course I wouldn’t mind seeing Linux achieve this level of desktop maturity and stability.

Should you dump Linux and join me in darkness? How the hell should I know? :-) I’m just sharing my two cents - if you’re happy using Linux you should definitely stick with it. Obviously I wasn’t and there weren’t that many alternatives lying around.

Not having to deal with hardware problems and immature desktop apps is like a breath of fresh air and it more than compensates for the few shortcomings of OSX. Nothing compensates the lack of that right control key on most keyboards, but after all that’s not an OS problem ;-)

There is great vibrant hacker community gathered around OSX and it’s one of the main driving forces of the OS. There is unfortunately a lot of corporate pressure from Apple as well, but as you already know by now - there are never perfect things, there are always compromises. I’d rather use a proprietary OS that stays out of my way, than a free OS into which I bump at every turn.

Soon I’ll blog a little bit more about the practical aspects and implication of the migration. Cheers, mates!

P.S. I’ve updated the original post a bit to reflect some of the initial feedback I received.

One of the harder parts of the journey to Emacs mastery is remembering all those keybindings at the beginning (C-h t), which can be really overwhelming. To make matters worse for many common commands there are two sets of keybindings - the Emacs ones (that are touch typing friendly) and the popular ones (that typically involve the use of the arrow keys). Most people never get to use the proper keybindings and forever make use of the arrow keys.

To help Emacs newcomers get used to the proper Emacs keybindings I’ve created guru-mode - a simple minor mode that will show you a (helpful) message in the minibuffer every time you try to use a non Emacs way keybinding.

It will probably annoy you a lot in the beginning, but trust me - it’ll be worth it in the long run.

guru-mode comes bundled with Emacs Prelude and is available for installation from Marmalade and MELPA.

P.S. True Emacs mastery cannot be achieved if you do not practice touch typing; if you’re doing hunt-and-peck typing you’d better fire up the venerable gtypist before looking at guru-mode.