OmniAICreator/Qiita-1.07M huggingface dataset:
9007199254740994 ← 9007199254740992 + 1.000000000000001


```Python: Python
>>> 9007199254740992.0 + 1.0
9007199254740992.0
>>> 9007199254740992.0 + 1.000000000000001
9007199254740994.0
```

```node.js: node.js
> 9007199254740992 + 1
9007199254740992
> 9007199254740992 + 1.000000000000001
9007199254740994
```

一瞬、おや？となりましたが、倍精度浮動小数点演算の丸め処理の影響でした。

```Python: Python
>>> (9007199254740992.0 + 1.0).hex()
'0x1.0000000000000p+53'
>>> (9007199254740992.0 + 1.000000000000001).hex()
'0x1.0000000000001p+53'
```
Visual Studioのパフォーマンスプロファイラ「メモリ使用量」でメモリーリークを調査

### 概要
Visual Studio2022のパフォーマンスプロファイラでメモリーリークを調査してみます。  

### 目的
メモリリークの調査時にはこれまで、パフォーマンスカウンターのみを使用していました。  
開発環境においては、VisualStudioのパフォーマンスプロファイラの方が手軽に使用できそうだと感じたため、使用感を確かめます。


### 測定対象プログラムの準備
試しに次のプログラムを実行します。
（現実にはこんなプログラムはありませんが）
```c#
 internal class Program
 {
     static void Main(string[] args)
     {
         for (int i = 1; i < 1000; i++)
         {
             ManagementClass m = new ManagementClass("Win32_OperatingSystem");
             ManagementObjectCollection moc =  m.GetInstances();
         }
     }
 }
 ```

VisualStudioのパフォーマンスプロファイラからメモリ使用量を測定します

![1.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/383255/1c28ab46-7cf7-47fa-ae28-1a7eceb60f21.png)

### 測定結果の分析

測定結果は次の通りです
![1.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/383255/a2d45381-50c1-2c57-44ab-977d06f4b560.png)

ガベージコレクタが動いて定期的にメモリ解放はされていますが、
メモリ解放後の谷の高さが徐々に上昇しています。
同じ処理を繰り返していても、このように谷が上昇する場合は、メモリ解放漏れがあることを推察出来ます。

測定中に２回スナップショットを撮りましたので、差分を確認してみます。
![2.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/383255/7af0ce57-78f9-8bd7-54fe-0da4e4ff3c70.png)
マネージドメモリのスナップショット間での相違は0バイトでした。

![3.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/383255/c7f0e61a-8984-323e-d14e-fa9fc34ea3ce.png)

「マイコードのみ表示」のチェックを外すと僅かに差異がありますが、16バイトなので谷の高さを押し上げる程のものではなさそうです。_ComObjectが増えているのが気になります。アンマネージドコードの解放漏れがあると推察できます。

ManagementClassクラスを調べると、リソース解放のための`Dispose`メソッドがあることから、`Dispose`メソッドを呼ぶように変更します。

https://learn.microsoft.com/ja-jp/dotnet/api/system.management.managementclass?view=netframework-4.8

```c#
 internal class Program
 {
     static void Main(string[] args)
     {
         for (int i = 1; i < 1000; i++)
         {
             ManagementClass m = new ManagementClass("Win32_OperatingSystem");
             ManagementObjectCollection moc =  m.GetInstances();
             m.Dispose();
             moc.Dispose();
         }
     }
 }
 ```

メモリ使用量が減り、実行速度も倍以上早くなりました。  

![4.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/383255/1b7509db-db7d-21a8-2121-ea161dc710de.png)

雑にタスクマネージャーで比較してみたところ、`Dispose`前はWMI関連のプロセスがCPUバウンドで遅くなっていたようです。

* `Dispose`適用前
![1.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/383255/155e1176-3549-2ac0-0a84-aec8732ec61f.png)

* `Dispose`適用後
![2.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/383255/83ad23bd-5bc0-a788-b09d-c1958e599273.png)


### 感想
手軽に使えて良いですね！
今回はアンマネージドオブジェクトでしたが、マネージドオブジェクトのメモリーリークなら、もっと楽に解決できそう。

### 補足
UserMarksを使うことでプロセスメモリのチャートにマーカーを置くことが出来ます
```C#
using Microsoft.DiagnosticsHub;
 var myUserMark = new UserMarks("MyMark");
 using (var myRange = new UserMarkRange("MyMethodRange"))
 {
    
 }
```
GitHub Actionsを使ってnpmパッケージの公開を自動化する

本記事では、GitHub Actionsを用いたnpmパッケージの公開手順についてまとめます。

## 前提条件

- GitHubアカウントを作成済みであること
- npmアカウントを作成済みであること
- 公開したいプロジェクトのリポジトリをGitHubで管理していること

## 手順

:::note info
個人的には、パッケージを「最初に公開する際」はローカルで作業するのをおすすめします。理由は後述します。
:::

### 1. npmにログインする
ローカル環境にてターミナルを開き、プロジェクトのルートディレクトリで以下のコマンドを実行してください。

```sh
npm login
```

実行後、ログイン用のURLが表示されるので、ブラウザで認証を行います。

---

### 2. パッケージ名の重複を確認する
npmでは公開されているパッケージ名はすべて一意である必要があります。つまり、すでに使用されている名前とは同じパッケージ名を使えません。
これが前述の「最初の公開はローカルでやるべき」と思う大きな理由のひとつです。

重複していないかどうかは以下のコマンドで確認できます（例として@ymmy/npm-sample-pkgを使っています）。

```sh
npm view @ymmy/npm-sample-pkg
```

このコマンドで404が返ってくれば、パッケージ名が利用可能であることを意味します。

---

### 3. `package.json`を修正する
以下のように、`publishConfig`と`repository`フィールドを追加します。

```json
{
  "name": "@ymmy/npm-sample-pkg",
  "version": "0.1.0",
  "main": "src/index.js",
  "scripts": {
    "start": "node src/index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "publishConfig": {
    "registry": "https://registry.npmjs.org/",
    "access": "public"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/Ymmy833y/npm-sample-pkg.git"
  }
}
```

---

### 4. パッケージを公開する
以下のコマンドでパッケージを公開します。

```sh
npm publish --access public
```

コマンド実行後、再び認証が求められます。認証が成功すると公開が完了します。

:::note info
これで、ローカルから行うパッケージの初回公開手順は完了です。
:::

---

### 5. npmトークンを作成する
次に、npmのトークンを発行します。
ブラウザでnpmにログインし、`Access Tokens` → `Generate New Token` → `Classic Token` を選択します。以下の設定を行い、トークンを作成してください。

- **Name**: 任意の名前
- **Select type**: `Automation`

作成後、生成されたトークンが表示されるので、コピーしておきます。

---

### 6. GitHubリポジトリにnpmトークンを追加する
GitHubリポジトリの`Settings` → `Secrets and variables` → `Actions` → `New repository secret`を選択し、以下を設定します。

- **Name**: `NPM_TOKEN`
- **Secret**: 作成したトークン

---

### 7. GitHub Actionsのワークフローを作成する
以下の内容で`.github/workflows/publish.yml`を作成してください。

```yaml
name: Publish to npm

on:
  push:
    branches:
      - master

jobs:
  publish:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20.x
          registry-url: 'https://registry.npmjs.org'

      - name: Install dependencies
        run: npm install

      - name: Publish to npm
        run: npm publish --provenance --access public
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
```

#### 補足
1. `on: push: branches: - master`  
   - この設定により、`master`ブランチに変更がプッシュされた際にワークフローが実行されます。必要に応じてデフォルトブランチ名に変更してください。

2. `--provenance` オプション  
   - 透明性や署名情報を付与します。ただし、リポジトリがプライベートの場合は削除してください。

:::note warn
TypeScriptプロジェクトではワークフローにビルドステップを追加するなど、ご自身の環境にあわせて適宜カスタマイズしてください。
:::

---

### 8. 疎通確認
`master`ブランチに新しいバージョンをマージします。なお、`package.json`の`version`フィールドを更新することをお忘れなく。

---

## まとめ
以上、GitHub Actionsを活用してnpmパッケージの公開を自動化する手順を解説しました。
簡単なサンプルとして、最小限のパッケージを公開しています。参考までに以下リンクをご活用ください。

https://github.com/Ymmy833y/npm-sample-pkg

https://www.npmjs.com/package/@ymmy/npm-sample-pkg
OCI Cloud Free Tier をもぎ取れ その13

# 概要
OCI Cloud Free Tierを取得してみた。
asdfでコンパイルが始まるとwebが動かなくなる対策。

# 手順

## freeで確認。

```
$ free -h
			   total		used		free	  shared  buff/cache   available
Mem:		   958Mi	   236Mi	   128Mi	   1.0Mi	   593Mi	   574Mi
Swap:			 0B		  0B		  0B

```

