What would be a fun next step here is to build a social system on top of this once more people are using it and show most commonly bookmarked pages, or ‘people who bookmarked this gem also bookmarked…’.

That’s all for now! P.S. Helio: where’s my firmware upgrade to fix all the wierd inconsistencies?

1. Use twitter for lightweight status updates (instead of emailing team@) – example: i am upgrading our hosting account, or I am refactoring something

2. Use twitter to ask a question when you don’t know who should answer it – example: has anyone touched my code? has anyone talked to Bob about Task X?

3. Do not use twitter as a chatroom. Pretend it’s a reply-all email, if you wouldn’t do it there, take it offline and talk to the person directly.

4. Tweet once or twice a day to let the team know what you’re working on. It helps keep the ball rolling and identify roadblocks without relying on once-a-week meetings.

5. If going on vacation or extended leave, you can turn off twitter updates and use the rss feed to pull a once a day list of everything that happened. Using the guidelines above the tweets for the day should be a list of about 10 items so it’s easy to digest.

6. (ok I lied about only having five) Use a twitter client or twitter gtalk bot to keep updated. The website is ridiculously slow.

7. If you’re on the road and it’s easier to reply to a twitter than to private message someone, use the direct messaging feature “d [username] message” to keep things private but use twitter as a preferred routing mechanism.

How are you using twitter in your workplace?

map.from_plugin :your_plugin_name

Now since I want a truly plug-n-play system, I can’t be modifying the route file of my main application. So here is a quick solution to import all the routes (note that in engine-plugin style you do not use the “map.” prefix for your routes, so I am adding that in)


#--routes.rb of the main applicatoin--
Dir["#{RAILS_ROOT}/vendor/plugins/*"].each do |plugin|
File.open("#{plugin}/routes.rb").each do |line|
eval "map.#{line}"
end
end


That’s all folks!

What did I miss?

We released two new versions of our financial trading appliances available on our website for free download. The virtual appliances can be run in vmware or Parallels, and feature a web admin console I wrote in Ruby on Rails (but of course). So you can boot them up on pretty much any environment and you’ve got a nice plug-n-play way to administer the appliance and so on.

Of course, all of my other copious spare time has been taken up by Planypus, where we have recently surpassed 1200 registered users! Come check it out and start making plans with your friends the easy way!

1. Never look when you can search. Why look when you can search? Even if you’re looking for one item in a list of ten, it is always faster to type three or four characters than to scan the list with your eyes. Most reasonable environments including the popular editors and IDEs offer at least some way to do inline completion-based searching. Hit the shortcut and type the first couple characters identifying what you’re looking for and you’re there.

2. Don’t repeat yourself. Are you typing the same thing over and over? Make a shortcut out of it. Use global keyboard shortcuts to call up your favorite apps. On OSX/Unix, alias is your friend. Make two character mnemonic aliases for everything. Corollary: Never Mouse when you can Key. A good approach to learning built in shortcuts is every time you reach for your mouse, make a note of the shortcut key for the action you’re performing, and then let go of the mouse and execute the action from the keyboard. Then do it two more times.

3. Learn a scripting language. Bash, Perl, Ruby, Python. Pick one and learn it. Perl used to be the king of one liners. These days I find myself reaching for ruby more because I use it on a daily basis anyway. Automate common tasks with bash and ruby.

4. Learn an editor. I mean a real editor. Both vi and emacs are acceptable choices here. Some people like TextMate but after PeepOpen came out for vim, delivering vim’s One Missing Feature, there’s really no reason to use TextMate over vim. With insanely fast window spitting, buffer searching, and text manipulation, you’ll save yourself thousands of keystrokes a day by using vim. There are good dotfiles that make it look just like TextMate anyway.

Corollary: Use that editor everywhere. Now that you know vi, type set -o vi on your bash command line. Now use vi to edit your command line. Instantaneous productivity boost of about 10x. If you’re an Eclipse junky, use the Vi plugin for Eclipse.

If you learn one thing in vi: learn to move around using the home row keys, skip words using w, b and change commands such as cw (change word), or ctA (change from current position until the next occurrence of A). This becomes second nature because you look ahead as you type the command to achieve efficiency. There are plenty of tutorials, use google or the built in vi help system.

5. Learn regular expressions. There is no excuse not to know at least the basics. You don’t have to be a regex guru, just be functional. It probably takes a lifetime of meditation to achieve true regex enlightenment. But spending an hour a day trying to use regexes will take you 80% of the way. Read the perlre manpages, that’s where I got my start. Learn to use regexes in your editor to search, on your command line for quick one off scripts, in your programs to do text manipulation.

None of these things are hard, they just take practice and dedication to become true habits. The most important way to turn them into habits is to establish a routine that forces you to apply one or more of these principles and ideas every day.

##### database.yml #####
production:
  adapter: oci
  username: user
  password: <%= PROD_DB_PASSWORD.decrypt(PROD_KEYFILE) %>
  host: host/schema

####### local.rb #######
class String
  def decrypt(keyfile)
   #do some magic to apply the keyfile to the password
  end
end

That’s all there is to it! Simply plugin any key-based encryption routine in there. In my case we were using a triple des two way encryption that was actually done by an external Java program. I simply invoked the java interpeter using backticks and got the output which was my decrypted password.

These objects are sort of the combination of what you might find in a traditional Java XML binding framework such as JiBX, except in Java you’ll typically write the object and then write an xml mapping file. ROXML feels more like Java annotations, where you write the object which is simultaneously the specification for how to marshall/unmarshall it.

# lang ruby
class LoginReq
include ROXML, Initializable
xml_name "LoginReq"
xml_attribute :xmlns
xml_object :Credentials, Credentials
end

class Credentials
include ROXML, Initializable
xml_name “Credentials”
xml_attribute :UserId
xml_attribute :Password
end

Here’s a really simple login request object with a sub element of Credentials. It’s that simple! Now i’ve got some objects that can read and write xml:

# lang ruby
loginReq = LoginReq.new(:xmlns => NS, :Credentials => Credentials.new(
     :UserId => username, :Password => password) )
xml = loginReq.to_xml.to_s

To make this work with webserivices, all you’ll need to do is wrap the xml generated with some soap headers which can be hardcoded as constants.

# lang ruby
def send_request(xml)
data = SOAP_HEAD + xml + SOAP_FOOT
response = Net::HTTP.start(host, port) {|http| http.post2(path, data,
     {"Content-Type" => "text/xml"}) }
end

On the way back, all you have to do is strip off the soap headers, and then unmarshall the xml back into an object

# lang ruby
response_body = response.strip_soap #this just uses a regex to get rid of the extra soap crud again
loginRsp = LoginRsp.parse(response)

The last piece of magic here is the Initializable module which simply allows you to initialize any class by passing in a hash of its attributes:

# lang ruby
module Initializable
def initialize(options);  options.each{|k,v|  self.send("#{k}=",v) };  end
end

Here are the headers and RE for stripping them

# lang ruby
SOAP_HEAD = %{ <soapenv:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><soapenv:Body> }
SOAP_FOOT = %{ </soapenv:Body></soapenv:Envelope> }
XML_RE = /<?xml[^>]+>/
SOAP_ENV_RE = /<w+:Envelope.*><w+:Body>(.*)</w+:Body></w+:Envelope>/

Now this may not be as automatic as generating the objects from wsdl, but on the other hand it allows you to extend your model objects and give them rich functionality along with the included xml binding skills they inherit from ROXML. And for now, this may be the only way to talk to complex webservices, whose wsdl is less than ideal for Soap4R. Enjoy!