オンプレconfluenceのURLをクラウドconfluenceのURLに変換するスクリプト

on-premisesなconfluenceからcloudに移行するとき、マイグレーションツールによってリンク等がある程度自動で引き継がれます。 が、ソースコードのコメントなどconfluence以外の場所に書かれたコンフルURLについては(もちろん)変換対象外なので旧コンフルURLのままになります。

pageIdあるしドメイン名変えれば大丈夫だろうと最初は思ったのですが、どうもpageIdも変わるし、URLの構造も変わる!という仕様のようです。 幸いなことに「spaceKeyとtitleでユニークになる」という仕様自体は同じようなので、mappingするスクリプトを作りました。

リポジトリにPRまですると大変そうだったので変換スクリプトを生成するスクリプトになっています。(実行すると置換されるので、PRなどは各自おねがいします方式) ガッと作ったのでAPI呼び出しでエラーになったときのエラーメッセージが雑ですが、認証関係がちゃんとしていれば大丈夫なはず。ただしコンフルのバージョンによってAPIが違うかもしれないのでそのへんは要調節です。

後、確実に変換漏れがあるのでコンフルの {pageId, spaceKey, title} をダンプしてどこかに保存しておくと、後からこれなんだっけ?という場合に辿れるようになるのでそちらもあると良いです。(以下のスクリプトを少し変えれば、そのjsonファイルから変換スクリプトを作ることも可能)

#!/bin/bash

set -eu

## require
# - ag
# - gsed
# - jq

### usage
#
# 1. generate convert.sh
# ./confluence.sh $JSESSIONID $CONFLUENCE_EMAIL $CONFLUENCE_API_TOKEN $OLD_CONFLUENCE_HOST $NEW_CONFLUENCE_HOST > convert.sh
#
# 2. execute convert
# ./convert.sh

### env
JSESSIONID="$1" # confluence session via cookie
CONFLUENCE_EMAIL="$2" # for login
CONFLUENCE_API_TOKEN="$3" # https://confluence.atlassian.com/cloud/api-tokens-938839638.html
OLD_CONFLUENCE_HOST="$4" # example.old.confluence.com
NEW_CONFLUENCE_HOST="$5" # example.cloud.confluence.com

grep_page_id() {
  ag --nofilename "$OLD_CONFLUENCE_HOST" | grep pageId | gsed 's/.*pageId=\([[:digit:]]\+\).*/\1/' | sort -n | uniq
}

get_page_space_key_title() {
  local pageId

  while read -r pageId; do
    pageJson=$(curl -sS "https://$OLD_CONFLUENCE_HOST/rest/api/content/$pageId" -H "Cookie: JSESSIONID=$JSESSIONID")
    echo "$pageJson" | jq -c "{spaceKey: .space.key, title: .title, oldPageId: \"$pageId\"}"
  done

}

get_new_confluence_page_id() {
  local pageJson

  while read -r pageJson; do
    local spaceKey=$(echo "$pageJson" | jq -r '.spaceKey')
    local title=$(echo "$pageJson" | jq -r '.title')
    local oldPageId=$(echo "$pageJson" | jq -r '.oldPageId')
    local newPageId=$(curl -sS --header 'Accept: application/json' --user "$CONFLUENCE_EMAIL:$CONFLUENCE_API_TOKEN" -G "https://$NEW_CONFLUENCE_HOST/wiki/rest/api/content/search" --data-urlencode "cql=(type=page and space=$spaceKey) AND (title=\"$title\")" | jq -r '.results|map(.id)[]')
    echo "$pageJson" | jq -c \
      --arg newPageId "$newPageId" \
      '.+ {newPageId: $newPageId}'
  done
}

convert_new_page_id_to_new_url() {
  local pageJson

  while read -r pageJson; do
    local spaceKey=$(echo "$pageJson" | jq -r '.spaceKey')
    local title=$(echo "$pageJson" | jq -r '.title')
    local oldPageId=$(echo "$pageJson" | jq -r '.oldPageId')
    local newPageId=$(echo "$pageJson" | jq -r '.newPageId')
    echo "$pageJson" | jq -c \
      --arg newUrl "https://$NEW_CONFLUENCE_HOST/wiki/spaces/$spaceKey/pages/$newPageId" \
      --arg oldUrl "https://$OLD_CONFLUENCE_HOST/pages/viewpage.action?pageId=$oldPageId" \
      '.+ {newUrl: $newUrl, oldUrl: $oldUrl}'
  done
}

