I’ve been doing distributed computing in various forms for many years. Some at the higher level, some at the lower level and can tell you that with all the research advances and toolkits out there, it’s getting easier, but it’s still not as straight forward as it should be. Similar issues exist in multi-[process|thread] implementations. Although abstraction toolkits exist and they definitely make it easier to perform such actions without knowing much about implementing distributed algorithms, they are still leaky abstractions that in most non-trivial cases lead to having to have knowledge of the memory model, synchronization semantics, mutability, network topologies, etc… I’m not saying this is bad, I’m just saying that we haven’t yet reached the point where distributed or multi-[process|thread] computing is a cross cutting application concern. We have to actively bake it into our applications. I’m not arguing that abstractions should make developers ignorant of the underlying mechanisms, it’s just that they should be introduced at different levels of abstraction. It’s good to know what makes things tick (i.e. algorithms, data structures, etc…). Just look at the ORM world. The promise of not having to know SQL and just programming using OO took the OO world by storm. The naive thought that if you didn’t know the latest/greatest in ORM, you weren’t worthy. Years later, it turned out to be just a fad. Most have now turned back to SQL or some abstraction that’s flexible enough to allow you to work as low level or as high level as needed. In some cases, people are turning away from SQL data stores completely, but that’s another story.

A Little History

About 3 years ago, I was in the process of starting a company with my partners and we had a dilemma. We needed to process large amounts of data in near real-time. We also needed to be able to scale this horizontally in a “near” linear fashion. Data throughput was not temporally predictable, if predictable at all. After doing some searching and trying to fight the urge to implement things from scratch, we came upon the tuple-space programming model. It’s similar to the blackboard system for those that have an AI background. This is exactly what we needed, some shared distributed memory model that we didn’t have to think about (it presented itself as a single unified tuple space), and a programming API that allowed us to distribute jobs to work on the data stored in that model. Javaspaces is the java specification for Tuple Space Model. At the time, the only company that implemented this spec was GigaSpaces. We took their toolkit for a spin and it worked. The model was pleasant to program to and things were great. That’s until they didn’t work. Debugging was difficult, it leaked distributed abstraction. Deployment was also not very straightforward. None of that was the limitation of the Tuple Space Model, rather it was the implementation. I’m not saying GigaSpaces didn’t have a good implementation. I actually think it was rather nice at the time and am sure it’s way better now. At one point, we wrote an intermediary home-brewed rewrite of the system, so that we didn’t have to rush with the main implementation and can flush it out without harsh time constraints. In a few months, we ended up folding the plans to use GigaSpaces not because of the software, but rather because the company [GigaSpaces] had financial difficulties and their software, not being open source, was in flux in our opinion and we didn’t want to bet the success of our company on a commercial product of a company that looked like they were going to fold. Years later, they are still in business, great for them, but I don’t particularly regret our decision, especially looking at today’s landscape.

Most of our backend software is written in Java, Scala, and Python. Our web CRUD front end is written in PHP. The front end has a model that reflects our business domain, though it already encapsulates all of the business rules for our relational backend data store. We have a calculation process that utilizes these business rules to perform a bunch of operations and in the process reads/writes to the database. This process is very involved as it crunches hundreds of thousands of data points and will go up to millions in the next few months. It was written in PHP. We want to rewrite it using the model of distributing the data and computation using data affinity (collocating data and computations together). We’ve done it before and it works. So we’re happy to do it again, but we want to do this right and that might take some time. In the meantime, we wanted to take an intermediary step of distributing the workload amongst multiple servers (brought up and down as needed). I’ve been looking at numerous distributed toolkits for a while, from Hadoop to Akka to Gridgain. One that always stood out in the crowd has been Gridgain and in the last 6 months I’ve tried to find some place where it would pay its dividends. This project was it. We had a distributed scheduling service running on ec2 within a week, not bad, being that I had to learn the APIs and various ec2 deployment ins and outs.

Implementation

Our implementation has a scheduler that decides what computations need to be performed. We then schedule these computations by pushing a job to a distributed worker node. Because our job is run as a shell script (invoking PHP) and outputs statistics after it successfully runs, we run the job using java’s ProcessBuilder class. We then run the process, and capture its output (in json). The output is then returned to the scheduling node, evaluated, and logged. The scheduler then knows that this job can run again (we have a need to ensure the job is a singleton when it comes to running in a grid).

Our implementation is in Scala. Gridgain has a rather nice Scala DSL. We used it as much as we could, but in some cases resorted to java API for reasons I’ll explain later.

First, here is our simple task that scheduler (once it figures out a job needs to run), pushes to remote nodes…

import org.gridgain.grid.GridClosureCallMode._
import org.gridgain.scalar.scalar
import scalar._
import java.io.File
import io.Source
import net.liftweb.json._
import net.liftweb.json.JsonDSL._
import java.util.{Date, Collections}
import java.util.concurrent.{Callable, TimeUnit, Executors, ConcurrentHashMap}


