Intertube Traveller

5 Useful Browser Extensions for Web Developers

jonas.a@revrise.com (Jonas Arnklint) — Sun, 15 Jul 2012 00:00:00 +0000

jsonview, stylish, 1password

On the theme of productivity and effiecency... I´d like to share the extensions I use daily to get more productive and do less stuff, while achieving even more.

Most extensions that I´ve installed tend to fade away and never gets used. These are the grain of gold of browser extensions for programmers that has stayed with me.

Web Developer

Available in Chrome and Firefox, Chris Pederick´s browser extension Web Developer is a perfect multi tool for developing the web. Easily disable cookies, images or JavaScript. One click to clear browser cache and validate everything from CSS to HTML. In short, a must have if you do client side programming.

LastPass and keepass can be considered as good alternatives also providing browser extensions for the same problem.

JSONView

Whenever doing an AJAX call or browsing an API through HTTP GET´s in the browser JSONView really comes in handy, formatting and making json more readable in the browser.

Stylish

Easily style any site the way you want and persist that style. Sort of like Greasemonkey/Userscripts (which works out of the box in Chrome), but for CSS. Create and manage CSS rules for matching URLs. Useful when performing repetetive tasks without scripting on a site. Removing noisy elements on sites that is used often, or trying out (persistant) styles on a project of yours, without deploying any code.

1Password

This is not just an extension, but also a great app for storing and managing passwords securely. It is a paid app and browser extension that comes to handy whenever i use a browser. I´ve used 1Password since their launch, but mostly since they launched the Chrome extension. This is not solely aimed at programmers of course, but a must have for security reasons for everyone.

Vimium

Being a bit of a geek when it comes to IDE´s/Text Editors, VIM is and has been my first choice the last couple of years. Since faster navigation is one of the pros using VIM, the same keystrokes and navigation methods can be applied in the browser. The usual HJKL is implemented as well as Insert mode and find. Give VIMium a go!

Tips appreciated

I´ve only touched on the surface of browser extensions for Web Developers. The less extensions I´m dependent on, the more I can focus on stuff that matters. It tends to be the same for me when it comes to programming or developing products.

However, those few golden grains in your toolbox can be hugely valuable and stay with you forever. So, please tell me which extensions I´m missing here.

What makes a good Web API?

jonas.a@revrise.com (Jonas Arnklint) — Mon, 07 May 2012 00:00:00 +0000

Building a great API is a hard task. There are many pitfalls to avoid to succeed and since (hopefully) your API will be a dependency for many systems, you will want to try to hit it hard right from the start.

During QCon San Francisco 2011 Evan Cooke, co founder of Twilio presents a great talk involving Web API's and how to make them awesome.

This makes a good API

In the talk Evan cites Joshua Bloch from Google who suggests that these points makes a great API:

Easy to learn
Easy to use - even without documentation
Hard to misuse
Easy to maintain the code that uses the API
Powerful enough to satisfy the requirements
Easy to extend
Appropriate to audience

Continuation

jonas.a@revrise.com (Jonas Arnklint) — Fri, 04 May 2012 00:00:00 +0000

We are working hard to get to Form Analytics out of the door into the real world. Early mornings and late nights. We put a large part of our life into something we cannot physically touch or hold in our hands. We are creating something new that hopefully brings a huge value to our customers. Every now and then, a bit of doubt comes knocking at our door, while happiness and satisfaction comes knocking the next day. Creating something innovative is an emotional rollercoster.

Blind folded

Sometimes when working on the same product hour after hour, you tend to stop seeing the real value it actually provides to the world. You stop seeing the benefits of using it. You might even start doubting about its existence and all the hours you put into it.

This is what I believe just a sign of pure sanity. It is perfectly normal to doubt. Just as long as you stay with it and continue the long path to happy users and a great product.

You can doubt as much as you want as long as you continue building an amazing product. ~ J.A.

We are humans and when building something innovative, ground breaking never seen before kind of product you should embrace the fact that this is a journey. A long lasting journey towards more satisfaction and a better world to live in.

Please do continue

I've had some minor previous success with a couple of projects, but they tended to fade out and I lost motivation for them. I doubted, I beleived in better ideas, I started seeing new opportunities.

