Technical Notes » Ruby http://blog.anthonychaves.net Life is software and jujitsu Tue, 16 Feb 2010 22:15:16 +0000 http://wordpress.org/?v=2.9.1 en hourly 1 Dummy Code (Quick’n'Dirty vs. Engineered) http://blog.anthonychaves.net/2009/02/04/dummy-code-quickndirty-vs-engineered/ http://blog.anthonychaves.net/2009/02/04/dummy-code-quickndirty-vs-engineered/#comments Wed, 04 Feb 2009 22:34:13 +0000 Anthony Chaves http://blog.anthonychaves.net/?p=125 When creating software, two people will never write the same implementation of a method or system of non-trivial design.  Creating software is a problem solving process and there are usually many ways to solve one problem.  The solutions may differ in elegance and efficiency while giving the same output for a given set of inputs.  A correct solutions is a correct solution regardless of implementation.

Building software modules within a team requires communicating, at a minimum,  method or class signatures and a general idea of the functionality.  This may include a detailed design document clearly specifying method signature and a pseudo-code implementation or method stubs and comments about what the method should do right in the source file.  One thing that should never be used for communicating a signature and functionality is dummy code.

Dummy code looks like real code.  It is real code but it rarely works.  Even if it compiles it doesn’t produce the correct result when run.  Nor are there any tests that prove it (in)correct.  Dummy code exists only for the sake of its author’s gratification.

Rather than talk about the desired functionality through some more productive means the dummy code author thinks he is helpfully providing a guesstimate of correct implementation.  What he has actually done is provide a jumbled mess of non-working code cleverly disguised as a working part of the project when he checks it in to the SCM.  The dummy code author thinks someone else will come along and provide the correct implementation “later”.

What he doesn’t realize is that his dummy code is almost indistinguishable from code that should be part of the project.  The next person to try to reuse this code is in for hours of WTF moments trying to figure out WTF the code is supposed to do and why it’s got code branching five levels deep.

At my first post-college job I had a wonderful mentor.  Thys (pronounced Tays, like “taste” without the second ‘t’) and I were talking one day when he asked me a question.  “Anthony, if you were given a task of writing software that would only be run once would you do it quick-and-dirty or with a well-measured, engineered approach?”

How bad could “quick-and-diry” be if the software would run only once?  I thought about it for a moment before answering.  Quick and dirty.

Thys said he would never write quick and dirty software.  Doing so figuratively creates a  monkey on the developerment team’s back.  The software that only needs to run once inevitably needs to run a second time and a third time and eventually run regularly.  Thys helped me realize that software evolves and escapes.  Useful software will run indefinitely.  Any time and effort saved on the initial write will be lost 10 times (I made that number up.  It is actually higher.  Any want to provide real data or examples?) over on the maintenance, bug fixes and rewrites.

Writing dummy code is writing software quick and dirty without any idea of the implementation details.  Bad code and bad algorithms.  The worst of both worlds.  It’s been a long time since Thys and I had that conversation but the years have proven him right again and again.  Any code worth checking in to SCM is worth writing well.  That includes unit tests.

Dummy code has no place in SCM.  If you’re not going to correctly implement a method you stub out then don’t provide an implementation at all.  Leave some comments around the method stub if you have to.  Open a ticket in the issue tracking system to let someone know the method needs an implementation and describe the input and output.  Let the implementer determine which algorithms and data structures to use.

Dummy code is a hazard to software projects.  It violates the principle of least astonishment.  Next time you think about writing some remember that the next person that uses the code will waste time figuring out why it doesn’t work as expected.

If you check code in to your SCM where other people can pull it, take a look at what you’re checking in.  Does it work?  Does it work well?  Are there tests that prove it?  Helping someone by coding less is sometimes the best help of all.

]]> http://blog.anthonychaves.net/2009/02/04/dummy-code-quickndirty-vs-engineered/feed/ 0 Industry Ignorance http://blog.anthonychaves.net/2009/01/22/industry-ignorance/ http://blog.anthonychaves.net/2009/01/22/industry-ignorance/#comments Thu, 22 Jan 2009 22:27:41 +0000 Anthony Chaves http://blog.anthonychaves.net/?p=106 Today I let out a dejected sigh after reading a response to my latest post on the Joel on Software message board.  My post was just a reminder about the BostonScalability User Group meeting that takes place next Wednesday the 28th.  I post the meeting announcements on JoS and a good number of people hear about the meetings from the JoS board.  Every month a few new people tell me they found the group through JoS.  So why did I sigh after reading the response to the meeting reminder?