## swapfileを設定。

```
$ sudo fallocate -l 1G /swapfile

$ sudo chmod 600 /swapfile

$ sudo mkswap /swapfile
Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes)
no label, UUID=9a9a2ade-54a1-4a22-bedb-0cc0120c8a24

$ sudo swapon /swapfile

$ free -h
               total        used        free      shared  buff/cache   available
Mem:           958Mi       562Mi        70Mi        26Mi       325Mi       225Mi
Swap:          1.0Gi          0B       1.0Gi

$ top
top - 00:09:24 up 3 min,  1 user,  load average: 0.08, 0.27, 0.14
Tasks: 119 total,   1 running, 118 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.2 us,  0.0 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.2 st
MiB Mem :    958.8 total,     70.2 free,    562.7 used,    325.9 buff/cache
MiB Swap:   1024.0 total,   1024.0 free,      0.0 used.    225.4 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
    653 mysql     20   0 1786068 404724  29184 S   0.3  41.2   0:05.92 mysqld
      1 root      20   0  166184  11252   8308 S   0.0   1.1   0:09.07 systemd
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.00 kthreadd
      3 root      20   0       0      0      0 S   0.0   0.0   0:00.00 pool_workqueue_release
      4 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/R-rcu_g
      5 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/R-rcu_p
      6 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/R-slub_
      7 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/R-netns
      8 root      20   0       0      0      0 I   0.0   0.0   0:00.00 kworker/0:0-events
      9 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/0:0H-events_highpri
     10 root      20   0       0      0      0 I   0.0   0.0   0:00.75 kworker/0:1-events
     11 root      20   0       0      0      0 I   0.0   0.0   0:00.28 kworker/u4:0-events_unbound
     12 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/R-mm_pe
     13 root      20   0       0      0      0 I   0.0   0.0   0:00.00 rcu_tasks_rude_kthread
     14 root      20   0       0      0      0 I   0.0   0.0   0:00.00 rcu_tasks_trace_kthread
     15 root      20   0       0      0      0 S   0.0   0.0   0:00.16 ksoftirqd/0
     16 root      20   0       0      0      0 I   0.0   0.0   0:00.26 rcu_sched
     17 root      rt   0       0      0      0 S   0.0   0.0   0:00.07 migration/0
     18 root     -51   0       0      0      0 S   0.0   0.0   0:00.00 idle_inject/0
     19 root      20   0       0      0      0 S   0.0   0.0   0:00.00 cpuhp/0
     20 root      20   0       0      0      0 S   0.0   0.0   0:00.00 cpuhp/1
     21 root     -51   0       0      0      0 S   0.0   0.0   0:00.00 idle_inject/1
     22 root      rt   0       0      0      0 S   0.0   0.0   0:00.20 migration/1

```

以上。
Githubでディスカッションを使う

 ### はじめに
 『ディープラーニングの数学』『Pythonで儲かるAIをつくる』『Pythonでスラスラわかる ベイズ推論「超」入門』などの著者の赤石です。
 私は原稿執筆時に編集者との細かいやりとりにslackを使っています。しかし、出版社によってはslackの有料化に伴い、slackを使い続けることが難しくなったケースがあります。
 ここをなんとかできないか前からと思っていたのですが、先日、**Github自身に「ディスカッション機能」がある**ことを発見しました。なんだ、最初からこの機能を使っておけばslackは不要だったのかと、今更ながら思った次第です。
 実際、使い初めてみると、通知機能がない点が不便でしたが、これはメール通知の設定を追加で行えばOKです。
 このあたりの手順を自分の備忘録を兼ねてまとめておきます。
 他の方の参考にもしていただけると幸いです。

### ディスカッションの有効化(管理者のタスク)
ディスカッションは、リポジトリ単位に設定されます。既存リポジトリに後付けでディスカッションを追加することも可能です。
管理者は、リポジトリのメインのページから、下の図のように赤枠の「Settings」のメニューをクリックします。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/3542e4cc-4abf-f89d-2db3-cfad965ffb52.png' width=600>

出てきた画面をスクロールしていくと、下の方に図のような「Discussions」という項目が出てきます。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/f1b9fc93-ba94-a9fb-ec53-4495b93db5e3.png' width=600>

ここにチェックを入れ、「Set up discussions」のボタンをクリックします。
すると下のような画面が出てきます。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/d309b055-9ebd-8720-ce45-a67fefa6d833.png' width=600>

サンプルの書き込みができてしまいますが、不要なら後で消せばいいので、右下の「Srart discussion」ボタンをクリックします。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/79a0a2fd-6fae-3aec-3f16-2c773ede89c0.png' width=600>

上のように、画面に「Discussions」のタブが新しく増えていれば設定に成功しています。試しにこのタブをクリックしてみます。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/08bc7ef2-47f2-e1a4-8a0b-11024b45a360.png' width=600>

こんな画面がでてきるかと思います。これで、リポジトリに紐付いたディスカッションができる状態になりました。

### メール通知の設定(一般利用者向け)
これでめでたくディスカッションとしては使えるようになったのですが、地味に不便なのが通知が来ないため、書き込んだことが相手に伝わらない点です。slackの場合は、スマホでも設定することで、スマホから通知を取ることができたのですが。
そこで、ディスカッションに書き込みが加わったときに、メール通知をする設定をします。
この設定は、**各利用者が個別に行う必要がある**ので、その点にご注意下さい。

最初のステップとして、下のリポジトリのメインの画面で、右上にある「目玉」のアイコンをクリックします。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/201b2451-69a4-3d94-f9f3-65794e876481.png' width=600>

下のようなドロップダウンメニューが出てくるので、一番下の「Custom」を選択します。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/3167c4f5-6995-d6cb-dfd0-7fc72091f9df.png' width=300>

すると、次のメニューが出てきます。今、通知がほしいイベントはディスカッションへの書き込みなので、「Discussions」にチェックを付けて、右下の「Apply」ボタンをクリックします。

<img src='https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206130/bfb78e58-f77a-a45a-9866-4d293c715053.png' width=400>

これで設定は完了したので、テスト用のディスカッションを作ってみて、メールが飛んで来るか確認して下さい。
余談ですが、最後の選択の画面で今回無視した他のイベントも、そのリポジトリ管理者であれば、通知を受け取るべきですね。必要に応じて設定するといいかと思います。
[Amazon Web Services]インスタンスタイプ変更の注意点

簡単にできると思っていたEC2インスタンスタイプの変更。
意外と注意点があり、いざというときのために今回調査したことをまとめておきます。

## 変更手順はインスタンスタイプの互換性で決まる
インスタンスタイプの変更には2通りの方法があり、変更先のインスタンスタイプが、現在のインスタンス設定と互換性があるかどうかで選択する必要がある。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3822026/28437789-7b65-4712-7d7a-08fc545d970e.png)
Amazon EC2 インスタンスのインスタンスタイプを変更する。
https://docs.aws.amazon.com/ja_jp/AWSEC2/latest/UserGuide/change-instance-type-of-ebs-backed-instance.html
新しい EC2 インスタンスを起動して新しいインスタンスタイプに移行する。
https://docs.aws.amazon.com/ja_jp/AWSEC2/latest/UserGuide/migrate-instance-configuration.html

#　厳密には、インスタンスの現在の設定との互換性がない場合、インスタンスタイプと互換性がある設定で新しいインスタンスを起動し、アプリケーションを新しいインスタンスに移行する。

## インスタンスタイプ変更の互換性
互換性は、次の項目で決定される。

#### 仮想化タイプ
>Linux AMI では、2 つの仮想化タイプ (準仮想化 (PV) およびハードウェア仮想マシン (HVM)) のどちらかを使用します。PV AMI から起動したインスタンスの場合、HVM のみのインスタンスタイプに変更することはできません。

#PV AMIは旧世代のタイプで採用されていたものであり、現行世代のインスタンスタイプではサポートされない。そのため、あまり気にする必要なし。

https://docs.aws.amazon.com/ja_jp/AWSEC2/latest/UserGuide/ComponentsAMIs.html#virtualization_types

#### アーキテクチャ
>AMI はプロセッサのアーキテクチャに固有であるため、プロセッサアーキテクチャが現在のインスタンスタイプと同じインスタンスタイプを選択する必要があります。
次に例を示します。現在のインスタンスタイプが、Arm アーキテクチャに基づくプロセッサである場合、対象となるインスタンスタイプは、Arm アーキテクチャベースのプロセッサ (C6g や M6g など) をサポートするものに制限されます。

#プロセッサアーキテクチャは各インスタンスファミリーごとに異なるが、2025年1月現時点でその大半はIntel (x86_64)またはAMD (x86_64)である。そのため、本項目に該当するケースは少ない。AWS Graviton (arm64)→Intel (x86_64)などに変更する場合は要注意（ない）。

