2024-08-01

大阪Ruby会議04に永和システムマネジメントから koic と haruguchi が登壇します

2024年8月24日(土) に開催される大阪Ruby会議04 に永和システムマネジメントから @koic と @haruguchi-yuma の2人が登壇します。

rubykansai.github.io

ここでは、それぞれの登壇者から講演内容について軽く紹介をします。

14:50-15:05 @haruguchi-yuma 『競技プログラミングでみる Ruby の豊かさ』

rubykansai.github.io

こんにちは、@haruguchiです。私は『競技プログラミングでみる Ruby の豊かさ』というタイトルで発表します。

今回のセッションでは、普段のWeb開発とは一味違った、競技プログラミングならではのクリエイティブで簡潔なコードの世界をご紹介します。

私は2年ほど競技プログラミングのコンテストに参加し続けています。その中で、Rubyの多様なシンタックスやメソッドに驚かされることが多々ありました。特に、普段のWeb開発ではあまり使用しないメソッドや、コードゴルフのような簡潔で難読なコード、可読性を多少犠牲にしても簡潔に記述するシンタックスなど、Rubyの豊かさを再発見しました。

対象者は、普段保守・拡張性に富んだ可読性の高いコードを書いてしまっているRubyistです。ぜひ一緒に、競技プログラミングらしい、クスッと笑えるお行儀の悪い（保守・拡張性に乏しく一見読めない）コードを楽しみましょう。

15:25-15:55 @koic 『Minify Ruby Code』

rubykansai.github.io

@koic です。今回は『Minify Ruby Code』というタイトルで Ruby のコードについて話します。タイトルにあるように JavaScript などの Web リソースの世界ではポピュラーな minify をとおした Ruby コードの話です。

近年では ruby.wasm が登場し、WASM/WASI により Web ブラウザーに限らずエッジコンピューティングへの可能性が広がってきていると思います。また来年の RubyKaigi 2025 では TRICK 2025 が開催されることもあるように、日頃目指している「動作するきれいなコード」ではない「動作する奇妙なコード」「動作する難読化されたコード」などが知られています。

Ruby における minify は、明日からすぐに役立つ技術ではありませんが、昨今の Ruby コミュニティ事情において、これらのことから考えられるネットワーク転送コストの軽量化や、コードで遊ぶことについてを考えるきっかけに繋がるコンテンツの提供を考えています。

なお本トークは、キーノートの kaneko さんと hasumikin さん、チーフオーガナイザーの ydah さんにちなみ構文解析の話が基盤にあります。Ruby を通じたコードの楽しさを再発見できるよう準備中です。お楽しみに。

また永和システムマネジメントとしては、Premium スポンサーとして関わっており、弊社気鋭の構文解析器研究部部員でもある @junk0612 がスポンサー LT として 14:10-14:15 の枠で登壇します。

スポンサーブースでは Ask the Speakers、出張！構文解析器研究部、角谷フェローによる『研鑽Rubyプログラミング』手売り販売所といった企画を予定しています。あわせてご期待ください。

大阪Ruby会議04は絶賛参加受付されています。

rubykansai.doorkeeper.jp

それでは大阪中之島の会場でお会いしましょう。

大阪Ruby会議04 に Premium スポンサーとしても参加している永和システムマネジメントでは、Ruby とアジャイルソフトウェア開発を通じてコミュニティと成長したいエンジニアを絶賛募集しています。

agile.esm.co.jp

2024-07-08

0 1 1 2 3 5 8 13 21 34 55 ...

こんにちは！健康のために1日1万歩の散歩を始めたら、雨に打たれて風邪をひいた@haruguchiです。

RubyKaigi 2024 が終わって早くも2カ月が経とうとしています。私にとってのKaigi Effectはなんだろうと考えると、言語処理系やコンピュータサイエンスといった別のレイヤに興味を持ったことだと思います。特に今年の@tompngさんの発表「Writing Weird Code」ではWeird Codeを書くということの楽しさを感じたり、テストの追加や言語仕様を深く理解するのに役立つことを実感しました。

