rabbit-slide-kou-rubykaigi-2017 2017.9.18.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56f66d64ab2afa98268d83f3b952625f45affcf9
+  data.tar.gz: c5b64688f7185fa0dd1a2504727f0f9f495d56a2
+SHA512:
+  metadata.gz: 0ff5431f5f138e4ef67318343aa4bbc17bd97187715ecc2f71b105defc96fe982b9a405b944d3428192fc6d41f3f38ad5e4b644b4aead1837c5e9eabc721a40a
+  data.tar.gz: 6af279da5452f64a9ef449b9b500fd88e4983f582871a5d531f66ec0c38179e1c276e175a35ed2f659124af45b2952b5f4ebd1f898c9748187ac86a1b3b8c8ce

data/.rabbit

@@ -0,0 +1 @@
+extension-by-cpp.rab

data/README.rd

@@ -0,0 +1,41 @@
+= Improve extension API: C++ as better language for extension
+
+Ruby's extension API is for C. This talk proposes C++ as a better language for extension API.
+
+== License
+
+=== Slide
+
+CC BY-SA 4.0
+
+Use the followings for notation of the author:
+
+  * Kouhei Sutou
+
+==== ClearCode Inc. logo
+
+CC BY-SA 4.0
+
+Author: ClearCode Inc.
+
+It is used in page header and some pages in the slide.
+
+== For author
+
+=== Show
+
+  rake
+
+=== Publish
+
+  rake publish
+
+== For viewers
+
+=== Install
+
+  gem install rabbit-slide-kou-rubykaigi-2017
+
+=== Show
+
+  rabbit rabbit-slide-kou-rubykaigi-2017.gem

data/Rakefile

@@ -0,0 +1,38 @@
+require "rabbit/task/slide"
+
+# Edit ./config.yaml to customize meta data
+
+spec = nil
+Rabbit::Task::Slide.new do |task|
+  spec = task.spec
+  spec.files += Dir.glob("images/**/*.*")
+  # spec.files -= Dir.glob("private/**/*.*")
+  spec.add_runtime_dependency("rabbit-theme-clear-code")
+end
+
+desc "Tag #{spec.version}"
+task :tag do
+  sh("git", "tag", "-a", spec.version.to_s, "-m", "Publish #{spec.version}")
+  sh("git", "push", "--tags")
+end
+
+namespace :example do
+  desc "Build Rubex example"
+  task :rubex do
+    cd("example/rubex") do
+      sh("rubex", "fibonacci.rubex")
+      cd("fibonacci") do
+        ruby("execonf.rb")
+        sh("make")
+      end
+    end
+  end
+
+  desc "Build JRuby example"
+  task :jruby do
+    cd("example/jruby") do
+      sh("javac", "Fibonacci.java")
+      sh("jar", "cf", "fibonacci.jar", "Fibonacci.class")
+    end
+  end
+end

data/config.yaml

@@ -0,0 +1,24 @@
+---
+id: rubykaigi-2017
+base_name: extension-by-cpp
+tags:
+- rabbit
+- ruby
+- extension
+- c++
+presentation_date: 2017-09-18
+version: 2017.9.18.0
+licenses:
+- CC-BY-SA-4.0
+slideshare_id: 
+speaker_deck_id: 
+ustream_id: 
+vimeo_id: 
+youtube_id: 
+author:
+  markup_language: :rd
+  name: Kouhei Sutou
+  email: kou@clear-code.com
+  rubygems_user: kou
+  slideshare_user: kou
+  speaker_deck_user: 

data/extension-by-cpp.rab