I don’t make any money running the group.  In fact it costs me money.  I do a good amount of planning, coordinating, buying, booking and raffle prize finding for the group.  I love seeing 30+ people show up for our after work meetings.   It’s a lot of work but I do it because I am passionate about emerging trends in application scalability.  It’s a labor of love that I find professionally and personally rewarding.  Like all good geeks I maintain a healthy hobby writing software outside business hours.

I’m interested in building bigger, better software.  Batch applications, database interactions, web applications, CPU intensive algorithims should be as effective as possible.  Effective does not necessarily mean efficient.  Effectiveness is based on price, time-to-market, performance, maintenance cost, etc.  Analyzing these facets is important. The tools used to arrive at the solution are important, too.

BostonSUG has wonderful speakers who generously donate their time to speak at our meetings.  These people come in from all over the country.  Just a few examples, we’ve hosted Orion Letizi and Nikita Ivanov from San Francisco, Billy Newport from Minnesota and Mike Culver from Washington.  We’ve had numerous local speakers who we appreciate just as much as those that fly to see us.  Patrick Peralta, Tom O’Hare and Rakesh Chaudhary had large audiences.  Each of these speakers is an expert in a different facet of building scalable applications.  They are industry leaders in compute clouds, data grids, object caching, streaming media and more.

One thing we haven’t touched yet is building a web site that performs well.  The person that replied to the meeting reminder said:

save your time:
only put strings in session; and only put one item per-user in the session; unless they are doing some heavy form processing.
use native clustering.
put professional load balancer in from.
max pipe.

Thanks.  That is a helpful reply.  It immediately invalidates the hours of insightful discussion we’ve had at past BostonSUG meetings that have spent less than five minutes total dedicated to the problem to which he so generously offers his solution</sarcasm>.

traditional-web-architecture

This is a picture of what is described in the reply post.  As an industry we have known this works for a long time.  That’s why we don’t talk about the architecture depicted by this diagram at BostonSUG.  Sure, we’ll talk about HOW an app server achieve scalability.  We’ll talk about the implementation, not just about using JBoss or Mongrel.  We got a good look inside GridGain.  We had a guided tour around Terracotta.  BostonSUG evokes deeper discussion than “small sessions, load balancer, database cluster, done!”.  You should do that anyway.

Past meetings aside we have a lot to talk about this year.  Rails 3, Java 7, CloudFront, Hibernate Shards, Google AppEngine, tons of topics that push the industry foward.  If you’re interested in evolving and not building the same old software then come to BostonSUG.  If you’re interested in building what we know works (and have known since pre-2000) then it’s not the meeting for you.

I didn’t intend for this to turn into a meeting plug but I might as well include the link to the meeting announcement.  Wednesday January 28, 2009 @ 6 p.m.  IBM Innovation Center Waltham, MA 02451

]]> http://blog.anthonychaves.net/2009/01/22/industry-ignorance/feed/ 4 Scalability round-table/forum on January 28 http://blog.anthonychaves.net/2009/01/13/scalability-round-tableforum-on-january-28/ http://blog.anthonychaves.net/2009/01/13/scalability-round-tableforum-on-january-28/#comments Tue, 13 Jan 2009 21:03:28 +0000 Anthony Chaves http://blog.anthonychaves.net/?p=80 The Boston Scalability User Group is hosting a technology round-table meeting on Wednesday January 28th at 6 p.m.  The meeting is at the IBM Innovation Center in Waltham, MA.

This is the first time we’ve done the round-table style meeting and I’m excited to see how it goes.  Guests are encouraged to come prepared with questions, answers and opinions on application scalability tools, strategies and designs.  Hot topics will include platform and software stack, cloud computing and resources, vendor tools and support and CDNs. Those are my guesses about hot topics doesn’t mean the meeting is limited to those topics.

