sinatra with bourbon

posted by alexis reigel on march 24, 2012

If you search the web for “bourbon sinatra” you get a whole lot about Frank Sinatra and his drinking habits. But that’s not what this post is about.

How to use bourbon scss mixins with sinatra is not documented on their project page. So here’s my short setup.

The following is standard, from their documentation.

$ gem install bourbon # or better, add to use Gemfile and use bundler
$ cd views/scss
$ bourbon install

Next, import bourbon in your main scss file (as first statement).

@import 'bourbon/bourbon'

The following is the important and the undocumented part, specifically for sinatra. You need to require the ruby libraries in your scss route.

get '/assets/css/:name.scss' do |name|
  require './views/scss/bourbon/lib/bourbon.rb'
  content_type :css 
  scss name.to_sym, :layout => false
end

static vs dynamic vs strong vs weak vs duck typing

posted by alexis reigel on march 19, 2012

Here’s my take at clearing up the confusion about the most common type systems used in programming.

I often hear how static and strong typing are used as synonyms. These two are however quite different systems. The same applies to dynamic and weak typing. For instance, a programming language can be both dynamically and strongly typed, but not dynamically and statically. Ruby is an example of a dynamically and strongly typed language.
Ok, I guess now it’s the time to elaborate.

static vs dynamic

  // example in c#

  string s = "asdf";

  # example in ruby

  s = "asdf"

strong vs weak

  # example in ruby

  "1" + 1 # TypeError

  // example in javascript

  "1" + 1 // "11"

duck typing

Duck typing is a style of dynamic typing.With duck typing, the set of methods and properties determine the valid semantics of a class, instead of inheritance from a specific class or implementation of an interface.
“When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.”
This means that we actually don’t care if the class we’re using is actually of a certain type, as long as it provides the methods or properties we’re interested in.
The term duck typing comes from python, but ruby is also very known for this behaviour.

sinatra on capistrano

posted by alexis reigel on january 31, 2012

Capistrano is really great for deployment. The documentation however is somewhat scattered. The capistrano wiki has a more or less useful From The Beginning instruction and a Getting Started that doesn’t quite get you started.
However, the instructions on github are actually a very good starting point. Neverthelesse I want to show my sample here that has two additions to the one in the github help.

  1. Multistage support (i.e. staging and production server)
  2. Custom task to upload a config file

For further reading I recommend the Capistrano Handbook.

I assume that you’ve setup capistrano as described in the github help. The one thing I suggest is to ignore the part where the password is stored in the file. I highly advise to use ssh agent forwarding instead.

ssh_options[:forward_agent] = true # use local ssh key
set :user, "deployer"

Let’s setup multistage:

require 'capistrano/ext/multistage'
set :stages, %w(production staging)
set :default_stage, "staging"

Also, on most deployment server you may not have rights to sudo:

set :use_sudo, false

As I’m assuming you’re using passenger mod_rails:

namespace :deploy do
  task :start do ; end
  task :stop do ; end
  task :restart, :roles => :app, :except => { :no_release => true } do
    run "#{try_sudo} touch #{File.join(current_path,'tmp','restart.txt')}"
  end
end

The last part uploads our configuration file to the server. This configuration contains user and password for the database login. We don’t store that in the source code repository.

namespace :config do
  task :db do
    upload('db.yml', "#{deploy_to}/current/db.yml")
  end
end

before "deploy:restart", "config:db"

The whole capistrano configuration file is on github.

swimming in zurich: "züribad"

posted by alexis reigel on april 25, 2011

My first android application is a utility app about all public swimming baths in Zurich. It shows the current water temperature for each bath and additional information is available too, such as address and routing info (how to get there by public transportation). Google map integration provides a geographical overview of the baths.

The app is freely available in the android market. The source code is hosted on Bitbucket.

share on minus from windows explorer context menu

posted by alexis reigel on february 19, 2011

There’s a new tool for the file sharing service minus.com that makes it really easy to share files. The tool provides a context menu entry in the windows explorer and a simple user interface to upload the files and provide you with the share url.