弊社ではQuine部*1なるものが発足され、熱量十分の状態です。そこで私も業務ではまず書かない Weird Code を書いてみたので紹介します。

ラムダ計算でフィボナッチ数列を出力する

ラムダ計算は関数を主体とした計算モデルの一つでチューリング完全であることが知られています。今回はフィボナッチ数列の第0項から第10項*2までの計算を、Rubyのlambda式を用いてシミュレートしていきます。

ここで、断っておくとラムダ計算自体は決してWeird Code ではなく計算の意味論だったり、型理論に使われたり、関数型プログラミングの論理的な土台となっていたりします。ラムダ式のみで書かれたコードが見た目上奇妙に見えるという意味で Weird Codeとして紹介します。

本体

コードの全容はこちらをご参照ください。ラムダ計算でフィボナッチ数列を計算する · GitHub

本体だけ抜粋すると以下のようになります。

# 本体(50文字折り返し)
proc =
  ->k{->f{->f{->x{f[->y{x[x][y]}]}[->x{f[->y{x[x][y]
  }]}]}[->f{->l{->x{->g{->b{b}[->p{p[->x{->y{x}}]}[l
  ]][x][->y{g[f[->l{->p{p[->x{->y{y}}]}[->p{p[->x{->
  y{y}}]}[l]]}[l]][x][g]][->l{->p{p[->x{->y{x}}]}[->
  p{p[->x{->y{y}}]}[l]]}[l]][y]}]}}}}][k][->x{->y{->
  f{f[x][y]}}}[->x{->y{x}}][->x{->y{x}}]][->l{->x{->
  l{->x{->x{->y{->f{f[x][y]}}}[->x{->y{y}}][->x{->y{
  ->f{f[x][y]}}}[x][l]]}}[l][f[x]]}}]}}[->f{->x{f[->
  y{x[x][y]}]}[->x{f[->y{x[x][y]}]}]}[->f{->m{->n{->
  b{b}[->m{->n{->n{n[->x{->x{->y{y}}}][->x{->y{x}}]}
  [->m{->n{n[->n{->p{p[->x{->y{x}}]}[n[->p{->x{->y{-
  >f{f[x][y]}}}[->p{p[->x{->y{y}}]}[p]][->n{->s{->x{
  s[n[s][x]]}}}[->p{p[->x{->y{y}}]}[p]]]}][->x{->y{-
  >f{f[x][y]}}}[->s{->x{x}}][->s{->x{x}}]]]}][m]}}[m
  ][n]]}}[m][n]][->x{->l{->x{->x{->y{->f{f[x][y]}}}[
  ->x{->y{y}}][->x{->y{->f{f[x][y]}}}[x][l]]}}[f[->n
  {->s{->x{s[n[s][x]]}}}[m]][n]][m][x]}][->x{->y{->f
  {f[x][y]}}}[->x{->y{x}}][->x{->y{x}}]]}}}][->s{->x
  {x}}][->s{->x{s[s[s[s[s[s[s[s[s[s[x]]]]]]]]]]}}]][
  ->n{->f{->x{f[->y{x[x][y]}]}[->x{f[->y{x[x][y]}]}]
  }[->f{->n{->b{b}[->n{n[->x{->x{->y{y}}}][->x{->y{x
  }}]}[n]][->x{->s{->x{x}}}][->b{b}[->n{->n{n[->x{->
  x{->y{y}}}][->x{->y{x}}]}[->m{->n{n[->n{->p{p[->x{
  ->y{x}}]}[n[->p{->x{->y{->f{f[x][y]}}}[->p{p[->x{-
  >y{y}}]}[p]][->n{->s{->x{s[n[s][x]]}}}[->p{p[->x{-
  >y{y}}]}[p]]]}][->x{->y{->f{f[x][y]}}}[->s{->x{x}}
  ][->s{->x{x}}]]]}][m]}}[n][->s{->x{s[x]}}]]}[n]][-
  >x{->s{->x{s[x]}}}][->x{->m{->n{n[->n{->s{->x{s[n[
  s][x]]}}}][m]}}[f[->n{->p{p[->x{->y{x}}]}[n[->p{->
  x{->y{->f{f[x][y]}}}[->p{p[->x{->y{y}}]}[p]][->n{-
  >s{->x{s[n[s][x]]}}}[->p{p[->x{->y{y}}]}[p]]]}][->
  x{->y{->f{f[x][y]}}}[->s{->x{x}}][->s{->x{x}}]]]}[
  n]]][f[->n{->p{p[->x{->y{x}}]}[n[->p{->x{->y{->f{f
  [x][y]}}}[->p{p[->x{->y{y}}]}[p]][->n{->s{->x{s[n[
  s][x]]}}}[->p{p[->x{->y{y}}]}[p]]]}][->x{->y{->f{f
  [x][y]}}}[->s{->x{x}}][->s{->x{x}}]]]}[->n{->p{p[-
  >x{->y{x}}]}[n[->p{->x{->y{->f{f[x][y]}}}[->p{p[->
  x{->y{y}}]}[p]][->n{->s{->x{s[n[s][x]]}}}[->p{p[->
  x{->y{y}}]}[p]]]}][->x{->y{->f{f[x][y]}}}[->s{->x{
  x}}][->s{->x{x}}]]]}[n]]]]}]][->s{->x{x}}]}}][n]}]

