adz

Fiscal Dates in Spreadsheets

2010-01-18T15:17:00.004+10:30

Australian fiscal year 2008-2009 is from 1st July 2008 - 30th June 2009.

July is the 7th month.

LET'S HAVE EXCEL FUN! :(

Assuming A1 is you're date column, calculate year by ADDING 1 to the year for month's of July or later:


  EXCEL:
  = ( YEAR(A1) + (IF(MONTH(A1) >= 7, 1, 0) )

  OPEN OFFICE CALC:
  = ( YEAR(A1) + (IF(MONTH(A1) >= 7; 1; 0) )

The calculation for fiscal month:


  # EXCEL
  = INT( 1 + MOD( MONTH(A1) - 7, 12) )

  # OPEN OFFICE CALC
  = INT( 1 + MOD( MONTH(A1) - 7; 12) )

Last is fiscal quarter...


  # EXCEL
  = INT( 1 + (MOD(MONTH(A1)-7, 12) / 3)  )

  # OPEN OFFICE CALC
  = INT( 1 + (MOD(MONTH(A1)-7; 12) / 3)  )

NOTES:

- For US fiscal years, just replace '7' with '10' -- since October is your first fiscal month.

- The semicolon is used to separate function arguments because OpenOffice accepts numbers with commas as the decimal point when it is running in a location that uses that notation. If it used commas for lists as well, then something like =SUM(20,2,30,6) would be completely ambiguous.

Loading smartclient in Rails...

2009-05-23T00:53:00.005+09:30

How to load smartclient (LGPL javascript framework) in rails:

Download smartclient LGPL version
Copy smartclientRuntime/isomorphic/* --> RAILS_ROOT/public/isomorphic/
Load up the javasacripts in your template

To help further, here's a nice application helper method (load_smart_client) to generate the right stuff for that last step:


module ApplicationHelper
  # All the modules in smartclient
  #  (actually there's a few more -- but less useful)
  ISC_MODULES = [
    [:core,         'ISC_Core.js'],
    [:foundation,   'ISC_Foundation.js'],
    [:containers,   'ISC_Containers.js'],
    [:grids,        'ISC_Grids.js'],
    [:forms,        'ISC_Forms.js'],
    [:data_binding, 'ISC_DataBinding.js']
  ]

  # Helper to generate paths to static urls
  #
  # Useful when you deploy under a path prefix
  # (for example, --prefix with mongrel)
  def static_url_for(path)
    "#{ActionController::Base.relative_url_root}#{path}"
  end

  # Load smartclient javascript framework (via script tags)
  #
  # Options are:
  #  :modules => array of js modules to load
  #  :skin    => skin name, as per subfolder in /isomorphic/skins
  #
  # Skins include:
  # BlackOps, Cupertino, Enterprise, fleet, SilverWave,
  # SmartClient, standard, ToolSkin or TreeFrog
  #
  # Loadable modules include:
  # :core, :foundation, :containers, :grids, :forms, :data_binding
  #
  # By default loads ALL modules, with Enterprise skin
  def load_smart_client(opts={})
    skin = opts[:skin] || 'Enterprise'
    modules_to_load = opts[:modules] || ISC_MODULES.map(&:first)

    # Set isomorphic dir
    out = "<script>var isomorphicDir='#{static_url_for('/isomorphic')}/';</script>"

    # Load each module
    ISC_MODULES.each do |key, js_file|
      if modules_to_load.include?(key)
        js_url = static_url_for("/isomorphic/system/modules/#{js_file}")
        out += "<script src='#{js_url}'></script>\n"
      end
    end
    
    # Load skin
    js_url = static_url_for("/isomorphic/skins/#{skin}/load_skin.js")
    out += "<script src='#{js_url}'></script>\n"
  end
end

Languages to learn...

2009-01-03T22:06:00.002+10:30

Javascript (more deeply)
Lisp
Smalltalk
OCAML
Haskell
Erlang

Don't lose my Money.new, or why 1 / 3 = ?

2008-07-01T01:03:00.004+09:30

If you're using the Money object in rails, you'll be storing your money as cent in your DB. Then, you use composed_of to read this into a whole separate object (of type Money).

This works great, but, I don't like losing Money.

The problem is, Money objects can't go into fractions below a cent. So when you divide 1 by 3, you can't have .33333 reoccurring... you get .33.

We tackled this issue by modifying division to round to the nearest cent, but auto-calculate the total error. This only makes sense when you have a way of dealing with the rounding...


class Money
  alias_method :lossy_divide, :/
  def /(*params)
    raise "Do not divide - losing Money!"
  end

  def split_between(x)
    result = self.lossy_divide(x)
    rounding_error = self - (result * x)

    result, rounding_error
  end
end

In this way, you 'split' money rather than exactly divide.

Our use-case is that we want to split the money between x people, or amongst x days. So, we generally have to assign the split money out to different instances.

This works beautifully if we return an array representing all the splits, and add the rounding error to the first entry:


class Money
  alias_method :lossy_divide, :/
  def /(*params)
    raise "Do not divide - losing Money!"
  end

  def split_between(x)
    result = self.lossy_divide(x)
    rounding_error = self - (result * x)

    [result + rounding_error] + (2..x).map{result}
  end
end

Graphing in Rails Roundup

2008-07-01T00:23:00.006+09:30

We recently built a small rails app to act as a portal into a large list of reports. Rails works great for this - we've added role-based authentication, integrated legacy reportss and, hmmm, why not add sexy graphs?

The following is a quick list of the current graphing/charting choices - with the intention of adding charts into this intranet-accessed reporting app...

Image Generating: GRUFF

The most often sited lib is 'gruff'. It works by generating an image of your graph which you can serve up. The API seemed very easy to use.

http://nubyonrails.com/pages/gruff

I had some issues when there were a lot of x-axis labels. You specify which x-label points to display in a hash, and to avoid the overlap it looked as though we would have to manually calculate an interval.

NOTE: there is also a library called scruff which generates SVG graphs. It uses a similar API to gruff.

Open Flash Charts

We are currently using Open Flash Charts. It's very easy to use, looks great, and provides a large number of styles.

The way it works is you embed a flash object into your browser, and tell it an url from where it should fetch it's data.

It puts your x-axis on an oblique which avoided our problem all together.

To help out, there's a nice Rails plugin, generating all of the above. See: http://www.pullmonkey.com/projects/open_flash_chart/.

AMCHARTS

AM Charts make some really professional looking components. It's pretty similar to Open Flash Charts, but the free version is not open source and contains a link back to amcharts.com.

However, it's not too expensive and there is a rails plugin for it: Ambling.

Ambling is a rails plugin makes it easy to generate XML needed by the wonderfully slick Amcharts.
Amcharts has two kinds of XML: the data xml and the settings xml. Ambling can help with both.

OTHERS

Fusion Charts - v2 is free: http://www.fusioncharts.com/free/
Fusion Charts - v3 is commercial: http://www.fusioncharts.com/

XML/SWF charts
XML/SWF has a free version - which if used, generates graphs as a link - where clicking on a graph directs you to their site. A commercial version is $45 for a developer.

XML/SWF plugin for rails: http://ziya.liquidrail.com/

One issue to be aware of - Flash objects don't seem to print in Firefox. I believe other browsers work fine - in particular, IE worked under test.

A work around (in most of the above libs) is to right click a particular graph and select "Print Chart".

JAVASCRIPT BASED

This is a very cool idea - javascript draws the graph in a canvas object within the browser. It works in IE too via an emulated canvas object.
http://en.wikipedia.org/wiki/Canvas_(HTML_element)

A roundup of these are as follows:

PLOTKIT, based on Mochikit javascript lib
PLOTR, is PLOTKIT with parts rewritten to use prototype
FLOT, is based off of jQuery
FLOTR, is similar to FLOT but uses prototype

All of these are quite simple to use, and have varying levels of maturity, documentation and compatibility. However, generally speaking they support browsers where the Canvas tag is supported: Firefox 1.5+, Safari 2.0+, Opera 9.0+ and IE6+ (emulated).

It's also worth mentioning that these integrate nicely with rails - all your app need do is embed JSON data (or return it via AJAX). The javascript is trivial to use - and can be controlled dynamically on the fly.

GOOGLE CHARTS

The charts you see in google analytics are openly available via a public API.

Lot's of info on their site (probably one of the best documented), and a rails plugin is available too: http://code.google.com/p/google-charts-on-rails/.

This is a very nice options if you have a public site, but not so good for intranet applications.

CSS GRAPHS HELPER

At the other end of the scale is this little plugin. It uses nothing but HTML, CSS (and optionally some images) to generate simple bar graphs.

I liked the simplicity of this one, but we did have some issues:

it seemed to conflict with some of our existing CSS
you are limited to one graph per page
all values need to be normalised to 100
it seemed to go wonky when you used more than 5 data points for vertical bar graphs (you can do more with horizontal ones)

It may still work well for you if you can work around those limitations. It's simplicity is also it's asset: no flash, no server-side processing, and works across browsers.
http://nubyonrails.com/pages/css_graphs.

If you've found another option please leave a note in a comment.

Array Subsets and Supersets

2008-02-07T15:05:00.000+10:30

I often find myself looking to see if an array contains all elements in another array. The code looks like this:-
!array.any? {|e| !other_array.include?(e)}

A much nicer solution is to use the build-in Set#subset because it reads so much better:
set.subset?(other_set)

A Set is like an array, but stores each element only once in an unordered sequence. You can't get at a particular index - but you can still use #each. Arrays, on the other hand, can store the same thing multiple times, and in different orders. Hence, it only makes sense to talk of 'subset' or 'superset' and not 'subarray'.

Quite usefully, Enumberable defines #to_set - which is included into Array giving us:-
array.to_set.subset?(other_array.to_set)

BTW - if you're outside rails, you'll need to require 'set'.

Fowler on Viagra Infused Rabbit Organisations

2007-11-26T11:27:00.000+10:30

Martin Fowler on Organization Structures (Accountability)

If you are dealing with an organization with a single hierarchy, or even a couple, then Organization Hierarchy (7) is the simplest way to deal with things. However larger organizations grow beyond this. You often find a host of different relationships between parties, all of which carry their own meaning. If your hierarchies start breeding like viagra infused rabbits, it’s time to look to Accountability (17).

Gotta love that description :)

He's describing how you can structure organisations (including relationships between them).

I strongly recommend reading up on Fowler's work. I really like his style - especially his method of demonstrating the simplest possible model first, then building up complexity to maximum flexibility.

It's important to recognize that while no-one likes needless complexity, it's extremely beneficial to know how to add just enough to cover your needs.

Do NOT Override Rails :default DATE_FORMAT!

2007-11-21T16:41:00.000+10:30

A subtle issue - I should've known better! Beware!

We defining our own date formats in our rails environment.rb - in order to format dates consistently across our app with 'some_date.to_formatted_s(:my_format)'. This is done by opening up the existing ActiveSupport class, and merging in your formats:


ActiveSupport::CoreExtensions::Date::Conversions::DATE_FORMATS.merge!(
  :in_words => "%A, %d %B %Y",    # Add format - Monday, 01 January 2007
  :short => '%d/%m/%Y'            # Override :short to ozzy style dates
 )

However, do NOT go overriding the :default format!
This one ALSO seems to be used for converting dates into SQL string-formatted dates.

MySql ended up receiving a blank string, and stored '0000-00-00' for all my dates... ...but no errors.

Not nice.

Rails Coding Standard

2007-11-14T08:50:00.001+10:30

The small team I'm part of work on a large Rails project (in complexity and scope). We've all got quite contrasting backgrounds: PHP hackers, J2EE pattern junkies & legacy spaghetti coders.

I've found some recurring issues that arise relating to code quality, so have set out to write a mini-code standard.

IN ESSENCE: ALL CODE SHOULD BE READABLE!

DO NOT OPTIMISE for performance - OPTIMISE FOR CLARITY OF CODE

STYLE: use 2 spaces for indent (not tabs)

STYLE: Line up hash arrows for readability

STYLE: put spaces around => hash arrows

STYLE: put spaces after ',' in method params - but none between method names and '('

VIEWS: use HAML for views

VIEWS: break up the structure with white space to help readability - VERTICALLY TOO!

VIEWS STYLE: Rely on structure of page, without having to insert messages or new components...
- Example: Effect to visually highlight then drop out an existing element rather than flash a message
- Example: Highlight newly added row rather than a message about it

AVOID logic in views - they should be simple
- put html generating logic into helpers
- instead of inline ruby logic, add to models (filtering, checking)

NEVER use ActiveRecord models in migrations unless you re-define them within the migration
- ...otherwise the migration fails when you later remove/rename the AR class
- BETTER SOLUTION: use bootstrapping until deployed!!!

AJAX only for sub-components of an object, and avoid over-use

Now the problem with code standards, is that they need to be adhered to, or they're totally useless. That's why the above is very short and easy to comprehend in one quick sitting.

What would you add or remove?

ActiveRecord Through ODBC Without Rails

2007-11-14T08:36:00.000+10:30

Install Ruby
Install active-record (plus any adapters... such as ODBC) on command line
gem install active_record --include-dependencies gem install odbc-rails --include-dependencies
Write some Ruby code...

The simplest case looks something like this:


# require AR
require 'rubygems'       # require gems first since AR is installed via gems
require 'active_record'

# connect to the database (sqlite in this case)
ActiveRecord::Base.establish_connection({
  :adapter  => odbc,
  :dsn      => your_pre-configured_odbc_datasource_name,
  :username => user_name,
  :password => secred_password,
  :trace    => true,
  :convert_numeric_literals => true})

# define your models - this one looks for a table called 'tasks'
class Task < ActiveRecord::Base
end

Then you're good to go! Go ahead and use all that Active Record stuff from a local script...

See here for futher info on using ODBC with rails:

The rails wiki has more on active record outside rails.

Colours?

2007-08-30T08:19:00.000+09:30

Ruby has helped me write beautiful code - more expressive and abstract - and hence more maintainable. I've become interested in enhancing my visual design skills to match!

One area of visual design that seems particularly subjective is colour (that's Australian for 'color').

This post is a summary of basic colour ideas researched up from the wild web.

Colour Matters!

On your website, use color to create the most functional user-interface design.

For example, use color to direct the eye to the most important areas on the page. The web designer must identify what ideal and normal sequences might entail: what the viewer should see first, where the eye should move next, and how much time the viewer's attention should be held by each area.

Keep colors to minimum. "Signal detection" theory means that the brain is able to understand and organize information when a minimum of colors and shapes exists within the visual field. Too many colors and shapes make it impossible to focus and find anything.

Notes:

Use colour to direct the eye to important areas
Identify the sequence of focal areas (ideal & normal)
Keep Colours and shapes to a minimum

The main emphasis is on using colour as a means of focusing attention ...but which colours?

Which Colours?

This is where things get very subjective - the realm of psychology. Color psychology is a field of psychology devoted to analyzing the effect of color on human behavior and feeling.

This seems to be very culturally dependent - see Wikipaedia for a table of some common cultural (symbolic) connotations attached to colors in Western cultures.

Notes:

Realise that colours will evoke behaviour & feelings in humans!
Keep in mind colour psychology when selecting your colours
It's subjective!

Using Colours For Focus

Let's move on to something less subjective - how to use colours to direct the eye. In order to understand this, you need to understand how colours relate to one another.

The Colour Wheel

An indispensible tool for selecting colour - the color wheel (or circle) is a visual representation of colors arranged according to their chromatic relationship. It essentially provides a method of selecting colours based on their relationship to one another.

There's a number of useful colour wheels you can user directly on the web - google 'em.

Here's a selection:-

Peter Piper's Pallete:
Uses a 'cross' rather than wheel, but shows 7 colours at once - each in varying levels of proporition.

The Color Wizard:
Select a colour - then it will show you related colours.

Digital Color Wheel:
Similar to the color wizard, it helps see which colors go with what. You can choose your primary or reference color, then move the mouse over the different color schemes – analogous, split complementary etc.

Random Color Generator:
Generates three random colours with a text block preview. Useful when you're totally stuck with designer's block!

Complimentary or analogous?

When complementary colours are used together, they seem to make each other brighter and more vivid. They are located opposite from each other on the colour wheel.

Analogous colours will tend to blend together, and provides a feeling of harmony. They are located next to each other around the colour wheel.

Passive or active?

The color wheel can be further divided into ranges that are visually active or passive.

Most often warm, saturated, light value hues are "active" and visually advance. Active colors will appear to advance when placed against passive hues.

Cool, low saturated, dark value hues are "passive" and visually recede. Passive colors appear to recede when positioned against active hues.

Proportions

When using colours, realise that the proportions of each colour affect focal points, and can help draw the eye from one area to another

The color with the largest proportional area is the dominant color (the ground).
Smaller areas are subdominant colors.
Accent colors are those with a small relative area, but offer a contrast because of a variation in hue, intensity, or saturation (the figure).

Placing small areas of light color on a dark background, or a small area of dark on a light background will create an accent.

Summary of links:

Principles of design: http://www.digital-web.com/articles/principles_of_design/.

Colour tutorial: http://www.worqx.com/color/index.htm

Color and E-Commerce: http://www.colormatters.com/des_ecom.html

Learning to Use Color on Your Website: http://www.creativepro.com/story/feature/6858.html

Peter Piper's Pallete: http://www.worqx.com/color/palette.htm

Random Color Generator: http://www.colorsontheweb.com/colorwheel.asp

The Color Wizard: http://www.colorsontheweb.com/colorwizard.asp

Digital Color Wheel: http://www.paintquality.com/color/index.html#

Gimmie an awesome main-menu

2007-07-01T20:15:00.000+09:30

Gimmie is a neat organiser/launcher for all your stuff on Gnome. You can add it to your gnome panel's as an applet, or as a stand alone dock.

It's a big improvement over existing menu-based structures (although I've yet to learn any nice keyboard shortcuts).

It splits things up into colour-coded tabs:

linux | programs, | library | people

You'll find synaptic, settings & places under 'linux';

your usual apps under 'programs';

documents, tomboy notes, music & media in 'library';

and contacts from Gaim/Pidgin under 'people'.

There's plans to integrate google contacts, flickr and the like in too.

What really makes it useful is that each has a set of buttons which act like filters - and one is "Recently Used". I've found that after a few days it learns the apps I use, the people I chat with and the doc's I'm working on. I just leave the Recently used button down and hardly ever have to go searching.

You can find gimmie in universe of Feisty, but it's in heavy development.

Get the latest from source.


./configure -prefix=/usr
make
sudo make install

NOTE:
The "-prefix=/usr" tells it to install in /usr - instead of /usr/local. Without it, the applet won't show up when you "Add to panel" (seems only /usr/lib/bonobo/servers is searched for applets and not /usr/local/lib/bonobo/servers).

Oh, and you'll need to sudo apt-get install python-gtk2-dev

More info here: http://www.beatniksoftware.com/blog/?p=53<

Association extensions tidy up your Rails models

2007-04-27T00:04:00.000+09:30

Don't underestimate the power of association extensions when building your rails models. I totally glossed over them until recently.

Consider this class:


class Project < ActiveRecord::Base
 has_many :stories do
   def backlog
     self.select { |s| s.iteration.nil? }
   end
 end
end

With this model you could say:
my_project.stories.backlog

As an alternative, you could put all the logic in the controller. This would, of course, violate Jamis Buck's 'Skinny Controller, Fat Model principle'.

Another alternative - use a more flat api style:


class Project < ActiveRecord::Base
 has_many :stories
 def backlog
   self.stories.select { |s| s.iteration.nil? }
 end
end

...and then you'd call it thusly:
my_project.backlog

The benefit of utilising association extensions is that methods will be grouped together more naturally, and tend to be shorter as a result of their context. The larger your model the more this will benefit you.

See more great examples of this in explainpmt - an open source web-based tool.

What Don't I Like About Ruby?

2007-04-26T21:54:00.000+09:30

Back in uni a friend told me you don't really understand a technology unless you see through the hype, and can enumerate what doesn't work so well. The benefit of doing so is a deeper and more practical level of knowledge ...which was a new idea to me at the time.

I've always been a bit like a human sponge. I soak up knowledge and can do so fairly quickly - but I don't do it objectively. It's not until I go and apply that knowledge that I see the more subtle effects. I think it's really only then that I can appreciate the results of the trade-off's that every language or library must make.

These days I *do* try and examine the negatives, and it's when I do so with Ruby that I find a most interesting situation. The negatives are a side-effect of the positives.

Look at 'Dynamic typing'... often seen as a big fat negative. After all, it's static typing that makes a language more easily processed by the machine - compiler's can point out bugs & IDE's can do funky refactoring. However, without it ruby wouldn't be able to express ideas so succinctly.

How about the 'Syntactic Sugar'? It's inconsistent, right? Cryptic?

No, it let's you express what you mean in the way you think it. It allows you to write code that is easier to *read*.

...and monkey patching. The process of patching core libraries by overriding existing methods in existing classes. When i first realised this was possible, alarm bells went off in my head - core classes don't have to be sub-classed - they're *wide open*. What about the clashes? Won't libraries override each other?? How can you debug-trace that?

Well, the danger is there but doesn't surface in practice. It's generally not done unless it provides real value - and then it becomes prominent. Case in point - 5.minutes.ago returns the time 5 minute ago - Rails cool bits like this wouldn't work without open classes.

Fundamentally, Matz goal was to make a programming language that was easier for developers - not machines. Everything else took a back seat - including performance, cross-platform ideals, or even purity.

"Language is the frame of thought."

In other words, our language not only defines how we communicate with each other, it also defines how we think, what concepts we are able to ponder, and how we internalize the workings of the world in our minds.

The moral of the story - constantly evaluate your language & tool-set. It'll provide a feedback loop into your learning and hence effectiveness.

:)

wireless ubuntu edgy

2007-01-13T17:31:00.000+10:30

No wireless! on my dell 6400... (with a Pro/Wireless 3945 ABG Network Connection).

Googling showed I needed to install linux-restricted-modules-generic but that didn't seem to fix it. I noticed ipw3945d was not in /sbin BUT /sbin/ipw3945d-2.6.17-10-generic *was*....

Copying this file to /sbin/ipw3945d makes it detect the wireless, but it drops out every 5 mins....

*UPDATE* No probs at all on Feisty.

I think it was most likely caused by messing with the ati video driver - and following HowTo's that installed a specific kernel. Anyway, I've learnt somewhat about kernel modules, X & some details on package management with ubuntu. That was half the point anyways...!

Using ActiveRecord Models in Migrations With STI

2006-12-18T20:45:00.000+10:30

It's cool to use ActiveRecord models in rails migrations...

However you might come across a problem i just had....

If you have a model utilising STI, you may find (like I) that you get a big bad "superclass mismatch for class X". ActiveRecord is instantiating your model class based on the 'type' column in your STI table - even if you use the parent class.

I hacked a workaround by disabling STI in my migration:


  # Disable Single Table Inheritance...
  ActiveRecord::Base.inheritance_column = 'something_to_disable_single_table_inheritance'

This will mean it won't look for a column called 'type' but whatever else you say there - just make sure you don't have a column called 'something_to_disable_single_table_inheritance'

:0

Find with :include ignores :order

2006-12-10T13:43:00.000+10:30

A rails bug bit me today! Ouch!

Well, at least the bug report was clear and explained the workaround well:

Ticket #6679 (new defect)
find with :include ignores :order from has_many declaration

Basically, when you eager load an association from a has_many relationship, :order is totally ignored. To work-around, you have to specify :order again on the eager load.

Vim 7.0 - Autocomplete With Rails

2006-07-12T11:08:00.000+09:30

Just installed Vim 7.0 ...and had to check out this cool 'omnicomplete' thingy! Like ctrl-space in eclipse to complete methods, etc...

I tried a ruby file, and on first go it complained:
'load_buffer_class': uninitialized constant MyClassNameHere

I wonder how I can tell vim where my rails code lives?

Found this blog describing how to setup for c - the key for me was this comment:


–run ctags on your C libraries (from VIM :help ft-c-omni)

I checked out :help ft-ruby-omni and it's all there:

Vim can detect and load the Rails environment for files within a rails project. The feature is disabled by default, to enable it add
let g:rubycomplete_rails = 1
to your vimrc

So I needed to add that line to my .vimrc file....

However, here I am on windows, and unsure where the .vimrc lives. It's supposed to go in your home directory - which on windows is typically 'C:\documents and settings\*user_name*\'.

Turns out, you can use unix style shortcuts within vim and they work fine. This is useful because I can edit the home .vimrc file using the following from within vim:
:e ~/.vimrc

Then, when i save the file (:w) it saves it in C:\documents and settings\*user_name*\.vimrc - problem solved!

BUT, then syntax and other defaults were turned off.... I had lost my 'default' settings.

What I needed was to source the defaults - which in my install was sitting in my VIM root, and named "_vimrc".

My final ~/.vimrc file looks like this:


source $VIM/_vimrc
let g:rubycomplete_rails = 1

And now all is good! Now I just need to spend some quality play-time...

Learning VIM

2006-07-12T09:50:00.000+09:30

A colleague of mine re-introduced me to Vim about 6 or so months ago. Like many people, I dismissed it originally as entirely too obscure and unnecessarily difficult to use.

However, as a programmer I've come to appreciate the powerful UNIX command line well-over the windows one. It only seemed logical to apply the same thing to my editor (command-line vs point-click)

The h-j-k-l keys are used as left-up-down-right movement keys because they are on your 'home' row and hence quicker to get to (and come back to). As a touch typer I can really appreciate that!

One interesting thing I've noticed is that after 10+ years using the arrow-keys I sometimes unconsciously hit the 'p' key (which means put or paste) instead of up when using these keys. :)

This is weird because I'm using my little finger - even though I use the middle finger for up-down when on the standard arrow keys...

It's something like 'spatial' body memory controlling my fingers!

Apache Tomcat Connector (JkMount) won't work for servlet base - without a slash

2006-07-11T16:36:00.000+09:30

We have a tomcat app-server running some java servlet apps which we pass through from apache using the tomcat JK connector. It all worked fine - so long as you don't request the base servlet path. As an example:

# Mount worker1 to all urls starting with that base
JkMount /jsp-examples/* worker1

The above won't work for http://localhost/jsp-examples (note there's no trailing slash!). A simple solution - mount the path without the slash too:

# Mount worker1 to all urls starting with that base
JkMount /jsp-examples/* worker1
JkMount /jsp-examples worker1

Progress, Java, Ruby

2006-06-23T00:08:00.000+09:30

I've spent way too much time working with Progress 4Gl. It's a language whose '4'ness is due to it's tight integration with the database.

You can do stuff like this:

FIND FIRST Order EXCLUSIVE-LOCK
 WHERE Order.OrderDate = TODAY.
DISPLAY Order.

A procedural style database access (over SQL's set-based style) with in-place access to tables and fields.

However, it can really suck.

Why? Well, you are limited in your ability to code at a higher level of abstraction. This has hit me again and again over the last 7 years while working with a large inherited code-base. You have no object instances, or struct's or function pointers or custom data-types. This limits the ability to have code be concise, or readable.

Recently I've had the interesting task of writing the same system in Progress 4GL, then Java, then Ruby (don't ask how or why!).

I loved some aspects of Java:

Objects and classes - using basic classes with collaborating objects drops a tonne of 'noise' you have to maintain with Progress because of it's primitive support for abstraction
Spring - I just love flinging around singleton instances, setting this on that so loosely. Loose coupling/tight cohesion city!
Massive number of quality open-source libraries out there
IDE support - i saw 'refactoring' happen in IntelliJ, but found almost as good support in Eclipse. Refactoring rules.

Then we got onto rails, and more importantly ruby. I've settled on ruby, I think, because the underlying philosophy seems to be about making life easier for the developer.

In my opinion, the 'noise' you drop in Progress -> Java is similar in Java -> Ruby.

POLS - Principal Of Least Suprise
Humane interfaces (multiple methods doing very similar things). How often do I think 'wonder if this'll work', and yep, it just does, then I lookup ri and find out it's an alias. It also makes code more readable.
Extraneous syntax can be left out - Methods don't need (), lines don't need a terminator.
Consistancy - everything is an object. This helps in simplifying your view on things. Java primitives suck.
Arrays and hashes are built in - and they are objects. Iterators work on both, and simply rock. They make complicated code compact yet readable and concise.
Operators are overloaded to work in ways that make sense.
Eg: array1 + array2,

Of course, rails is great with it's principle of DRY (Do nor Repeat Yourself), which is a principle I've often strived for but with limited success.

I think matz, the creator of ruby, sums it up best:
Often people, especially computer engineers, focus on the machines. They think, "By doing this, the machine will run faster. By doing this, the machine will run more effectively. By doing this, the machine will something something something." They are focusing on machines. But in fact we need to focus on humans, on how humans care about doing programming or operating the application of the machines. We are the masters. They are the slaves.

I couldn't agree more. Thank's matz.