jbowles

The :hub is the transaction and/or application (more on this later). Each :node is wrapper around a Hero Formula responsible for passing the non-boolean values to the :hub, but it also returns a boolean. Each camel-cased line inside the :node parentheses is a Hero :formula and the values in quotes are the return values of a Formula's :step. Formula.step is the only thing responsible for changing state.

The following is in Clojure but it should be interpretable from a Ruby perspective; it's the relations that matter here not the syntax.

[:hub ;; begin transaction
 ( ;; begin set of Nodes
  
  :node-unique-accept 

jbowles

Horizon

Transactional system that defines a set of primitive and composable concepts. It is inspired by Finite State Grammars.

ABSTRACT

Finite State Transactional Grammar. I don't know if I made up this term, so I won't claim to have invented this, but I'm running with it. What is sketched here is a transactional system inspired by finite state machines, finite state grammars, rule engines, map-reduce algorithms, functional programming (namely Clojure and LISP), business intelligence, and the rubygem Hero.

Hub

jbowles

require File.join(File.dirname(__FILE__), 'lib','new_class.rb')
has_many :hadoop_logs

  def self.twitter_creds
    tconfig_file = Rails.root.join 'config', 'twitter_oauth.yml'
    NimbleTwitter.twitter_config(NimbleTwitter.dev_twitter("#{tconfig_file}"))
  end

  def self.json_encoder
    Yajl::Encoder.new

jbowles

require File.join(File.dirname(__FILE__), 'lib','new_class.rb')
nc = NewClass

tell_me = NewClass.tell_me_something
rs = nc.randomize_select
app = Proc.new do |env|
  response = []
  response << 200
  response << { 'Content-Type' => 'text/plain'}
  response << ["Here is our class: #{nc}.\n Here is our method call from the class: #{tell_me}.\n And check this out: #{rs}"]

jbowles

class NewClass
  def self.tell_me_something
    "whatup!"
  end
  def self.randomize_select
    list = [
      "one",
      "two",
      "three"
    ]

jbowles

require 'kafka'

consumer = Kafka::Consumer.new
consumer.loop do |message|
  puts "received"
  message.each do |m|
    #puts "Payload: #{m.payload}, Magic: #{m.magic}, Checksum: #{m.checksum}"
    puts m.payload
  end
end

jbowles

require 'kafka'

def batch(m1, m2, m3)
  producer = Kafka::Producer.new
  producer.batch do |msgs|
    puts "batching multi-message..."
    msgs << Kafka::Message.new("#{m1} ONE")
    msgs << Kafka::Message.new("#{m2} TWO")
    msgs << Kafka::Message.new("#{m3} THREE")
  end

jbowles

# Use case for goldmine:
# the pivoting functionality of Goldmine#dig allows you to easily mine data
# from Mongo collections

require 'goldmine'
require 'mongo'
require 'yajl'
class Digger

  # Convenience for connecting to MongoDB database instance on localhost

jbowles

# this is a work in progress!!

######################################################
# I'm on a CentOS dev VM provided by my company      #
######################################################
#uname -a
#Linux ------- 2.6.18-128.el5 ----- x86_64 x86_64 x86_64 GNU/Linux
# OR
#cat /proc/version 
#Linux version 2.6.18-128.el5 ([email protected]) (gcc version 4.1.2 20080704 (Red Hat 4.1.2-44)) ----

jbowles

var first = function(){return 'first';},
  second = function(){return 'second';},
  func_one = function(someFunction, someValue){someFunction(someValue);},
  func_two = function(anotherFunction, anotherValue){anotherFunction(anotherValue);};

function say(word) {console.log(word);}
function speak(anotherWord) {console.log(anotherWord);}

/*
 * run the two functions above