これは全てRubyのlambda記法によって表現されています。このコードは奇妙さを演出するためにスペースを削除したり50文字で折り返して人間にとって読みにくいものになっています。なので、ラムダ式を意味のまとまりに区切り定数に代入してみます。すると以下のようになります。

# natural number(必要のない数も存在する)
ZERO     = -> s { -> x { x } }
ONE      = -> s { -> x { s[x] } }
TWO      = -> s { -> x { s[s[x]] } }
THREE    = -> s { -> x { s[s[s[x]]] } }
FOUR     = -> s { -> x { s[s[s[s[x]]]] } }
FIVE     = -> s { -> x { s[s[s[s[s[x]]]]] } }
TEN      = -> s { -> x { s[s[s[s[s[s[s[s[s[s[x]]]]]]]]]] } }
FIFTEEN  = -> s { -> x { s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[x]]]]]]]]]]]]]]] } }

# bool
TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }

# if
IF = -> b { b }

IS_ZERO = -> n { n[-> x { FALSE }][TRUE] }
IS_ONE = -> n { IS_ZERO[SUB[n][ONE]] }

# pair
PAIR = -> x { -> y { -> f { f[x][y] } } }
LEFT = -> p { p[-> x { -> y { x } }] }
RIGHT = -> p { p[-> x { -> y { y } }] }

# operator
SUCC = -> n { -> s { -> x { s[n[s][x]] } } }
SLIDE = -> p { PAIR[RIGHT[p]][SUCC[RIGHT[p]]] }  # ペア型を引数に取り、右の値と右の値+1したペア型のデータを返す
PRED = -> n { LEFT[n[SLIDE][PAIR[ZERO][ZERO]]] }
ADD = -> m { -> n { n[SUCC][m] } } # n + m
SUB = -> m { -> n { n[PRED][m] } } # n - m

# z-combinator
Z = -> f { ->x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }

# list
EMPTY = PAIR[TRUE][TRUE]
UNSHIFT = -> l { -> x { PAIR[FALSE][PAIR[x][l]] } }
IS_EMPTY = LEFT
FIRST = -> l { LEFT[RIGHT[l]] }
REST = -> l { RIGHT[RIGHT[l]] }

# comparable
IS_LESS_OR_EQUAL = -> m { -> n { IS_ZERO[SUB[m][n]] } }

RANGE = Z[-> f {
  -> m { -> n {
    IF[IS_LESS_OR_EQUAL[m][n]][
      -> x { UNSHIFT[f[SUCC[m]][n]][m][x] }
    ][
      EMPTY
    ]
  } }
}]

# 畳み込み演算
FOLD = Z[-> f {
  -> l { -> x { -> g {
    IF[IS_EMPTY[l]][x][
      -> y {
        g[f[REST[l]][x][g]][FIRST[l]][y]
      }
    ]
  } } }
}]

