diff --git a/lib/rb/lib/thrift/client.rb b/lib/rb/lib/thrift/client.rb
index 55e72b3..0b0d13e 100644
--- a/lib/rb/lib/thrift/client.rb
+++ b/lib/rb/lib/thrift/client.rb
@@ -7,22 +7,22 @@
     end
 
     def send_message(name, args_class, args = {})
-      @oprot.writeMessageBegin(name, MessageTypes::CALL, @seqid)
+      @oprot.write_message_begin(name, MessageTypes::CALL, @seqid)
       data = args_class.new
       args.each do |k, v|
         data.send("#{k.to_s}=", v)
       end
       data.write(@oprot)
-      @oprot.writeMessageEnd()
+      @oprot.write_message_end()
       @oprot.trans.flush()
     end
 
     def receive_message(result_klass)
-      fname, mtype, rseqid = @iprot.readMessageBegin()
+      fname, mtype, rseqid = @iprot.read_message_begin()
       handle_exception(mtype)
       result = result_klass.new
       result.read(@iprot)
-      @iprot.readMessageEnd()
+      @iprot.read_message_end()
       return result
     end
 
@@ -30,7 +30,7 @@
       if mtype == MessageTypes::EXCEPTION
         x = ApplicationException.new()
         x.read(@iprot)
-        @iprot.readMessageEnd()
+        @iprot.read_message_end()
         raise x
       end
     end
diff --git a/lib/rb/lib/thrift/protocol.rb b/lib/rb/lib/thrift/protocol.rb
index 47fe723..553d8d4 100644
--- a/lib/rb/lib/thrift/protocol.rb
+++ b/lib/rb/lib/thrift/protocol.rb
@@ -35,106 +35,145 @@
       @trans = trans
     end
 
-    def writeMessageBegin(name, type, seqid); nil; end
+    def write_message_begin(name, type, seqid); nil; end
+    deprecate! :writeMessageBegin => :write_message_begin
 
-    def writeMessageEnd; nil; end
+    def write_message_end; nil; end
+    deprecate! :writeMessageEnd => :write_message_end
 
-    def writeStructBegin(name); nil; end
+    def write_struct_begin(name); nil; end
+    deprecate! :writeStructBegin => :write_struct_begin
 
-    def writeStructEnd(); nil; end
+    def write_struct_end(); nil; end
+    deprecate! :writeStructEnd => :write_struct_end
 
-    def writeFieldBegin(name, type, id); nil; end
+    def write_field_begin(name, type, id); nil; end
+    deprecate! :writeFieldBegin => :write_field_begin
 
-    def writeFieldEnd(); nil; end
+    def write_field_end(); nil; end
+    deprecate! :writeFieldEnd => :write_field_end
 
-    def writeFieldStop(); nil; end
+    def write_field_stop(); nil; end
+    deprecate! :writeFieldStop => :write_field_stop
 
-    def writeMapBegin(ktype, vtype, size); nil; end
+    def write_map_begin(ktype, vtype, size); nil; end
+    deprecate! :writeMapBegin => :write_map_begin
 
-    def writeMapEnd(); nil; end
+    def write_map_end(); nil; end
+    deprecate! :writeMapEnd => :write_map_end
 
-    def writeListBegin(etype, size); nil; end
+    def write_list_begin(etype, size); nil; end
+    deprecate! :writeListBegin => :write_list_begin
 
-    def writeListEnd(); nil; end
+    def write_list_end(); nil; end
+    deprecate! :writeListEnd => :write_list_end
 
-    def writeSetBegin(etype, size); nil; end
+    def write_set_begin(etype, size); nil; end
+    deprecate! :writeSetBegin => :write_set_begin
 
-    def writeSetEnd(); nil; end
+    def write_set_end(); nil; end
+    deprecate! :writeSetEnd => :write_set_end
 
-    def writeBool(bool); nil; end
+    def write_bool(bool); nil; end
+    deprecate! :writeBool => :write_bool
 
-    def writeByte(byte); nil; end
+    def write_byte(byte); nil; end
+    deprecate! :writeByte => :write_byte
 
-    def writeI16(i16); nil; end
+    def write_i16(i16); nil; end
+    deprecate! :writeI16 => :write_i16
 
-    def writeI32(i32); nil; end
+    def write_i32(i32); nil; end
+    deprecate! :writeI32 => :write_i32
 
-    def writeI64(i64); nil; end
+    def write_i64(i64); nil; end
+    deprecate! :writeI64 => :write_i64
 
-    def writeDouble(dub); nil; end
+    def write_double(dub); nil; end
+    deprecate! :writeDouble => :write_double
 