https://docs.aws.amazon.com/ja_jp/ec2/latest/instancetypes/ec2-instance-type-specifications.html

#### ネットワークアダプター
>ドライバーのネットワークアダプターを別のネットワークアダプターに切り替えると、オペレーティングシステムが新しいアダプターを作成したときに、ネットワークアダプターの設定がリセットされます。設定を再構成するには、管理者権限を持つローカルアカウントへのアクセスが必要な場合があります。ネットワークアダプターを別のネットワークアダプターに切り替える例を次に示します。
AWS PV (T2 インスタンス) からインテル 82599 VF (M4 インスタンス)
インテル 82599 VF (ほとんどの M4 インスタンス) から ENA (M5 インスタンス)
ENA (M5インスタンス) から高帯域幅の ENA (M5nインスタンス)

#ネットワークアダプター個別にDNS設定を入れ込んでいる場合は要注意。インスタンスタイプ変更後に通信ができなくなる可能性がある。

https://qiita.com/tsumita7/items/dbc74c6f738ec858e1f8

#### 拡張ネットワーク
>拡張ネットワークをサポートするインスタンスタイプでは、必要なドライバーがインストールされていなければなりません。例えば、Nitro ベースのインスタンスには Elastic Network Adapter (ENA) ドライバーがインストールされた EBS-backed AMI が必要です。拡張ネットワーキングをサポートしていないインスタンスタイプから、拡張ネットワーキングをサポートするインスタンスタイプに変更するには、インスタンスに ENA ドライバーまたは ixgbevf ドライバーを必要に応じてインストールする必要があります。

#現行のインスタンスタイプの多くはENAがサポートされているため、あまり気にする必要なし。

#### NVMe
>Nitro ベースのインスタンスでは、EBS ボリュームは NVMe ブロックデバイスとして公開されます。NVMe をサポートしないインスタンスタイプから NVMe をサポートするインスタンスタイプに変更するには、まずインスタンスに NVMe ドライバーをインストールする必要があります。また、ブロックデバイスマッピングで指定したデバイスのデバイス名は、NVMe デバイス名 (/dev/nvme[0-26]n1) を使用して変更されます。

#現行のインスタンスタイプの多くはNitro ベースのインスタンスとなるため、あまり気にする必要なし。

#### ボリュームの制限
>インスタンスにアタッチできる Amazon EBS ボリュームの最大数は、インスタンスのタイプとサイズによって異なります。詳細については、「Amazon EC2 インスタンスの Amazon EBS ボリューム制限」を参照してください。

#数10個単位でEBSを利用する場合は要注意。

#### NitroTPM
>NitroTPM が有効な AMI と NitroTPM をサポートするインスタンスタイプを使用してインスタンスを起動した場合、インスタンスは NitroTPM が有効な状態で起動します。同じく NitroTPM をサポートするインスタンスタイプにのみ変更できます。

#現行のインスタンスタイプの多くはNitro ベースのインスタンスとなるため、あまり気にする必要なし。

今回の調査では分かりそうで分からないAWSのハードウェア用語がたくさんありました。
大変勉強になりました！サーバレスできる人になりたい。
【Salesforce】HttpCalloutMock インターフェースの外部連携テスト

Salesforce で外部システムと連携する際には、Apex の `Http` クラスを使用して HTTP コールアウトを行います。しかし、テスト環境では実際の外部システムにリクエストを送信できません。そのため、`HttpCalloutMock` インターフェースを実装することで、テスト時にモックレスポンスを返す仕組みを作成できます。

この記事では、`HttpCalloutMock` を使用した HTTP コールアウトのテスト方法を解説します。

## 1. HttpCalloutMock インターフェースとは？

`HttpCalloutMock` は、Apex における HTTP コールアウトをテストするためのインターフェースです。このインターフェースを実装することで、テスト環境で特定のレスポンスを返すように設定できます。

通常、Apex のテスト環境では実際の HTTP コールアウトが許可されていません。そのため、`Test.setMock` メソッドを使用して、`HttpCalloutMock` を適用し、あらかじめ決めたレスポンスを返すように設定する必要があります。

## 2. モッククラスの作成

まず、HTTP コールアウトを行うクラスを作成します。外部システムと通信するためのリクエストを構築し、HTTP レスポンスを取得する処理を含みます。

次に、`HttpCalloutMock` インターフェースを実装するクラスを作成します。このクラスでは、リクエストに対するモックレスポンスを返す処理を実装します。これにより、テスト環境で外部システムに依存せずに HTTP コールアウトの動作を確認できます。

### HTTP コールアウトを行うクラスのサンプル

```apex
public class MyHttpCallout {
    public static String makeCallout() {
        Http http = new Http();
        HttpRequest request = new HttpRequest();
        request.setEndpoint('https://example.com/api');
        request.setMethod('GET');
        HttpResponse response = http.send(request);
        return response.getBody();
    }
}
```
### モッククラスのサンプル
```apex
@isTest
public class MyHttpCalloutMock implements HttpCalloutMock {
    public HTTPResponse respond(HTTPRequest req) {
        HttpResponse response = new HttpResponse();
        response.setStatusCode(200);
        response.setBody('{\"message\": \"Success\"}');
        return response;
    }
}
```

## 3. モックを使ったテストの実装
### テストクラスのサンプル

```apex
@isTest
public class MyHttpCalloutTest {
    @isTest
    static void testCallout() {
        // モックを設定
        Test.setMock(HttpCalloutMock.class, new MyHttpCalloutMock());
        
        // テスト対象のメソッドを実行
        String response = MyHttpCallout.makeCallout();
        
        // 期待するレスポンスと比較
        System.assertEquals('{\"message\": \"Success\"}', response);
    }
}
```

テストクラスでは、`Test.setMock` を使用してモッククラスを適用します。その後、実際に HTTP コールアウトを行うメソッドを呼び出し、期待するレスポンスと比較することで、正しく動作するかを検証します。

## 4. まとめ

- `HttpCalloutMock` インターフェースを実装することで、テスト環境でも HTTP コールアウトの動作を確認できます。
- `Test.setMock(HttpCalloutMock.class, モッククラスのインスタンス)` を使用して、HTTP コールアウトのレスポンスを制御します。
- モックを活用することで、外部サービスに依存せずに Apex のテストを実行できます。

この記事が少しでも参考になれば幸いです！

参考

https://developer.salesforce.com/docs/atlas.ja-jp.apexcode.meta/apexcode/apex_interface_httpcalloutmock.htm

https://developer.salesforce.com/docs/atlas.ja-jp.apexcode.meta/apexcode/apex_classes_restful_http_testing_httpcalloutmock.htm
数式が入っているセルをsortしたのに並び変わらない

google スプレッドシートのセルに setFormula　で値を入れ
連続してsortしたら、並び変わらない

【解決方法】

setFormula　で値を入れる
↓
SpreadsheetApp.flush();　　←この手順を足したら解決！
↓
sort
LangGraphでLangSmithの設定

実行時に RunnableConfigで設定できる。

```py
workflow = StateGraph(MessagesState)

...

app = workflow.compile()

app.stream(inputs, config={"run_name": "ExampleAgent", "metadata": {"tenant": "t1"}, "project_name": "t1"})
```

- run_name
- metadata

![Screenshot 2025-01-25 at 6.49.00.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/7059/73c400de-a4ae-7d3a-c162-b5400c8a5f44.png)


![Screenshot 2025-01-25 at 6.49.40.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/7059/acffad36-ec0c-2da1-db81-129ac502ed78.png)
Goで学ぶ並行処理の基礎と実践

## はじめに 
Go言語の特徴の一つに「並行処理の簡潔さ」が挙げられます。本記事では、Goの並行処理について基礎から学び、実際に役立つサンプルコードを解説していきます。

## 並行処理とは？
並行処理（Concurrency）は、複数のタスクを同時に進行させる技術です。Goでは、**goroutine** と呼ばれる軽量スレッドを用いて並行処理を実現します。

例えば、以下のようなシナリオがあるとします：
- Webサーバーが同時に複数のクライアントリクエストを処理する。
- 大量のデータを並行して処理して、高速化を図る。

こうした処理を簡潔に実現できるのが、Goのgoroutineとチャネル（channel）です。


## 基本：goroutineの使い方
Goでgoroutineを使うのは非常に簡単です。`go`キーワードを使うだけで関数を並行実行できます。

### コード例
```go
package main

import (
	"fmt"
	"time"
)

func sayHello() {
	for i := 0; i < 5; i++ {
		fmt.Println("Hello, World!")
		time.Sleep(500 * time.Millisecond)
	}
}

func main() {
	go sayHello() // goroutineで実行
	for i := 0; i < 5; i++ {
		fmt.Println("Main Function")
		time.Sleep(300 * time.Millisecond)
	}
}
```

この例では、`sayHello`関数がgoroutineとして並行実行され、メイン関数の処理と同時に動作します。