# map
MAP = -> k { -> f { FOLD[k][EMPTY][-> l { -> x { UNSHIFT[l][f[x]] } }] } }


def to_nat(nat)
  nat[-> n { n + 1 }][0]
end

def to_bool(bool)
  IF[bool][true][false]
end

def to_ary(proc)
  ary = []

  until to_bool(IS_EMPTY[proc])
    ary << FIRST[proc]
    proc = REST[proc]
  end

  ary
end

# フィボナッチ数列の漸化式
FIB = Z[-> f {
  -> n {
    IF[IS_ZERO[n]][
      -> x { ZERO }
    ][IF[IS_ONE[n]][
      -> x { ONE }
    ][
      -> x {
        ADD[f[PRED[n]]][f[PRED[PRED[n]]]]
      }
    ]][ZERO]
  }
}]

proc = MAP[RANGE[ZERO][TEN]][-> n { FIB[n]} ]
results = to_ary(proc).map { to_nat(_1) }
p results #=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

とても読みやすくなったのではないでしょうか。順を追ってみていきましょう。

自然数を表現する

今回作ったのはフィボナッチ数列の第0項から第10項までを計算するラムダ計算です。計算結果は自然数で表されますが、ラムダ計算では関数しか登場しないので関数を自然数(チャーチ数)に対応づける必要があります。

# natural number
ZERO     = -> s { -> x { x } }
ONE      = -> s { -> x { s[x] } }
TWO      = -> s { -> x { s[s[x]] } }
TEN      = -> s { -> x { s[s[s[s[s[s[s[s[s[s[x]]]]]]]]]] } }

引数sをxに何回適用するかを自然数に対応づけています。例えばs[x]であれば1回の関数適用があるので1を表し、s[s[s[x]]]であれば3回関数適用されているので3を表します。これで理論上100でも1000でも自然数を表すことができます。(大変ですが、、、)

これを私たちが普段扱っている数として視認できるように変換メソッドも併せて定義しておきます。

def to_nat(nat)
  nat[-> n { n + 1 }][0]
end

to_nat(ZERO) #=> 0
to_nat(TEN) #=> 10

条件式を表現する

ラムダ計算はチューリング完全なのでbool値や条件分岐IFも表すことができます。 bool値に関しては2つの引数をとり、前者を返すのをtrueと表し、後者を返す関数をfalseで表します。

# bool
TRUE = -> x { -> y { x } }
FALSE = -> x { -> y { y } }

# if
IF = -> b { b }

IFは非常にシンプルで引数であるbをそのまま返す恒等関数になっています。それゆえ、IF[condition][consequnce][alternative]のような使い方ができます。

# 簡約の様子
IF[TRUE][ONE][THEREE]
          ↓
TRUE[ONE][THREE]
          ↓
ONE

IF[FALSE][ONE][THREE]
          ↓
FALSE[ONE][THREE]
          ↓
THREE

IFはこのままではELSIF節を表せませんが、ELSIFを表すときにはIFを入れ子にして対応します。また、bool値においてもラムダ計算では関数で表されているので値(true, false)に変換するメソッドを作っておきます。

def to_bool(bool)
  IF[bool][true][false]
end

ペア型のデータ構造を表す

データ構造も関数で表すことができます。ここでは2つの値の組みを表すペア型のでデータ構造を作っていきます。また、ペア型のデータの左の値と右の値を取り出す関数も実装します。

# pair
PAIR = -> x { -> y { -> f { f[x][y] } } }
LEFT = -> p { p[-> x { -> y { x } }] }
RIGHT = -> p { p[-> x { -> y { y } }] }

算術演算を表す

フィボナッチ数列の任意の項を求める場合、2つの数(に対応付けられたラムダ式)の足し算をする必要があるためラムダ式の世界の算術演算を導入する必要があります。任意の自然数*3に対し、次の自然数を取得するSUCCと前の自然数を取得するPREDそして、足し算を表すADD、引き算を表すSUBを作ります。掛け算や、割り算も同じように実装することができますが、フィボナッチ数列の計算では使わないので割愛します。