-    def writeString(str); nil; end
+    def write_string(str); nil; end
+    deprecate! :writeString => :write_string
 
-    def readMessageBegin(); nil; end
+    def read_message_begin(); nil; end
+    deprecate! :readMessageBegin => :read_message_begin
 
-    def readMessageEnd(); nil; end
+    def read_message_end(); nil; end
+    deprecate! :readMessageEnd => :read_message_end
 
-    def readStructBegin(); nil; end
+    def read_struct_begin(); nil; end
+    deprecate! :readStructBegin => :read_struct_begin
 
-    def readStructEnd(); nil; end
+    def read_struct_end(); nil; end
+    deprecate! :readStructEnd => :read_struct_end
 
-    def readFieldBegin(); nil; end
+    def read_field_begin(); nil; end
+    deprecate! :readFieldBegin => :read_field_begin
 
-    def readFieldEnd(); nil; end
+    def read_field_end(); nil; end
+    deprecate! :readFieldEnd => :read_field_end
 
-    def readMapBegin(); nil; end
+    def read_map_begin(); nil; end
+    deprecate! :readMapBegin => :read_map_begin
 
-    def readMapEnd(); nil; end
+    def read_map_end(); nil; end
+    deprecate! :readMapEnd => :read_map_end
 
-    def readListBegin(); nil; end
+    def read_list_begin(); nil; end
+    deprecate! :readListBegin => :read_list_begin
 
-    def readListEnd(); nil; end
+    def read_list_end(); nil; end
+    deprecate! :readListEnd => :read_list_end
 
-    def readSetBegin(); nil; end
+    def read_set_begin(); nil; end
+    deprecate! :readSetBegin => :read_set_begin
 
-    def readSetEnd(); nil; end
+    def read_set_end(); nil; end
+    deprecate! :readSetEnd => :read_set_end
 
-    def readBool(); nil; end
+    def read_bool(); nil; end
+    deprecate! :readBool => :read_bool
 
-    def readByte(); nil; end
+    def read_byte(); nil; end
+    deprecate! :readByte => :read_byte
 
-    def readI16(); nil; end
+    def read_i16(); nil; end
+    deprecate! :readI16 => :read_i16
 
-    def readI32(); nil; end
+    def read_i32(); nil; end
+    deprecate! :readI32 => :read_i32
 
-    def readI64(); nil; end
+    def read_i64(); nil; end
+    deprecate! :readI64 => :read_i64
 
-    def readDouble(); nil; end
+    def read_double(); nil; end
+    deprecate! :readDouble => :read_double
 
-    def readString(); nil; end
+    def read_string(); nil; end
+    deprecate! :readString => :read_string
 
     def write_field(name, type, fid, value)
-      writeFieldBegin(name, type, fid)
+      write_field_begin(name, type, fid)
       write_type(type, value)
-      writeFieldEnd
+      write_field_end
     end
 
     def write_type(type, value)
       case type
       when Types::BOOL
-        writeBool(value)
+        write_bool(value)
       when Types::BYTE
-        writeByte(value)
+        write_byte(value)
       when Types::DOUBLE
-        writeDouble(value)
+        write_double(value)
       when Types::I16
-        writeI16(value)
+        write_i16(value)
       when Types::I32
-        writeI32(value)
+        write_i32(value)
       when Types::I64
-        writeI64(value)
+        write_i64(value)
       when Types::STRING
-        writeString(value)
+        write_string(value)
       when Types::STRUCT
         value.write(self)
       else
@@ -145,19 +184,19 @@
     def read_type(type)
       case type
       when Types::BOOL
-        readBool
+        read_bool
       when Types::BYTE
-        readByte
+        read_byte
       when Types::DOUBLE
-        readDouble
+        read_double
       when Types::I16
-        readI16
+        read_i16
       when Types::I32
-        readI32
+        read_i32
       when Types::I64
-        readI64
+        read_i64
       when Types::STRING
-        readString
+        read_string
       else
         raise NotImplementedError
       end
@@ -167,50 +206,50 @@
       if type === Types::STOP
         nil
       elsif type === Types::BOOL
-        readBool()
+        read_bool()
       elsif type === Types::BYTE
-        readByte()
+        read_byte()
       elsif type === Types::I16
-        readI16()
+        read_i16()
       elsif type === Types::I32
-        readI32()
+        read_i32()
       elsif type === Types::I64
-        readI64()
+        read_i64()
       elsif type === Types::DOUBLE
-        readDouble()
+        read_double()
       elsif type === Types::STRING
-        readString()
+        read_string()
       elsif type === Types::STRUCT