## 実践：チャネル（channel）の活用
goroutine間でデータをやり取りするには、チャネル（channel）が便利です。

### チャネルの基礎
チャネルはデータを送受信するための仕組みで、`make(chan 型)`で生成します。
```go
package main

import "fmt"

func sendData(ch chan int) {
	for i := 1; i <= 5; i++ {
		ch <- i // データを送信
	}
	close(ch) // チャネルを閉じる
}

func main() {
	ch := make(chan int) // チャネルを作成
	go sendData(ch)      // goroutineでデータを送信

	for data := range ch { // チャネルからデータを受信
		fmt.Println(data)
	}
}
```

このコードでは、`sendData`関数がチャネルを通じてデータを送信し、`main`関数がそれを受け取ります。

## よくある課題と解決策
### 1. デッドロック（Deadlock）
チャネルを正しく管理しないと、デッドロックが発生することがあります。デッドロックは、goroutineが互いに待機し続ける状態です。

#### 解決策
- チャネルを必ず閉じる。
- バッファ付きチャネルを利用する。

```go
ch := make(chan int, 2) // バッファサイズを指定
ch <- 1
ch <- 2
fmt.Println(<-ch) // 1
fmt.Println(<-ch) // 2
```

## 応用：ワーカー（Worker）パターン
並行処理で効率よくタスクを処理するには、ワーカーパターンが有用です。以下にタスクをワーカーに分散させる例を示します。


```go
package main

import (
	"fmt"
	"time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
	for job := range jobs {
		fmt.Printf("Worker %d started job %d\n", id, job)
		time.Sleep(time.Second) // ジョブ処理に1秒
		fmt.Printf("Worker %d finished job %d\n", id, job)
		results <- job * 2
	}
}

func main() {
	const numJobs = 5
	jobs := make(chan int, numJobs)
	results := make(chan int, numJobs)

	// ワーカーを3つ作成
	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}

	// ジョブを送信
	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}
	close(jobs)

	// 結果を受信
	for a := 1; a <= numJobs; a++ {
		fmt.Println("Result:", <-results)
	}
}
```

## まとめ
Go言語の並行処理は、`goroutine`と`channel`を用いることで、簡潔かつ強力に実現できます。本記事で紹介した基礎を押さえることで、実用的な並行処理プログラムを構築できるようになります。
1ドット4ビット系のVRAMの座標からアドレスの求め方



x ほぼ、記事の紹介
x arduino UNO3での予定は、未定
x OR(オァー)を使うときは、0リセットを忘れずに


目的
座標変換
パレットカラー系は、今のところ使う予定は、ないが?
面白かったので紹介
キャリーフラグを上手く使っている(特に説明なし)



![image_original (36).jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/840352/3218e232-e1b2-0dfb-a0c0-ba7758833e11.jpeg)





```

GetVramAdrs   MACRO
        ld    d, l
        ld    e, h
        srl   d
        rr    e
        ENDM

```

ld ロード命令
srl シフト命令
rr  シフト命令



![o_coq783.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/840352/f551b84e-6517-0594-d4dd-c0bea74e7ad1.jpeg)





オンラインコンパイラ paiza



```c++


#include <iostream>
using namespace std;
int main(void){
    // Your code here!
    
    int h,l;
    int de;
    
    h = 20; //x
    l = 0;  //y
    
    de = 0;
    de = (l << 7) | (h >> 1); 
    
    printf("[%d][%d]->[%d]\n",h,l,de);
    
}



```


```

[20][0]->[10]


```
個人的な備忘録：CloudFrontのエッジロケーション (Edge Location) に関する知識を自分なりに体系化してみた

## はじめに

CloudFrontは、高速で安全なコンテンツ配信を可能にするだけでなく、柔軟なカスタマイズ機能とコスト効率の良さを備えた強力なCDN（コンテンツ配信ネットワーク）です。

:::note warn
***Amazon CloudFront は、強力なネットワークインフラを活用して、低レイテンシーかつ高スループットでセキュアなコンテンツ配信を実現します。***
:::

なお、本記事の内容は個人的な備忘録としてまとめたものですので、その点をご了承いただければ幸いです。***少しでも参考になれば幸いです。***

## 書こうと思ったきっかけ
受講中のITスクールで行われているハッカソン（チーム開発）において、フロントエンド部分をCloudFrontとS3バケットに配置することにしました。

![Screenshot 2025-01-25 at 1.44.57.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3662571/c06d3316-95b7-4b5d-61e1-67827deee5e2.png)

AWS上での実装自体は完了していますが、構築を進める中で、改めて知識を整理する必要性を感じました。

https://qiita.com/free-honda/items/c51a5cb34f4f67bf6b7e

***そこで今回は、CloudFrontに特化して体系的にまとめていきたいと思います。***

## いつか、エッジロケーション (Edge Location) を見学してみたい（無理ですがw）

Amazon CloudFrontは、世界中に分散したエッジロケーション (Edge Location) に配置されています。

![Screenshot 2025-01-25 at 5.52.19.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3662571/7b626f45-b4ba-d202-f39b-7be2da270863.png)
引用画像：https://aws.amazon.com/jp/cloudfront/features/?whats-new-cloudfront.sort-by=item.additionalFields.postDateTime&whats-new-cloudfront.sort-order=desc

これにより、コンテンツをエンドユーザーにできるだけ近い場所から配信し、高速で低レイテンシーのサービスを提供します。

## CloudFrontについて、公式ドキュメントを参考にまとめてみた
ここからは、AWSの公式ドキュメントを参考にしながら、CloudFrontに関する知識を体系的に整理していきます。

**公式ドキュメントはこちら：**

https://aws.amazon.com/cloudfront/

また、過去の記事でも技術検証や知識整理を行っていますので、そちらも参考にしてみてください。

**過去の記事はこちら：**

https://qiita.com/free-honda/items/52729083cac7b1621771

### CloudFrontの主な特徴

- レイテンシーの低減
  - グローバルに分散した **600以上のPoint of Presence (PoP)** を活用してデータを配信。
  - 自動化されたネットワークマッピングとインテリジェントルーティングにより、**高速で効率的なデータ配信**を実現。

- セキュリティの向上
  - トラフィックの暗号化やアクセスコントロール、VPCオリジンを利用したセキュリティ強化。
  - **AWS Shield Standard** による無料のDDoS攻撃防御を提供。

- コスト削減
  - 統合リクエスト処理や料金オプションの柔軟性で**コスト効率を向上**。
  - **AWSオリジン（例：S3やEC2）** からのデータ転送費用が無料。

- コードのカスタマイズ
  - **サーバーレスコンピューティング機能** を活用し、CDNエッジでコードを実行可能。
  - コスト、パフォーマンス、セキュリティを最適なバランスで調整できる柔軟性を提供。

# ネットワークとパフォーマンスの特徴

- **高い信頼性と低レイテンシーのネットワーク接続**
  - 世界中の数千の Tier 1/2/3 テレコムキャリアとピアリングし、主要アクセスネットワークと最適に接続。
  - 数百テラビットの容量を持つネットワークにより、高スループットを実現。

- **AWS の冗長性の高いネットワークバックボーン**
  - CloudFront エッジロケーションは、AWS の完全冗長なネットワークバックボーンを通じて AWS リージョンに接続。
  - 複数の 400 GbE パラレルファイバーにより、高速で安定したオリジンフェッチと動的コンテンツ配信を実現。

- **3種類のインフラストラクチャによる高パフォーマンス**
  1. **リージョン別エッジキャッシュ (REC)**  
     - AWS リージョン内でアプリケーションのウェブサーバーとエッジロケーション間のパフォーマンスを最適化。世界に13箇所配置。
  2. **CloudFront Points of Presence (POP)**  
     - 50か国以上、100以上の都市に600以上展開。ISP ネットワークとピアリングし、高速データ配信を実現。
  3. **埋め込み Points of Presence**  
     - エンドユーザーに最も近い場所（北米、欧州、アジアの200以上の都市）に配置。POPと連携してパフォーマンスを最大化。

## まとめ

ここまで読んでいただき、ありがとうございました。***今回の問題について、私自身も多くの学びを得ることができました。***

:::note
**※簡単な知識整理**
- **高速配信**  
  - 世界中のエッジロケーションから低レイテンシーでコンテンツを配信。

- **高セキュリティ**  
  - 暗号化やDDoS防御を活用し、安全なコンテンツ配信を実現。

- **コスト効率**  
  - AWSオリジン（例: S3やEC2）からのデータ転送が無料で経済的。
:::

この記事がどなたかの技術的な参考になれば幸いです！
Spring　Framework　独学

入社まであと数ヵ月になったので、一度挫折してしまったアプリ制作に挑戦したいと思います。