# operator
SUCC = -> n { -> s { -> x { s[n[s][x]] } } }
# ペア型を引数に取り、右の値と右の値+1したペア型のデータを返す
SLIDE = -> p { PAIR[RIGHT[p]][SUCC[RIGHT[p]]] }
PRED = -> n { LEFT[n[SLIDE][PAIR[ZERO][ZERO]]] }
ADD = -> m { -> n { n[SUCC][m] } } # n + m
SUB = -> m { -> n { n[PRED][m] } } # n - m

SUCCではs[...]と...の中のn[s][x]に分けると考えやすいです。s[]は関数適用1回分で、n[s][x]は関数sをxでn回呼び出すという意味になり合計n+1回の関数適用になります。よって次の値の自然数を表すことになります。

またここからn[●][○]という形式がよく出てきますが、●を○でn回適用すると読み替えると理解しやすいです。

引き算に関するラムダ式(PREDやSUB)は少し難しいです。n回関数適用したときにn-1を表すような関数を作るためにはペア型のデータ構造をうまく使います。SLIDEというペア型を引数に取り、ペア型の右の値とそれに+1した値のペア型を返す関数を用意します。

PREDのLEFT[n[SLIDE][PAIR[ZERO][ZERO]]]の部分を見るとSLIDEを引数PAIRでn回適用していることがわかるので例えば6という数に対してPREDを適用するとイメージとして以下のようになります。

# イメージ
n = 6
n[SLIDE][PAIR[0][0]]

1[SLIDE][PAIR[0][0]] → (0, 0 + 1) → (0, 1)
2[SLIDE][PAIR[0][0]] → (1, 1 + 1)  → (1, 2)
...
6[SLIDE][PAIR[0][0]] → (5, 5 + 1)  → (5, 6)

# ペア型の左の値を取り出す
LEFT[6[SLIDE][PAIR[0][0]]] → 5

もちろん実際には数に対応付けられた関数を取り出すのであくまでイメージです。 1増やしたり、1減らしたりできるようになったら nを引くことは1減らすをn回適用するという感じでADDやSUBを作ることができます。

またここで <=のような比較演算子で必要最低限のものを実装しておきます。

# comparable
IS_LESS_OR_EQUAL = -> m { -> n { IS_ZERO[SUB[m][n]] } }

今回扱っている数は自然数(0含む)のみなので引き算が負の数にならないことを利用し0かどうかを判定しています。

Z-コンビネーターを表す

Z-コンビネータとは不動点コンビネータの一種で $\displaystyle f(g(f)) = g(f)$ となるような性質を持ちます。

# z-combinator
Z = -> f { ->x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }

これを用いることで無名再帰を実装することができます。余談ですが、不動点コンビネータには Yコンビネータというものもありますが、Rubyの場合 Yコンビネータを用いることができないことに注意してください。Yコンビネータの場合無限ループに陥ります。コンビネータについての詳しい解説はここでは割愛します。詳しくは、Jim Weirichの以下の動画をご参照ください。

www.youtube.com

リストを表現する

リストというデータ構造が必要になってくるのでここで用意します。このコードでは、ペア型のデータ構造を用いて2つの値を組にしています。これを利用して、値と次の値へのポインタを格納した連結リストを構築します。この連結リストでは、各ノードが次のノードへの参照を持つことで、データの順序を保持しながらリスト全体を構成しています。

# list
EMPTY = PAIR[TRUE][TRUE]
UNSHIFT = -> l { -> x { PAIR[FALSE][PAIR[x][l]] } }
IS_EMPTY = LEFT
FIRST = -> l { LEFT[RIGHT[l]] }
REST = -> l { RIGHT[RIGHT[l]] }

次のようにデータを構築します。

list = UNSHIFT[
  UNSHIFT[
    UNSHIFT[EMPTY][THREE]
  ][TWO]
][ONE]

# イメージ
# [ONE, TWO, THREE]

またこれを可視化するためにto_aryというメソッドを用意します。

def to_ary(proc)
  ary = []

  until to_bool(IS_EMPTY[proc])
    ary << FIRST[proc]
    proc = REST[proc]
  end

  ary