Those were the exact reasons to why those projects failed in the end. I lost motivation and stopped working on them. The continuation was gone.

Lets face it. The only way to not succeed in something is to give up and stop making it happen. This goes for all of us. Whether you are a creator, inventor, developer, employee, boss or a baby bird in its nest.

Most fellow entrepreneurs experience the same, so don't be afraid.

So my advice to myself and to you, fellow creator, inventor and human;

Have doubts, be happy, be sad. Feel fear for failure, opportunity for success.

Using VIM Buffers

jonas.a@revrise.com (Jonas Arnklint) — Mon, 23 Apr 2012 00:00:00 +0000

Thinking of buffers in vim as tabs when using Textmate just made so much sense. So much sense that I wanted to write down the basics for me to come back to. Here are some few tips on how to use them to work efficient in VIM.

Buffers?

I think of buffers as references to the files you are working with currently. Try visualizing opening a file in a Textmate project. It becomes a tab and when opening another file, that too becomes another tab. So for me buffers in VIM is like tabs in Textmate, but not as visible or noisy.

List buffers

:ls - list all buffers
:b [tab] - display all buffers
:b my[tab] - display buffers whos filename starts with ´my´

Navigate between buffers

:e#5 - go to buffer 5
:b5 - go to buffer 5
:b# - Switch between two buffers

Delete buffers

If you want to delete a buffer in vim (like closing a tab in TextMate eg):

:bdelete [buffernumber or filename]
:bd - a shorter version

Next I´ll try to figure out how bookmarks works.

Prowl Node.js API

jonas.a@revrise.com (Jonas Arnklint) — Sat, 21 Apr 2012 00:00:00 +0000

PUSH notifications are all good and all. But do our products in RevRise really need them? We´re in the middle of making the last couple of changes to Form Analytics and I´m evaluating a couple of additions to it.

Testing PUSH notifications in a prototype/early stage product

When evaluating stuff, you might want a cost effective and quick to setup solution. Let´s realize that you don´t code an iPhone app to test the behaviour/response of PUSH notifications IRL. No you don´t. However, there is actually an app for that.

I quickly stumbled upon Prowl which is like Growl, but for iPhone. Through its HTTP REST(ful) API you can send PUSH notifications to iPhone/iPad with the prowl app on them.

Since the biggest part of our stack rely on JavaScript, I decided to make a sweet little Node.js library for sending PUSH notifications via Prowl.

Meet node-prowl - the Node.js lib for Prowl

It´t super easy to use:

var prowl = new Prowl('MY-API-KEY'); prowl.push('YO, this is awesomez!', 'My app', function( err, remaining ){ if( err ) throw err; console.log( 'I have ' + remaining + ' calls to the api during current hour. BOOM!' ); });

Install it by:

npm install node-prowl

It's as simple as that!

Find the docs and source in its repository.

Tagging version in Git

jonas.a@revrise.com (Jonas Arnklint) — Wed, 18 Apr 2012 00:00:00 +0000

As the work with the Node.js wrapper for our public API at RevRise has got on, I just realized that tagging versions in git is super important in the aspect of package managers.

How to tag versions in Git

This is my first public node package, that is already used by a number of clients and therefore it is extra important to keep it versioned.

Let´s get going:

$ git tag -a v0.0.3 -m "Bumping version"

View tags by:

$ git describe --tags

And show the actual commit by:

$ git show v0.0.3

To finilize:

$ git push --tags

Voila!

Decision Making

jonas.a@revrise.com (Jonas Arnklint) — Wed, 21 Mar 2012 00:00:00 +0000

Everybody have to make them, we make them all the time, some turn out to be the right ones and other do not. Decisions are there to make them.

Decisions! Can't make them. Can't not make them. Can't not not make them.
— Eric Wahlforss (@ericw) November 7, 2011

Different types of decisions

There are different types of decisions to be made in your life. Those that don´t matter, those that really matter. Those that take time and those that don't take any time at all to make.

Wether deciding your meal at the restaurant or choosing city to live in the next couple of years, they have one thing in common. You do have to make them. So lets make them fast, trust our instincts and learn from the wrong decisions you will make.