The tool is on github.

windows console: spawn new process

posted by alexis reigel on january 19, 2011

Under linux spawning a new process is as easy as appending an & to the command. In windows it’s not (obviously). I pretty quickly found out about the start command. Not as elegant as the linux version, but still pretty intuitive. Or, wait, not? It took me half a decade to find out how to use it properly.

First i had a look at the help output, which can be invoked by the switch /?. I’m not 100% sure, but i have in mind that this switch isn’t really standardized, i think I also had to use /h or /help in the past. Anyway, that’s not the sad part yet.

console start

Reading through that, all you have to do is call start my_command. Easy huh? No. It’s not.

After digging around this article lead me to the solution: “title: Text for the CMD window title bar (required)”. Title! Required!
Let me say that again. Title! Required!
First thought: Why? Why is a title required? A title is clearly something optional, especially when you’re starting a GUI application.
Second thought: Why? Why is that “required” not stated as such in the help output? Not the slightest hint in the help output. And furthermore, isn’t it a convention that required parameters are NOT surrounded by brackets? Don’t brackets mean “optional”? Apparently, in the windows tooling environment all this does not apply.

I know, windows is a GUI centered OS, and therefore the console didn’t evolve as nicely as it did in other OS’s. Nevertheless, every time I have to work on a console or write a batch file it gives me the creeps. Everything is so unbelievably clumsy. At least I found out about the Console project, which is a pretty decent replacement for the windows console. Copy/paste works as desired with keyboard shortcuts and you can resize the window. Resize the window! How cool is that! But that’s a different story…

DataGridView with an object data source

posted by alexis reigel on september 04, 2010

For my Batch Replacer I am using a DataGridView with an object data source, meaning that I have a collection class that holds the data to be displayed. At first that class inherited from a usual List<T>, which led to the problem that the data binding wasn’t two-way. As soon as I bound data to the DataGridView, it wasn’t possible to add any new rows to it in my user interface. After some research I found out that instead of using a normal List&lt;T&gt; I was supposed to use a BindingList<T>. Using that the binding is two-way, and the user interface is normally editable and new rows can be added. Also, of course, all modifications done in the user interface are reflected in the object (meaning e.g. that when a new row is added, the object data source contains a corresponding entry).

replace as in batch replace

posted by alexis reigel on september 03, 2010

So I once again needed to replace several patterns in multiple files with something new… Windows lacks a nice terminal with all the pipeable tools. Instead of doing this all in my favorite text editor by using repeatedly find/replace, I decided that something more handy was needed. Of course I could have done all that replace stuff with xslt too, for even more awesomeness (you can’t see my face, that what sarcasm).

The result of my disapproval of the above mentioned options is the Batch Replacer. As always it is released under the gpl. I also used git:" for the first time and published the source code on github".

navigate to those... out of the box with firefox

posted by alexis reigel on march 30, 2010