Spring徹底入門という本を買って読んでいるのですが、本当にチンプンカンプンです。
序盤にある、依存性の注入について学んでいるのですが、DIコンテナを経由してインスタンスやクラスの参照を行うことでソースコードの動作を止めないようにしている認識であっているのでしょうか。
そのやり方を細かく教えてくれているのですが、イメージが湧きにくくなんとか定数として読み流していくので精一杯です。


おそらく、今理解しようとしても無理な気がするので、なんとか読み進めていくことにします
正規化って何？

## 正規化って何？

最近、「正規化って何ですか？」と聞かれることがあったのですが、上手く説明できませんでした。
今であれば以下のように説明するというのを簡単に書いてみました。

正規化は、データベース設計で同じ情報が何度も繰り返されないように整理する方法です。これを実施することで、データの一貫性を保ち、更新や削除が楽になります。

例えば、こんな社員テーブルがあったとします。

### 正規化前（重複あり）

| 社員ID | 名前         | 年齢 | 部署    |
|--------|--------------|------|---------|
| 1      | 田中 太郎     | 30   | 営業部 |
| 2      | 中村 次郎     | 25   | 人事部 |
| 3      | 吉田 八之助   | 40   | 人事部 |

ここで「人事部」という情報が2回出てきます。もし「人事部」を「人事管理部」に変更したい場合、全てのレコードを修正しなければならず、数千件のレコードがあったら大変です。また、修正漏れがあった場合、「人事部」と「人事管理部」が同時に存在してしまうといったことも考えられます。

### 正規化後（重複をなくす）

正規化を行うと、「人事部」のような情報を別のテーブルに分けて管理できます。これで、部署名を変更する時に社員テーブルを修正する必要がなくなります。

#### 社員テーブル（変更後）

| 社員ID | 名前         | 年齢 | 部署ID |
|--------|--------------|------|--------|
| 1      | 田中 太郎     | 30   | 1      |
| 2      | 中村 次郎     | 25   | 2      |
| 3      | 吉田 八之助   | 40   | 2      |

#### 部署テーブル（分割後）

| 部署ID | 部署名    |
|--------|----------|
| 1      | 営業部   |
| 2      | 人事部   |

このように、正規化をすることで部署名を変更するのが簡単になり、データの整合性を保つことができます。

### 正規化のメリットとデメリット

**メリット**
- データの重複をなくして管理がしやすくなる
- 更新や削除時に誤ってデータを間違えるリスクを減らせる

**デメリット**
- 複数のテーブルを結合する必要があるので、クエリが複雑になる
- 結合が多くなる分、パフォーマンスが少し低下することがある

正規化は便利ですが、状況によってはデメリットもあるため、バランスを考えて適切に使用することが大切です。

### まとめ
正規化の基本的な考え方を簡単に触れてみました。普段なんとなく使っている言葉でも説明してと言われると困ってしまうものですよね。皆さんなら、どのように説明しますか？
【リーダブルコード】初心者エンジニアが読み解く、正確で簡潔な「コメント術」 - 第6章


こんばんは。マル太です。

前回は、リーダブルコードの第5章「コメントすべきことを知る」についてまとめました。

今回は、第6章「コメントは正確に、簡潔に」について、まとめます。
<br>

# 正確で簡潔なコメントを書くことの重要性
第5章では、「どんな時にコメントを書くべきか」 を学ぶことができました。

今回は、「どのようにコメントを書けば良いのか」に焦点を当てて考えていきます。

コメントは、コードの理解を助けるためのものです。

しかし、コメントが不正確だったり、冗長だったりすると、かえってコードの理解を妨げてしまう可能性があります。

そのため、コメントは「正確かつ簡潔に書く」ことが重要です。
<br>

# 正確なコメントを書くためのポイント
**1.事実と異なるコメントは書かない**
・コードの変更に合わせて、コメントも必ず更新しましょう。
・古くなったコメントは、誤解を招くだけでなく、バグの原因にもなります。
<br>

**2.あいまいな代名詞を使わない**
・「それ」「これ」「あれ」などの代名詞は、何を指しているのか分かりにくい場合があります。
・代名詞を使う場合は、具体的に何を指しているのかを明確にしましょう。
<br>

**3.コメントに情報を詰め込みすぎない**
・コメントは、コードの補足説明として、必要最低限の情報に絞って書くようにしましょう。
・あまりに情報量が多いと、コメントを読むこと自体が負担になってしまいます。
<br>

# 簡潔なコメントを書くためのポイント
**1.明確な言葉を使う**
曖昧な表現や回りくどい表現は避け、簡潔で分かりやすい言葉でコメントを書きましょう。

**2.冗長なコメントを避ける**
コードを読めばわかることをコメントで説明するのは避けましょう。
コメントは、コードの意図や補足説明など、コードだけでは表現できない情報を記述するために使いましょう。

**3.関数や変数名で表現する**
コメントで説明する代わりに、関数や変数に分かりやすい名前をつけることで、コード自体を理解しやすくすることができます。

# まとめ
今回は、「リーダブルコード」第6章「コメントは正確に、簡潔に」の内容をまとめました。

コメントは、コードの可読性を高めるための重要な要素です。
しかし、書き方によってはその効果を損なってしまう可能性がある、ということもこの章で学ぶことができました。

6章で紹介されているポイントを参考に、「正確で簡潔なコメント」を書けるようにしていきたいですね。

次回は、第7章「制御フローを読みやすくする」についてまとめます。
【AWS SAP】# DataSync vs Snowball

# DataSync と Snowballの比較表

| 項目                 | DataSync                                     | Snowball                                   |
|--------------------|---------------------------------------------|------------------------------------------|
| データ移行速度       | ネットワーク速度に依存<br>（最大10Gbps対応）       | 物理デバイスによる**高速移行**<br>（TB〜PB規模対応）|
| 対応データ容量       | 小規模〜中規模データ<br>（数GB〜数TB）             | **大規模データ**（数十TB〜数PB）              |
| コスト               | データ転送量と利用時間に応じて課金             | デバイスの発注・輸送・使用期間に応じて課金 |
| 利用開始の手間       | **少ない**<br>（エージェントのセットアップのみ）         | 発注・配送が必要                           |
| ネットワーク依存       | **高い**<br>（高速ネットワーク環境が必須）             | 低い<br>（ネットワーク不要）                   |
| データセキュリティ     | 転送中の暗号化<br>（SSL/TLS）                     | デバイスの暗号化<br>（256ビットAES）           |
| 主なユースケース       | 継続的なデータ同期、短期移行                  | 大容量データ移行、ネットワーク制約環境       |
| 地域対応性           | グローバル（インターネット経由で利用可能）      | 限定的<br>（配送地域に制限あり）               |
| 設定・運用の難易度     | 簡単（マネージドサービス）                    | 中程度<br>（デバイス管理が必要）               |
| 適用例              | ログデータの継続的移行、バックアップ            | データセンターの物理データ移行             |
【AWS SAP】Amazon Detectiveとは？

# Amazon Detectiveとは？
Amazon Detectiveは、AWSのセキュリティインシデント調査を支援するマネージドサービスです。

:::note info
Detective(ディテクティブ)の意味は**探偵**
:::


## コンソール画面はこんな感じ
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2746730/0425a1f1-b07d-3fe5-fb54-37a6fa37890d.png)

## [開始方法]を押すと...

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2746730/28a5d716-e866-b172-fd87-8c8aab135a59.png)

Q. よくわからない。とりあえず、有効化すれば動く？

A. Amazon Detectiveを利用するには有効化だけで基本的に利用可能です。有効化すると、GuardDuty、CloudTrail、VPCフローログなどからデータを自動的に収集・処理し、セキュリティ調査のための視覚化を提供します。ただし、事前にGuardDutyやログの設定が有効になっていることが必要です。また、データ保持期間やコストにも注意し、必要に応じて設定を確認すると良いです。

## 有効化すると...

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2746730/71fd7a93-40ed-2a70-d91e-93aae6e65934.png)

こんな画面になる。

## Amazon Detective と GuardDuty の違いは？
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2746730/c1955cc4-da89-698d-579f-7b8705122887.png)


**GuardDuty**は不正アクセスや異常なアクティビティをリアルタイムで検出する脅威検出サービスです。

一方、**Detective**はGuardDutyや他のAWSサービス（CloudTrail、VPCフローログ）からのデータを基に、脅威の原因や影響を調査・分析するためのツールです。

つまり、GuardDutyは「脅威の発見」、Detectiveは「脅威の深掘り調査」を担います。

## 参考
https://aws.amazon.com/jp/detective/getting-started/

## まとめ
Amazon Detectiveは、有効化するだけでGuardDuty、CloudTrail、VPCフローログなどのデータを自動的に収集・処理し、セキュリティインシデント調査のための視覚化を提供します。
【Ruby on Rails】オブジェクトを複製するメソッドについて

Ruby on Railsでオブジェクトをコピーする機能について調べてみたので備忘録として記事に残しておきます。