Most of my friends tends to spend more time comparing different meals on a restaurant than buying that expensive pair of jeans, which is kind of strange when looking at what resources (money) that you spend in either case.

How to make decisions

The people I know that have been successful in one way or another, tend to make fast decisions. They decide based on current situation and context and then simply move on. If it turns out to be the wrong decision, they choose a different path. The important thing is to make them and move on.

Thinking about it made me realize that

Most decisions do not turn out to be right or wrong until after you made them.
Humans think all decisions matter equaly. That's not true. Think of this the next time ordering food or choosing walking path in the woods.
In most cases you are able to change your decision after some time.
Think of it as A/B testing. Try one path and change if it you have to later on.
Do, Fail, Iterate. The worst thing that will happen is that you learn from it and gain experience.

The Nine Month Entrepreneur

jonas.a@revrise.com (Jonas Arnklint) — Wed, 22 Feb 2012 00:00:00 +0000

Today exactly one year ago I was on the same flight as I am now, meeting up with the same friend down in Stockholm as I was then, on the same trip to Chamonix, France as I was then. There is only two major differences from one year ago. I'm staying in Chamonix and my friend has just made his first exit.

The bet (exit before 30)

There is this Jazz bar in central Chamonix, France where me and my very good friend just had had a couple of beers and sat down talking about life and the future. We were there on a much needed vacation from work and every day life. On friday, this was exactly one year ago.

One year ago

Since I started consulting five years ago, I've always had ideas and a hard time not thinking about them. I've had my own company since 2004 and think of myself as one who solves problems and make life easier for other people. I was constantly on hacker news, or reading about startups, tech and opportunities to do just that. Solve problems. Even during vacation. Because I loved it.

My friend was completely the other way around. He never thought about the latest javascript framework or tools that could help you solve problems. He had ideas, but no urge to execute them. He had always been an employee but was a bit tired of being one. I don't know how many times during that week he told me to chill out, stop browsing Hacker News and read a book...

The local beer in chamonix is a lighter one with a taste that my friend loves. After a day in the slopes those taste just great.

There is a jazz/funk bar in central chamonix where we went one night drinking a couple of those white beers. A common theme of discussion for this trip was our future lives and entrepreneurship. I had just had a life changer and my friend was just about to get over his. I remember how we spoke jokingly about how great it would be to live in Chamonix and how your quality of life would increase. How you would wake up in the morning looking out from the balcony into a horizon filled with mountains and peaks. We could ski during daytime only on days when the weather conditions were perfect and the snow was of highest quality. And during the rest of the days and during night time, we could work from a small office in central Chamonix. Hacking away on our next big saas-app. What a way to live your life!

That evening in the bar we also made jokes about who was going to be the first one of us doing an exit. We asked ourselves how our lives would be different in just one year.

And here we are, exactly one year later. My friend is in the middle of making his first exit, which in total has taken him nine months from an idea to a product used by numerous client mainly in Scandinavia. His team has not only executed beautifully and built the product, they are actually selling it already!

I'm living in a chalet on top of that very same jazz/funk bar in Chamonix. Hacking away during night time and skiing during the day. I've incorporated a startup around e-commerce and web analytics which has just seen some of its first traction!

Sometimes you have got to take one step back, to get a clear view of life from another perspective than you always look through and make bigger decisions about how you really want to live it. Say no, don't be afraid of variation because usually that is only healthy. Don't be afraid to combine life style with your startup because if you want to continue doing the things you love, health, motivation and fun will be key.

Update: I got their press release which you'll read here.

Saying No

jonas.a@revrise.com (Jonas Arnklint) — Wed, 25 Jan 2012 15:14:14 +0000

The hardest thing is, when you think about focusing, is saying no.

~ Steve Jobs

Some may have realized this a long time ago. But I know quite a few freelancers in my business having a hard time keeping a balance of work load. This includes me.

Keeping work load down and having a balanced schedule is key to keep happiness, health and well being.

Greediness

Sure, saying no can be really hard. I find that most of the times I say yes to work it’s about greediness. You just want more and more money or credit for something you create. In some ways this can be a good thing that maybe motivates you, allthough life would indeed be dull if the only thing that keeps you motivated was money.

Fear