class GridTask(scriptCommand:String, scriptEnv:String, scriptDir:String) extends Callable[JValue] {

  def call() = {
    val proc = new ProcessBuilder(scriptCommand.split(" "): _*)
    proc.command()
    proc.directory(new File(scriptDir))
    proc.environment().put("APPLICATION_ENV", scriptEnv);
    val p = proc.start()
    p.waitFor();
    val retString = Source.fromInputStream(p.getInputStream).getLines()
    val errString = Source.fromInputStream(p.getErrorStream).getLines()
    if (p.exitValue == 0 && !retString.isEmpty) {
      parse(retString.mkString("\n"))
    } else {
      ("event_id" -> 53) ~
        ("start_time" -> new Date().getTime) ~
        ("error" -> errString)
    }
  }
}

The above is pretty self explanatory. I kept of bunch of irrelevant things around, like inferring the return of the process and parsing/returning json.

Our scheduler is more complex, so I won’t show it, but it’s all custom business logic, nothing that has to do with scheduling a job on the grid. To scheduler the job, all you have to do is…

val retVal = grid.remoteProjection().call(
      UNICAST, 
      new GridTask(scriptCommand, scriptEnv, scriptDir))

retVal is now the JValue instance returned from the remote job. If you get rid of the custom business logic in the GridTask implementation, the whole thing is a few lines of code. Talk about an “abstraction”! Also, one mention is that don’t let simplicity in their examples fool you. Their API is full blown and gives you the level of granularity you need, jus ask, and ye shall have. For example, grid.remoteProjection() returns a projection of all remote nodes (not including the current node, which is local). This is important for us because we didn’t want the local node (scheduler) doing any computations as it’s running on a box not able to support it.

Deployment

One great thing about Gridgain, is that it works the same on a single node as it does on multiple nodes (same physical box), as it does on multiple physical nodes. You can also start multiple nodes within a single JVM. When I first heard this, I thought to myself, sounds great, but why? Nikita mentioned debugging and then a light came on. I remembered debugging GigaSpaces stuff and what worked on a single node, sometimes didn’t on multiple nodes. Mind, it was almost always my mistake, but debugging it was not very easy.

Our infrastructure runs on EC2. Gridgain provides EC2 images, but besides the fact that they run CentOS I believe, which I’ve grown to dislike, I’m also a control freak when it comes to my servers. I want them clean and mean:-). I prefer debian/ubuntu boxes, though I opted to create my own AMI. Installing Gridgain was easy, configuring is also a 2 minute task. It took me a few hours to figure it out and with the help of the forum, the configuration was a few lines of XML. We’re using the community edition, which comes with rudimentary IP discovery SPI. They have much more robust discovery SPIs available in their enterprise edition. One which I think makes the most sense on EC2 is S3 discovery. Basically, it uses S3 to write node information, and all nodes communicate using a S3 bucket. Makes sense. We weren’t ready to dish any money out for enterprise version yet, so I had to settle for IP discovery. In our case, it wasn’t hard. Basically, the scheduler in a single node that runs behind an elastic IP address that never changes. That means that the other boxes only have to know the IP address of the scheduler to make the initial communication. Once it can connect to one node, it joins the full grid. Because we have a single scheduler, if the scheduler goes down, the workers are no longer a part of the grid until the scheduler comes back up. This is OK for us, since due to some domain details, we can only have a single scheduler at this time and we’re OK with that single point of failure, especially being that we can bring it back up in no time and the worker nodes patiently retry the join operation at an interval and then rejoin the grid once the scheduler is back up. This is out topology. Gridgain supports pretty much what ever you want, including P2P no single point of failure topology. Below are the relevant configurations for our stuff…

Scheduler

<property name="discoverySpi">
    <bean class="org.gridgain.grid.spi.discovery.tcp.GridTcpDiscoverySpi">
        <property name="localAddress" value="10.1.1.1"/>
        <property name="ipFinder">
            <bean class="org.gridgain.grid.spi.discovery.tcp.ipfinder.vm.GridTcpDiscoveryVmIpFinder">
                <property name="shared" value="true"/>
                <property name="addresses">
                    <list>
                        <value>10.1.1.1:47500</value>
                    </list>
                </property>
            </bean>
        </property>
        <property name="heartbeatFrequency" value="2000"/>
    </bean>
</property>

The 10.1.1.1 is the local IP address of the scheduler box. The ip is repeated in the “addresses” section, telling gridgain that this can be the sole server and it doesn’t have to join a grid topology before it goes live. Also, shared=”true” is important, as it tells gridgain to share configurations amongst the boxes in the grid. Without it, you’ll have an “order of operations” issue, where a master must be started first before the worker. With it, that issue is moot and you can start/stop things as you please. I wish they would make this the default.