Guests, be the regular or first-timers, will drive the direction of the discussion.  We’ll talk about solving technical problems based on past experience or serve as an advisory panel on where and when to use a particular tool.

Full meeting details are at the BostonSUG web site.  We ask that you sign up for the meeting at the meeting registration page so we have an idea of how much food to buy.  There will be snacks and bottled water at this meeting.

Hope to see everyone on the 28th at 6 p.m.!

]]> http://blog.anthonychaves.net/2009/01/13/scalability-round-tableforum-on-january-28/feed/ 0 Rails and Restful Authentication http://blog.anthonychaves.net/2008/07/11/rails-and-restful-authentication/ http://blog.anthonychaves.net/2008/07/11/rails-and-restful-authentication/#comments Fri, 11 Jul 2008 16:28:01 +0000 Anthony Chaves http://blog.anthonychaves.net/?p=54 It’s been quite a while since my last Ruby on Rails post so let’s go over a little “gotcha” that you might encounter when using the restful_authentication plugin.

Getting started with restful_authentication is fairly easy.  After installing the plugin it’s just a matter of running the following generate command:

script/generate authenticated user sessions

This will create a migration for a users table, a model and controller for users and a sessions controller.  It will also add some named routes to config/routes.rb.

So far so good, right?  Well, a common mistake when generating the model and controllers is to user the singular form of both user and session.  The command will run successfully and do exactly what you told it to do.  You won’t become aware of a problem until you try to log in for the first time and see this:

NameError        in SessionsController#create


uninitialized constant SessionsController


RAILS_ROOT: C:/rails/bookmarks


Application Trace |             Framework Trace |             Full Trace






Request


Parameters:


{"commit"=>"Log in",
"authenticity_token"=>"0c0f07222da8ed58d8c6ebcafb9bf32f0bc84143",
"login"=>"anthony",
"password"=>"mysupersecretpassword"}


Uh oh! what went wrong?  It looks like Rails is looking for a controller called SessionsController.  But we generated one named SessionController.  Why is this happening?  Take a look in the views/session/new.html.erb file.


<% form_tag session_path do -%>


<p><label for="login">Login</label><br/>


<%= text_field_tag 'login' %></p>


<p><label for="password">Password</label><br/>


<%= password_field_tag 'password' %></p>


<!-- Uncomment this if you want this functionality


<p><label for="remember_me">Remember me:</label>


<%= check_box_tag 'remember_me' %></p>


-->


<p><%= submit_tag 'Log in' %></p>


<% end -%>


The form_tag target is session_path.  session_path is created for us by magic because of its mapping in routes.rb.


map.resource :session


When mapping a resource like this Rails looks for the controller with the pluralized name of the resource name by default, which means session_path is getting SessionsController.  We can change the behavior by explicitly setting the controller for the resource.


map.resource :session, :controller => :session


Try to log in again and you will be authenticated!  Of course it may just be easier to remember to use the pluralized name of whatever controller you want to use for managing sessions.
]]> http://blog.anthonychaves.net/2008/07/11/rails-and-restful-authentication/feed/ 3 Boston Scalability User Group http://blog.anthonychaves.net/2008/02/04/boston-scalability-user-group/ http://blog.anthonychaves.net/2008/02/04/boston-scalability-user-group/#comments Mon, 04 Feb 2008 20:59:16 +0000 Anthony Chaves http://blog.anthonychaves.net/java/2008/02/04/boston-scalability-user-group I’ve been digging around lately for a Boston area user group dedicated to architectural scalability and I haven’t been able to find one. Other user groups that I regularly attend have meetings centered around scalability once in a while, but I’m looking for something with a schedule dedicated to the topic. It’s a hot topic in the industry right now with a lot happening on different fronts and there should be some ongoing professional discussion dedicated what goes into growing an application.