-        readStructBegin()
+        read_struct_begin()
         while true
-          name, type, id = readFieldBegin()
+          name, type, id = read_field_begin()
           if type === Types::STOP
             break
           else
             skip(type)
-            readFieldEnd()
+            read_field_end()
           end
-          readStructEnd()
+          read_struct_end()
         end
       elsif type === Types::MAP
-        ktype, vtype, size = readMapBegin()
+        ktype, vtype, size = read_map_begin()
         for i in 1..size
           skip(ktype)
           skip(vtype)
         end
-        readMapEnd()
+        read_map_end()
       elsif type === Types::SET
-        etype, size = readSetBegin()
+        etype, size = read_set_begin()
         for i in 1..size
           skip(etype)
         end
-        readSetEnd()
+        read_set_end()
       elsif type === Types::LIST
-        etype, size = readListBegin()
+        etype, size = read_list_begin()
         for i in 1..size
           skip(etype)
         end
-        readListEnd()
+        read_list_end()
       end
     end
 
diff --git a/lib/rb/lib/thrift/protocol/binaryprotocol.rb b/lib/rb/lib/thrift/protocol/binaryprotocol.rb
index 9832383..6a69f5e 100644
--- a/lib/rb/lib/thrift/protocol/binaryprotocol.rb
+++ b/lib/rb/lib/thrift/protocol/binaryprotocol.rb
@@ -18,38 +18,38 @@
       super(trans)
     end
 
-    def writeMessageBegin(name, type, seqid)
+    def write_message_begin(name, type, seqid)
       writeI32(VERSION_1 | type)
       writeString(name)
       writeI32(seqid)
     end
 
-    def writeFieldBegin(name, type, id)
+    def write_field_begin(name, type, id)
       writeByte(type)
       writeI16(id)
     end
 
-    def writeFieldStop()
+    def write_field_stop()
       writeByte(Thrift::Types::STOP)
     end
 
-    def writeMapBegin(ktype, vtype, size)
+    def write_map_begin(ktype, vtype, size)
       writeByte(ktype)
       writeByte(vtype)
       writeI32(size)
     end
 
-    def writeListBegin(etype, size)
+    def write_list_begin(etype, size)
       writeByte(etype)
       writeI32(size)
     end
 
-    def writeSetBegin(etype, size)
+    def write_set_begin(etype, size)
       writeByte(etype)
       writeI32(size)
     end
 
-    def writeBool(bool)
+    def write_bool(bool)
       if (bool)
         writeByte(1)
       else
@@ -57,34 +57,34 @@
       end
     end
 
-    def writeByte(byte)
+    def write_byte(byte)
       trans.write([byte].pack('n')[1..1])
     end
 
-    def writeI16(i16)
+    def write_i16(i16)
       trans.write([i16].pack('n'))
     end
 
-    def writeI32(i32)
+    def write_i32(i32)
       trans.write([i32].pack('N'))
     end
 
-    def writeI64(i64)
+    def write_i64(i64)
       hi = i64 >> 32
       lo = i64 & 0xffffffff
       trans.write([hi, lo].pack('N2'))
     end
 
-    def writeDouble(dub)
+    def write_double(dub)
       trans.write([dub].pack('G'))
     end
 
-    def writeString(str)
+    def write_string(str)
       writeI32(str.length)
       trans.write(str)
     end
 
-    def readMessageBegin()
+    def read_message_begin()
       version = readI32()
       if (version & VERSION_MASK != VERSION_1)
         raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Missing version identifier')
@@ -95,7 +95,7 @@
       return name, type, seqid
     end
 
-    def readFieldBegin()
+    def read_field_begin()
       type = readByte()
       if (type === Types::STOP)
         return nil, type, 0
@@ -104,31 +104,31 @@
       return nil, type, id
     end
 
-    def readMapBegin()
+    def read_map_begin()
       ktype = readByte()
       vtype = readByte()
       size = readI32()
       return ktype, vtype, size
     end
 
-    def readListBegin()
+    def read_list_begin()
       etype = readByte()
       size = readI32()
       return etype, size
     end
 
-    def readSetBegin()
+    def read_set_begin()
       etype = readByte()
       size = readI32()
       return etype, size
     end
 
-    def readBool()
+    def read_bool()
       byte = readByte()
       return byte != 0
     end
 
-    def readByte()
+    def read_byte()
       dat = trans.readAll(1)
       val = dat[0]
       if (val > 0x7f)
@@ -137,7 +137,7 @@
       return val
     end
 