Strangely fear has struck me when making desicions about work. I’m really afraid that if I say no this time, the client will never hire me again. Thinking this way will soon burn you out. The imminent likelyhood of you doing a good job somewhere and word of mouth begin spreading while you keep saying ‘yes’ will force you to work long hours, having less fun at work, evolving slower and so on. This is wrong.

Saying no to something just allows you to spend time and focus on more important stuff.

Never too late

A great friend of mine once told me that “It’s never too late to say no”. Soon thereafter I took on a job with a lot of risk which eventually resulted in a complete failure.

If I could have said no even a week in or two, I’m sure the client and myself would have been a lot more happier with the end result than we are now. I won’t go into details, but hey, we all make mistakes right.

Even if you have already said ‘yes’, you can always say no.

Creating Quality is About Focus

It takes a great amount of effort to create something of great quality. It also takes a lot of focus. Since I started consulting about four years ago, I’ve always tended to have lots of ideas and a lot of different duties, working on two or three projects in parallel.

This is really good if you want to produce work of low quality but on a greater scale. You’ll never become an expert if you do this. You’ll only keep struggleing when planning your days and get lots of interruptions that will cost you even more focus and time.

Promise yourself to dare saying no. Increase your hourly rate if money is an issue, but make sure to produce good stuff. That is what will differentiate you from the others.

So before I go and say no to a big deal, this sums up my thoughts on the issue quite well:

We’re always thinking about new markets we could enter, but it’s only by saying no that you can concentrate on the things that are really important.

~ Steve Jobs, Business Week (12 October 2004)

'load' vs 'require' in Ruby

jonas.a@revrise.com (Jonas Arnklint) — Fri, 26 Aug 2011 00:00:00 +0000

Another 'note to self'. This time it's about Ruby.

load 'file.rb'

This needs the extension to be supplied, reads the file's content each time it is loaded, no matter how many times it is. And you can load a file from another directory simply by providing a relative or absolute path;

load '../file.rb'
load '/home/deploy/file.rb'

require 'file'

No file extension should be supplied
Only reads the target files content the first time.

Minimal Rake Deploy Task

jonas.a@revrise.com (Jonas Arnklint) — Sun, 10 Jul 2011 00:00:00 +0000

A great professor that I had during my studies at JTH always said that while a Volvo kept on running smoothly, a Ferrari would need service every 500 kilometer just because of its refined design of the engine and other parts.

I think the same goes for code. Basically, whenever you bring in an extra third party library or a gem as we, ruby people, might call them, you tend to add complexity and dependencies.

Skipping capistrano for small projects

Take Capistrano for instance. A great gem for deploying apps to remote servers. It has a ton of support for different scm's and stuff and does a great job doing what it is supposed to do. However, when analysing what I tend to use it for nowadays, I realized that I basically only push production code to a bunch of servers. I never rollback, as all the apps I'm dealing with has staging environments, where those issues will be noticed first.

So why not skip capistrano and go with good old Rake instead? This even saves you time on each deploy:

desc "Deploy the application"
task :deploy do
  commands = [
    "cd /apps/my_app",
    "git fetch",
    "git reset --hard origin/production",
    "git submodule init",
    "git submodule update",
    "mkdir -p tmp",
    "touch tmp/restart.txt"
  ]
  exec "ssh deploy@server.remote '#{commands.join(" && ")}'"
end

Put that in your Rakefile and you're good to go. Simple, elegant, flexible - just the way you want it!

Autocompiling Coffeescript on Save in VIM

jonas.a@revrise.com (Jonas Arnklint) — Sun, 03 Jul 2011 00:00:00 +0000

There are two problems with keeping a "daemon" compiling coffeescript and those are error handling and always having to initialize that daemon. However, there is a simpler way.

Changing .vimrc

Keeping some kind of long running process just to compile Coffeescript running doesn't really seem like the right solution. Since VIM has great support for modding and making your custom scripts and commands in .vimrc, I decided to find a solution for autocompiling on save instead:

autocmd BufWritePost,FileWritePost *.coffee :silent !coffee -c <afile>

Pretty simple, right? Add parameters according to the Coffeescript documentation to customize the compilation. For example, I don't want to wrap all my separate files with Coffeescripts own wrapper, so I'll add --no-wrap:

autocmd BufWritePost,FileWritePost *.coffee :silent !coffee --no-wrap -c <afile>

Tada! The simple way to compile Coffeescript on save in VIM!

File Type Icons for Links with CSS

jonas.a@revrise.com (Jonas Arnklint) — Wed, 29 Sep 2010 07:09:01 +0000

First of all, there is a github repo which I'm referring mostly referring to down below. There is all you need to install this CSS module.

This is a "plugin" essentially consisting of an image (a sprite image) and a stylesheet for you to add nice little icons to the right of hyperlinks that lead to a file with a certain extension. Like my non-existing pdf-file for example.

Installation

For production, simply use the hyperlink_icons.css as a stylesheet and make sure that it is referencing the sprite.gif image correctly. This should make links look like the examples below:

Extensions

.rtf .doc
.txt
.pdf
.xls
.xpi
.atom .rss
.opml
.vcard
.exe
.app .dmg
.pps
.ical
.eps .jpg .gif .png .bmp .svg .eps
.fla .swf
.css
.m4a .mp3 .wav .ogg .wma
.ace .zip .rar .gzip .bzip .ace
.ttf
.mpg .mov .wmv .mp4 .avi .mpg
.phps
.torrent

e-Mail/Messaging URI schemes

Compatibility

This CSS module has been successfully tested in

