rabbit-slide-Piro-readable-code-workshop-2022-08-04-performance 2022.08.04

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d9a00a9415e33fd59505e098d1ab42b91c5ac23db295c039a9c76fa0fc1b0ad
+  data.tar.gz: 1342bd0c700bdbfbeb10929092cd8349e78e52404adb701aba8004b77f66cded
+SHA512:
+  metadata.gz: 03fb94c05950f1aea0002b3b830ab3f5effd19bbceb848927b19119c2295fc19eb84f03780fcdc83e4fcb9605fed46f466330a54fade4ff9fa1c3a2b16c0753d
+  data.tar.gz: 56aef32470adc0118b66274e2f332c881f404b3d88c5c9538abc9c25791c175b9ba9107a73b57941ce62bc7b5892d562504e8f64037388fe28d038a3e954b101

data/.rabbit

@@ -0,0 +1 @@
+performance.rab

data/README.rd

@@ -0,0 +1,32 @@
+= プログラムの計算量と実行性能について
+
+2022-08-04開催のリーダブルコード演習の予習としての、プログラムの実行性能の話。
+
+== ライセンス
+
+CC BY-SA 4.0
+
+原著作者名は以下の通りです。
+
+  * 株式会社クリアコード
+
+== 作者向け
+
+=== 表示
+
+  rake
+
+=== 公開
+
+  rake publish
+
+== 閲覧者向け
+
+=== インストール
+
+  gem install rabbit-slide-piroor-readable-code-workshop-2022-08-04-performance
+
+=== 表示
+
+  rabbit rabbit-slide-piroor-readable-code-workshop-2022-08-04-performance.gem
+

data/Rakefile

@@ -0,0 +1,17 @@
+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

data/config.yaml

@@ -0,0 +1,22 @@
+---
+id: readable-code-workshop-2022-08-04-performance
+base_name: summary
+tags:
+- rabbit
+- readable-code
+presentation_date: 2022-08-04
+version: 2022.08.04
+licenses:
+- CC BY-SA 4.0
+slideshare_id: readable-code-workshop-2022-08-04-performance
+speaker_deck_id: 
+ustream_id: 
+vimeo_id: 
+youtube_id: 
+author:
+  markup_language: :rd
+  name: YUKI Hiroshi
+  email: yuki@clear-code.com
+  rubygems_user: Piro
+  slideshare_user: pirooutsiderreflex
+  speaker_deck_user: piroor

data/performance.rab