Ok well, this doesn’ seem to be new at all, but nevertheless I missed that. Firefox has the great functionality to assign shortcuts to certain bookmarks and supply a parameter to the URL. This leads to really great quick searches (aka. the art of bookmarking="http://lifehacker.com/196779/hack-attack-firefox-and-the-art-of-keyword-bookmarking).

What I have now are shortcuts to all my often used search sites. To search in wikipedia e.g. I type CTRL + L (shortcut for placing the cursor in the URL bar in firefox), then type wp asdf and there I go.

I guess this fact renders my previously posted quick link access tool obsolete…

navigate to those urls over and over again...

posted by alexis reigel on may 15, 2009

I’ve written a tool that allows to define commonly used URLs for repeated access, varying only by a defined parameter-part. When you call one of those URLs, you just need to pass a parameter and it opens in the browser. That way you get quick access to often used URLs, e.g. your preferred search engine, your ticketing system or whatever. For even faster access the URLs are bound to predefined global hotkeys.

More infos can be found on github.

Screenshot of the main application's window

nullable average in linq

posted by alexis reigel on october 12, 2008

The following code is one possibility (there may be more elegant solutions to this) to handle a nullable average from a linq query. The problem arises when the linq query does not return a result, thus the average being null. If you don’t use a nullable type, you’ll get an exception. To get a nullable average from an integer value you’ll need to provide a transform function to the Average funtion.

double? nullableAverage = 	
    (from m in dataContext.Moods 	 
	join g in dataContext.Groups on m.GroupGUID equals g.GUID 	 
	where g.GUID == groupGUID 	 
	select m.Level) 	
	.Average&lt;int&gt;(x =&gt; new double?(x));  
int average = (int)Math.Round(nullableAverage.HasValue ? nullableAverage.Value : 0, 0);  
// ...

custom application settings

posted by alexis reigel on june 28, 2008

Within a c# winform application I needed to store a generic collection to my settings, which I found out was not possible out of the box. It is possible though to set the required type in the properties designer dialog, but the serialization’s output is always nothing.

On my research on the internet for a solution i stumbled upon the post Tips for C# .NET Software Developers, which described that the attribute [SettingsSerializeAs(SettingsSerializeAs.Binary)] was required for the settings property, and to set it accordingly in the Settings.Designer.cs file. The problem here is that modifying designer generated code file is not the best of all ideas, as the manual changes are overwritten every time the settings are modified by the designer. Thus, I followed the msn article on how to create application settings, which told me to create a custom settings class. The drawback with this solution is that I now have two settings classes, and not only one single to cover it all.

Here’s an example of the settings class. Note the use of the SettingsSerializeAs attribute, as it is the key to the successful serialization.

using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;

namespace Koffeinfrei
{
    /// &lt;summary&gt;
    ///   This class provides extended settings. Use this class for types that need to have special     
    ///   attributes for serialization, that cannot be set using the config designer dialog.
    /// &lt;/summary&gt;
    internal class ExtendedSettings : ApplicationSettingsBase
    {
        private static readonly ExtendedSettings defaultInstance =
            ((ExtendedSettings) (Synchronized(new ExtendedSettings())));

        /// &lt;summary&gt;
        ///   Returns the default instance of this class.
        /// &lt;/summary&gt;
        /// &lt;remarks&gt;
        ///   Get the value of the &lt;see name="defaultInstance" /&gt; member.
        /// &lt;/remarks&gt;
        public static ExtendedSettings Default
        {
            get { return defaultInstance; }
        }

        /// &lt;summary&gt;
        ///   The &lt;see cref="SomeCustomClass" /&gt;s stored in the user scoped settings.
        /// &lt;/summary&gt;
        /// &lt;remarks&gt;
        ///   Get / set the value of the &lt;c&gt;CustomClasses&lt;/c&gt; property.
        /// &lt;/remarks&gt;
        [UserScopedSetting]
        [DebuggerNonUserCode]
        [SettingsSerializeAs(SettingsSerializeAs.Binary)]
        public Queue&lt;SomeCustomClass&gt; CustomClasses
        {
            get { return ((Queue&lt;SomeCustomClasses&gt;) (this["CustomClasses"])); }
            set { this["CustomClasses"] = value; }
        }
    }
}

EDIT

Thanks to partial classes you can merge the custom settings to the main settings. Just use the same class name internal class Settings.

ruby blood through your .net veins with a vengeance

posted by alexis reigel on june 28, 2008

In my last blog entry i totally neglected the fact that there are lamda expressions. This nice little C# 3.0 feature makes anonymous methods much more readable. With that in mind, we can make our Times method much nicer.

Example 1: Ruby style iterator with lambda expression

2.Times( number => { Console.WriteLine("> " + number); } );

Compared to the former syntax, it increases readability considerably.

Example 2: Ruby style iterator with bare delegate

2.Times( 
    delegate(int number)   
	{     
	    Console.WriteLine("> " + number);   
	}
);

ruby blood through your .net veins

posted by alexis reigel on april 07, 2008

No other programming language has been syntactically as nice as ruby. Ruby is fully object oriented, most other languages appear to be not so consistent, especially when it comes to primitive data types vs classes. In ruby, everything is an object, in many other object oriented language this is not the case. Most of them have primitive data types besides classes, which means that you cannot necessarily call methods on all types. And, ruby’s syntax lets you write much functionality with little code.

But ruby is not alone, .NET is catching up a bit with each release. Now with version 3.5, M$ has introduced extension methods. They allow to extend classes dynamically, without the need to subclass.

My first thought was, let’s .NET look more like ruby, in respect to its fully ojbect oriented data types. In ruby you could write 2.times {...} to create a neat loop. In .NET, this is now possible too! You just have to write a static class with static methods, where its first paramater is prefixed with this. The first parameter defines the class type the method is added to. That’s it. You can even overload methods. And, the newly created methods popup in intellisense!

Extension methods - intellisense

2.Times? The rubyists among you know where this is going…

Example 1: Extend String class

Let’s extend the string class with an overloaded Replace-Method that performs a regexp replace.

public static class StringExtensions
{
    public static string Replace(this string stringRef, string pattern, string replace, RegexOptions options)
    {
        return Regex.Replace(stringRef, pattern, replace);
    }
}

Call it like this:

public class Program
{
    private static void Main(string[] args)
    {
        string stringOrig = "this is stupid.";
        string stringReplaced = stringOrig.Replace(@"(this) is ([^\.]+)\.", "$1 is not $2!", RegexOptions.None);
        Console.WriteLine(string.Format("Orginal string: {0}\nReplaced string: {1}", stringOrig, stringReplaced));
        Console.ReadLine();
    }
}

Pretty neat so far huh? But now, let’s face the 2.times code.

Example 2: Create a ruby style iterator

public static class IntegerExtensions
{
    public delegate void IntegerExtensionsDelegate(int intRef);

    public static bool IsEven(this int intRef)
    {
        return intRef % 2 == 0;
    }

    public static void Times(this int intRef, IntegerExtensionsDelegate invokeMethod)
    {
        for (int i = 0; i < intRef; ++i)
        {
            invokeMethod(i);
        }
    }
}

Let’s call it now:

public class Program
{
    private static void Main(string[] args)
    {
        /* ruby heart beats faster */
        if (2.IsEven())
        {
            Console.WriteLine("Number 2 is even!");
        }
        Console.WriteLine("And now: 2 times loop"); 
        /* ruby heart collapses in bliss */
        2.Times(delegate(int number) { Console.WriteLine("> " + number); });
        Console.ReadLine();
    }
}

The Times method almost looks like a ruby iterator with a block assigned. Instead of having a block, we just pass a anonymous method (aka. delegate) to the Times method, and we pretty much get what we wanted.

If you’re interested in details on the compiler output, you can read about it on Scott Hanselmann’s Computer Zen.

too many parameters?

posted by alexis reigel on october 06, 2006

Today I came across an interesting fact about java (referring to the programming language, not the island). But first things first. You may not be interesting in the previous history but I’ll tell it anyway.
During my diploma work (that will be finished in one week by the way) I had to generate some classes invoking the wsdl2java parser. I won’t explain what that parser is about. Anyway, I invoked the parser on the amazon web service which got me an interesting error. ItemAttributes.java:538: too many parameters. So I counted them and I got 261 arguments. That made me wonder how many arguments were actually allowed for a method in java. I searched the java forums and mailinglist and found the answer in the Java Virtual Machine Specification. The following summarizes the facts I was interested in.

"Java limits the number of method parameters to 255 or 254 or less if parmeters are of type long or double. The 255 method parameter limit is for static methods and 254 for non static methods."

And some more limitation facts for that matter.

I hope that no programmer will ever get even close to those limits. Otherwise the class design should definitely be reconsidered. Anyway, I’m positive that I’m not going to ever see a method that has more parameters than this one…

Looking for more? Head on over to the archives.