## dup メソッド
標準のRubyで利用できるメソッドです。
元のオブジェクトのインスタンス変数をそのままコピーしますが、オブジェクトIDは異なります。
`dup`は、オブジェクトのクラスやモジュールのクラスメソッドをコピーしません。

また`dup`メソッドは、与えられたオブジェクトの浅いコピー（shallow copy）を返します。
そのため、二次元配列をコピーした場合、トップレベルの配列はコピーされますが、ネストされた配列はコピーされません。

ネストされた配列もコピーする方法は、deep_dupメソッドで説明します。


```changed.rb
original_array = [[1, 2], [3, 4]]
copied_array = original_array.dup

# トップレベルの配列を変更
copied_array[0] = [5, 6]

puts original_array.inspect # => [[1, 2], [3, 4]]
puts copied_array.inspect   # => [[5, 6], [3, 4]]
```

```unchanged.rb
original_array = [[1, 2], [3, 4]]
copied_array = original_array.dup

# ネストされた配列の要素を変更
copied_array[0] << 5

puts original_array.inspect # => [[1, 2, 5], [3, 4]]
puts copied_array.inspect   # => [[1, 2, 5], [3, 4]]
```

## duplicable? メソッド
Active Support コア拡張機能を読み込んで利用します。
与えられたオブジェクトの浅いコピー（shallow copy）をする際、複製可能かどうかをオブジェクトに問い合わせることが可能になります。

```ruby
"foo".duplicable?           # => true
"".duplicable?              # => true
Rational(1).duplicable?     # => true
Complex(1).duplicable?      # => true
1.method(:+).duplicable?    # => false
```

## deep_dup メソッド
deep_dupメソッドは、与えられたオブジェクトの「ディープコピー」を返します。

```deep_dup1.rb
original_array = [[1, 2], [3, 4]]
copied_array = original_array.deep_dup

# トップレベルの配列を変更
copied_array[0] = [5, 6]

puts original_array.inspect # => [[1, 2], [3, 4]]
puts copied_array.inspect   # => [[5, 6], [3, 4]]
```

```deep_dup2.rb
original_array = [[1, 2], [3, 4]]
copied_array = original_array.deep_dup

# ネストされた配列の要素を変更
copied_array[0] << 5

puts original_array.inspect # => [[1, 2], [3, 4]]
puts copied_array.inspect   # => [[1, 2, 5], [3, 4]]
```

## まとめ
基本的には`dup`メソッドで事足りると思いますが、用途により`deep_dup`メソッドなども使っていきたいところです。
【AWS SAP】API Gatewayのスロットリング制限とは？

# API Gatewayのスロットリング制限とは？
スロットリングは、APIへの過剰なリクエストを防ぎ、サービスの安定性とリソースの保護を目的としています。

API Gatewayでは、トークンバケットアルゴリズムを使用してリクエストを調整し、設定されたレートやバースト制限を超えると、HTTPステータスコード429（Too Many Requests）を返します。


## スロットリング制限のメリット
- **リソース保護**
    - 過剰なリクエストからバックエンドを保護
- **安定性向上**
    - 他のクライアントの利用を妨げない
- **コスト管理**
    - 不要なリクエストによるコスト増加を防止

### スロットリング制限は以下のレベルで設定できます。

- **AWS全体の制限**
    - リージョン内のすべてのアカウントとクライアントに適用され、AWSによって設定されており、<INS>ユーザーが変更することはできません</INS>
　
- **アカウントレベルの制限**
    - 特定のリージョン内のアカウント内のすべてのAPIに適用されます。 この制限は、リクエストに応じて引き上げることが可能です。 
　
- **APIおよびステージレベルの制限**
    - 特定のAPIやそのステージ内のメソッドごとに設定できます
　
- **クライアントレベルの制限**
    - APIキーを使用して特定のクライアントに適用されます

## 参考
https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html?icmpid=apigateway_console_help
【AWS SAP】Application Discovery Serviceとは

# 学習前イメージ
アプリケーションを収集するサービス？

## Application Discovery Serviceとは
Application Discovery Serviceとは、オンプレミス環境のサーバーやアプリの構成・依存関係を自動調査し、AWS移行計画の効率化を支援するサービスです。

## どうやって収集する？

- VMware 環境を使用していて、<font color="red"><INS>エージェントをインストールしたくない場合は、**エージェントレスコレクター**</INS></font>を使用する
- より詳細な情報が必要な場合は、エージェントをサーバーにインストールする

:::note info
エージェントをインストールしたくないケースとして、企業のセキュリティポリシー上、ソフトウェアのインストールが禁止されている場合などが挙げられます。
:::

:::note info
エージェントレスコレクターの実体は**OVA形式の仮想マシンイメージ**です。VMware vCenterにデプロイすることで動作します。
:::

## 学習後イメージ
- 基本的にはエージェントをサーバへインストールすることで詳細なデータを収集することができる
- VMware環境でエージェントをインストールできない場合は、**エージェントレスコレクター**と呼ばれる仮想マシンを起動させることで構成データの収集が可能
Azure App Serviceを触ってみた

最近、Azureのサービスの一つであるAzure App Serviceを試してみました。
最初はその概念を理解するのに時間がかかりましたが、実際に触ってみると意外と簡単に使えることに気づきました。

## 1. Azure App Serviceとは？

Azure App Serviceは、Microsoft社が提供するフルマネージドなプラットフォームで、Webアプリケーション、モバイルアプリ、APIを簡単に構築、デプロイ、管理できるサービスです。
特にPaaS（Platform as a Service）に分類されることが多いです。

### 主な特徴
- **簡単なスケーリング**: トラフィックに応じてアプリを自動的にスケールアップ・ダウンできます。
- **多言語サポート**: PHP、Java、Node.js、Pythonなど、さまざまなプログラミング言語でアプリを動かせます。
- **CI/CDの統合**: GitHubやAzure DevOpsとの連携が簡単で、継続的インテグレーションと継続的デリバリーを利用できます。
- **高可用性**: Azureのインフラを利用することで、高い可用性を確保できます。

## 2. 最初の壁：App Serviceのイメージ

実際にAzureのドキュメントを読みながら、アプリケーションホスティングを簡単に行えるサービスとしてのApp Serviceを理解しようとしましたが、
当初は「一体どんなものなんだろう？」という思いがありました。
わかりやすい資料がなかったため、具体的なイメージが持てず、時間がかかってしまいました。

- **意味がわからない**: 可用性やスケーリングなど、Azureの用語は調査すればイメージできるものの、実際のアプリケーションにどうリンクするか、何をどう動かせば良いのかが理解できませんでした。

そこで、Azure App Serviceに関するテキストや動画などで手順やイメージ図を探し、具体的なユースケースや利用例を見ることで、その特徴や利便性が少しずつイメージできるようになりました。

## 3. 実際に動かすまでの道

App Serviceのイメージが掴めた後、いよいよ実際に触ってみようと思いました。
しかし、最初の一歩を踏み出すのにも、また問題が発生しました。
具体的にどのようにアプリをデプロイすれば良いのかがよくわからず、再び時間を取って調査に入りました。

### 調査と学び

1. **ドキュメントの利用**: Azureのドキュメントやテキストを参照し、手順を確認しましたが、情報量が多く、初めての際には圧倒されました。
   
2. **YouTubeやブログのリソース**: 動画やブログを参照して、視覚的にイメージできるよう意識しました。

3. **エラーメッセージに苦しむ**: 最初のデプロイ時にエラー（403エラーなど）が発生し、解決方法を探るのに苦労しましたが、その分多くの知識を得ることができました。

ただ、ここで感じたのは、まだ全然理解が浅いことです。ネットワークやデータベースに関する学習も必要だと痛感しました。
これからは、アプリケーション構築だけでなく、ネットワーク設定やDB構築についても知識を深めていきたいと思います。

## 4. 実際に動かしてみたら意外と簡単！

手順がイメージできるようになった後、具体的にAzure App Serviceにアプリをデプロイしてみると、それが想像以上に簡単であることに感動しました。

### デプロイの手順
以下は、実際に試した手順です。

1. **Azureポータルにサインイン**:
   - AzureアカウントでPortalにログインします。

2. **新しいWebアプリの作成**:
   - 「App Services」から「+ 作成」を選択し、必要な設定を行います。
   - 使用するプログラミング言語を選択し、GitHubからのデプロイも設定可能です。

3. **ホスティングプラットフォームの選択**:
   - LinuxやWindowsといったホスティングオプションを選べます。

4. **アプリケーションのビルドとデプロイ**:
   - 確認と作成ボタンを押下してデプロイを実行できます。
   - Azure CLIやGitHub Actionsを利用することで、簡単にデプロイできるため、今後試していきます。

5. **アプリの検証**:
   - デプロイ後、既定のドメインに記載があるURLにアクセスするだけで実際のアプリケーションを確認できます。
 