@@ -0,0 +1,844 @@
+= Improve extension API
+
+: subtitle
+   C++ as better language for extension
+: author
+   Kouhei Sutou
+: institution
+   ClearCode Inc.
+: content-source
+   RubyKaigi 2017
+: date
+   2017-09-18
+: allotted-time
+   35m
+: theme
+   .
+
+= Ad1: I'm distributing shocker combatmen to Rabbit users\n(('tag:x-small:宣伝1：Rabbitユーザーに'))\n(('tag:x-small:ショッカー戦闘員を配布中'))
+
+  # img
+  # src = images/shocker.jpeg
+  # relative_height = 110
+  # reflect_ratio = 0.1
+  # relative_margin_top = -2
+
+== Slide properties
+
+: enable-title-on-image
+   true
+
+= Ad2: Silver sponsor
+
+  # img
+  # src = images/clear-code-silver-sponsor.png
+  # relative_height = 100
+  # reflect_ratio = 0.1
+
+== Slide properties
+
+: enable-title-on-image
+   false
+
+= Ad3: Red Data Tools
+
+  * Project that provides data processing tools for Ruby\n
+    (('note:Ruby用のデータ処理ツール群を提供するプロジェクト'))
+    * https://red-data-tools.github.io/
+  * Workshop in afternoon break at the 2nd day (today!)\n
+    (('note:2日目（今日！）の午後休憩中にワークショップがあるよ！'))
+
+= Ad4: OSS Gate
+
+  * Project that increases people who join OSS development\n
+    (('note:OSSの開発に継続的に参加する人を継続的に増やす取り組み'))
+    * https://oss-gate.github.io/
+
+= Ad4: OSS Gate
+
+  * Ruby is an OSS\n
+    (('note:RubyもOSS'))
+    * OSS Gate wants to increase people to join Ruby itself and RubyGems development!\n
+      (('note:OSS GateではRuby本体の開発や各種RubyGemの開発に参加する人も増やしたい！'))
+
+= Ad4: OSS Gate
+
+  * Now, works on Tokyo, Sapporo, Osaka and Kyoto\n
+    (('note:現在は東京・札幌・大阪・京都で活動中'))
+    * If you live at one of them, join "OSS Gate workshop"!\n
+      (('note:これらの地域に住んでいる人は「OSS Gateワークショップ」に参加しよう！'))
+
+= Ad4: OSS Gate
+
+  * Wants to work on Hiroshima and other areas all over the world!\n
+    (('note:広島や世界中のいろんな地域で活動したい！'))
+    * If you're interested in increasing people who join OSS development, talk to me!\n
+      (('note:OSSの開発に参加する人が増えることに興味のある人は私に声をかけて！'))
+
+= What I want to do\n(('note:やりたいこと'))
+
+(('tag:center'))
+Improve performance\n
+with C/C++ libraries\n
+(('note:C/C++のライブラリーを使った高速化'))
+
+  * Not wanting to create binding\n
+    (('note:バインディングを作りたいわけじゃない'))
+
+= Point of improve perf\n(('note:高速化するために大事なこと'))
+
+(('tag:center'))
+Done in C/C++\n
+as much as possible\n
+(('note:できるだけC/C++内で完結させる'))
+
+  * Don't move between\n
+    C/C++ and Ruby\n
+    (('note:C/C++とRuby間でいったりきたりしない'))
+
+= Example: #sum\n(('note:例：#sum'))
+
+  # coderay ruby
+
+  numbers = (1..100000).to_a
+  # Move between C and Ruby: 25.1ms
+  numbers.inject(&:+)
+  # Done in C:                0.5ms
+  # 50x faster（50倍速い）
+  numbers.sum
+
+= Extension and binding\n(('note:バインディングと拡張ライブラリー'))
+
+  * Extension(('note:（拡張ライブラリー）'))
+    * Ruby library implemented in C\n
+      (('note:Cで実装されたRubyのライブラリー'))
+  * Binding(('note:（バインディング）'))
+    * Ruby library to use library implemented in other languages\n
+      (('note:他言語実装のライブラリを使うためのRubyのライブラリ'))
+
+= Binding usage\n(('note:バインディングの使い方'))
+
+  * Export each API to Ruby\n
+    (('note:それぞれのAPIをRubyで使えるようにする'))
+  * Combine exported APIs in Ruby\n
+    (('note:バインディングが提供するAPIをRubyレベルで組み合わせる'))
+
+= Binding usage example\n(('note:バインディングの使い方例'))
+
+  # coderay ruby
+
+  require "cairo"
+  include Cairo
+  # Combine APIs
+  s = PDFSurface.new("red.pdf", 10, 10) # API
+  context = Context.new(s)              # API
+  context.set_source_color(:red)        # API
+  context.paint                         # API
+  context.show_page                     # API
+  s.finish                              # API
+
+= Point of improve perf\n(('note:高速化するために大事なこと'))
+
+(('tag:center'))
+Done in C/C++\n
+as much as possible\n
+(('note:できるだけC/C++内で完結させる'))
+
+  * Don't move between\n
+    C/C++ and Ruby\n
+    (('note:C/C++とRuby間でいったりきたりしない'))
+
+= Improve perf example\n(('note:高速化例'))
+
+  # coderay ruby
+
+  # Don't combine APIs in Ruby
+  # RubyレベルでAPIを組み合わせない
+  ## context.set_source_color(:red) # API
+  ## context.paint                  # API
+  ## context.show_page              # API
+  # Just call higher level API in Ruby
+  # Rubyからはもっと高レベルなAPIを呼び出す
+  context.show_red_page # Implemented in C
+                        # ここはCで実装
+
+= What I want to do\n(('note:やりたいこと'))
+
+(('tag:center'))
+Improve performance\n
+with C/C++ libraries\n
+(('note:C/C++のライブラリーを使った高速化'))
+
+  * Not wanting to create binding\n
+    (('note:バインディングを作りたいわけじゃない'))
+
+= Use case\n(('note:高速化したい場面'))
+
+  * Machine learning\n
+    (('note:機械学習'))
+    * Combine array/matrix operations\n
+      (('note:配列・行列に対する演算をまとめる'))
+
+= Raw C API\n(('note:生のC API'))
+
+(('tag:center'))
+Not bad but has some verbosities because of C\n
+(('note:悪くないんだけどCなので冗長'))
+
+  * Need better approach\n
+    (('note:もっといい感じの方法を使いたい'))
+
+= Requirements\n(('note:要件'))
+
+  * Easy to use C/C++ libraries\n
+    (('note:C/C++のライブラリーを簡単に使えること'))
+  * Easy to write (('note:as much as possible'))\n
+    (('note:できるだけ書きやすいこと'))
+  * Easy to debug (('note:as much as possible'))\n
+    (('note:できるだけデバッグしやすいこと'))
+
+= Approaches(('note:（実現方法）'))
+
+  * Extend language to support writing extension\n
+    (('note:拡張ライブラリーを書けるように言語を拡張'))
+  * Based on not C language\n
+    (('note:C以外の言語を使う'))
+  * Provide convenient API\n
+    (('note:便利APIを提供'))
+
+= Recommended approach\n(('note:オススメの実現方法'))
+
+  * Extend language to support writing extension\n
+    (('note:拡張ライブラリーを書けるように言語を拡張'))
+  * Based on not C language\n
+    (('note:C以外の言語を使う'))
+  * ((*Provide convenient API*))\n
+    (('note:便利APIを提供'))
+
+= Provide convenient API\n(('note:便利なAPIを提供'))
+
+  * Rice: ((*C++*)) + Ruby
+  * Ext++: ((*C++*))11 + Ruby
+  * Boost.Python: ((*C++*)) + Python
+  * pybind11: ((*C++*))11 + Python
+
+= Convenient API and C++\n(('note:便利なAPIとC++'))
+
+  * C++ can use C API directory\n
+    (('note:C++ではCのAPIを直接使える'))
+    * No need wrapper API nor libffi\n
+      (('note:ラッパーAPIもlibffiもいらない'))
+  * C++ has many convenient features\n
+    (('note:C++には便利機能がたくさんある'))
+
+= Convenient API example1\n(('note:便利なAPI例1'))
+
+  # coderay ruby
+
+  # Ruby: Normal
+  class Sample
+    def hello
+      "Hello"
+    end
+  end
+
+= Convenient API example1\n(('note:便利なAPI例1'))
+
+  # coderay ruby
+
+  # Ruby: No syntax sugar
+  Sample = Class.new do
+    define_method(:hello) do
+      "Hello"
+    end
+  end
+
+= Convenient API example1\n(('note:便利なAPI例1'))
+
+  # coderay cpp
+
+  // C++: Ext++
+  #include <ruby.hpp>
+  extern "C" void Init_sample(void) {
+    rb::Class("Sample"). // class Sample in Ruby
+      define_method("hello", // def hello in Ruby
+        [](VALUE self) { // lambda {|| "Hello"} in Ruby
+          return rb_str_new_static("Hello");
+        });
+  }
+
+= Convenient API example1\n(('note:便利なAPI例1'))
+
+  # coderay c
+
+  /* C */
+  #include <ruby.h>
+  static VALUE rb_sample_hello(VALUE self) {
+    return rb_str_new_static("Hello");
+  }
+  void Init_sample(void) {
+    VALUE sample = rb_define_class("Sample", rb_cObject);
+    rb_define_method(sample, "hello", rb_sample_hello, 0);
+  }
+
+= Convenient API example2\n(('note:便利なAPI例2'))
+
+  # coderay cpp
+
+  // C++: Rice
+  #include <rice/Class.hpp>
+  static const char * // Not VALUE! (Auto convert)
+  rb_sample_hello(Rice::Object self) {
+    return "Hello";
+  }
+  extern "C" void Init_sample() {
+    Rice::define_class("Sample").
+      define_method("hello", &rb_sample_hello);
+  }
+
+= Convenient C++ API1\n(('note:便利なC++ API1'))
+
+  * Default arguments(('note:（デフォルト引数）'))
+    * Parent class is omittable\n
+      (('note:RubyのAPIのように親クラスを省略可能'))
+  * Template(('note:（テンプレート）'))
+    * Auto C/C++ <-> Ruby convert\n
+      (('note:C/C++↔Ruby間の自動変換'))
+
+= Convenient API example3
+
+  # coderay cpp
+
+  // C++11
+  #include <iostream>
+  #include <xtensor/xarray.hpp>
+  int main(void) {
+    xt::xarray<double> array = {1.0, 2.0, 3.0};
+    // Type deduction. Operator overloading.
+    auto result = (array + 2.0) * 3.0; // element-wise ops
+    for (const auto &element : result) { // result.each {}
+      std::cout << element << std::endl; // 9 12 15
+    }
+    return 0;
+  }
+
+= Convenient C++ API2\n(('note:便利なC++ API2'))
+
+  * auto: Type deduction(('note:（型推論）'))
+    * Simpler code\n
+      (('note:コードがシンプルになる'))
+  * Range-based for loop(('note:（範囲forループ）'))
+    * Simpler code\n
+      (('note:コードがシンプルになる'))
+
+= C++ based API: Pros1\n(('note:C++ベースのAPI：長所1'))
+
+(('tag:center'))
+Easy to write than C\n
+(('note:Cより書きやすい'))
+
+  * Require C++11 or later\n
+    (('note:C++11以降なら'))
+
+= C++ based API: Pros2\n(('note:C++ベースのAPI：長所2'))
+
+(('tag:center'))
+Easy to use for C API users\n
+(('note:既存のC APIを使っている人なら使いやすい'))
+
+  * Can use C directly incl macro\n
+    (('note:マクロも含めてCの機能を直接使える'))
+  * Don't need to migrate to all convenient API at once\n
+    (('note:一気に書き換えるのではなく徐々に移行できる'))
+
+= C++ based API: Pros3\n(('note:C++ベースのAPI：長所3'))
+
+(('tag:center'))
+Easy to debug for C API users\n
+(('note:既存のC APIを使っている人ならデバッグしやすい'))
+
+  * Can use GDB/LLDB directly\n
+    (('note:GDB/LLDBを直接使える'))
+    * GDB/LLDB have built-in C++ support\n
+      (('note:GDB/LLDBは組み込みでC++をサポート'))
+
+= C++ based API: Pros4\n(('note:C++ベースのAPI：長所4'))
+
+(('tag:center'))
+Easy to optimize\n
+(('note:最適化しやすい'))
+
+  * [Feature #13434] better method definition in C API\n
+    (('note:Cのメソッド定義APIの改良'))
+
+= Better method definition\n(('note:メソッド定義の改良'))
+
+  * Metadata for optimization\n
+    (('note:最適化のためにメタデータを付与'))
+    * e.g.: Reduce memory allocations\n
+      (('note:例：メモリーアロケーションを減らす'))
+  * Lazy method definition\n
+    (('note:必要になるまでメソッド定義を遅らせる'))
+    * e.g.: Reduce start-up time\n
+      (('note:例：起動時間の高速化'))
+
+= Argument metadata\n(('note:引数のメタデータ'))
+
+  # coderay ruby
+
+  class Hello
+    # Default argument is just for
+    # example. Other metadata will
+    # be more useful for optimization.
+    def hello(name, message="world")
+    end
+  end
+
+= Argument metadata\n(('note:引数のメタデータ'))
+
+  # coderay cpp
+
+  // Rice
+  cHello.
+    define_method(
+      "hello",
+      &hello,
+      (Rice::Arg("name"), // ↓Default
+       Rice::Arg("message")="world"));
+
+= Lazy method definition\n(('note:遅延メソッド定義'))
+
+  # coderay ruby
+
+  class X
+    def a; end # Not define yet
+    def b; end # Not define yet
+  end
+  x = X.new
+  x.a # Define #a and #b
+
+= Lazy method definition\n(('note:遅延メソッド定義'))
+
+  # coderay c
+
+  /* One of new C API ideas */
+  struct rb_method_entries entries[] = {
+    "a", ...,
+    "b", ...,
+  };
+  /* The definitions aren't defined at once. */
+  /* They are defined when the next method call. */
+  rb_define_method_with_table(rb_cX, entries);
+
+= Lazy method definition\n(('note:遅延メソッド定義'))
+
+  # coderay c
+
+  // C++ implementation sample
+  {
+    rb::Class("X").
+      // Don't call rb_define_method() yet.
+      define_method("a", ...).
+      // Don't call rb_define_method() yet.
+      define_method("b", ...);
+    // Destructor is called.
+    // Call rb_define_method_with_table()
+    // in destructor.
+  }
+
+= Lazy method definition\n(('note:遅延メソッド定義'))
+
+  # coderay c
+
+  // Ext++ implementation is just for test
+  rb::Class("X").
+    // Call rb_define_method() immediately.
+    define_method("a", ...).
+    // Don't call rb_define_method() in
+    // the following define_method()s.
+    enable_lazy_define_method().
+    // Don't call rb_define_method() yet.
+    define_method("b", ...);
+
+= Lazy method definition\n(('note:遅延メソッド定義'))
+
+  # coderay ruby
+
+  # Define only benchmark code in Ruby.
+  # Real benchmark code is in C++.
+  n = 10000
+  Bench = Class.new do
+    n.times do |i|
+      define_method("method#{i}") do
+      end
+    end
+  end
+
+= Lazy method definition\n(('note:遅延メソッド定義'))
+
+  # coderay ruby
+
+  # Call benchmark code in Ruby.
+  # Real benchmark code is in C++.
+  n = 10000
+  bench = Bench.new
+  n.times do |i|
+    bench.__send__("method#{i}")
+  end
+
+= Lazy method definition\n(('note:遅延メソッド定義'))
+
+  # RT
+
+  Type, Define only, Called
+
+  Normal, 0.005675s, 0.005625s
+  Lazy,   0.001142s, 0.005674s
+
+(('tag:center'))
+5x faster when any methods aren't called\n
+(('note:メソッドが呼ばれなければ5倍速い'))
+
+= C++ based API: Cons1\n(('note:C++ベースのAPI：短所1'))
+
+(('tag:center'))
+C++ is difficult\n
+(('note:C++は難しい'))
+
+  * e.g.: Template\n
+    (('note:たとえばテンプレート'))
+  * Easy to write unreadable code\n
+    (('note:簡単にリーダブルじゃないコードを書ける'))
+
+= C++ based API: Cons2\n(('note:C++ベースのAPI：短所2'))
+
+(('tag:center'))
+Slower build\n
+(('note:ビルドが遅い'))
+
+  * It may reduce try&error cycle\n
+    (('note:試行錯誤しにくくなるかも'))
+
+= C++ based API: Problem\n(('note:C++ベースのAPI：課題'))
+
+(('tag:center'))
+Exception\n
+(('note:例外'))
+
+  * Ruby exception breaks C++ RAII (destructor)\n
+    (('note:Rubyの例外発生→C++のRAII（デストラクター）が動かない'))
+    * Because it uses setjmp/longjmp\n
+      (('note:Rubyの例外はsetjmp/longjmpを使っているから'))
+
+= Exception: Solution\n(('note:例外：解決法'))
+
+  (1) Rescue Ruby exception\n
+      (('note:Rubyの例外をrescue'))
+  (2) Throw C++ exception\n
+      (('note:C++の例外にしてthrow'))
+  (3) Re-raise the Ruby exception\n
+      (('note:安全な場所でRubyの例外を再raise'))
+
+= Conclusion\n(('note:まとめ'))
+
+  * C++ based API is useful\n
+    (('note:C++ベースのAPIは便利'))
+    * For writing ext uses C/C++ library\n
+      (('note:C/C++のライブラリを使う拡張ライブラリを書くとき'))
+    * For optimizing w/ easy to use API\n
+      (('note:例：使いやすいAPIを維持したまま最適化するとき'))
+
+= Appendix\n(('note:付録'))
+
+(('tag:center'))
+Introduce easy to write extension approaches\n
+(('note:拡張ライブラリーを簡単に実装する方法を紹介'))
+
+  * The following contents are used only when time is remained\n
+    (('note:以降の内容は時間が残っている場合だけ使う'))
+
+= Approaches(('note:（実現方法）'))
+
+  * Extend language to support writing extension\n
+    (('note:拡張ライブラリーを書けるように言語を拡張'))
+  * Based on not C language\n
+    (('note:C以外の言語を使う'))
+  * Provide convenient API\n
+    (('note:便利APIを提供'))
+
+= Extend language\n(('note:言語を拡張'))
+
+  * Rubex: Extended Ruby\n
+    (('note:Rubex：Rubyを拡張'))
+  * Cython: Extended Python\n
+    (('note:Cython：Pythonを拡張'))
+
+= How to run\n(('note:動かし方'))
+
+  * Compile code for extended language to C\n
+    (('note:拡張言語で書かれたコードをCにコンパイル'))
+  * Build compiled C code\n
+    (('note:コンパイルされたCコードをビルド'))
+  * Load the built extension\n
+    (('note:ビルドした拡張ライブラリーを読み込む'))
+
+= Extended syntax\n(('note:拡張された構文'))
+
+  * Type information\n
+    (('note:型情報を書ける'))
+  * C code snippet\n
+    (('note:Cのコードを書ける'))
+
+= How to run: Rubex\n(('note:Rubexの動かし方'))
+
+  # coderay ruby
+  # fibonacci.rubex
+  class Fibonacci
+    # "int" is type information
+    def compute(int n)
+      # ...
+    end
+  end
+
+= How to run: Rubex\n(('note:Rubexの動かし方'))
+
+  # coderay console
+  % rubex fibonacci.rubex
+  % cd fibonacci
+  % ruby extconf.rb
+  % make
+
+= How to run: Rubex\n(('note:Rubexの動かし方'))
+
+  # coderay ruby
+  require_relative "fibonacci.so"
+  p Fibonacci.new.compute(100)
+
+= Extend language: Pros1\n(('note:拡張言語：長所1'))
+
+(('tag:center'))
+Friendly syntax for base language users\n
+(('note:ベースの言語のユーザーにはなじみやすい構文'))
+
+  * Most syntaxes are same\n
+    (('note:構文の大部分は同じだから'))
+
+= Extend language: Pros\n(('note:拡張言語：長所2'))
+
+(('tag:center'))
+Easy to migrate from base lang\n
+(('note:ベースの言語からの移行が容易'))
+
+  * Because upper compatibility\n
+    (('note:上位互換だから'))
+  * Code for base language works without modification\n
+    (('note:ベースの言語で書かれたコードは変更なしで動く'))
+
+= Extend language: Pros\n(('note:拡張言語：長所3'))
+
+(('tag:center'))
+Don't require large C knowledge\n
+(('note:そんなにCの知識は必要ない'))
+
+  * Most codes can be written with base language knowledge\n
+    (('note:コードの大部分はベースの言語の知識で書ける'))
+
+= Extend language: Cons1\n(('note:拡張言語：短所1'))
+
+(('tag:center'))
+You realize that it's not friendly syntax when you use it\n
+(('note:使うとそんなになじみやすい文法ではないと気づく'))
+
+  * Small differences will confuse you\n
+    (('note:小さな違いがいろいろあってわかりにくい'))
+
+= Extend language: Cons2\n(('note:拡張言語：短所2'))
+
+(('tag:center'))
+Difficult to debug\n
+(('note:デバッグが難しい'))
+
+  * Need base language, extend language and C knowledge\n
+    (('note:ベースの言語の知識も拡張言語の知識もCの知識も必要'))
+
+(('note:Cython has GDB integration to solve this problem'))\n
+(('note:Cythonはこの問題を解決するためにGDB用の便利機能を提供'))
+
+= Extend language: Cons3\n(('note:拡張言語：短所2'))
+
+(('tag:center'))
+Need many works to maintain\n
+(('note:(For maintainers, not for users)'))\n
+(('note:（ユーザーではなくメンテナーが）メンテナンスが大変'))
+
+  * Base language introduces a new syntax then extend language should implement it\n
+    (('note:ベースの言語が新しい構文を導入→拡張言語でも実装'))
+
+= Based on not C language\n(('note:C言語以外をベースにする'))
+
+  * JRuby: Java + Ruby
+  * Helix: Rust + Ruby
+
+= How to run: JRuby\n(('note:JRubyでの動かし方'))
+
+  # coderay java
+  // Fibonacci.java
+  public class Fibonacci {
+    public long[] compute(int n) {
+      // ...
+    }
+  }
+
+= How to run: JRuby\n(('note:JRubyでの動かし方'))
+
+  # coderay console
+  % javac Fibonacci.java
+  % jar cf fibonacci.jar Fibonacci.class
+
+= How to run: JRuby\n(('note:JRubyでの動かし方'))
+
+  # coderay ruby
+  require "fibonacci.jar"
+  java_import "Fibonacci"
+  p Fibonacci.new.compute(100)
+
+= Based on not C: Pros1\n(('note:C言語以外をベースにする：長所1'))
+
+(('tag:center'))
+Easy to write than C\n
+(('note:Cより書きやすい'))
+
+  * Simpler syntax\n
+    (('note:洗練された構文'))
+  * Rich features than C\n
+    (('note:Cより機能が多い'))
+
+= Based on not C: Pros2\n(('note:C言語以外をベースにする：長所2'))
+
+(('tag:center'))
+Can use libraries in base language\n
+(('note:ベース言語のライブラリーを使える'))
+
+  * Major languages have many libraries\n
+    (('note:広く使われている言語はライブラリーも多い'))
+
+= Based on not C: Cons1\n(('note:C言語以外をベースにする：短所1'))
+
+(('tag:center'))
+Need base language knowledge\n
+(('note:ベース言語の知識が必要'))
+
+  * Java for JRuby(('note:（JRubyならJava）'))
+  * Rust for Helix(('note:（HelixならRust）'))
+
+= Based on not C: Cons2\n(('note:C言語以外をベースにする：短所2'))
+
+(('tag:center'))
+May need C knowledge\n
+(('note:(When Ruby implementation is MRI)'))\n
+(('note:Rubyの実装がMRIならCの知識が必要かもしれない'))
+
+  * Base language wraps Ruby C API\n
+    (('note:ベースの言語はRubyのC APIをラップしている'))
+    * e.g.: (({sys::RSTRING_PTR})) on Helix\n
+      (('note:例：Helixならsys::RSTRING_PTRがラップしたAPI'))
+
+= Based on not C: Cons3\n(('note:C言語以外をベースにする：短所3'))
+
+(('tag:center'))
+May need many works to maintain\n
+(('note:(When Ruby implementation is MRI)'))\n
+(('note:Rubyの実装がMRIならメンテナンスが大変かも'))
+
+  * Ruby introduces a new API then base language may need to implement it\n
+    (('note:Rubyが新しいAPIを追加→ベース言語でも実装？'))
+    * e.g.: (({rb_gc_adjust_memory_usage()}))
+
+= Provide convenient API\n(('note:便利なAPIを提供'))
+
+  * Rice: C++ + Ruby
+  * Ext++: C++ + Ruby
+  * Boost.Python: C++ + Python
+  * pybind11: C++11 + Python
+
+= How to run: Rice\n(('note:Riceの動かし方'))
+
+  # coderay cpp
+
+  #include <rice/Class.hpp>
+
+  static const char * // Not VALUE!
+  rb_sample_hello(Rice::Object self) {
+    return "Hello";
+  }
+  extern "C" void Init_sample() {
+    Rice::define_class("Sample").
+      define_method("hello", &rb_sample_hello);
+  }
+
+= How to run: Rice\n(('note:Riceの動かし方'))
+
+  # coderay ruby
+
+  # extconf.rb
+  require "mkmf-rice"
+  create_makefile("sample")
+
+= How to run: Rice\n(('note:Riceの動かし方'))
+
+  # coderay console
+
+  % ruby extconf.rb
+  % make
+
+= How to run: Rice\n(('note:Riceの動かし方'))
+
+  # coderay ruby
+
+  require_relative "sample.so"
+  p Sample.new.hello
+  # => "Hello"
+
+= Provide C++ API: Pros\n(('note:C++ APIを提供：長所'))
+
+Omit\n
+(('note:省略'))
+
+= Provide C++ API: Cons\n(('note:C++ APIを提供：短所'))
+
+Omit\n
+(('note:省略'))
+
+= Provide C++ API: ConsN\n(('note:C++ APIを提供：短所N'))
+
+(('tag:center'))
+Conv from Ruby may be a bother\n
+(('note:Ruby実装の移植が面倒'))
+
+  * C++ with convenient Ruby C API needs more codes than Ruby\n
+    (('note:RubyのC APIにC++の便利APIがあってもRubyよりもたくさんコードが必要'))
+
+= From Ruby: Rice\n(('note:RubyからRiceに移植'))
+
+  # coderay ruby
+  def fib(n)
+    prev = 1
+    current = 1
+    1.step(n - 1).collect do
+      prev, current = current, current + prev
+      prev
+    end
+  end
+
+= From Ruby: Rice\n(('note:RubyからRiceに移植'))
+
+  # coderay cpp
+  std::vector<uint64_t> fib(Rice::Object self, int n) {
+    uint64_t prev = 1, current = 1;
+    std::vector<uint64_t> numbers;
+    for (int i = 1; i < n; ++i) {
+      auto temp = current; current += prev; prev = temp;
+      numbers.push_back(prev);
+    }
+    return numbers;
+  }

data/theme.rb

@@ -0,0 +1,4 @@
+@title_slide_title_font_size = @large_font_size
+@title_slide_subtitle_font_size = @small_font_size
+
+include_theme("clear-code")

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: rabbit-slide-kou-rubykaigi-2017
+version: !ruby/object:Gem::Version
+  version: 2017.9.18.0
+platform: ruby
+authors:
+- Kouhei Sutou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rabbit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: rabbit-theme-clear-code
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby's extension API is for C. This talk proposes C++ as a better language
+  for extension API.
+email:
+- kou@clear-code.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rabbit"
+- README.rd
+- Rakefile
+- config.yaml
+- extension-by-cpp.rab
+- images/clear-code-silver-sponsor.png
+- images/shocker.jpeg
+- pdf/rubykaigi-2017-extension-by-cpp.pdf
+- theme.rb
+homepage: http://slide.rabbit-shocker.org/authors/kou/rubykaigi-2017/
+licenses:
+- CC-BY-SA-4.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: 'Improve extension API: C++ as better language for extension'
+test_files: []