Here are some of the topics I want to talk about:

  • Data growth and access – What kind of DBMS topologies allow maximum scalability without breaking the budget? What if the budget wasn’t a problem? How do you migrate your data model from hundreds of users to millions of users? Should you partition user data across shards or keep it in a central database? How do you profile data access paterns? Is your application mostly-read or mostly-write? When should you use an LDAP directory for data storage? When should you use MySQL and when should you use Oracle?
  • Application server scaling – app server clustering, web server integration, load balancing, application session management, data caching
  • Web Tier – load balancing reverse proxies, data caching, working with HTTP, considerations for exposing functionality via REST
  • Language conisderations and platform choices – Dynamic languages vs. Static languages, Linux vs. Windows, Solaris vs. Linux, RedHat vs. Oracle, IBM vs. Oracle – How do you make these choices? What evaluation critera are most important? Which ones are misleading?
  • Framework scalability – How can you scale if your framework can’t? Does Rails really scale better than Spring Web MVC? Where do PHP frameworks fit in? What are the alternatives? This is where we will investigate what you gain and lose by binding yourself to a particular framework, how to keep the coupling to a minimum and how to use your framework as a solid foundation instead viewing it as a cage.
  • Emerging technology – Should you become familiar with Map Reduce and Hadoop? What kind of impact do object databases have on your application? Should you buy your own Sun or Dell boxes or use Amazon’s EC2 and S3?
  • Application architecture – How do you write an application that scales? What does your application look like as it grows from servicing hundreds to millions of users? How does it handle session management? How does it access datastores? Are there any design patterns that are helpful? What are the anti-patterns to be aware of?

Like I said, I haven’t found a group dedicated to discussing these topics. If you know of one in the Boston area please let me know. Assuming there isn’t one I am willing to start one. I’d like to start off small and meet at coffee shops around Burlington or Lowell. I have no delusions that this is going to start off or even become as big as NEJUG is now. If it starts off as a few people getting together to talk about scalability trends, cool caching solutions and specific products then I’d call it a good start.

The meeting location is still TBD and will be based on how many people are interested in attending. It will probably be somewhere in Burlington, MA. There is no planned presentation at this time. Instead we will have a meet and greet and then discuss scalability trends and news, what approaches to scalability are commonly used now and what are the plans for the future.

If you are interested in coming or in finding out more information please email me at <my first name>@<my domain name>.<my tld> or leave a comment below. Please make sure to include your email address when you fill out the form so that I can get in touch with you – your email address will not be displayed on my site.

]]> http://blog.anthonychaves.net/2008/02/04/boston-scalability-user-group/feed/ 0 Ruby Modules, Mixins and name clashes http://blog.anthonychaves.net/2006/07/01/ruby-modules-mixins-and-name-clashes/ http://blog.anthonychaves.net/2006/07/01/ruby-modules-mixins-and-name-clashes/#comments Sun, 02 Jul 2006 02:56:03 +0000 anthony http://www.actechnotes.com/blog/?p=8 Ruby allows the creation of modules that provide namespaces for methods and constants to live. They are also used to mixin these methods and constants into classes. These mixed-in modules provide a class with references to whatever is defined within the module. Below is a small (meaningless) Ruby module. 

module AnthonyModule
  CONST_DATA = "I am a constant from AnthonyModule"

  def who_am_i
    puts "My name is: #{@name}"
  end

  def ten_times write_me
    10.times { puts "#{write_me}" }
  end
end

This module provides two methods and one constant. When this module is mixed in with a class these methods will become instance methods of the class. Below is an example of using the require method to load the AnthonyModule.rb file and the include method to reference the module in the class. 

require "AnthonyModule"

class MyClass
  include AnthonyModule

  def initialize name
    @name = name
  end

end

Notice this class does not have a method called ten_times defined in it. However when an instance of this class is created it will have a ten_times method because the AnthonyModule is included. A call to this method is shown below. 

m = MyClass.new "Instance 1"
m.ten_times "Hello modules!"

This will produce ten lines each with “Hello modules!” printed on it. Now what happens if another module is introduced that provides another method also named ten_times? 

module NewModule
  CONST_DATA = "I am a constant in newmodule.rb"

  def ten_times multiply_me
    puts "ten times #{multiply_me} is: #{ 10 * multiply_me }"
  end
end