end

p to_ary(list).map { to_nat(_1) }
#=> [1, 2, 3]

次に範囲を表すRANGEを実装します。

RANGE = Z[-> f {
  -> m { -> n {
    IF[IS_LESS_OR_EQUAL[m][n]][
      -> x { UNSHIFT[f[SUCC[m]][n]][m][x] }
    ][
      EMPTY
    ]
  } }
}]

考え方としてはrange(a, b)の場合、aからbまでの全ての要素を再起的にリストに追加しています。また、終端まで繰り返すため先ほど作成したZコンビネータを使っています。

続いて、MAPを実装するための準備として畳み込み演算(FOLD)を実装しておきます。

# 畳み込み演算
FOLD = Z[-> f {
  -> l { -> x { -> g {
    IF[IS_EMPTY[l]][x][
      -> y {
        g[f[REST[l]][x][g]][FIRST[l]][y]
      }
    ]
  } } }
}]

リストが空だったら初期値xを返し、そうでない場合は関数gを再起的に呼び出します。

畳み込みを実装したのでMAPは簡単に記述することができます。

# map
MAP = -> k { -> f { FOLD[k][EMPTY][-> l { -> x { UNSHIFT[l][f[x]] } }] } }

MAPは引数を2つ取ります。kが元のリストでFOLDを使って畳み込みを行っています。また2つ目の引数fは適用する関数を表しています。

フィボナッチ数列の計算を表す

以上で、フィボナッチ数列を計算するのに必要な役者が揃いました。フィボナッチ数列は

$\displaystyle n: 自然数(0を含む) \\\ a_{0} = 0, a_{1} = 1, a_{n+2} = a_{n} + a_{n+1}$

という漸化式で表されます。これをもとに実装すると以下のようになります。

FIB = Z[-> f {
  -> n {
    IF[IS_ZERO[n]][
      -> x { ZERO }
    ][IF[IS_ONE[n]][
      -> x { ONE }
    ][
      -> x {
        ADD[f[PRED[n]]][f[PRED[PRED[n]]]]
      }
    ]][ZERO]
  }
}]

proc = MAP[RANGE[ZERO][TEN]][-> n { FIB[n]} ]

FIBはフィボナッチ数列の任意の項の計算になっています。条件分岐が3つ入っており、漸化式の通りの計算を行います。

procの部分はMAP関数を使って計算結果をリストに格納している処理です。

先ほど定義したラムダ式(関数)を数やデータ構造に変換するメソッドを群を適用すると結果が得られます。

result = to_ary(proc).map { p to_nat(_1) }
p result #=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

今回は第0項から第10項までのフィボナッチ数列を計算しましたが、任意の数をラムダ式で表しRANGE関数に渡すことで任意の項までの計算ができます。ただし、Rubyのプログラムで実行すると関数呼び出しが多くコールスタックがオーバーフローします。(RUBY_THREAD_VM_STACK_SIZEという環境変数でスタックサイズを変更できます)

まとめ

RubyKaigi 2024に参加した私のKaigi Effectとしてラムダ計算のみでフィボナッチ数列を計算するというWeird Codeに挑戦しました。本当はラムダ計算を使ってQuineを作れないか考えたのですが、うまくできそうになかったので個人的な宿題にしたいと思います。

永和システムマネジメントでは、Ruby とアジャイルソフトウェア開発を通じてコミュニティと成長したいエンジニアを絶賛募集しています。

agile.esm.co.jp

*1:Quineに限らない超絶技巧プログラミングについてワイワイします。

*2:0-indexedに合わせるため初項を第0項としています

*3:ここでは自然数に0を含める立場を取っています。

2024-07-08

Rails / OSS パッチ会 2024年7月のお知らせ

2024年7月の Rails / OSS パッチ会を 7月10日(水)に Discord でオンライン開催します。

この会をひとことでいうと、日頃のお仕事で使っている Rails をはじめとする OSS について、upstream にパッチを送る会です。

会には Ruby と Rails のコミッターである顧問の a_matsuda もいますので、例えば Rails に送るパッチのネタがあるけれど、パッチを送るに適しているかの判断やパッチを送る流れが悩ましいときなど a_matsuda に相談して足がかりにするなどできます。