-    def readI16()
+    def read_i16()
       dat = trans.readAll(2)
       val, = dat.unpack('n')
       if (val > 0x7fff)
@@ -146,7 +146,7 @@
       return val
     end
 
-    def readI32()
+    def read_i32()
       dat = trans.readAll(4)
       val, = dat.unpack('N')
       if (val > 0x7fffffff)
@@ -155,7 +155,7 @@
       return val
     end
 
-    def readI64()
+    def read_i64()
       dat = trans.readAll(8)
       hi, lo = dat.unpack('N2')
       if (hi > 0x7fffffff)
@@ -167,13 +167,13 @@
       end
     end
 
-    def readDouble()
+    def read_double()
       dat = trans.readAll(8)
       val, = dat.unpack('G')
       return val
     end
 
-    def readString()
+    def read_string()
       sz = readI32()
       dat = trans.readAll(sz)
       return dat
diff --git a/lib/rb/lib/thrift/struct.rb b/lib/rb/lib/thrift/struct.rb
index f1907a3..ee3a360 100644
--- a/lib/rb/lib/thrift/struct.rb
+++ b/lib/rb/lib/thrift/struct.rb
@@ -17,31 +17,31 @@
     end
 
     def read(iprot)
-      iprot.readStructBegin()
+      iprot.read_struct_begin()
       loop do
-        fname, ftype, fid = iprot.readFieldBegin()
+        fname, ftype, fid = iprot.read_field_begin()
         break if (ftype === Types::STOP)
         handle_message(iprot, fid, ftype)
-        iprot.readFieldEnd()
+        iprot.read_field_end()
       end
-      iprot.readStructEnd()
+      iprot.read_struct_end()
     end
 
     def write(oprot)
-      oprot.writeStructBegin(self.class.name)
+      oprot.write_struct_begin(self.class.name)
       each_field do |fid, type, name|
         if ((value = instance_variable_get("@#{name}")) != nil)
           if is_container? type
-            oprot.writeFieldBegin(name, type, fid)
+            oprot.write_field_begin(name, type, fid)
             write_container(oprot, value, struct_fields[fid])
-            oprot.writeFieldEnd
+            oprot.write_field_end
           else
             oprot.write_field(name, type, fid, value)
           end
         end
       end
-      oprot.writeFieldStop()
-      oprot.writeStructEnd()
+      oprot.write_field_stop()
+      oprot.write_struct_end()
     end
 
     protected
@@ -99,24 +99,24 @@
 
     def write_container(oprot, value, field = {})
       if field[:type] == Types::MAP
-        oprot.writeMapBegin(field[:key][:type], field[:value][:type], value.size)
+        oprot.write_map_begin(field[:key][:type], field[:value][:type], value.size)
         value.each do |k, v|
           write_data(oprot, k, field[:key])
           write_data(oprot, v, field[:value])
         end
-        oprot.writeMapEnd
+        oprot.write_map_end
       elsif field[:type] == Types::LIST
-        oprot.writeListBegin(field[:element][:type], value.size)
+        oprot.write_list_begin(field[:element][:type], value.size)
         value.each do |elem|
           write_data(oprot, elem, field[:element])
         end
-        oprot.writeListEnd
+        oprot.write_list_end
       elsif field[:type] == Types::SET
-        oprot.writeSetBegin(field[:element][:type], value.size)
+        oprot.write_set_begin(field[:element][:type], value.size)
         value.each do |k, v|
           write_data(oprot, k, field[:element])
         end
-        oprot.writeSetEnd
+        oprot.write_set_end
       else
         raise "Not a container type: #{field[:type]}"
       end
diff --git a/lib/rb/lib/thrift/transport/ttransport.rb b/lib/rb/lib/thrift/transport/ttransport.rb
index b2fa813..dd015ae 100644
--- a/lib/rb/lib/thrift/transport/ttransport.rb
+++ b/lib/rb/lib/thrift/transport/ttransport.rb
@@ -29,7 +29,9 @@
 # TTransport is basically an abstract class, but isn't raising NotImplementedError
 # TODO: Think about if this is the right thing - Kevin Clark - 3/27/08
 class TTransport
-  def is_open?; end
+  def open?; end
+  deprecate! :isOpen => :open?
+  deprecate! :is_open? => :open?
 
   def open; end
 
@@ -49,22 +51,11 @@
     
     buff
   end
+  deprecate! :readAll => :read_all
   
   def write(buf); end
 
   def flush; end
-  
-  ################
-  ## Deprecated
-  ################
-  
-  def isOpen
-    is_open?
-  end
-  
-  def readAll(sz)
-    read_all sz
-  end
 end
 
 class TServerTransport