Firefox (Mac & PC)
Camino
Safari
Opera (Mac & PC)
Internet Explorer 7 (6 doesn't work)

Icons by famfamfam

This work is licensed under a Creative Commons Attribution License.

Git Submodule Guide

jonas.a@revrise.com (Jonas Arnklint) — Sat, 11 Sep 2010 00:00:00 +0000

Sometimes you may have to keep third party libraries included in you project up to date in an easy way. Submodules in Git makes this as simple as a pimple.

Adding a Submodule to a Git Repository

First, lets add the third party repository as a submodule to a sub folder in our own repository:

~/code > git submodule add git@mygithost:project.git lib/folder
Cloning into lib/folder...
remote: Counting objects: 448, done.
remote: Compressing objects: 100% (444/444), done.
remote: Total 448 (delta 290), reused 0 (delta 0)
Receiving objects: 100% (448/448), 493.84 KiB | 322 KiB/s, done.
Resolving deltas: 100% (290/290), done.

Now, lets see what this did to our repository:

~/code > git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#new file:   .gitmodules
#new file:   lib/folder

The .gitmodules file basically tells Git to keep track of lib/folder as a git submodule. Add those files and get on with it:

git add . && git commit -m "Submodule added"

Using and Updating a Git Submodule

When cloning a repository with submodules in it for the first time, the folders where the submodules live are empty. In order to get the latest source you can initialize the submodule:

git submodule init

And then update it:

git submodule update

Voila!

You can look at submodules as its own repositories inside yours. And as submodules updated this way are headless, we can make sure to pull from a specific branch in our submodule (in this case, master):

cd lib/folder
git checkout master
git pull

Commit those changes and we're done!

Using variables in Ruby Regular Expressions

jonas.a@revrise.com (Jonas Arnklint) — Wed, 02 Sep 2009 00:00:00 +0000

An easy way to deal with variating Regular Expressions.

Use variables in regular expressions

Pretty basic concept, that I can't seem to remember whenever I need it.

# Note to self!

re = "string"
"my string" =~ /#{re}/    # => 3

# So you can do:

a = 'dog'
b = 'hates cats'
str = "my dog hates cats"
str.match(/#{a} #{b}/)    # => true

Distribute your Rails App with a One Click .exe

jonas.a@revrise.com (Jonas Arnklint) — Sun, 30 Aug 2009 00:00:00 +0000

Ever wondered how to distribute you rails application to a window instance. This is how:

Distribute your Rails app with a one click .exe

There is a great tool for making a ruby application run smoothly on Microsoft platforms. It's called RubyScript2Exe and Tar2RubyScript. The author of both of these has made a great job explaining how to distribute a Rails app as a one click .exe with the above tools. However, the example is about three years old by now, so a small update is posted here.

The part I have changed since Erik posted the tutorial (which is using Ruby on Rails version 0.14.3) is the following. Instead of:

module Rails
  class Configuration
    def database_configuration
      conf = YAML::load(ERB.new(IO.read(database_configuration_file)).result)
      if defined?(TAR2RUBYSCRIPT)
        conf.each do |k, v|
          if v["adapter"] =~ /^sqlite/
            v["database"] = oldlocation(v["database"]) if v.include?("database")
            v["dbfile"]   = oldlocation(v["dbfile"]) if v.include?("dbfile")
          end
        end
      end
      conf
    end
  end
end

Super Simpler SPAM Protection in Ruby on Rails

jonas.a@revrise.com (Jonas Arnklint) — Thu, 27 Aug 2009 00:00:00 +0000

SPAM bots usually fill in all of the fields in a form, especially those who a user would normally fill in. The plan is to simply trick the bot into filling in a form element, call it "comment", that is hidden from the real users. When the form is submitted, we will detect if it is filled in. If it is, well, then we have our SPAM bot.

Protect your Rails Application from SPAM

The model:

class Post < ActiveRecord::Base
  attr_accessor :comment # fake attribute used for spam trapping
  validates_length_of :comment, :in => 0..1
end

And then the view in which we ask the user to not care about a field (if CSS is turned off, otherwise it's hidden)

<% form_for @comment do |f| %>
   ...
   <p style="width: 1px; height: 1px; overflow: hidden;">
     Please leave following field blank:
     <%= f.text_area :comment %>
   </p>
<% end %>

SPAM means problem

One common problem with popular sites are SPAM bots. You know, the ones that fill in your forms, submit them and hopes to get their word out about what I should buy and click on. But as they don't really contribute to your site, you'd probably want to get rid of them or don't have their posts published in the first place.

Don't let the user suffer from the problem One way to get rid of them are CAPTCHA's. Even if those are good at differentiate users from bots thus protecting your site, they rarely make life easier for your actual users.

Additional reading

How to Become an Efficient Programmer

jonas.a@revrise.com (Jonas Arnklint) — Wed, 12 Aug 2009 00:00:00 +0000

Good programmers usually have one thing in common. They work efficiently. These are my own rules on how to get better and foremost more efficient when it comes to programming stuff. Whether you do C#, Ruby or even LOLCode, these rules apply to all of them. Sure, you can be a master of Zen in one or two languages, but that doesn't mean that you are an efficient and good programmer overall. Do give me feedback if you know something this post lacks!

Automate the stuff you are able to automate

When it comes to stuff you do daily on your computer or programming device (I know people that hack on their cellphone), you should always try to automate that stuff as much as you can. Try to find tasks that can be automated and automate them. It could be file transfers or creation of a base template application.

Depending on the project you are working on tests are great to automate when possible. As for Ruby, Autotest/Zentetest is a great tool for automating tests.

Learn the shortcuts

I'm not only talking about keyboard shortcuts or the ones you can click on to get to a different location in your file structure. Try to always be on your watch when programming or even just using the OS for smart and fast ways to get from A to B. Especially tasks that you repeat often will save you a lot of time in the long run.

Use Version Control

Keep your projects in a Source Version Control. Git is a great tool to do that. Whenever you make a change, you can commit it to your repository and later on switch back to a commit you did earlier if something goes wrong. Keep your changes small and describe them well, so that you easily can look back in history when you are in need for that. Too small changes though makes you inefficient and finding a balance might take a while.

Do Instead of Talk

A golden rule that I used to ignore. The worst thing that can happen if you start doing stuff before planning is that you fail. Then you get to do it all over again. And what comes with that? That's right, experience. Try to get feedback more often while developing a feature instead of planning how it will look like when its done. Chances are that you will fail along the way anyway and have to go back to the planning stage. The best solutions are usually those, which are tested and tried out by users who will use them.

Keep a Library

While Google is a great code library, there are some snippets of code you will never find there. Keep a personal code library of stuff you have done. This way, you will always be able to go back and fetch code from a project later on to reuse in the next one. This saves you time and makes your life as a programmer easier.

Focus

Get rid of the noise that's bothering you. You might not even notice, but your IM, cellphone and e-mail client doesn't always deserve the amount of attention that you are giving them.

A couple of years ago during a super hectic time at work/school, I did them both at the same time, I simply closed down my e-mail client only launched it three times a day. One time in the morning, one before lunch and one half an hour before i finished work. This has kept me from focusing on my customers problems or requests all day long. Remember, you are not saying no to your customers/colleagues, you are simply putting them on hold for you to be totally focused on them later on.

IM and texts are a great tool of communication. Thats a fact. But not at all times! Interruptions are usually a bad thing when you are programming. Think about it!

This is really a subject of saying no!

I know there are great tools that can help you follow these rules and I would really appreciate some feedback about just those.

Custom jQuery selectors

jonas.a@revrise.com (Jonas Arnklint) — Fri, 23 Nov 2007 00:00:00 +0000

I find that a lot of times you want to use jQuery selectors that are a bit messy on a couple of places. Making your own selectors tidies your code and makes it DRY.

DRY up your JavaScript code using your own custom selectors

jQuery is starting to be really enjoyable. This is an easy peasy way to make your own custom selector, which could be used to extract elements in a cleaner way. This also allows you to find any type of element based on one or more attributes which you couldn't use the included selectors to find.

$.expr[':'].my_elements = function(obj){
  var $this = $(obj);
  return ($this.attr('special_attribute') != '');
};

Then you can use your homebrewed selector the same way you would use the pre defined:

$('h1:my_elements').css({color: "green"});

Deploy your Jekyll Site Directly from TextMate

jonas.a@revrise.com (Jonas Arnklint) — Thu, 01 Nov 2007 15:14:14 +0000

Jekyll is the "engine for static blogs" that I'm using here when blogging. You simply write your posts in any text editor (preferably TextMate if you are on a Mac) and then process the blog posts that are written in Markdown or Textile formats via the Liquid Templating Language.

Automate

Before this post, there were no clean way to deploy your precompiled Jekyll site to a remote server. So I made a Textmate command allowing you to compile your jekyll site before you deploy it via rsync to your server. It's a super simple, yet neat way to use Textmate for deploying your site.

Simply follow the instructions in the README in the Github repo to install the command and deploy script.

The Textmate command simply launches a shell script in your ./_tasks directory called up:

#!/usr/bin/env bash
jekyll ../ ../_site --pygments && 
rsync -avz --delete ../_site/ user@server:/path/to/webroot

Your own API based on Ruby on Rails

jonas.a@revrise.com (Jonas Arnklint) — Mon, 11 Jun 2007 00:00:00 +0000

Making your own REST(ful) API based on Ruby on Rails is not that hard. There are plenty of libraries that makes it a bit easier, but as you probably know, dependencies are not always a good thing for maintainability.

Why an API?

A great way to open up your application is to enable your users to write their own applications interacting with your web app. While opening up, the users are likely to produce more traffic and more buzz if there is a simple way to integrate your app with theirs.

Planning an API

I've been producing a couple of API's lately and the one and only rule I can think of in general is to start small and add to it. Be responsible when writing the API and try to plan ahead so that you wont have to remove parts of it in the future, which might cause other apps dependent upon your API to fail. Another option is to make versions of the api, so that new changes wont affect apps that consume your API. Consider different endpoints for different versions:

http://myapp.com/api/v1/comments.json
http://myapp.com/api/v2/comments.json

How it's done in Rails

Create an "API base controller" that will be inherited from the rest of your API controllers (namespace them or whatever).

# app/controllers/api_controller.rb
class ApiController < ActionController::Base
  attr_accessor :current_user
  prepend_around_filter ApiAuthorizedFilter.new
end

# app/models/api_authorized_filter.rb

class ApiAuthorizedFilter
  def before(controller)
    return true unless controller.params[:api_key]
    controller.current_user =
User.find_by_api_key(controller.params[:api_key])
  end

  def after(controller)
    controller.current_user = nil
  end
end

This way, we can control authorization with an API key. Additional parameters can of course be taken into consideration when autorizing the user.

Now you can use the 'api_controller.rb' when implementing the api and make each new controller inherit from it like:

# app/controllers/comments_controller.rb
class CommentsController < ApiController 
  def index
    Comment.find(:all)
  end
end

You´ve just accomplished a super easy filter to authenticate/authorize a user via your own Ruby on Rails based API!