開催時間は 17:00-19:00 となりますがご都合のあう方はぜひご参加下さい。

Discord の Rails/OSS パッチ会サーバーへの招待 URL は以下です。

discord.gg

今後予定されている地域Ruby会議や各種プロポーザルに思いを馳せながらという雰囲気になると思います。

rubykaigi.org

これからパッチ会に参加してみたいという方、OSS 開発者間の会話に興味があるので聞いてみたいという方もお気軽にどうぞ。

永和システムマネジメントでは、Ruby とアジャイルソフトウェア開発を通じてコミュニティと成長したいエンジニアを絶賛募集しています。

agile.esm.co.jp

2024-06-28

Ruby Hack Challengeはじめました

Ruby Hack Challenge Ruby 社内勉強会

こんにちは。構文解析器研究部員のS.H.です。

アジャイル事業部内ではじめたRuby Hack Challengeについて紹介します。

Ruby Hack Challengeとはなにか？

元々はRubyコミッターのko1さんがCookpadで開催されていたRubyの内部をハックするイベントです。 Rubyの内部実装を読んだり、Cのコードを変更して新しいメソッドを追加したりとRubyをより身近に感じられるイベントです。

techlife.cookpad.com

github.com

それを社内向けに勉強会として始めてみました。

はじめたきっかけ

元々、ko1さんたちが開催されていたRuby Hack Challengeに何度か参加していました。また参加していく中で「Rubyをハックできる人を増やしたい」なという思いがあり、そこで僕がオーガナイザーをしているHamada.rbでもforkとして開催していました。

また、Hamada.rbで開催していた時に溜まっていたノウハウが社内向けに活用できそうだったことと、「社内Ruby Hack Challengeやりたいな」と元々思っていたことなどもあり、Kaigi Effectで一気にやる気に火がついた勢いで始めました。

やっている内容

基本的にはRuby Hack Challengeのチュートリアルをベースに進めています。

github.com

また参加者にMacを使っている人が多いので、Mac向けのビルド手順なども別途用意したりしています。

初回はRubyのビルドを行い、全員がminirubyが動くところまで進みました。

また余談としてUniversal Parser を有効化する方法なども紹介しました。

今後

当面はRuby Hack ChallengeのチュートリアルをベースにRubyの内部実装の話をしつつ、独自メソッドの追加などのハックをしていきたいと思います。

個人的な野望としては、「Ruby本体にパッチを送れる人を増やしていきたいな」と思っているのでゆるく長く続けていければと思います。

永和システムマネジメントでは、Rubyのハックを通じてコミュニティと成長したいエンジニアを絶賛募集しています。

agile.esm.co.jp

2024-06-19

LR Parser Night w/ Asakusa.rb をアンドパッドさんと共催します

RubyKaigi 構文解析器研究部

こんにちは。構文解析器研究部員の @junk0612 です。

After RubyKaigi 2024 LR Parser Night w/ Asakusa.rb というイベントを、アンドパッドさんのオフィスで共催します。普段は島根にいる @S.H. 研究部員も現地登壇します！

andpad.connpass.com

大まかな流れとしては、LR_parser_gangs の4人が集まって、1人5分のトークをしたあとに and the World っぽいパネルディスカッションをする予定です。

各メンバーのトーク内容は募集ページに載っている以上の情報を僕も知りませんが、それぞれの立場からの面白い発表が聞けそうです。乞うご期待。

パネルディスカッションについては、いまのところ @hsbt さんに司会役をお願いして、いくつかのトークテーマについて話す予定です。参加者の Rubyist が知りたそうなテーマをなんとなく考えていますのでお楽しみに。もし聞いてみたい話題があれば、僕まで DM などで連絡をいただけると考慮できたりできなかったりするかもしれません。

それでは当日、会場でお会いしましょう！

永和システムマネジメントでは、Ruby とアジャイルソフトウェア開発を通じてコミュニティと成長したいエンジニアを絶賛募集しています。

agile.esm.co.jp