Right now, Gridgain cannot bind to a wildcard, though you have to specify the private IP address. If it changes (box reboots), you have to change it too. They promised a solution in their next release, which will allow to listen on private IP and communicate over public IP. This will help in other NAT topologies. Being able to listen to a wildcard will also help in having a config you never have to change. But even with this caveat, this is quite a breeze.

The worker config is similar, except it only needs to know about the scheduler and does not need to operate until it has joined a topology…

<property name="discoverySpi">
    <bean class="org.gridgain.grid.spi.discovery.tcp.GridTcpDiscoverySpi">
        <property name="localAddress" value="10.1.1.2"/>
        <property name="ipFinder">
            <bean class="org.gridgain.grid.spi.discovery.tcp.ipfinder.vm.GridTcpDiscoveryVmIpFinder">
                <property name="shared" value="true"/>
                <property name="addresses">
                    <list>
                        <value>scheduler.node.com:47500</value>
                    </list>
                </property>
            </bean>
        </property>
        <property name="heartbeatFrequency" value="2000"/>
    </bean>
</property>

Caveats

There are small caveats I found, none of which created much of a hurdle.

First is serialization. In my case, I’m was using logback for logging, gridgain uses log4j. We both use slf4j, which takes the first in the classpath. If you’re going to distributed a job that references something that clashes with classpaths, you have to do some classpath mangling. Removing log4j from gridgain’s lib directory would fix the issue, but I didn’t want to customize the install. I was originally using a Scala closure as a job unit, which had no references to the log object. In theory, if that’s the unit that gets serialized and sent over the wire, the other end should not have to worry about any logback references, since they aren’t a part of the serialized closure references. In my case, that didn’t work. Somehow the serialization decided to serialize logback related stuff, because the top level class where the closure was being created used the logger. I’m not sure if this is a problem with serialization or a leaky abstraction of the JVM and the fact that functions aren’t first class citizens. I think the lowest level of serialization is at the class level, though I had to extract it to a class and implement a GridTask instead. Because GridTask class extension didn’t reference any logger object, it was serialized as needed and sent over without causing a classpath conflict. I haven’t had the time yet to figure out whether it’s the fault of Gridgain’s optimized serializer or whether this is a side effect of the JVM (as I mentioned above). I’ll try to find some time to test this later.

Second, Gridgain Community Edition has discovery that works great in a homogeneous topology, but for EC2 (NAT, ephemeral private IP addresses, etc…), configuration is transient in terms of if any of the things I listed changes, the config must change. This can be remedied by startup scripts, but Nikita said they’ll add better support for it in the next version (public IP communication would be a good first step, binding to wildcard interfaces would be a great second).

Conclusion

Overall we had an awesome experience with Gridgain. The grid application ran flawlessly during our busiest time of the year (Thanksgiving weekend). It ran so flawlessly, that this morning, I forgot which boxes it was physically running on.

I plan on using Gridgain in the future and hopefully utilize their data grid to rewrite our computation system to utilize in memory data/compute collocation (data affinity).

Nikita, thanks for all the help getting things sorted out in the first few days.

But what if one needs a distributed mutex to allow mutual exclusion amongst distributed clients? At that, the mutex has to offer various guarantees, as is with any shared state. We know shared state is hard to reason about and provokes a lot of bug-prone software, shared distributed state, is much harder, requiring distributed guaranteed consensus all while operating in a non-reliable network environment. There are various distributed consensus algorithms, Paxos being one of the more widely used ones.

But you can deploy your own distributed locking service, without having to implement your own. Apache Zookeeper, offers distributed synchronization and group services. Mutex/locking is just one of the things you can do with Zookeeper. Zookeeper is rather low level, so implementing a distributed lock, although trivial, requires some boilerplate.

Recently we needed a distributed lock service, to ensure only one person in our organization is performing a particular systems activity at any given point and time. We implemented it on top of a homegrown tool written in ruby. The example below is in ruby, though the api calls would translate to any language…

require 'zookeeper'