sed_old_to_new() {
  local pageJson

  while read -r pageJson; do
    local oldUrl=$(echo "$pageJson" | jq -r '.oldUrl')
    local newUrl=$(echo "$pageJson" | jq -r '.newUrl')
    local spaceKey=$(echo "$pageJson" | jq -r '.spaceKey')
    local newPageId=$(echo "$pageJson" | jq -r '.newPageId')
    if [ "$newPageId" != "null" ] && [ "$newPageId" != "" ] && [ "$spaceKey" != "null" ] && [ "$spaceKey" != "" ]; then
      echo "ag --files-with-matches -Q \"$oldUrl\" | xargs -I {} sed -i '' \"s@$oldUrl@$newUrl@g\" {}"
    fi
  done
}

check_remaining() {
  echo 'echo "remaining after sed"'
  echo "ag --ignore convert.sh $OLD_CONFLUENCE_HOST/"
}

grep_page_id | get_page_space_key_title | get_new_confluence_page_id | convert_new_page_id_to_new_url | sed_old_to_new
check_remaining

参考

ペアプロとフロー効率

世の中に大量にペアプロ記事があるのに新たに追加してしまうシリーズ。

自分の考えのまとめ置き場が欲しかったんだ(´;ω;`)

背景

ペアプロのメリットについて、詳しい人からの知識移転ができる。先輩から後輩へのスキル移転ができてチームが成長するといったメリットが挙がることが多いと思います。

これはこれで分かるし必要だと思うんですが、一方で二人で一つの作業をやったら効率は半分になるのでは?といったもやもやがあるときに上記のような長期的なメリット*1を挙げられると頭ではわかるけど腹は膨れないなというか、実践につなげるのが難しいことってないでしょうか?

特にペアプロは一人では完結しないので草の根的に行うのには大きな熱量を必要とします。 「長期的なメリットがあるからやろうぜ」といって人を巻き込んで、それを布教して、長期的なメリットが得られるまでやり続けられるって結構大変じゃないかなと思ってます。

この記事では、長期的なメリットについては脇に置いて、ペアプロをやることで短期的にもこんなメリットがありそうだ!といった近視眼的視野でペアプロについて考えます。 そのためガチ勢からすると重要なところが語られてない!と思うかもしれません。その辺はちゃんとした記事がたくさんあると思うので許して。 あといくつか仮定があるので、うちはこうじゃないとかうちには当てはまらないとかもあると思います。人によって答えは違って良いだろうということでこれも許して。

なお話の前提になるフロー効率については フロー効率性とリソース効率性について で学べます。

行ったり来たりのレビュー HELL

さて、機能開発においてはどのような言語でもそこそこの量のコードを書くことになると思います。 典型的な着手方法としてAさんは機能1を作ってBさんは機能2を作るといった形での作業分担方式がありそうです。

作るところまではいいんですが、レビューがなかなか大変ですよね。 正直、ドメインのコードが300行どーん!みたいなPRがきても一発でマージできることはなかなかないでしょう。

これは得てしてスキルの問題ではなく将来どんな追加が予想されるのか?といった未来に関する想定の違いや、こういう概念もあるんじゃない?といった捉え方の違いだったりします。 ドメインの捉え方、パッケージやクラスをどう切るか、一人だと考え方の癖がどうしても出るしレビュアーと合意に至るためには多少なり議論が必要になることが多いでしょう。

こういった議論が必要なケースで非同期のレビューを続けてレビューコメント数が100近くになったり、レビュアーが別業務で忙しかったりすると3時間に一回レビューコメントを返信し続けて早一週間みたいな状況になり得ます。

さらにレビュー対応によりドメインの構造が大きく変わったので先に開発しておいた5つのPRを順番にリベースしてまわるみたいな地獄に続くこともあるでしょう。

反対に、(なんかここまで書いてもらってるしAPI実装自体はできてるからそこまでモデリングこだわらなくてもよいか・・?自分の考えも一長一短あるからこれの方が良いのかも・・)みたいな気持ちになってLGTM!!!みたいなことも人生に一度くらいは覚えがあるのではないでしょうか。 こんなことになったら、もうレビューは単なる作業チェックです。*2

こうして長い長いレビュー時間が必要になったり妥協したソフトウェアが完成するわけです。 後者については防ぐべき事柄だと思います。前者についてはどうでしょうか?

フロー効率と手戻りの最小化

レビュー待ち時間が長くても、レビュアー・レビュイーは待っている間に何かの仕事を行ってはいるのでリソース効率については問題ないと言えます。 ですが、「一つの機能がマージされるまでが長い」「リベースといった本来不必要な作業が発生する」といった点はまさにフロー効率が悪い場合の特徴と言えます。

フロー効率を改善しようというのはペアプロを始める一つの動機になるでしょう。 具体的なメリットとして、ドメインのコードを書く段階で合意が取れたコードを作成できます。 また書いてしまったし今更言うのもな・・といった遠慮の問題も大きく軽減できます。

書いたコードが即レビューされる小さいフィードバックサイクルを持つ開発プロセスでは、レビューによって後から大量の修正が必要となるような手戻りのコストを削減できます。

また、ペアプロでは非常に細かい単位でこれはどうしてこうするのか説明を求められます。 口頭での説明を通して、二人が本当に対象を深く理解しているのか?を細かく確認し合う中で、惰性で書いたコードとそうでないコードを区別できるようになります。

そこで説明できないコードはおそらく対象となる問題への理解が不足しているでしょう。 そしてそれは、何かを説明しているようで結局聞かないとわからないあいまいなコメントや、何となくここに入れておけば怒られないゴミためパッケージの誕生につながります。

説明と議論を通してコードやモデリングの穴を探すのは非常に有効な手段です。(それこそが単なる作業チェックではないレビューのあるべき姿のはず。) ペアプロではこうした妥協による品質の低下も削減できますし、むしろ通常のレビューよりも濃いレビューを促進できます。*3

ペアプロではたしかに二人でコードを書くことになりますが、レビューのやりとりとリベース地獄によって消費される時間を思えばそこまでスループットは低下しません。むしろ普段集中するために費やしてる時間もコード書けるので向上を感じられることもあるんじゃないかなと思います。 レビューが長くなりそうだなと感じたときにペアプロを始めると成功してる実感を得やすいはずです。(ペアレビューから始めるのもおすすめです)

さらに、細かいフィードバックサイクル(レビュー・説明)によって作業分担方式では検出できなかった潜在的な問題を早期に検出できるような効果も期待できます。 細かい品質の積み重ねが後に大きな違いになるのは想像に難くありませんし、議論によってリファクタを繰り返すスタイルは細かい成功してる実感も感じやすいんじゃないかなと思います。

あと単純に楽しいです。集中できない日もペアでとりあえず始めると意外と集中できます。

ペアプロしたい時

ぶっちゃけ手戻りとか難しいこと考えずに、これレビューコメントが多くなりそう!みたいな予感がしたらペアプロするというのが一番簡単な判断基準です。

ただしペアプロは魔法の薬ではないので、いつ何時もうまく行くわけではありません。 会話のスピードで色々決まってしまうので一人で考えたほうが細部まで詰められるということもあるし、モデリングの自由度が高すぎる状態で0から初めると議論が発散する可能性もあります。便利な仕組みを1から作るときや0からモデルの土台を作るところまでは一人でやったりして、適宜切り替えられると便利です。

まとめ

昨今ではペアプロやってるところも特に珍しくなくなってきてモブプロが推進されているチームも多くなってきているので(要出典)、いまさらペアプロの良さを書くのはやや時代遅れな感じもしますが、一方でどういう効果があるんだっけ?というのは常に捉えておかないと、「いいよねペアプロ教」みたいになって(理由の説明が十分じゃないのに)誰かに押し付けてしまったり、逆に「ペアプロはいつも有効なわけじゃない」となって十分に議論されずに不要とされてしまうことはまだまだあるのではないかなと思います。

楽しくできてれば良いかなと言う気持ちもありますが、トレードオフ関係を明らかにした上で良い方法を選択したいので考えをまとめました。(でも全体的にふわっとしてるし、書いてから読み直しただけでちょっと恥ずかしくなる・・・)

ということで、フロー効率が下がってきたな(PRのマージがなかなか終わらないな、議論ちゃんとできてないな)なんてときにペアプロすると短期的な効果が実感しやすくて、長期的な目的を根気強く目指さなくても気軽にペアプロやりやすいんじゃないかなという話でした。

ref

*1:ここでの長期は割と感覚的なものなので人によって違うはず。自分の中では”いつかメリットを感じられるその時まで”やり続ける必要があるといったイメージ

*2:ここまでで、こんなこと一度もない。と思った人は成熟したチームの一員として一つの目標として働けていると思うのでめっちゃ羨ましい限り。

*3:ここはオンラインのレビューでも元からできてるよ!っていうチームもあるかもしれません。

見積もりについて勉強したことを色々スライドにしてみた

見積もりについて思ってることとかをまとめてみました。

マネージメントの実戦経験というよりソフトウェア開発手法について学んだ結果のアウトプットみたいなノリでみていただければ幸いです。

社内勉強会で話したので会社のスライド使ってますが、会社が今こうというわけではなく一般的な話にとどめています。(あとstudy_lean_agileっていう名前の勉強会なんですが、このスライドはリーンもアジャイルもあまり意識していません)

前半は自分なりの考え方、後半は具体的にはこうしたらいいんじゃないかと思っていることという風に分けています。

www.slideshare.net

www.slideshare.net

descriptionにもちょっと書いてあるんですが、「見積もりと計画は違う」みたいな話とか「じゃあ見積もりについてはこれでいいとして計画はどうすればいいの?」みたいな話とかいろいよ残っているので続きを書く予定です。

こういう価値観をどう広めるのか?も難しい問題だと思うのでその辺も入れないと、なんかもにゃっとするかなとは思うので、また何か考えたらそこについても書いていきたいなと思います。

あと割とベーシックな話で終わってしまってるので、もうちょい突っ込んだ話もどこかでまとめたい(とはいってもそんなに深掘りできてはいないんですが)

本については色々載せたけど個人的には以下の二冊が好きです。

他の名著情報があったらぜひ教えてください。

magnoliaで素振り

magnoliaは型クラスのインスタンス自動導出のためのscalaライブラリです。 GitHub - propensive/magnolia: A better generic macro for Scala

既にscalaz-magnoliascalacheck-magnolia などがリリースされています。

公式チュートリアルもしっかりとあり、それに加えて特に何かというわけではないんですが最近本ばっかり読んでてあんまり色々いじれてないので個人の素振り備忘録です。 (つまりこの記事よりも Magnolia: Home を見たほうが良いです)

magnolia特長

型クラスの自動導出自体はshapelessでもできますが、Genに移した後HListとCoproduct用のインスタンスを定義して〜とやると意外とコード量が増えたりコンパイルエラーが起きてデバッグする時間が多くなったりします。

magnoliaを使うと以下のようなメリットが得られます。

  • 短く書ける
  • 導出に失敗した際のデバッグメッセージが詳しく出る
  • shapelessに比べて4~15倍速いcompile時間

ただフリーランチというわけではなく以下のような弱点もあります。

  • まだexperimentalなので色々変わるかもしれない
  • 一部型チェック諦めてるのでClassCastExceptionが実行時に出る可能性がある
  • 現時点ではhigher-kindな型クラス(Functor)の導出はできない

やってみた

チュートリアルとほぼ内容同じなので解説はそっち読んで貰えればと思います。 チュートリアルの延長線上でStringじゃなくて型名とパラメータ名を構造化してほしいなって思ったのでMapDumpみたいな物を作ってみました。 https://github.com/matsu-chara/magnolia-example

package example.domain

case class UserId(value: Long) extends AnyVal
case class UserName(value: String)

sealed trait UserType
object UserType {
  case object Normal extends UserType
  case object Premium extends UserType
}

case class User(
  id: UserId,
  name: UserName,
  tpe: UserType
)
package example

import example.domain.{User, UserId, UserName, UserType}
import example.dump.MapDump

object Main extends App {
  val u1 = User(UserId(1L), UserName("sato"), UserType.Normal)

//  if derivation failed, then output
//  Main.scala:11:22: magnolia: could not find MapDump.Typeclass for type Long
//       in parameter 'value' of product type example.domain.UserId
//       in parameter 'id' of product type example.domain.User
  println(MapDump.gen[User].dumpAsMap(u1))

//  same as above. but no debug output
//  (User,Map(id -> (UserId,UserId(1)), name -> (UserName,Map(value -> (string,sato))), tpe -> (Normal,Normal)))
  println(implicitly[MapDump[User]].dumpAsMap(u1))
}
package example.dump

import magnolia._

import scala.language.experimental.macros

trait MapDump[A] {
  /** return
    * (className, Map(param1 -> value1, param2 -> value2))
    * or
    * (className, value1)
    * when value class or object
    */
  def dumpAsMap(value: A): (String, Any)
}

object MapDump extends GenericMapDump {
  def apply[A](f: A => (String, Any)): MapDump[A] = new MapDump[A] {
    override def dumpAsMap(value: A): (String, Any) = f(value)
  }

  implicit val stringDump: MapDump[String] = MapDump[String] { value =>
    ("string", value)
  }

  implicit val longDump: MapDump[Long] = MapDump[Long] { value =>
    ("long", value)
  }
}

trait GenericMapDump {
  type Typeclass[T] = MapDump[T]

  def combine[T](ctx: CaseClass[Typeclass, T]): Typeclass[T] = new Typeclass[T] {
    override def dumpAsMap(value: T): (String, Any) = {
      val valueOrMap = if (ctx.isValueClass || ctx.isObject) {
        value
      } else {
        ctx.parameters.map { p =>
          p.label -> p.typeclass.dumpAsMap(p.dereference(value))
        }.toMap
      }
      (ctx.typeName.short, valueOrMap)
    }
  }

  def dispatch[T](ctx: SealedTrait[Typeclass, T]): Typeclass[T] = new Typeclass[T] {
    override def dumpAsMap(value: T): (String, Any) = ctx.dispatch(value) { sub =>
      sub.typeclass.dumpAsMap(sub.cast(value))
    }
  }

  implicit def gen[T]: Typeclass[T] = macro Magnolia.gen[T]
}

この型クラス何の役に立つんだろう・・・?というツッコミとか色々有る気がするけどとりあえず動いてるのでセーフ。

せっかくなのでdecodeも作ってみました

package example

import example.domain.{User, UserId, UserName, UserType}
import example.dump.{MapDump, FromDumpedMap}

object Main extends App {
  val u1 = User(UserId(1L), UserName("sato"), UserType.Normal)

  // User(UserId(1),UserName(sato),Normal)
  val dumped = MapDump.gen[User].dumpAsMap(u1)
  println(FromDumpedMap.gen[User].constructFrom(dumped))
}
package example.dump

import magnolia._

import scala.language.experimental.macros
import scala.util.control.NonFatal

trait FromDumpedMap[A] {
  def constructFrom(value: (String, Any)): A
}

object FromDumpedMap extends GenericFromDumpedMap {
  def apply[A](f: (String, Any) => A): FromDumpedMap[A] =
    new FromDumpedMap[A] {
      override def constructFrom(value: (String, Any)): A = f(value._1, value._2)
    }

  implicit val stringDump: FromDumpedMap[String] = FromDumpedMap[String] {
    case (clazz, param: String) if clazz == "string" =>
      param
    case arg =>
      throw new IllegalArgumentException(s"failed to decode. $arg")
  }

  implicit val longDump: FromDumpedMap[Long] = FromDumpedMap[Long] {
    case (clazz, param: Long) if clazz == "long" =>
      param
    case arg =>
      throw new IllegalArgumentException(s"failed to decode. $arg")
  }
}

trait GenericFromDumpedMap {
  type Typeclass[T] = FromDumpedMap[T]

  def combine[T](ctx: CaseClass[Typeclass, T]): Typeclass[T] = new Typeclass[T] {
    override def constructFrom(value: (String, Any)): T = {
      if (ctx.isValueClass || ctx.isObject) {
        try {
          value._2.asInstanceOf[T]
        } catch {
          case NonFatal(e) => throw new IllegalArgumentException(s"failed to decode. $ctx $value", e)
        }
      } else {
        ctx.construct { p =>
          val paramMap = try {
            value._2.asInstanceOf[Map[String, (String, Any)]]
          } catch {
            case NonFatal(e) => throw new IllegalArgumentException(s"failed to decode. $ctx $value", e)
          }

          val param = if (paramMap.contains(p.label)) {
            paramMap(p.label)
          } else {
            throw new IllegalArgumentException(s"failed to decode. $ctx $p $value")
          }
          p.typeclass.constructFrom(param)
        }
      }
    }
  }

  def dispatch[T](ctx: SealedTrait[Typeclass, T]): Typeclass[T] = new Typeclass[T] {
    override def constructFrom(value: (String, Any)): T = {
      val (subtype, subTypeValue) = ctx.subtypes.find(_.typeName.short == value._1) match {
        case Some(sub) =>
          try {
            (sub, value._2.asInstanceOf[sub.SType])
          } catch {
            case NonFatal(e) => throw new IllegalArgumentException(s"failed to decode. $ctx $value", e)
          }
        case _ => throw new IllegalArgumentException(s"failed to decode. $ctx $value")
      }
      subtype.typeclass.constructFrom((value._1, subTypeValue))
    }
  }

  implicit def gen[T]: Typeclass[T] = macro Magnolia.gen[T]
}

この形式をデシリアライズしたい人間は居るのか?というところは置いといて出来てそうです。 (そしてちゃんとやるならStringじゃなくてTypeNameとかParamNameにしたほうが良い)

consturctメソッドや中で呼んでるrawConstructメソッド的にdecode失敗したらEitherで返すみたいなことはできないっぽいので、そういうことがやりたい場合はまだ難しそうですね。

ある程度パターン化できてるので、さっくりderivingしたいだけの時はかなり便利そうです。(decodeとか書くとdecode自体が面倒なのでさくっとという範疇ではない気がしますがそれはdecode自体の問題)

HackerTackle2018でPonyの発表をしてきました

HACKER TACKLE というイベントでPonyについて発表してきました。

タイトルの主張がやや強めになってしまった感がありますが、僕としてはPony自体というよりPonyがチャレンジしていること、それによって到来する未来に注目してもらえたらなーみたいな素朴な気持ちでつけました。

そんな感じの内容だったのでPony入門と見せかけてPonyのコードは少ししか出てきませんでした。 (でもスライド発表で文法の話しても文字が小さくて見えなかったりするしまあいいかみたいな気持ち・・(( ◜◡‾))

既に発表したことのある内容と被りすぎず、でもそらし過ぎて上級者向きにならないように・・など色々考えました。が!入門的な内容を改定を重ねつつ発表するのはやっぱり難しいですね。 (マイナー言語エバンジェリストあるある(?))

次のセッションがRustコミッターの発表でタイトルが「Concurrency in Rust」という状況でConcurrencyに長所があるPonyの話をするのはなかなか緊張感のある形でしたが、 自分としてはConcurrencyの問題は型で(部分的には)解決できる!というのが世の中に伝わるのが一番(ある意味Ponyの繁栄よりも)重要だと思っているので、むしろ良かったのかなと思います。

現段階でのPonyは結構独自感がありますが、mutable/immutableやモナドのような概念が様々な言語に取り入れられて来ているのと同じ流れでPonyの取り組みの成果みたいなものもどんどん他の言語に取り入れられる流れができると良いなーと思っています。今かどうかは分かりませんがそのうちきっと出来るはず!
そういった流れをいち早くキャッチアップするために、新しい取り組みを行っている尖った言語に触ってみるというのも一興なのではないでしょうか。つまり今すぐponycをインストールしてIntroduction · Pony Tutorialをやりましょう!!

www.slideshare.net