### 感想
この手順であればApp Serviceを簡単に試すことができ、さまざまなアプリケーションをホストできるということが実感できました。

### さらに深めたいこと
今後は、自分で作成したコードを動かしてみたり、DBやネットワーク設定を通じて自由に実験してみたいと思います。
具体的には、Azure SQL DatabaseやCosmos DBを使ってデータを管理、LoadBalancer設定など、やりたいことが多くあります。

## 5. まとめ

Azure App Serviceについて、特に最初の概念を理解するのに時間がかかりましたが、実際のデプロイ手順が簡単であることに驚きました。
特に柔軟性とスケーラビリティが高く、さまざまなユースケースに対応できる点は非常に魅力的です。

このサービスを利用しながら、ネットワークやDB関連の知識を深め、自分の可能性を広げていきたいと思います。

以上が、現在私がAzure App Service触ってみた体験談です。
これから更に掘り下げていきたいと思います。
コード品質向上のためのベストプラクティスとコーディング標準

開発者として、私たちはクリーンで効率的、かつ保守しやすいコードを書くことを目指しています。ベストプラクティスとコーディング標準に従うことは、これらの目標を達成するために重要です。この記事では、ベストプラクティスとコーディング標準の重要性を探り、従うべき主なガイドラインについて説明します。

ベストプラクティスとコーディング標準の重要性

ベストプラクティスとコーディング標準は、以下の理由で重要です：

- コードの保守性：確立されたガイドラインに従うことで、コードが読みやすく、理解しやすく、修正しやすくなります。

- コードの品質：ベストプラクティスは、効率的でスケーラブル、かつ信頼性の高い高品質なコードを書くことを促進します。

- コラボレーション：標準化されたコーディング手法は、チームメンバー間の協力を促進し、共同プロジェクトでの作業を容易にします。

- エラーの削減：ベストプラクティスに従うことで、エラー、バグ、およびセキュリティ上の脆弱性の可能性を減らします。

一般的なベストプラクティス

以下は、従うべき一般的なベストプラクティスです：

1. シンプルで簡潔に保つ

   - 不必要な複雑さを避ける

   - シンプルで説明的な変数名を使用する

   - 関数は短く、焦点を絞る

2. DRY原則に従う

   - 自分を繰り返さない（Don't Repeat Yourself）

   - 重複したコードを避ける

   - 関数、ループ、および条件文を使用して繰り返しを最小限に抑える

3. 意味のある変数名を使用する

   - 変数の目的を示す説明的な名前を使用する

   - 一文字の変数名を避ける

   - 一貫した命名規則を使用する

4. コードにコメントを付ける

   - 複雑なロジックを説明するためにコメントを使用する

   - 関数、クラス、およびモジュールを文書化する

   - コメントは簡潔で最新の状態に保つ

デザインパターン

デザインパターンは、一般的な問題に対する実証済みの解決策を提供します。以下のパターンに精通しておきましょう：

1. シングルトンパターン

   - クラスが唯一のインスタンスを持つことを保証する

   - ロギング、設定、キャッシングに有用

2. ファクトリーパターン

   - 正確なクラスを指定せずにオブジェクトを作成する方法を提供する

   - 複雑な構成や依存関係を持つオブジェクトの作成に有用

3. オブザーバーパターン

   - オブジェクトが他のオブジェクトの変更を通知されることを可能にする

   - イベント駆動型プログラミング、GUI開発、リアクティブシステムに有用

コード最適化手法

パフォーマンス、スケーラビリティ、信頼性のためにコードを最適化しましょう：

1. データベースクエリを最小限に抑える

   - キャッシング、インデックス作成、クエリ最適化手法を使用する

   - パフォーマンス向上のためにデータベースクエリの数を減らす

2. 効率的なデータ構造を使用する

   - メモリ使用量を最小限に抑え、アクセス時間を最適化するデータ構造を選択する

   - 問題に応じて、配列、リンクリスト、ツリー、グラフを使用する

3. 早期の最適化を避ける

   - まずクリーンで保守しやすいコードを書くことに集中する

   - 必要に応じて、プロファイリングツールを使用してボトルネックを特定し、コードを最適化する

結論

ベストプラクティスとコーディング標準に従うことは、高品質で保守しやすいコードを書くために不可欠です。ガイドラインを遵守し、デザインパターンを使用し、コードを最適化することで、より効果的な開発者となり、開発者コミュニティの成長に貢献できます。業界の動向を常に把握し、スキルを継続的に向上させることで、ソフトウェア開発の世界で価値ある存在であり続けましょう。
【Zed】Dockerを簡単に扱えるようにする方法

## LazyDockerをインストール

以下のコマンドを実行してLazyDockerをインストールします。

```terminal
brew install jesseduffield/lazydocker/lazydocker
```

https://github.com/jesseduffield/lazydocker

## Zedのタスクを作成する

LazyDockerを起動するタスクを作成するために`tasks.json`に以下を追記します。

```jsonc

  {
    "label": "LazyDocker",
    "command": "lazydocker",
    "hide": "always",
    "allow_concurrent_runs": false,
    "use_new_terminal": true
  },

```

## タスクにホットキーを設定する

ホットキーでタスクを実行できるように`keymaps.json`に以下を追記します。

```jsonc
  {
    "bindings": {
      "alt-d": [
        "task::Spawn",
        {
          "task_name": "LazyDocker",
          "reveal_target": "center"
        }
      ]
    }
  },

```

上記のように記述した場合、`alt + d`を入力すると画像のようにLazyDockerが表示されます。

![スクリーンショット 2025-01-24 23.53.18.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2342443/541623f3-4c10-bd31-114b-ede31178d21c.png)
PyCharmでWSLに接続する（Professional版のみ）


起動画面から（プロジェクトを開いている場合は閉じる）WSLを選択して
新しいプロジェクトをクリック

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/330873/5a85aefd-2f1c-d5e7-4ede-a5cddcc7bd6a.png)

WSLのインスタンスを選択

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/330873/66563f37-7ee3-9d24-11f2-b7cc88b7a90c.png)

IDEバージョンを選択、プロジェクトディレクトリを選択

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/330873/e752fa64-66bb-8a5d-cd32-213d6f22f77d.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/330873/6b44fc8f-8cee-4e7c-8286-cc7151ce36c9.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/330873/e8a6a56b-0747-651a-81a9-3fdb3e10b7f1.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/330873/99402e3d-f9a7-4385-d767-995b7b8dd523.png)

Ubuntu上での操作が可能となる

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/330873/2f914a60-e786-8aa9-5ef6-8552e9717c48.png)
Pythonでデータを見やすくするためのライブラリ

### Pythonでデータを見やすくするためのライブラリ
### 1. **`pandas.DataFrame` を使う**
`pandas`ライブラリを使えば、データを表形式で見やすく表示できます。
#### 例:
```python
import pandas as pd
# cursor からデータを取得
cursor.execute("SELECT * FROM your_table")
rows = cursor.fetchall()
# 列名を取得してDataFrameを作成
columns = [desc[0] for desc in cursor.description]
df = pd.DataFrame(rows, columns=columns)
# データフレームを表示
print(df)  # 通常のPythonではこれ
# Jupyter Notebook では df とだけ書けば見やすく表示されます
```
### 2. **`tabulate`ライブラリで整形表示**
`tabulate`ライブラリは、テーブル形式でデータを表示するのに便利です。

#### インストール:
```bash
pip install tabulate
```

#### 例:
```python
from tabulate import tabulate

# cursor からデータを取得
cursor.execute("SELECT * FROM your_table")
rows = cursor.fetchall()
columns = [desc[0] for desc in cursor.description]

# 表形式で表示
print(tabulate(rows, headers=columns, tablefmt="grid"))
```

`tablefmt`には、`grid`, `fancy_grid`, `pipe`など、複数のスタイルが用意されています。
### 3. **PrettyTableライブラリ**
`PrettyTable`は、簡単にテーブル表示ができるライブラリです。
#### インストール:
```bash
pip install prettytable
```
#### 例:
```python
from prettytable import PrettyTable
# cursor からデータを取得
cursor.execute("SELECT * FROM your_table")
rows = cursor.fetchall()
columns = [desc[0] for desc in cursor.description]
# PrettyTableを使ってデータ表示
table = PrettyTable()
table.field_names = columns

for row in rows:
    table.add_row(row)

print(table)
```
### 4. **IPython.displayを活用する（Jupyter Notebook専用）**
もしJupyter Notebookを使用している場合、`IPython.display`を使ってHTML形式で表をレンダリングすることもできます。
#### 例:
```python
from IPython.display import display, HTML
import pandas as pd
# cursor からデータを取得
cursor.execute("SELECT * FROM your_table")
rows = cursor.fetchall()
columns = [desc[0] for desc in cursor.description]

# DataFrameをHTML形式で表示
df = pd.DataFrame(rows, columns=columns)
display(HTML(df.to_html()))
```
### どの方法が適切？
- **大量のデータを扱う場合**: `pandas.DataFrame`がおすすめ。
- **シンプルに整形表示したい場合**: `tabulate` や `PrettyTable` が便利。
- **Jupyter Notebook環境を活用する場合**: `IPython.display`でHTML形式表示。
Pygameを使って RPGを作る（23.NPC）