class Lock  
  def initialize(host, root="/my-app")    
    @zk = Zookeeper.new(host)
    @root = root
  end
  
  def with_lock(app, timeout, timeout_callback, &block)
    new_lock_res = @zk.create(:path => "#{@root}/#{app}-", :sequence => true, :ephemeral => true)
    unique_lock_path = new_lock_res[:path]
    if get_lock(unique_lock_path, timeout)
      yield
      @zk.delete(:path => unique_lock_path)
    else
      timeout_callback.call
    end
  end

  private
  def get_lock(unique_lock_path, timeout)
    lock_key = unique_lock_path.gsub(/^#{Regexp.quote(@root)}\//, '')

    (0..4).each do
      children = @zk.get_children(:path => @root)[:children].sort
      watcher = Zookeeper::WatcherCallback.new {}
      if (children.first == lock_key)
        return true
      else
        less_than_path_idx = (children.index {|p| p == lock_key}) - 1
        stat_res = @zk.stat(:path => "#{@root}/#{children[less_than_path_idx]}", 
                           :watcher => watcher)
        if stat_res[:stat].exists
          success = wait_until(timeout) { watcher.completed? }
          if !success
            return false            
          end
        end
      end
    end
    return false
  end

  def wait_until(timeout=10, &block)
    time_to_stop = Time.now + timeout
    until yield do
      if Time.now > time_to_stop
        return false
      end
      sleep 0.1
    end
    return true
  end
end

The usage of this Lock class is such:

    Lock.new("localhost:2181").with_lock(
      "/myapp",
      5, ## Timeout in seconds
      lambda { ## Timeout callback
        abort("Couldn't acquire lock.  Timeout.") },
      lambda { ## Do what ever you want here  }
    )

The details of the algorithm are outlined here.

Of course, before you use it, you must install Zookeeper and create the root path /myapp in order to be able to use it.

Also, please note, I have removed the access control part from the example. In order to use this in production, I strongly encourage you read this.

If you are running a java app on ec2 and want to remotely connect to it using jconsole or jvisualvm, you need to start your java app with a few options. Here is my configuration. Also, note that disabling authentication, opens this up for everyone. Not good, so don’t do this in production or on a box that matters. Also, this doesn’t work with a restrictive firewall. Since RMI port is chosen randomly, you must have a rather loose firewall policy. There are ways around it, with ssh tunneling I believe, but this post won’t cover it as this point, I might do it at some point later.

First you need a policy file. Again this can be fine tuned, the example below shows a dangerously loose one…

grant {
  permission java.security.AllPermission;
};

Place this file in some directory. In my example it’s sitting in my home dir and is named .java.policy

java -Dcom.sun.management.jmxremote \
  -Dcom.sun.management.jmxremote.port=9001 \
  -Dcom.sun.management.jmxremote.authenticate=false \
  -Dcom.sun.management.jmxremote.ssl=false \
  -Djava.security.policy=.java.policy \
  -Dcom.sun.management.jmxremote.local.only=false \
  -Djava.rmi.server.hostname=your.public.hostname.com \
  -jar test.jar Runner

This starts the app and an jndi service listening on port 9001.

In jvisualvm, you now can connect to your.public.hostname.com:9001. You can tune your parameters as needed, but two are crucial in my experience: com.sun.management.jmxremote.local.only and java.rmi.server.hostname. I had to specify these in order to make things work. Your mileage may vary.

The below command creates a proxy and writes the protocol to files…

mknode /tmp/backpipe p

nc -l 61610 0</tmp/backpipe | \
tee -a /tmp/inflow | \
nc localhost 61611 | \
tee -a /tmp/outflow 1>/tmp/backpipe

In this case the server listens to port 61610 and then forwards the incoming packets to localhost:61611. You should modify the ports and forward host/port to what ever suits your need. Now, if you point the connection of any device to your server’s 61610 port, you can tail /tmp/inflow and /tmp/outflow to see the protocol communications, you can tail both together with…

tail -f /tmp/inflow /tmp/outflow

If you are on Mac OS X, in order to create a fifo file, you should replace the mknode command with…

mkfifo /tmp/backpipe

Startups

I’m going to use the word “startup” to not only refer to companies that are just launching or haven’t been around for a while. In my opinion startup is now synonymous with a company that operates like one. They are always in launch mode, always looking for new adventures and opportunities, and always innovating.

Not all small companies are startups. Many small companies have been around long enough to amass some or many startup antipatterns, which is in most cases rather detrimental to its growth. Large organizations can bear some of these antipatterns for years, as they lurke and hide behind large bureaucracies and/or residual revenues. Large organizations also have different priorities.

Startups are the innovation backbone in this country and others. Their beginnings usually involve individuals who have knowledge and experience in a particular area and/or they see a need to fill a gap. Sometimes it’s not a gap, in terms of a complete void, rather it’s a gap in terms of doing something better. These individuals are motivated by their idea and the vision of making a world (as they see it) a better place, glory, recognition, etc… There is also monetary motivation, but the product or service motivation is usually higher (at least in the ones that succeed). Also, there is drive and the drive has to be strong. I mean, in lots of cases, these individuals give up good paying jobs and benefits, put their quality of life and possibly the quality of life of others in jeopardy, without any guarantees, all for this dream. A lot of these folks have worked at other companies and they’ve decided that they can form a successful team and eventually bear the fruits of their labor (again not only in monetary compensation). Wow, that’s inspirational and also… “scary”.

During the initial stages of the startup, there is no time for bullshit. The bureaucracy and overhead that plagues established companies has to go. They have to get shit done, they have to do it good, and they have to do it fast. They don’t want to rush to sacrifice quality, since this is the reason they formed this alliance, to create a “quality” product, better than their competitors. This is also the time when creativity is at its highest. How else can you stay in business when you’re competing with a company that has 10 times as many employees, has been adding features for years, has an established brand, and more money.

Now the more technical side (I’m mostly writing about tech startups here, as this is what I’m more familiar with).

There are many things to do, design, architecture, programming, testing, deployment, etc… Choices need to be made and these choices have different priorities than in large companies. Stuff has to be done fast, so there is no time for the “Enterprise” stuff. Whatever that word at one point signified, it’s now become synonymous with “clueless pointy hairy bosses”. There is not time for commercial product evaluation, negotiations, and life cycles. Open Source Software usually rules in successful startups. It allows them to benefit from quality code with the ability to resolve bugs, add features and augment the software as they wish. They often built software using open source platforms and frameworks and themselves greatly contribute to open source. Many times the tools that they built, that aren’t specific to their business and don’t contain any intellectual property, are released to benefit the community. Now others can use that as a tool to benefit in their endeavor. The cycle continues.

I’m going to refrain from discussing specific examples of what I’d consider sensible choices. Every business and motivation has different priorities and in many cases what I would consider a suboptimal choice, would actually be the best choice for a task/dilemma at hand. One thing’s for sure though, open source software rules and beyond the brilliant people that make things happen, is a big contributor to the success of these companies.

Because people are smart, they have to get things done, and they put their blood and sweat into it, they take their time to create fun and productive environments. I mean, who wants to work a lot and not have fun doing it? Or who wants to give up the security of a full time job to fail?

Large companies

So I actually won’t talk about large companies here. I use the name mostly to refer to practices that are prevalent in larger organizations. I’m mostly going to look at the shift from an efficient, fun startup, to a bureaucratic mind draining organization that has lost its ways.

This happens all the time. The talent looses its interest and usually scatters to other companies or to start their own. The company is left with a product that’s aging and a leadership team that’s focused on maximizing the profit from the product it has. Nothing wrong with maximizing the profit, but not at the cost of stagnation. The talent drain is prevailing and the leadership for the lack of better judgment blames this on the lack of a process. “We’ve lost our ways, we’re not productive any more. We need to put a process in place that will get us going.” they say. I’m not going to judge these folks at this point, I mean their core competency isn’t innovation, it’s stability. The two are polar opposites.

Then havoc wreaks. Process after process is established; Feature after feature thoughtlessly gets added to the product; Documentation and processes take priority to common sense and productivity; Code base grows unmanageable; More time is spent talking about doing, than doing. Sometimes more and more people get hired, with less and less qualifications or for qualifications that aren’t critical to success. Sounds familiar?

This happens all the time. The bottom line is that most innovators don’t spend their lifetime chasing an idea (especially these days). They innovate and then when they don’t see any more room for innovation and fun, they leave. Yes, they have what some would call ADHD when it comes to stability and work ethics. They probably do, but in a good form, they are chasing their dreams and refuse to waste time on something that won’t make them happy.

This is not to say that innovators are better than “stabilizers” (I just made that one up). There is room for both, but stabilizers need to understand how to maintain the level of competitiveness and innovative spirit in the organizations. They should recruit and motivate the brightest, not the workaholics per say, not the conformists, but free spirited minds. These are the folks that make shit happen. These folks of course have to be kept in check by the stabilizers, but not by getting in their way. Actually, the total opposite, by getting out of their way. Give them room to do what they do best.

Conclusion

I don’t think it’s ever too late for a company to change its ways. Get back to a startup environment. Large organizations might have a hard time doing this. They have too many people and they can’t just start over. Small companies are great for this. They can start afresh. They can retain talent, pay them well, make them happy, and most of all, I’ll say it again, get out of their way. If you hired a development team to create a product, let them do it. The more shackles you put on them, the less likely they’ll succeed and the more likely they’ll leave ASAP. Intellectuals are always in demand and it really bothers me to see companies treat such employees as sweat shop workers. We pay you, you do as you’re told. That’s a recipe for disaster.

If your developers are more productive with language x and platform y, unless their choice is completely ridiculous, let them use it. They’ll thank you later, with a better quality product, more productivity and generally a more positive attitude.

The reason I’m posting is to get some comments. I’d love to hear your thoughts on how a lisp nOOb can improve this

(defun merge-sort (lst)
  (let ((size (length lst)))
    (if (= size 1)
        lst
        (progn
          (let ((seq1 (merge-sort (subseq lst 0 (floor (/ size 2)))))
                (seq2 (merge-sort (subseq lst (floor (/ size 2)) size))))
            (merge-it seq1 seq2))))))


(defun merge-it (l1 l2)
  (let ((new-arr (make-array (+ (length l1)
                                (length l2))
                             :fill-pointer 0)))
    (loop for idx from 0 to (+ (length l1) (length l2)) do
         (let ((x (car l1))
               (y (car l2)))
           (when (and (not (null x)) (not (null y)))
             (if (<= x y)
                 (progn
                   (setf l1 (cdr l1))
                   (vector-push x new-arr))
                 (progn
                   (setf l2 (cdr l2))
                   (vector-push y new-arr))))))
    (mapcar #'(lambda (e) (vector-push e new-arr)) (append l1 l2))
    (coerce new-arr 'list)))

I ran into a problem trying to validate a date field (defined in ActiveRecord) as:

class CreateAssets < ActiveRecord::Migration
  def self.up
    create_table :assets do |t|
      t.date :manufacturing_date

.....

Rails also doesn’t have a built-in date validation, but it’s easy enough to either provide your own validator method or create a reusable validator. I opted for the later, as I might need to reuse the same validator across the site.

require 'chronic'

class DateValidator < ActiveModel::EachValidator
  
  def validate_each(record, attribute, value)
    valid = true
    begin
      y = Chronic.parse(value)
      valid = false unless y
    rescue
      valid = false
    end   
    record.errors[attribute] << (options[:message] || "is not a valid date") unless valid  
  end
end

So running this with any invalid date value, like say 11111111111 which gets parsed by Date.parse method didn’t yield an error, actually it never even invoked the validator.

After a bit of digging, I figured out that it has to do with the lifecycle of ActiveRecord, basically it tries to typecast the value to the value defined in migrations. Typecasting invalid values like above causes ActiveRecord to set the value to nil (not sure why yet, will dig into source code later). Because the validator isn’t invoked on nil values, unless you specifically tell it to not allow nil with :allow_nil => false, the validate_each method is bypassed. You can see the logic for yourself in the validate method.

In order to fix this issue, you have to access the raw value that’s kept around after the typecast. I turned this into a reusable class, though if the validator that needs to operate on the raw (uncasted) value, you just inherit from this class. Here is the class…

class RawEachValidator < ActiveModel::EachValidator
  
  def validate(record)                                     
    attributes.each do |attribute|
      raw_value = record.send("#{attribute}_before_type_cast") || record.read_attribute_for_validation(attribute)
      self.validate_each(record, attribute, raw_value)
    end
  end
  
end

Now the DataValidator above just need to inherit from RawEachValidator and you’re all set.

We had a really good start yesterday. We decided to read Ch. 1-4 of LearnYouAHaskell before the meeting and then discuss the relevant topics. Here are some of the n00b things we talked about:

• function declarations and definitions
• function argument destructuring and polymorphic dispatch
• implemented recursive product function and quick sort
• logging, which turned into having pure/impure function mixture

So our quicksort implementations turned out to be such:

-- Product function
product' [] = 1
product' (x:xs) = 
  do putStrLn "testing"
     return ((product' xs) * x)

-- quicksort function using where clause
qsort [] = []
qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger
               where
                 smaller = [a | a <- xs, a <= x]
                 larger = [b | b <- xs, b > x]

-- reverse quicksort function
rqsort [] = []
rqsort (x:xs) = rqsort (rqsort larger) ++ [x] ++ smaller
               where
                 smaller = [a | a <- xs,a <= x]
                 larger = [b | b <- xs,b > x]

-- quicksort done using filters vs. where clause
qsort' [] = []
qsort' (x:xs) = (filter (< x) xs) ++ [x] ++ qsort' (filter (>= x) xs)       

One thing that I still haven’t concretely figured out is the fourth bullet point, logging. Basically I wanted to perform logging while say calculating a product. Evidently you can either have a destructive function, which performs/returns IO operation(s), or a pure function. Mixing both doesn’t seem to work.

Something as simple as:

printSomething' = do 
  putStrLn "test"
  return (1 + 1)

Didn’t work, yielding this error:

Occurs check: cannot construct the 
infinite type: b = IO b
      Expected type: b
      Inferred type: IO b
    In the first argument of return', 
    namely((product' xs) * x)'
    In the expression: return ((product' xs) * x)

I was able to find information discussing doing this through an IO Monad, but am yet to actually construct a working example. Seems like too much work for something as simple, but it might just be that I’m misunderstanding something due to lack of Haskell knowledge. Off to learn more this week and I’ll post a working hybrid function example once I get it worked out.

I don’t have access to the exact code at this time, but below is a simple example that demonstrated similar issue in Java.

import java.util.*;

public class ChainDemo {
  
  static interface Command {
    void execute(Map<String, Object> ctx);
  }

  static class Chain {
    private List<Command> commands = new ArrayList<Command>();
    
    public void addCommand(Command cmd) {
      commands.add(cmd);
    }                   
    
    public void execute() {
      Map<String, Object> ctx = new HashMap<String, Object>();
      
      for (Command cmd : commands) {
        cmd.execute(ctx);
      }
    }
    
  }  
  
  public static void main(String[] args) {
    Chain chain = new Chain();
    chain.addCommand(new Command() {
      public void execute(Map<String, Object> ctx) {
        // Perform some calc here
        ctx.put("result1", 1234);
      }
    });
    chain.addCommand(new Command() {
      public void execute(Map<String, Object> ctx) {
        int res = (Integer) ctx.get("result1");
        ctx.put("result2", res * 2);
      }
    });
    chain.addCommand(new Command() {
      public void execute(Map<String, Object> ctx) {
        System.err.println("Results: ");
        for (String key : ctx.keySet()) {
          System.err.println("\t" + key + ": " + ctx.get(key));
        }
      }
    });
    chain.execute();
  }

}             

Running the above yields:

Results: 
    result1: 1234
    result2: 2468

Besides the mandatory java ceremony, it’s also not apparent to me that this can be accomplished any better without the use of reflection, which of course would add yet more boilerplate.

Macros to the rescue. If any of you aren’t familiar with what makes lisp (besides its simple syntax allure) so powerful, you should familiarize yourself with macros. The example I give below doesn’t even make a dent into the possibilities of macros.

With a simple macro

(defmacro make-cmd [args & body]
  `(fn [{:keys [~@args] :as ctx#}]
     (doseq [ar# [~@(map keyword args)]]
       (if (not (contains? ctx# ar#))
         (throw (Exception. (str "'" (name ar#) "' argument is required!")))))
     ~@body
     ))

(defn- exec-cmd [cmd context]
  (merge context (cmd context)))

(defn exec-chain [& cmds]
    (loop [chain cmds
           ctx {}]
      (if (first chain)
        (recur (rest chain) (exec-cmd (first chain) ctx)))))

The above can now be utilized with the following api…

(exec-chain 
  (make-cmd [] (println "Executing first") {:first "first arg"})
  (make-cmd [first] (println "Executing second:" first) {:second "second arg" :random "random arg"})
  (make-cmd [second random] (println "Executing third:" second random) {:third "third arg"}))

Yielding (in SLIME REPL):

Executing first
Executing second: first arg
Executing third: second arg random-arg
nil

Running a similar script with an added parameter in the third command that doesn’t exist in the chain

(exec-chain 
    (make-cmd [] (println "Executing first") {:first "first arg"})
    (make-cmd [first] (println "Executing second:" first) {:second "second arg" :random "random arg"})
    (make-cmd [second random does-not-exist] (println "Executing third:" second random) {:third "third arg"}))

Throws an exception (in SLIME REPL):

'does-not-exist' argument is required!
  [Thrown class java.lang.Exception]

Of course the above can be much improved, one off the top of my head improvement is to allow default values for arguments that don’t exist and possibly be able to specify arguments who’s lack of should throw and exception an in other cases either bind a nil or default value. But the concise example demonstrates similar abilities of my java program but with added runtime argument name matching. I’d love to see if the same can be accomplished with a statically typed language with type compile time vs. runtime argument checking. Going to investigate this with Haskell and Scala this week.

It might be that Apple wants Oracle to take the charge in maintaining the OS X port and deprecating support might be a way to negotiate this without face-to-face negotiations. I’m fine with that, frankly I could care less who provides the JVM, as long as one is provided and is relatively actively supported. Until that announcement happens, this is yet another bump in the future of the JVM. First the Oracle purchase of Sun, then the lawsuit, and now the decision by Apple, definitely creates unneeded distractions for this platform’s developers all over the globe.

So I started this not to gripe any more about Apple’s decision, I’m sure there are enough posts out there flooding your RSS streams to keep you busy, rather I wanted to question the future of languages/industry in regards to the language/platform of the future.

Last week I attended the StrangeLoop conference in St. Louis. It was a gem of a conference, definitely the best I’ve been too in a long time. Alex, besides seeming like an overall awesome guy, has some extraordinary “brilliant people herding” abilities. How he managed to bring together a group of brilliant speakers and then convince another group of awesome developers to attend, is beyond me. The conference had some great talks and panels about the latest/greatest and bleeding edge tech stuff. One of the best panels was about the future of programming languages. The panel consisted of (Guy Steele, Alex Payne, Josh Bloch, Bruce Tate, and Douglas Crockford), all whom I have great respect for. One prevailing factor in most discussions in this panel as well as throughout the conference, has been concurrency. In the mutli-core/cpu world, what language/platform will allow for this paradigm transition to happen seamlessly. The fact is that although there are some awesome innovations/implementations going on in this area, STM, Actors, fork/join, and various others, none have yet abstracted the concurrency model away from the developer, as seamless as memory management and garbage collection is done in today’s runtime environments. But this is an exciting time to be in, many ideas are flowing around and something will appear on the horizon sooner or later. This something, as Guy Steele pointed out, will most likely be a model that will allow for divide/conquer, map/reduce operations to happen through language idioms and possible seamless abstractions. Accumulators are evil

There are many languages/platforms out there today, but none have been as predominant and as overall polished as Java and the JVM. From the language perspective Java’s getting stagnant and to some, boring, but the fact that it has an ecosystem of wonderful libraries and products is hard to ignore. The fact that all of these are bytecode compatible is even more to rant about, as with the advent of numerous great languages built on top of the JVM, it makes the transition to a different language and programming paradigm, much easier. It is truly hard to think of any current platform/VM that’s more prevalent and better suited for large scale enterprise development than the JVM. .NET comes to mind, but I doubt anyone from the non-Microsoft camp will be switching . There are other platforms, most notably Python and Ruby, but although both are credible, the presence of GIL on both, make the choice of using them in a concurrency model very difficult. You can architect and deploy your system as multi-process vs. multi-thread and arguably that model has its benefits, mostly by getting rid of the shared state model concurrency issues, but we (at least I do) like to have a choice. This decision shouldn’t be shoved down our throats because the language development camp doesn’t want, doesn’t think one is necessary, or [add your own excuse here] to produce a thread-safe non-GIL thread model.

The other issue with most of these languages/platforms, as well as the other ones I like, is the deployment options. They suck! From providing modular builds to deploying production applications, they just aren’t as polished and in most cases as stable/supported as the JVM ones. Common Lisp, one of my favorites as of late, for example, is an awesome language with numerous compilers/interpreters. Lisp doesn’t have a good packaging, dependency resolution, and build story, but even if you can get past that with some of the available half-baked solutions, then when it’s time to build/compile/deploy your app, you’re fucked, unless you want to build one yourself. I enjoy such challenges on Friday/Saturday nights, but not when time is limited and milestones are due (which is most of the time).

Ruby and Python for example, have a decent package managers gem and easy_install/pip respectively, but two problems lurk. First, lots of modules are written in C and in many cases, in my experience, are a big pain in the ass to compile, especially with today’s heterogeneous architectures i386, x86_64, etc… Lots of incompatibilities arise, forcing more time away from doing what I should be doing. Somehow my milestones never include the 2+ day derailments due to such issues. Maybe that’s what’s left of my optimism. The second problem only applies if you’re writing a web app and if you are, then you know the issues. Where are those stable/supported app servers? WSGI and rack should provide answers soon, for now, there are many options and none are without major issues as well. Some are a pain to install/deploy, some aren’t actively maintained. I mean, am I just being anal and asking for way too much or am I eternally spoiled by the JVM. Is it too much to ask to bundle the application into some archive or directory structure and just drop it in somewhere or point your server config towards it. Either way, even if they ease the pain of deploying webapps, the fact that [Python/Ruby] are not suitable in multi-core/cpu environments where threads are needed, is a show stopper for lots of apps I write. I know I can architect around the issues, but again, why should I have to program to the platform vs. the other way around. Give me the choices and trust me to make the best decision.

The next things is native GUI development. It is true that lots of interesting apps today are developed and deployed as web apps, but that doesn’t discount the fact that there is still a need for a native GUI in lots of use cases. Swing provides a good and in some instances really good, cross platform GUI library which allows to deploy your GUI across most popular platforms with 95% or more cross platform consistency. That sounds pretty good to me.

There are other toolkits, wxWidgets, QT, etc…, which also have bindings to python and ruby, but again, with today’s multicore, it would be a shame to not be able to utilize these cores simultaneously due to GIL. The bindings in languages that due provide a better concurrency story, work great, but these languages still suffer from the other pain points I mentioned before (i.e. deployment, build, package management, etc…). It’s a Catch-22.

So maybe I’m missing something here, but I think the JVM is the best option we have at this time that allows for multiple platforms, languages, paradigms, and comes with a great success story in the enterprise (build tools, deployment/modularity, enterprise grade servers, etc…). Languages implemented on top of the JVM benefit from this quite successful ecosystem. Ah, and might I mention that great libraries exist for about anything you’re trying to do. This is also true of Python, but I can’t say the same for Ruby. Ruby has numerous gems for most tasks, but they all seem half-baked at most. There are frameworks like Rails and Sinatra, which are great and fully supported with active communities, though as long as you don’t venture too far off the traditional path.

JVM has it’s own set of issue, the fact that it was written with static languages in mind and lacks support for dynamic bindings, tail call optimizations, and other things that make writing languages on top of it more difficult. It’s future is now also in question due to the new Oracle stewardship and the legal obstacles it chose to pursue rather than spend that time and money on the platform. Nevertheless, the ecosystem is still flourishing, kept afloat but tons of great developers and supporting companies who care about the platform and greatly benefit from it. JVM allows us to program in different languages while being concentrated on the task at hand, not peripheral issues like compiling for different architectures, battling the deployment inadequacies, not being able to utilize cores efficiently, and a variety of other issues. JVM ecosystem might not have the most ideal solutions to these problems, but they are far better than anything out there right now. If people that spend their time bashing the JVM platform would spend as much time making their platform better, maybe we’d have other choices.

I’d love to hear other’s thoughts on this topic. What do you think about the JVM and what’s your language/platform of choice. How do you build, deploy, distribute your applications? What concurrency options are available on that platform and how they compare to others? I’m familiar with most JVM options, especially Clojure and Scala, so I’m mostly asking for anything outside of the JVM ecosystem. I hope to someday compile a list of these and present them in an objective manner, for now, all I have is my empirical opinions.