@@ -0,0 +1,692 @@
+= プログラムの計算量と実行性能について
+
+: author
+   結城洋志
+: institution
+   株式会社クリアコード
+: content-source
+   リーダブルコード演習
+: date
+   2022-08-04
+: allotted-time
+   90m
+: theme
+   clear-code
+
+== ノート
+
+TODO：次回やるのであれば、サンプルコードはPythonで書くようにする。
+（学生さんはPythonはカリキュラムの中で学ばれているため、JSより浸透している）
+
+= 講師紹介
+
+(('tag:center'))(('tag:margin-bottom * 2'))
+結城洋志（ゆうき ひろし）\n
+aka Piro
+
+  * 株式会社クリアコード所属
+  * FirefoxやThunderbirdの\n
+    法人サポートに従事
+    * トラブルの原因や対策を探るため\n
+      ソースコードを調査することが多い
+
+== ノート
+
+Mozilla FirefoxはWebブラウザー。
+Mozilla Thunderbirdはメールクライアント。
+
+開発元のMozillaは、企業ユーザーからのトラブル問い合わせなどに回答するサービスは提供していない。
+そのため、クリアコードのような事業者が、ある意味で勝手にサポートサービスを行っている。
+
+Firefoxで特定のサービスの動作が遅い、といった問い合わせを受ける
+
+
+= アジェンダ
+
+  * プログラムの実行性能に\n
+    影響する要素について
+  * 計算量について
+  * 実際に確かめてみる
+
+
+= プログラムは「軽い」「速い」方がいい
+
+= 「軽い」「速い」とは？
+
+* ((*目的が素早く達成される*))\n
+  例：データ変換プログラム
+  * 同じ時間で多くの件数のデータを\n
+    変換できる
+  * データを1件変換する所要時間が短い
+
+= 性能の指標と測定方法
+
+* 他の方の講義で詳しく\n
+  扱われるそうなので\n
+  割愛
+
+= 性能に影響する要素
+
+* 外部要因
+  * 通信待ち
+  * ディスクアクセス待ち\n
+    (('note:など'))
+* 内部要因
+  * ((*計算量*))
+
+= 計算量
+
+実行される処理の\n
+((*回数の大小*))
+
+= 例
+
+「データを10件取得する」
+
+= 1件ずつ取得する
+
+    SELECT * FROM table OFFSET 0 LIMIT 1;
+    SELECT * FROM table OFFSET 1 LIMIT 1;
+    ...                         
+    SELECT * FROM table OFFSET 8 LIMIT 1;
+    SELECT * FROM table OFFSET 9 LIMIT 1;
+
+→処理の実行回数は((*10回*))
+
+== ノート
+
+これは「計算量が10」と言える。
+
+= 10件まとめて取得する
+
+    SELECT * FROM table OFFSET 0 LIMIT 10;
+
+→処理の実行回数は((*1回*))
+
+== ノート
+
+これは「計算量が1」と言える。
+
+= 計算量は少ない方がいい！
+
+
+= アルゴリズム(1/3)
+
+* 計算量は((*計算方法*))で決まる
+* 計算(処理)方法＝((*アルゴリズム*))
+  * ((*より少ない計算量*))で同じ結果を\n
+    得られる\n
+    ＝より優秀なアルゴリズム
+
+= アルゴリズム(2/3)
+
+* データ件数が増えれば\n
+  計算量も増える(('note:（ことが多い）'))
+  * データの件数の増加度合いに対して\n
+    ((*計算量の増加度合いが小さい*))\n
+    ＝より優秀なアルゴリズム
+
+= こういうのよりは
+
+  # image
+  # src = images/graph-ONfactorial.png
+  # relative_width = 90
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+= こういうのの方が嬉しい
+
+  # image
+  # src = images/graph-ON2.png
+  # relative_width = 90
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+= こうだとなお嬉しい
+
+  # image
+  # src = images/graph-O1.png
+  # relative_width = 90
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+= アルゴリズム(3/3)
+
+* 計算量は、((*実行しなくても*))\n
+  アルゴリズムから見積もれる
+
+== ノート
+
+これはとても大事な性質。
+遅いアルゴリズムは、コードを見ただけで「これは遅い」と分かる。
+1時間で終わると思ったら、実際動かしてみたら1日かかりました、といったことを避けられる。
+
+= どうやって見積もる？
+
+= 計算量の見積もり方・表し方
+
+* Ο記法（オーダー）
+  * O(1)
+  * O(N)
+  * O(N^2)
+  * O(N!)
+  * O(logN)
+
+= O(1)：定数時間
+
+    // 色の名前とカラーコードのデータ（ハッシュ構造）
+    const COLOR_CODE_BY_NAME = {
+      blue:   0x0000FF,
+      green:  0x00FF00,
+      red:    0xFF0000,
+      yellow: 0xFFFF00,
+    };
+    // 色の名前でカラーコードを特定する
+    let color = COLOR_CODE_BY_NAME['red'];
+    console.log(color); // => 0xFF0000
+
+== ノート
+
+データ件数にかかわらず一定の速度で結果が出る。
+最速のアルゴリズム。
+
+= O(1)：定数時間
+
+  # image
+  # src = images/graph-O1.png
+  # relative_width = 90
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+= O(N)：線形関数
+
+    // 色の名前とカラーコードのデータ（配列構造）
+    const COLOR_CODES = [
+      { name: 'blue',   code: 0x0000FF },
+      { name: 'green',  code: 0x00FF00 },
+      { name: 'red',    code: 0xFF0000 },
+      { name: 'yellow', code: 0xFFFF00 },
+    ];
+    // 色の名前でカラーコードを特定する
+    let color;
+    for (const item of COLOR_CODES) {
+      if (item.name == 'red') {
+        color = item.code;
+        break;
+      }
+    }
+    console.log(color); // => 0xFF0000
+
+== ノート
+
+計算量がデータ件数に正比例する。
+（最悪の場合は全データを1回ずつ処理するため。）
+
+= O(N)：線形関数
+
+  # image
+  # src = images/graph-ON.png
+  # relative_width = 90
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+= ループを使ってなくても安心できない
+
+    [a,b,c,d,e].indexOf(c) // => 2
+    
+    [a,b,c,d,e].includes(c) // => true
+
+= メソッドの中身が線形関数な場合がある(1/2)
+
+    function indexOf() {
+      const items = [a,b,c,d,e];
+      for (let i = 0; i < items.length; i++) {
+        if (item == c) {
+          return i; // => 2
+        }
+      }
+      return -1;
+    }
+
+= メソッドの中身が線形関数な場合がある(2/2)
+
+    function includes() {
+      const items = [a,b,c,d,e];
+      for (let i = 0; i < items.length; i++) {
+        if (item == c) {
+          return true; // => 2
+        }
+      }
+      return false;
+    }
+
+
+= O(N^2)：二乗時間
+
+    // 重複を含む配列
+    const duplicated = [
+      0,1,2,3,2,1,4,3,4,5,6,7,5,6,4,8,9,5,3,2
+    ];
+    // 重複を取り除いた配列
+    const unique = [];
+    for (const duplicatedItem of duplicated) {
+      let included = false;
+      for (const uniqueItem of unique) {
+        if (uniqueItem == duplicatedItem) {
+          included = true;
+          break;
+        }
+      }
+      if (!included)
+        unique.push(duplicatedItem);
+    }
+    console.log(unique); // => [0,1,2,3,4,5,6,7,8,9]
+
+== ノート
+
+データ件数の増加に対し、計算量の増加がいわゆる指数関数的な増加を見せる。
+パスワードの総当たりの場合、O(n^文字数)となる。
+
+= O(N^2)：二乗時間
+
+  # image
+  # src = images/graph-ON2.png
+  # relative_width = 90
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+= ループを使ってなくても安心できない
+
+* メソッドの中身が（以下略）
+
+= O(logN)：対数
+
+    // 検索対象の配列（ソート済み）
+    const values = [0, 3, 6, 9, 12, 70, 102];
+    // 特定の値が何番目にあるかを二分探索で調べる
+    const target = 12;
+    let index = -1;
+    let minIndex = 0;
+    let maxIndex = values.length - 1;
+    while (minIndex <= maxIndex) {
+      let middleIndex = Math.floor((minIndex + maxIndex) / 2);
+      if (values[middleIndex] == target) {
+          index = middleIndex;
+          break;
+      }
+      else if (values[middleIndex] < target)
+        minIndex = middleIndex + 1;
+      else
+        maxIndex = middleIndex - 1;
+    }
+    console.log(index); // => 4
+
+== ノート
+
+コードは https://tech-blog.s-yoshiki.com/entry/195 の物を加工して掲載した。
+データ件数の増加割合に対して計算量の増加割合が少ない。
+データ件数の増加に対して、計算量の増加が緩やか。
+
+= O(logN)：対数
+
+  # image
+  # src = images/graph-OlogN.png
+  # relative_width = 90
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+
+= O(N!)：階乗関数(1/3)
+
+巡回セールスマン問題
+
+    // ある都市から他の都市までの移動に要する時間のデータ
+    const cities = {
+      tokyo:    { osaka: 2, hokkaido: 3, okinawa: 4,  kagawa: 5   },
+      osaka:    { tokyo: 2, hokkaido: 5, okinawa: 3,  kagawa: 1   },
+      hokkaido: { tokyo: 3, osaka: 5,    okinawa: 7,  kagawa: 6   },
+      okinawa:  { tokyo: 4, osaka: 3,    hokkaido: 7, kagawa: 8   },
+      kagawa:   { tokyo: 5, osaka: 1,    okinawa: 8,  hokkaido: 6 },
+    };
+
+== ノート
+
+各都市と、各都市間の移動に要する時間。
+ここから、移動時間が最短になる巡回ルートを求めたい。
+こういう計算を「巡回セールスマン問題」と呼ぶ。
+
+= O(N!)：階乗関数(2/3)
+
+    // 配列から順列組み合わせを作る処理
+    function getPermutations(array) {
+      const permutations = [];
+      const nextPermutation = [];
+      function permutate(array) {
+        if (array.length === 0)
+          permutations.push(nextPermutation.slice());
+        for (let i = 0; i < array.length; i++) {
+          array.push(array.shift());
+          nextPermutation.push(array[0]);
+          permutate(array.slice(1));
+          nextPermutation.pop();
+        }
+      }
+      permutate(array);
+      return permutations;
+    }
+
+== ノート
+
+組み合わせを列挙する関数。
+Original version is: get-permutations npm module made by Jan Järfalk
+Licensed: ISC
+https://github.com/janjarfalk/get-permutations
+
+= O(N!)：階乗関数(3/3)
+
+    // 総当たりで移動時間を求めて、最短の移動パターンを見つける
+    const results = [];
+    for (const start of Object.keys(cities)) {
+      const patterns = getPermutations(
+        Object.keys(cities).filter(dest => dest != start)
+      );
+      for (const pattern of patterns) {
+        let last;
+        let total = 0;
+        const route = [start, ...pattern, start];
+        for (const current of route) {
+          if (last)
+            total += cities[last][current];
+          last = current;
+        }
+        results.push({ route: route.join('-'), total });
+      }
+    }
+    console.log(results.length);
+    // => 120
+    results.sort((a, b) => a.total - b.total);
+    console.log(results[0]);
+    // => { route: "tokyo-hokkaido-kagawa-osaka-okinawa-tokyo", total: 17 }
+
+== ノート
+
+愚直にやると、データ件数の階乗回の計算が必要になる。
+ここでは、件数5で120回ループが回る。
+
+= O(N!)：階乗関数
+
+  # image
+  # src = images/graph-ONfactorial.png
+  # relative_width = 90
+
+7件で5040回、8件で40320回
+
+== プロパティー
+
+: enable-title-on-image
+   false
+
+== ノート
+
+データ件数	計算量
+1	1
+2	2
+3	6
+4	24
+5	120
+6	720
+7	5,040
+8	40,320
+
+= 　
+
+= 計算量を減らしたい！
+
+== ノート
+
+同じ結果を得られるなら、計算量は小さいに越したことはない。
+
+
+= 計算量
+
+* どういう結果を
+* どういうデータから
+* どのように求めるか
+
+によって、計算量は大きく変わる
+
+= どうすれば計算量を減らせる？
+
+= 計算量を減らすには(1/3)
+
+* 計算方法を変える\n
+  ＝((*アルゴリズムを工夫する*))
+
+= 元のアルゴリズム：O(N^2)
+
+    // 重複を含む配列
+    const duplicated = [
+      0,1,2,3,2,1,4,3,4,5,6,7,5,6,4,8,9,5,3,2
+    ];
+    // 重複を取り除いた配列
+    const unique = [];
+    for (const duplicatedItem of duplicated) {
+      let included = false;
+      for (const uniqueItem of unique) {
+        if (uniqueItem == duplicatedItem) {
+          included = true;
+          break;
+        }
+      }
+      if (!included)
+        unique.push(duplicatedItem);
+    }
+    console.log(unique); // => [0,1,2,3,4,5,6,7,8,9]
+
+
+= アルゴリズムを変えた：O(N)
+
+    // 重複を含む配列
+    const duplicated = [
+      0,1,2,3,2,1,4,3,4,5,6,7,5,6,4,8,9,5,3,2
+    ];
+    // 既に見つかった項目の情報
+    const found = {};
+    // 重複を取り除いた配列
+    const unique = [];
+    for (const item of duplicated) {
+      if (found[item])
+        continue;
+      found[item] = true;
+      unique.push(item);
+    }
+    console.log(unique); // => [0,1,2,3,4,5,6,7,8,9]
+
+= ループの実行回数を減らす！
+
+* ループせず済ませるように\n
+  する(('note:（O(1)に寄せる）'))
+* 直近の実行結果を使い回す\n
+  （キャッシュ）
+
+= アルゴリズムは色々ある
+
+= 例：並べ替え（ソート）
+
+* クイックソート：O(NlogN)～O(N^2)
+  * 結果は不安定
+* バブルソート：O(N^2)
+  * 結果は安定
+* マージソート：O(NlogN)
+  * 結果は安定
+
+= それぞれアルゴリズムには得手・不得手がある
+
+例：
+
+* ある程度揃ったデータだと速い
+* データ件数が少ないと速い\n
+  (('note:など'))
+
+先達の知見を活かそう
+
+= 　
+
+= 計算量を減らすには(2/3)
+
+* データの構造の方を変える\n
+  ＝((*前加工する*))
+
+= データ構造による制約：O(N)
+
+    // 色の名前とカラーコードのデータ（配列構造）
+    const COLOR_CODES = [
+      { name: 'blue',   code: 0x0000FF },
+      { name: 'green',  code: 0x00FF00 },
+      { name: 'red',    code: 0xFF0000 },
+      { name: 'yellow', code: 0xFFFF00 },
+    ];
+    // 色の名前でカラーコードを特定する
+    let color;
+    for (const item of COLOR_CODES) {
+      if (item.name == 'red') {
+        color = item.code;
+        break;
+      }
+    }
+    console.log(color); // => 0xFF0000
+
+== ノート
+
+配列構造でデータが与えられている場合、どう頑張ってもこれ以上は計算量を減らせない。
+
+= データ構造による制約：O(1)
+
+    // 色の名前とカラーコードのデータ（ハッシュ構造）
+    const COLOR_CODE_BY_NAME = {
+      blue:   0x0000FF,
+      green:  0x00FF00,
+      red:    0xFF0000,
+      yellow: 0xFFFF00,
+    };
+    // 色の名前でカラーコードを特定する
+    let color = COLOR_CODE_BY_NAME['red'];
+    console.log(color); // => 0xFF0000
+
+== ノート
+
+同じ意味のデータでも、構造がハッシュテーブルになっていれば、O(1)でいける。
+
+= データ構造を変える(1/2)
+
+    // 色の名前とカラーコードのデータ（配列構造）
+    const COLOR_CODES = [
+      { name: 'blue',   code: 0x0000FF },
+      { name: 'green',  code: 0x00FF00 },
+      { name: 'red',    code: 0xFF0000 },
+      { name: 'yellow', code: 0xFFFF00 },
+    ];
+              ↓
+    // 色名をキーにしたハッシュ構造
+    const COLOR_CODE_BY_NAME = {
+      blue:   0x0000FF,
+      green:  0x00FF00,
+      red:    0xFF0000,
+      yellow: 0xFFFF00,
+    };
+
+= データ構造を変える(2/2)
+
+    const COLOR_CODES = [
+      { name: 'blue',   code: 0x0000FF },
+      { name: 'green',  code: 0x00FF00 },
+      { name: 'red',    code: 0xFF0000 },
+      { name: 'yellow', code: 0xFFFF00 },
+    ];
+    
+    const COLOR_CODE_BY_NAME = {};
+    for (const item of COLOR_CODES) {
+      COLOR_CODE_BY_NAME[item.name] = item.code;
+    }
+
+= 変換のコスト
+
+* 何回も使うなら割に合う
+* 1回しか使わなくても、\n
+  応答性を挙げたいときにも\n
+  (('note:（初期化に時間をかけてよければ）'))
+
+= 計算量を小さくしやすいデータ構造にしよう
+
+* 配列の全走査は基本的に遅い
+* 配列は((*よく検索するキー*))で\n
+  ハッシュテーブルにしておく\n
+  （インデックス）
+* 読み込んだデータはとりあえず\n
+  ハッシュテーブルにしがち
+
+=　
+
+= 計算量を減らすには(3/3)
+
+「求めたい結果」を変えてしまう
+
+* 厳密な結果でなく\n
+  ((*近似値*))でいいことにする
+* ((*制約条件*))を設ける
+
+= 巡回セールスマン問題
+
+* 各町を1回ずつ訪問したい
+* すべての町を訪問したい
+* なるべく短い時間で済ませたい
+
+時間が最も短く済むのは\n
+どのような巡回ルートか？
+
+
+= 巡回セールスマン問題なら
+
+* 最適解を求めることを諦めて、\n
+  ((*現実的な計算時間の範囲で*))\n
+  ((*ほどほどにいい結果*))を求める
+* 巡回できる町の\n
+  ((*最大数を制限する*))
+
+
+= 　
+
+= 練習してみよう
+
+* https://github.com\n
+  　/clear-code\n
+  　/readable-code-workshop\n
+  　/tree/master/20220804\n
+  　/0performance\n
+  　/try.docx または try.pdf
+
+== ノート
+
+
+

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: rabbit-slide-Piro-readable-code-workshop-2022-08-04-performance
+version: !ruby/object:Gem::Version
+  version: 2022.08.04
+platform: ruby
+authors:
+- YUKI Hiroshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-08-04 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: 2022-08-04開催のリーダブルコード演習の予習としての、プログラムの実行性能の話。
+email:
+- yuki@clear-code.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rabbit"
+- README.rd
+- Rakefile
+- config.yaml
+- images/graph-O1.png
+- images/graph-ON.png
+- images/graph-ON2.png
+- images/graph-ONfactorial.png
+- images/graph-OlogN.png
+- pdf/readable-code-workshop-2022-08-04-performance-summary.pdf
+- performance.rab
+- samples.pdf
+- try.pdf
+homepage: http://slide.rabbit-shocker.org/authors/Piro/readable-code-workshop-2022-08-04-performance/
+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.7.6
+signing_key: 
+specification_version: 4
+summary: プログラムの計算量と実行性能について
+test_files: []