Using require and include to mix in NewModule into the class there are now two methods with the same name and signature in the class. Because Ruby looks in the module included last in a class it will find the NewModule#ten_times method before the AnthonyModule#ten_times method. Running the sample code gives an error now. 

ruby/NewModule.rb:5:in `*': String can't be coerced into Fixnum (TypeError)

The problem here is that Ruby does not know how to multiply a number by a string. I don't want to do this though, I want to print out my message ten times. Because I'm calling the ten_times method outside of the class I can't specify exactly which ten_times method I want to call. Ruby picks the first one it finds searching backwards (upwards) through the include list. It appears as though using mixed in methods with a name clash outside of the class can not be done. If the module's methods were called in some class methods the module name could be used to differentiate between which method should be called. Outside the class there is no such luck.

I'll be starting a Rails app later.

Anthony

]]> http://blog.anthonychaves.net/2006/07/01/ruby-modules-mixins-and-name-clashes/feed/ 0 Ruby threads and processes http://blog.anthonychaves.net/2006/06/26/ruby-threads-and-processes/ http://blog.anthonychaves.net/2006/06/26/ruby-threads-and-processes/#comments Mon, 26 Jun 2006 07:53:17 +0000 anthony http://www.actechnotes.com/blog/?p=9 I made quite a bit of progress in reading the Pick Axe Book over the weekend. I wrote a little program to reflect what I read and to scratch an itch of mine too.

I have three processes that I want to run at all times if it can be helped, but it's ok if there is some downtime for each. Whether these processes are started at system boot time or any time later doesn't make a difference to me, if they go down I want to start them back up. For a (very short) time I just blindly used the cron for my user account to start the processes once every X hours. Unfortunately this meant that five instances of the Unreal Tournament 2004 server would be running at once. svnserve would fail and send me email every few hours when it was invoked and JBoss would consume far too many resources because it was running too many instances. Using the cron to blindly kick off the servers was a bad idea.

Because I wanted to use the cron or an equivalent to periodically check on the servers I had to come up with a way to determine if the servers were already running before trying to start them again. I came up with two short Ruby scripts to solve this problem. The first is a class to represent the process to monitor and start. 

class ProcessMonitor

  def initialize(name, processString, restartCmd)
    @name, @processString, @restartCmd = name, processString, restartCmd
  end

  def get_process_list
    @ps = IO.popen("ps -ef", "r")
  end

  def is_running?
    re = Regexp.new(".*?#{@processString}.*?")
    @ps.each do | line |
      if re.match(line)
        return true
      end
    end
    return false
  end

  def restart_process
    puts "Process  is not running.  Trying to restart."
    process = Process.fork { system("#{@restartCmd}") }
    Process.detach(process)
  end

  def run
    get_process_list
    if !is_running?
      restart_process
    end
  end

end

The constructor takes a name (which doesn't do anything at this point), a substring of the process to look for in the ps output and the command used to restart the process if it isn't running. The get_process_list serves only to get a ps listing of all the processes running.

The is_running? method examines each entry in the listing until it finds a process that matches the processString snippet passed in when the object was created. The run method will execute the restartCmd string only if the process is not running. The restart_process method uses the Process.fork method to start the command as a process outside the current Ruby interpreter. It then detaches any interest in that long running process, enabling the Ruby interpreter to exit normally.

I should point out that I had some trouble debugging what turned out to not be a problem. I developed this class in Eclipse using and the Ruby interpreter would not terminate when run from inside Eclipse. Running the program on the command line works without this strange hang.

Because I do not want to provide a cron entry to call this class for each process I want to monitor I have written a small driver class that takes input from a file. 

require "process_monitor"


filename = ARGV[0]


processes = Array.new


IO.foreach(filename) do | line |

  params = Array.new

  line.each("::") do | param |

    params 



This script takes one filename as its argument.  Each line in the file should contain a "::"-delimited list of parameters to create a ProcessMonitor object with.  After parsing each line a new ProcessMonitor object is created and run in a new thread.  After all threads have been run the script waits for each to finish and the program exits.  I plan to put error handling and write test cases sometime this week.

]]>
			http://blog.anthonychaves.net/2006/06/26/ruby-threads-and-processes/feed/
		1