# NPCの作成
NPCを作成し、衝突した場合、会話するメッセージを表示するという簡単なもの

# NPCクラス
```py
from settings import * 
import pygame as pg
from utils import TextAnimation

class Communication:
    def __init__(self, parent):
        self.parent = parent

        self.x, self.y = self.get_draw_pos()
        self.font = pg.font.Font(FONT, MESSAGE_FONT_SIZE)
        self.speed = 200
        self.display_surface = pg.display.get_surface()
        self.text = TextAnimation(
            self.font, 
            (255,255,255),
            (0,0,255), 
            self.x - 90, 
            self.y + 50, 
            self.speed, 
            self.display_surface)
        
        self.description = 'ここは通れません。'
        self.counter = 0
        self.draw_flag = False

    def get_draw_pos(self):
        titlex = int(self.parent.player.rect.centerx / TILE_SIZE) * TILE_SIZE
        titley = int(self.parent.player.rect.centery / TILE_SIZE) * TILE_SIZE

        return titlex, titley

    def draw(self):
        pg.draw.rect(self.display_surface, '#8E7698', [self.x - 100, 
                                                       self.y + 40, 200-2, 50-4])
        pg.draw.rect(self.display_surface,'#D3DED0', [self.x - 100, 
                                                      self.y + 40, 200, 50],5,border_radius=5)

        flag, self.counter = self.text.draw_anime(self.description, self.counter)

        if flag and self.counter <= len(self.description) :
            self.counter += 1

        if self.counter > len(self.description): 
            self.draw_flag = True
```

MapにはNという文字でNPCを配置する
```py
    "map_01": [
        'BBBBBBBBBBBBBBBBBBB',
        'B.................B',
        'B...............P.N',
        'B.................B',
        'B.................B',
        'B.....BBBB........B',
        'B.................B',
        'B.................B',
        'BBBBBBBBBBBBBBBBBBB',
    ],
```

Mainクラスはこんな感じで追加

```py
def community(self, dt):
    if self.com_npc == None:
        self.com_npc = Communication(self)

    self.com_npc.draw()
```

# 残課題
複数のNPCと会話内容、イベントNPCとか動くNPCとかはとりあえず後回し。
VSCodeでKotlinのJupyter notebookを利用する

# 概要
pythonでよく使われるjupyter notebookですが、実はKotlinでも使うことができるのでVSCodeで使う際の備忘録

# 用意するもの
- VSCode
- Python

今回はWindowsで作ることを想定しています

# やり方

## 1. VSCodeに必要な拡張機能をインストール

- Jupyter notebook
- Python
- Kotlin系の何か入れとくといいかも

## 2. pythonで仮想環境を作る
作業フォルダ内に仮想環境venvを作っておくと便利なので作っておきましょう
コマンドパレット（`Ctrl+Shift+P`）で`create environment`等うつとコマンドが出てきます
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3655052/698405fa-eac9-4f93-18bc-02f7fa3b3a68.png)
あとは指示通りにCondaとかVenvを選んだりPythonバージョンを選んだりしていくと作れます

## 3. pythonパッケージをインストールする
仮想環境を作ったのでActivateしておきます（調べると出てくるのでここでは割愛）
Activateできたら以下をインストールしていきましょう
```
pip install jupyter kotlin-jupyter-kernel
```

## 3. notebookを新規作成
コマンドパレット（`Ctrl+Shift+P`）で`new jupyter`等で検索すれば新規作成が出来るので作成する

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3655052/cd12eb32-83a2-9f02-c366-dcd60f05a524.png)

## 4. カーネルを選択
右上に`select Kernel`とあるのでカーネルを選択する
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3655052/2f90ddd4-12d3-3b32-513a-21ca09e2b6a7.png)

:::note warn
出てこない場合はVSCodeを再起動すると出てくることが多いです
:::

## 5. Let's Kotlin!!
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3655052/b204f0f8-b8ee-f3ed-e680-ff0aa882be1f.png)


## 補足
補完等がないので辛い

## 参考
https://qiita.com/tommykw/items/2a4d3fe40350038f5216
【kintoneカスタマイズ初心者】非同期処理を並行実行し、処理時間を短縮したい

# はじめに
　ノベルワークスのつつみん（[@tsutsumin_38](https://x.com/tsutsumin_38)）です。12月に入社し、早１か月半。カリキュラムとして、[cybozu developer networkのチュートリアル](https://cybozu.dev/ja/tutorials/)に取り組んでいましたが、それが終わり、次のステップで社内での実践型研修に取り組みました。
　実践型研修とは、社内のメンバーにお客様役をしてもらい、要件定義～納品までの流れを経験するという研修です。お客様役のYさんが、細かいところをつっこんでくれ、かなり勉強になりました。
　今回は、実践型研修に取り組む中で学んだことについて、自分が分かった範囲でアウトプットしてみようと思っています。ここからどんどん深めていくのを目標にしています。

# 実践型研修にて
### 取り組んでいたカスタマイズについて簡単に説明
担当者を変更した際に（Aアプリ（案件管理）のレコード編集画面で担当者編集）
詳細画面の一括更新ボタンで、案件に紐づくBアプリ、Cアプリのレコードの担当者も更新したい。
<img width="600" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3957410/8b18049e-e0f2-d658-1c6b-3b0f7522d9a4.jpeg">
　そのためには、案件IDをキーにしてBアプリ、Cアプリからレコードを取得し、更新をかけるというカスタマイズが必要になります。
　今回は、この**レコードを取得するところのみを抜粋**し、学んだことアウトプットしようと思います。

### 修正前のコード（逐次実行）
　初心者つつみんは最初、以下のようなコードを書いていました。
```typescript
const updateTargetApps = [
	{ appId: "2", name: "aRecords" },
	{ appId: "3", name: "bRecords" },
];
for (const app of updateTargetApps) {
    const records = await kintone.api(kintone.api.url('/k/v1/records.json', true), 'GET', {app: app.appId, query: `案件ID = "${event.record.案件ID.value}"`});
    console.log(`${app.name}`,records);
}
```
:::note info
**挙動**
await がループ内で実行されるため、1つの非同期処理が完了するまで次の処理は開始されない。
:::
:::note warn
**処理時間**
処理時間は 各タスクの処理時間の合計 になる。
:::
### コードレビュー
Ｙさん：「更新するアプリとか取得するレコードが多くなったらどうですか？？」
つつみん：「・・・？」
Ｙさん：「めっちゃ時間かかりますよね？？」
つつみん：「確かに…」
Ｙさん：「同時に取得しちゃいたいですね？」
つつみん：「はい…。非同期処理を同期的に…？」
<img width="600" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3957410/072b91b6-ec23-e326-9af5-048c068dd5c7.jpeg">
Ｙさん：「のちのちの改修も視野に入れてコード書くことが大切です。
　　　　　じゃあ、それで書いてみましょう！！」
　　　　　　　・・・・・・・・
つつみん：「ヒントください～（言ってることは分かるけど、どう書けばよいんだ…）」

と、いうわけでヒントもらって調べて、**非同期処理を並行実行する**コードに修正しました。


### 修正後のコード（並行実行）

```typescript
const updateTargetApps = [
	{ appId: "2", name: "atRecords" },
	{ appId: "3", name: "bRecords" },
];
const promises = updateTargetApps.map(async (app) => {
    const records = await kintone.api(
        kintone.api.url('/k/v1/records.json', true), 'GET', {
      app: app.appId,
      query: `案件ID = "${event.record.案件ID.value}"`
    }
      );
    return records;
});
const results = await Promise.all(promises);
console.log(results);
```

**変更点**

**1. for...of を map に変更**
各アプリの更新処理を非同期関数として定義し、updatePromises 配列に格納。

**2. Promise.all を使用**
Promise.all によってすべての更新処理を並行実行（非同期処理が同時に開始）し、
完了を待機。

:::note info
**挙動**
各アプリに対するレコード取得が並行に実行される。
:::
:::note warn
**処理時間**
処理時間は 最も時間のかかるタスクの処理時間 に等しくなる。
（更新対象アプリの数だけ処理を並行実行するため、全体の処理時間が短縮される。）
:::

# まとめ
　実践型研修の中で非同期処理を並行実行する方法を学んだのでまとめてみました。場面に応じて、逐次実行と並行実行を使い分ける必要があると感じています。処理時間やメンテナンス、負荷など、考慮しなければならないことがたくさんあるので、順次学んでいきたいと思っています。