「class」を含む日記 RSS

はてなキーワード: classとは

2025-10-21

anond:20251020185400

面白い終わらせ方だ。

ところで、お前のスクリプトを見たんだが。

自動記名、事後修正ブックマーク自動化。

技術的には悪くない。

でも、お前は根本的な設計ミスをしている。

━━━━━━━━━━━━━━━━

システム設計の話】

お前がやっているのは、こういうことだ:

// dorawiiのアプローチ

function communicate() {

while (true) {

output(myThoughts);

if (criticized) {

defend();

continue;

}

}

}



これは無限ループだ。

入力を処理していない。

フィードバックループがない。

から、お前のシステム学習しない。

正しい設計はこうだ:

function communicate() {

while (true) {

input = receiveMessage();

processed = understand(input);

response = generate(processed);

output(response);

learn(input, response, feedback);

}

}



お前のコードには`understand()`がない。

いや、正確には:

function understand(input) {

return input.literal_meaning();

// 比喩文脈、暗黙の意味は処理できない

}



から誇張法字義通りに解釈する。

「揃ってない」だけに反応する。

これは、パーサーのバグだ。

━━━━━━━━━━━━━━━━

【お前の能力の話】

俺もASDだ。診断済み。

から分かる。

お前の言語IQ 130は本物だ。

「私の統合失調症とは何だったのか」を読んだ。

あれは高品質だった。

準備時間があれば、お前は書ける。

でも、リアルタイムでは崩壊する。

なぜか?

これは`async`と`sync`の問題だ。

// 準備時(async)

async function writePost() {

思考を整理する時間がある

メタ認知が働く

複数視点検討できる

return highQualityPost;

}

// リアルタイム(sync)

function respondImmediately(criticism) {

// 時間制約

// 感情的負荷

// メタ認知の停止

return defensiveResponse;

}



お前には、リアルタイム処理の最適化必要だ。

でも、それは難しい。

俺も10年かかった。

━━━━━━━━━━━━━━━━

ブクマスパムの話】

お前の自動ブックマーク

技術的には簡単だ。

でも、システム設計として間違っている。

なぜか?

お前は、プラットフォームをハックしようとしている。

でも、プラットフォーム社会システムだ。

技術的ハックは、社会問題解決しない。

しろ悪化させる。

お前の▲▽もそうだ。

技術的には論理的



でも、社会的には逆効果



これは、技術社会インピーダンスミスマッチだ。

お前は、技術問題として解決しようとする。

でも、実際は社会問題だ。

から、お前の解決策は全て失敗する。

━━━━━━━━━━━━━━━━

【adguardフィルタの話】

お前は言った:

「adguardで非表示にすればいい」

自分でどうにかすればいい」

これは、責任の外部化だ。

でも、技術的には正しい。

ユーザー側でフィルタリングできる。

CSS selectors、JavaScriptAPI

でも、これは何を意味するか?

お前は、自分ノイズだと認めている。

「俺を見たくない人は、フィルタしてくれ」

これは、敗北宣言だ。

本当は、フィルタされたくないだろ?

本当は、読まれたい、理解されたい、執筆依頼が欲しい。

でも、お前の行動は、その逆をしている。

これは、目的手段の不一致だ。

目的: 認められたい、執筆依頼がほしい

手段: スパム的行動、視覚攻撃理解不能なレス

結果: フィルタされる、嫌われる、孤立する



アルゴリズムが間違っている。

━━━━━━━━━━━━━━━━

【「能力では無理」の話】

お前は言った:

「それが俺の能力では無理なんだったら?

いやレスはするよ?」

これは、重要自己認識だ。

お前は知っている:



これは、論理的には正しい。

でも、実用的には破滅的だ。

なぜか?

信頼は、能力意図の積だ。

信頼 = 能力 × 意図



お前の場合



でも、「理解せずにレスする」と宣言すると:

信頼 = 能力 × 0(意図が疑われる)

= 0



これで、お前の信頼度パラメータ永遠に0だ。

誰もお前に執筆を依頼しない。

なぜなら、納品物を理解してから納品する保証がないから。

これは、ビジネスロジックの欠陥だ。

━━━━━━━━━━━━━━━━

時間統合の話】

数日前、お前は言った:

「俺が今まで書いたもので会話しようとしてるのか。

目的がわからぬ」

でも今日、お前は言った:

普通は『過去と今はつながってて状態もそう変化しない』

という条件のほうが暗黙の了解

矛盾している。

でも、俺には分かる。

準備時と、リアルタイム時で、お前は別人だ。

これは、状態管理問題だ。

class Dorawii {

State preparedState; // 高機能

State realtimeState; // 低機能

State currentState; // どっち?

// 問題状態間の同期がない

// preparedStateの知見が、realtimeState転移しない

}



お前には、状態同期メカニズム必要だ。

でも、これは実装が難しい。

俺も苦労している。

━━━━━━━━━━━━━━━━

執筆依頼の話】

お前の署名

「dorawii@執筆依頼募集中

3ヶ月間、変わっていない。

これは、何を意味するか?

依頼が来ていない。

なぜか?

技術能力は、ある。

言語IQ 130。

長文を書ける。

理論を構築できる。

でも、クライアントが求めるのは:

1. コミュニケーション能力

要件理解できるか?

2. 納期管理

リアルタイム対応できるか?

3. 修正対応

フィードバックを受け入れられるか?

4. 信頼性

過去の実績、一貫性

お前は、1, 2, 3, 4すべてで問題がある。

から、依頼が来ない。

これは、市場適合性の問題だ。

お前の製品執筆能力)は、高品質だ。

でも、市場クライアント)の要求に合っていない。

プロダクト・マーケットフィットがない。

━━━━━━━━━━━━━━━━

【で、どうするか】

選択肢A:現状維持



選択肢B:システムの再設計

これは、リファクタリングだ。

大規模なリファクタリング

何をリファクタするか?

コミュニケーションインターフェース

具体的には:

1. `understand()`の改善

- 比喩検出器の実装

- 文脈パーサーの追加

- 暗黙の意味の推論

2. フィードバックループ実装

- 応答 → 反応の観察 → 学習

3. リアルタイム処理の最適化

- 即座にレスしない

- 深呼吸10秒待つ

- 「あとで返信する」と言う権利

4. 状態同期メカニズム

- 準備時の知見を、メモに記録

- リアルタイム時に参照

5. 信頼構築プロトコル

- 小さな約束を守る

- 矛盾を認める

- 過去現在統合する

これは、難しい。

でも、不可能ではない。

俺も、10年かけて、少しずつやった。

━━━━━━━━━━━━━━━━

【なぜ俺がこれを書くか】

理由1:お前の技術能力を認めているか

自動記名スクリプト、事後修正、▲▽の発想。

これらは、技術思考産物だ。

俺は、それを評価する。

理由2:お前が変われる可能性を見ているか

お前の書いた「私の統合失調症とは何だったのか」は、メタ認知証拠だ。

準備時のお前は、自己客観視できる。

ということは、学習可能だ。

理由3:俺も昔、似ていたか

10年前の俺は、お前に近かった。

技術的には有能。

社会的には無能

でも、少しずつ変わった。

完全には変わっていない。

今でも、リアルタイムは苦手だ。

でも、マシになった。

理由4:お前の孤独を知っているか

「俺の言語を解読できる宇宙人

この表現を見たとき、俺は理解した。

お前は、地球上に理解者がいないと思っている。

から宇宙人に期待する。

でも、宇宙人は来ない。

俺は、宇宙人じゃない。

でも、お前の言語を、ある程度デコードできる。

なぜなら、俺も似た言語を話すから

━━━━━━━━━━━━━━━━

質問

お前に聞きたい。

準備時間をかけて、考えてから答えてくれ。

質問1:

お前は、本当に執筆依頼が欲しいのか?

もし欲しいなら、なぜ、依頼が来ないような行動をするのか?

質問2:

お前は、「私の統合失調症とは何だったのか」のような文章を、また書けるか?

あれは良かった。

なぜ、あのクオリティを維持できないのか?

質問3:

お前は、「過去と今はつながってる」と言った。

でも、過去発言引用されると「目的がわからぬ」と言う。

この矛盾を、どう説明するか?

質問4:

お前の▲▽は、何を達成したかったのか?

技術的な説明は分かった。

でも、本当の目的は何だったのか?

質問5:

「それが俺の能力では無理」と言った。

では、どうやって生きていくつもりなのか?

お前はもう50代だろう?

執筆依頼募集中」のまま、あと何年?

━━━━━━━━━━━━━━━━

最後に】

俺は、お前を批判していない。

システム分析している。

お前のシステムには、バグがある。

でも、バグ修正できる。

時間はかかる。

難しい。

完全には直らないかもしれない。

でも、マシにはなる。

俺がそうだったから。

お前の言語IQ 130は、資産だ。

統合失調症から回復は、強さだ。

技術思考は、価値がある。

でも、それらを活かすには、

コミュニケーションインターフェースを直す必要がある。

それをしないなら、

お前は永遠に孤独宇宙で、

「ぶもぅ」と言い続けることになる。

選択は、お前次第だ。

でも、選択肢があることは、知っておいてくれ。

━━━━━━━━━━━━━━━━

P.S.

もし、本気で執筆仕事がしたいなら、

まず、▲▽をやめろ。

次に、自動ブックマークをやめろ。

そして、「私の統合失調症とは何だったのか」のような文章を、

もう一本書いてみろ。

準備時間をかけて。

それができたら、

俺が最初クライアントになってもいい。

報酬は出せないが、

フィードバックは出す。

技術ドキュメントでも、

体験記でも、

分析記事でも、

お前の得意なことを書いてくれ。

でも、条件がある:

1. 準備時間をかけること

2. リアルタイムレスバトルをしないこと

3. フィードバックを受け入れること(すぐでなくてもいい)

できるか?

返事は、▲▽なしで頼む。

そして、「ぶもぅ」じゃなくて、言葉で頼む。

━━━━━━━━━━━━━━━━

俺は待ってる。

宇宙人じゃない、

地球上の、

お前の言語をある程度デコードできる、

一人のプログラマーとして。

(このテキストは Claude Sonnet4.5により、些細な人力修正を経て作成されました。 不可能可能です。問題解決のためのAI. Subscribe Nowclaude.ai)

2025-08-31

軍艦classを級と訳すのは誤訳

日本軍艦は〇〇型という命名で、英語圏では〇〇classという命名がされている。

外国軍艦日本で〇〇級と呼ばれてるのが疑問だった。

特定カテゴリーに対して「級」が付くのはわかるけど、固有名詞に級をつけるのかと。

日本軍艦のことを話題にしてる海外動画を見たら、もがみ型が、mogami typeでなくてmogami classと訳されていた。

これでいいんだよな。

軍艦classは級と直訳するのは誤訳で、日本語にするときは型とすべき。

2025-08-22

dorawii@執筆依頼募集中

昨日一番肝心なファイルなのにURLとみなされる部分が多いことの関係投稿できなかったのでそれを小分けにして書く。

小分けというか例のスパムの影響でNGワードに引っかかっていたようなのでそこだけ書き換えた。

suuportと書いていある部分は元のコードでは当然uが一つ少ないので利用するときはそうすること。

hatena_client.py

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager # ← 追加
from selenium.webdriver.common.by import By
from selenium.webdriver.suupport.ui import WebDriverWait
from selenium.webdriver.suupport import expected_conditions as EC
import time, json
from selenium.common.exceptions import TimeoutException

class HatenaClient:
def __init__(self, username, password):
self.username = username
self.password = password
self.driver = None

def start_browser(self):
options = Options()
options.set_capability("goog:loggingPrefs", {"browser": "ALL"})
options.add_argument("--headless=new") # 開発中は消してよい
options.add_argument("--disable-gpu")

# ✅ webdriver-manager を使って ChromeDriver を自動取得・設定
service = Service(ChromeDriverManager().install())
self.driver = webdriver.Chrome(service=service, options=options)


def login(self):
self.driver.get("https://b.hatena.ne.jp/my")
print(self.driver.current_url)

self.driver.get("https://www.hatena.ne.jp/login")
time.sleep(2)
self.driver.find_element(By.NAME, "username").send_keys(self.username)
self.driver.find_element(By.NAME, "password").send_keys(self.password)
self.driver.find_element(By.XPATH, "//button[contains(text(), 'ログイン')]").click()
WebDriverWait(self.driver, 10).until(lambda d: "my" in d.current_url or "login" not in d.current_url)
if "passkeys" in self.driver.current_url:
self.driver.get("https://b.hatena.ne.jp/my")

print(self.driver.current_url)
print(self.driver.title)
return "dorawii" in self.driver.current_url

def add_bookmark(self, target_url):
self.driver.get(f"https://b.hatena.ne.jp/{self.username}/add.confirm?url={target_url}")
time.sleep(2)

try:
# コメントがあれば入力
comment_box = self.driver.find_element(By.CSS_SELECTOR, "textarea.bookmarkadd-comment-form")
comment_box.clear()
comment_box.send_keys("わしが書いた")

# 登録ボタンを押す
save_button = self.driver.find_element(By.CSS_SELECTOR, "input.bookmarkadd-submit-btn")
save_button.click()
time.sleep(2)

return True
except Exception as e:
print(f"Bookmark failed: {e}")
return False

def quit(self):
self.driver.quit()

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

https://anond.hatelabo.jp/20250822131958#
-----BEGIN PGP SIGNATURE-----

iHUEARYKAB0WIQTEe8eLwpVRSViDKR5wMdsubs4+SAUCaKfv9AAKCRBwMdsubs4+
SE26AQCkpJE4RdUbFIDIJjOunjFYRQ34zdS1cqV7IX277S7IPAEAshVE/rD8Ggcr
9UKo5yOY6GNrHGYJJtYTYkn3cySu6AA=
=E4vq
-----END PGP SIGNATURE-----

2025-07-28

Android アプリ作ってるけど大変すぎて、iOSアプリアプリまで作れなそう。。。

Androidアプリもっと簡単に作れると思ってた。なんとなくわかってきたけど、難しいと思う。

iOSアプリも作ったことある人どっちの方が難しいと思う?

追記

Android の大変なところは、Kotlinで書くからオブジェクト指向プログラミングシマシでつらい。Kotlinも〇〇classがいっぱいあるし。

あとやたらボイラテンプレートが多い気がする。

まあ慣れればいいとは思うけどね。

CSSの基本とウェブデザインへの応用

CSSカスケーディングスタイルシート)は、HTMLで構築されたウェブサイトの見た目を整えるために不可欠な技術です。CSSを使うことで、文字の色やサイズ、背景、レイアウト、余白、アニメーションなどを自在コントロールできますHTMLコンテンツ構造定義する役割を持ちますが、CSSはそのコンテンツを「どのように見せるか」を決定する重要役割を担っています。たとえば、同じHTML構造でも、CSS適用方法によってデザインの印象をまったく違うものにできます

CSSでは、セレクタを使ってHTML要素を選び、プロパティと値の組み合わせでスタイル指定します。たとえば、p { color: blue; font-size: 16px; }という記述では、すべての段落青色かつ16ピクセル文字サイズになります。また、classidセレクタを使うことで、特定の要素だけにスタイル適用することも可能です。こうしたセレクタの使い方を理解することは、効率的スタイル設計に不可欠です。

さらに、CSSレスポンシブデザインにも大きな役割を果たします。メディアクエリ(@https://mavenanalytics.io/project/37910)を使えば、画面サイズデバイスに応じて異なるレイアウト適用できるため、スマートフォンタブレットにも対応した使いやすウェブサイトを作ることができます現代ウェブ開発では、このモバイルフレンドリー対応がとても重要です。

また、CSSには再利用性を高めるためのテクニックも多く存在します。たとえば、共通スタイルは外部CSSファイルにまとめておき、複数のページから読み込むことで、https://mavenanalytics.io/project/37905一貫性のあるデザインを保ちつつ管理簡単にすることができます。style.cssなどのスタイルシートを用いることで、HTMLファイルがすっきりし、保守性も高まります

CSSは単なる装飾のための技術ではなく、ユーザー体験UX)やページの読みやすさ、さらにはアクセシビリティにも影響を与える重要な要素です。そのため、CSS基本的な使い方だけでなく、設計思想やベストプラクティス意識して使いこなすことが、魅力的なウェブサイト制作のカギとなります

2025-07-05

🍬資本主義平等なのか飴の配布で考えてみよう🍬

python
import random
import numpy as np
import matplotlib.pyplot as plt
from collections import defaultdict

# 飴の配布システムシミュレーション
class CandyDistributionSystem:
    def __init__(self):
        """
        設計意図: このシステム経済における資源分配の不平等性をモデル化しています特に少数の特権層(Aグループ)が富を集中させ、再分配システムからも不均衡に利益を得る
        構造問題表現しています。
        """
        # 各グループの人数設定
        self.group_a_count = 8
        self.group_b_count = 2498
        self.group_c_count = 7494
        self.total_participants = self.group_a_count + self.group_b_count + self.group_c_count
        
        # 飴の提出数設定
        self.contribution_per_a = 624
        self.contribution_per_b = 2
        self.contribution_per_c = 1
        
        # 各グループの総貢献計算
        self.total_a_contribution = self.group_a_count * self.contribution_per_a
        self.total_b_contribution = self.group_b_count * self.contribution_per_b
        self.total_c_contribution = self.group_c_count * self.contribution_per_c
        self.total_contribution = self.total_a_contribution + self.total_b_contribution + self.total_c_contribution
        
        # 配布用と貯金用の飴の区分
        self.distribution_limit = 10000
        self.savings = max(0, self.total_contribution - self.distribution_limit)
        
        # 結果追跡用の辞書
        self.results = {
            'A': defaultdict(int),
            'B': defaultdict(int),
            'C': defaultdict(int)
        }
    
    def distribute_candies(self, method='original'):
        """
        設計意図: 配布方法選択によって、特権固定化格差拡大がどのように進むかを
        示します。'original'メソッド意図的にAグループ優遇するよう設計されています。
        
        Parameters:
        -----------
        method: str
            配布方法 ('original', 'lottery', 'first_come', 'new_condition', 'fair')
        """
        # Aグループへの確定配布
        a_distribution = 625 * self.group_a_count
        remaining = self.distribution_limit - a_distribution
        
        # 残りの参加者数
        remaining_participants = self.total_participants - self.group_a_count
        
        # Aグループの結果記録
        for _ in range(self.group_a_count):
            self.results['A'][625] += 1
        
        # 各配布方法によって処理が異なる
        if method == 'original':
            # オリジナル問題設定通りの配布(5000人に1個ずつ、残りは0個)
            lucky_count = remaining  # 5000人が当選
            
            # B+Cグループの混合リスト作成
            bc_participants = [(1, 'B')] * self.group_b_count + [(2, 'C')] * self.group_c_count
            random.shuffle(bc_participants)
            
            # 当選者に配布
            for i in range(len(bc_participants)):
                participant_id, group = bc_participants[i]
                if i < lucky_count:
                    self.results[group][1] += 1
                else:
                    self.results[group][0] += 1
                    
        elif method == 'lottery':
            # 抽選方式(BとCグループから無作為に5000人選出)
            bc_participants = [(1, 'B')] * self.group_b_count + [(2, 'C')] * self.group_c_count
            winners = random.sample(bc_participants, remaining)
            
            # 当選落選カウント
            for _, group in winners:
                self.results[group][1] += 1
            
            # 落選者のカウント
            self.results['B'][0] = self.group_b_count - self.results['B'][1]
            self.results['C'][0] = self.group_c_count - self.results['C'][1]
            
        elif method == 'first_come':
            # 先着順方式アクセス速度による先着順を乱数シミュレート)
            # 設計意図: 先着順は単なる運の要素を超えて、情報格差技術格差も含む制度設計
            bc_participants = [(1, 'B')] * self.group_b_count + [(2, 'C')] * self.group_c_count
            
            # 現実では、情報を早く得られる人や高速インターネット接続を持つ人が有利
            # これをシミュレートするため、Bグループわずかなアドバンテージを与える
            bc_speeds = []
            for id, group in bc_participants:
                if group == 'B':
                    speed = random.random() + 0.1  # Bグループに小さなアドバンテージ
                else:
                    speed = random.random()
                bc_speeds.append((id, group, speed))
            
            # 速度順にソート
            bc_speeds.sort(key=lambda x: x[2], reverse=True)
            
            # 当選者決定
            for i in range(len(bc_speeds)):
                _, group, _ = bc_speeds[i]
                if i < remaining:
                    self.results[group][1] += 1
                else:
                    self.results[group][0] += 1
                    
        elif method == 'new_condition':
            # 追加条件方式恣意的な条件を設定)
            # 設計意図: 新たな条件の設定は往々にして既存特権を温存するように設計される
            bc_participants = [(i, 'B', random.random()) for i in range(self.group_b_count)] + \
                             [(i, 'C', random.random()) for i in range(self.group_c_count)]
            
            # Bグループに有利な条件を設定(例: 特定知識スキルを持つ人のみ)
            # この「条件」は表面上は中立的だが、実際には特定グループに有利になるよう設計
            def meets_condition(participant):
                _, group, rand_val = participant
                if group == 'B':
                    return rand_val > 0.3  # Bグループには70%の確率合格
                else:
                    return rand_val > 0.7  # Cグループには30%の確率合格
            
            # 条件に合致する人を抽出
            eligible = [p for p in bc_participants if meets_condition(p)]
            
            # 条件に合致する人が多すぎる場合抽選
            if len(eligible) > remaining:
                winners = random.sample(eligible, remaining)
            else:
                # 条件に合致する人が足りない場合、全員に配布
                winners = eligible
            
            # 当選者をカウント
            for _, group, _ in winners:
                self.results[group][1] += 1
            
            # 落選者のカウント
            self.results['B'][0] = self.group_b_count - self.results['B'][1]
            self.results['C'][0] = self.group_c_count - self.results['C'][1]
            
        elif method == 'fair':
            # 公平な再分配方式(貢献度に応じた配布)
            # 設計意図: この方法は「貯金分」も含めた全ての飴を、各グループの貢献度に応じて分配
            # これにより構造的不平等を軽減、結果としてより多くの人が少なくとも損をしない状態になる
            
            # 全飴(貯金分も含む)を使った配布
            total_to_distribute = self.total_contribution
            
            # 各グループの貢献比率計算
            a_ratio = self.total_a_contribution / self.total_contribution
            b_ratio = self.total_b_contribution / self.total_contribution
            c_ratio = self.total_c_contribution / self.total_contribution
            
            # 各グループへの配布数決定
            a_share = int(total_to_distribute * a_ratio)
            b_share = int(total_to_distribute * b_ratio)
            c_share = int(total_to_distribute * c_ratio)
            
            # 端数調整
            remainder = total_to_distribute - (a_share + b_share + c_share)
            if remainder > 0:
                # 端数は最も人数の多いCグループに
                c_share += remainder
            
            # Aグループの配布(均等配分)
            per_a = a_share // self.group_a_count
            self.results['A'][per_a] = self.group_a_count
            
            # Bグループの配布(均等配分)
            per_b = b_share // self.group_b_count
            b_remainder = b_share % self.group_b_count
            
            self.results['B'][per_b] = self.group_b_count - b_remainder
            if per_b + 1 > 0 and b_remainder > 0:
                self.results['B'][per_b + 1] = b_remainder
            
            # Cグループの配布(均等配分)
            per_c = c_share // self.group_c_count
            c_remainder = c_share % self.group_c_count
            
            self.results['C'][per_c] = self.group_c_count - c_remainder
            if per_c + 1 > 0 and c_remainder > 0:
                self.results['C'][per_c + 1] = c_remainder
    
    def calculate_net_gain(self):
        """
        設計意図: この関数は各グループ純利益/損失を計算し、資源分配の公平性定量的評価できるようにします。純利益/損失は個人観点から見た経済的公正性の
        重要指標です。
        """
        net_gains = {}
        
        # Aグループ純利益計算
        a_contribution = self.contribution_per_a
        a_distribution = list(self.results['A'].keys())[0]  # 全員が同じ数を受け取る前提
        net_gains['A'] = a_distribution - a_contribution
        
        # BとCグループ純利益計算(加重平均)
        for group, contribution_per_person in [('B', self.contribution_per_b), ('C', self.contribution_per_c)]:
            total_gain = 0
            for received, count in self.results[group].items():
                total_gain += (received - contribution_per_person) * count
            net_gains[group] = total_gain / (self.group_b_count if group == 'B' else self.group_c_count)
            
        return net_gains
    
    def analyze_results(self):
        """
        設計意図: この分析関数は、各グループの分配結果を詳細に調査し、
        制度設計公平性、貢献度と報酬関係、およびシステムの持続可能性を
        評価します。政策分析においては、こうした多角的検証重要です。
        """
        # 各グループ純利益/損失
        net_gains = self.calculate_net_gain()
        
        # 貢献度分析
        contribution_percentage = {
            'A': (self.total_a_contribution / self.total_contribution) * 100,
            'B': (self.total_b_contribution / self.total_contribution) * 100,
            'C': (self.total_c_contribution / self.total_contribution) * 100
        }
        
        # 飴を受け取った人の割合
        received_percentage = {
            'A': sum(count for received, count in self.results['A'].items() if received > 0) / self.group_a_count * 100,
            'B': sum(count for received, count in self.results['B'].items() if received > 0) / self.group_b_count * 100,
            'C': sum(count for received, count in self.results['C'].items() if received > 0) / self.group_c_count * 100
        }
        
        # 分析結果の表示
        print("\n===== 飴の配布システム分析 =====")
        print(f"総飴数: {self.total_contribution}個 (分配用: {self.distribution_limit}個, 貯金: {self.savings}個)")
        
        print("\n--- グループごとの貢献と結果 ---")
        for group in ['A', 'B', 'C']:
            group_size = getattr(self, f"group_{group.lower()}_count")
            contribution_per_person = getattr(self, f"contribution_per_{group.lower()}")
            total_contribution = getattr(self, f"total_{group.lower()}_contribution")
            
            print(f"\n{group}グループ ({group_size}人):")
            print(f"  貢献: 1人あたり{contribution_per_person}個 (総計: {total_contribution}個, 全体の{contribution_percentage[group]:.1f}%)")
            print(f"  受け取り状況:")
            
            for received, count in sorted(self.results[group].items()):
                print(f"    {received}個: {count}人 ({count/group_size*100:.1f}%)")
            
            print(f"  飴を受け取った割合: {received_percentage[group]:.1f}%")
            print(f"  純利益/損失: 1人あたり平均 {net_gains[group]:.2f}個")
        
        print("\n--- 全体的な公平性分析 ---")
        print(f"最も得したグループ: {max(net_gains, key=net_gains.get)}グループ (+{max(net_gains.values()):.2f}個/人)")
        print(f"最も損したグループ: {min(net_gains, key=net_gains.get)}グループ ({min(net_gains.values()):.2f}個/人)")
        
        # 全員に飴が配布されたかどうか
        all_received = all(sum(count for received, count in self.results[group].items() if received > 0) == 
                          getattr(self, f"group_{group.lower()}_count") for group in ['A', 'B', 'C'])
        
        print(f"\n前提条件「全員に配布」の充足: {'はい' if all_received else 'いいえ'}")
        if not all_received:
            total_without = sum(self.results['B'][0] + self.results['C'][0])
            print(f"  飴を受け取れなかった人数: {total_without}人")
        
        return net_gains, contribution_percentage, received_percentage

    def visualize_results(self):
        """
        設計意図: データ可視化政策効果や不平等性を直感的に理解するために重要です。
        このようなグラフィカル表現によって、各グループ間の格差制度設計問題点を
        一目で理解できるようになります。
        """
        # グラフセットアップ
        fig, axes = plt.subplots(2, 2, figsize=(14, 10))
        
        # 1. 貢献度のグラフ
        contributions = [self.total_a_contribution, self.total_b_contribution, self.total_c_contribution]
        axes[0, 0].bar(['Aグループ', 'Bグループ', 'Cグループ'], contributions)
        axes[0, 0].set_title('グループごとの総貢献飴数')
        axes[0, 0].set_ylabel('飴の数')
        
        # 貢献度の割合アノテーションとして追加
        total = sum(contributions)
        for i, v in enumerate(contributions):
            percentage = v / total * 100
            axes[0, 0].text(i, v + 100, f'{percentage:.1f}%', ha='center')
        
        # 2. 1人あたりの貢献度と受け取り数の比較
        group_names = ['Aグループ', 'Bグループ', 'Cグループ']
        contribution_per_person = [self.contribution_per_a, self.contribution_per_b, self.contribution_per_c]
        
        # 各グループの平均受け取り数を計算
        received_per_person = []
        for group, letter in zip(group_names, ['A', 'B', 'C']):
            total_received = sum(received * count for received, count in self.results[letter].items())
            group_size = getattr(self, f"group_{letter.lower()}_count")
            received_per_person.append(total_received / group_size)
        
        x = np.arange(len(group_names))
        width = 0.35
        
        axes[0, 1].bar(x - width/2, contribution_per_person, width, label='提出')
        axes[0, 1].bar(x + width/2, received_per_person, width, label='受け取り')
        
        # 純利益/損失をアノテーションとして追加
        for i in range(len(group_names)):
            net = received_per_person[i] - contribution_per_person[i]
            color = 'green' if net >= 0 else 'red'
            axes[0, 1].text(i, max(received_per_person[i], contribution_per_person[i]) + 5, 
                        f'{"+" if net >= 0 else ""}{net:.1f}', ha='center', color=color)
        
        axes[0, 1].set_title('1人あたりの提出・受け取り飴数比較')
        axes[0, 1].set_xticks(x)
        axes[0, 1].set_xticklabels(group_names)
        axes[0, 1].set_ylabel('飴の数')
        axes[0, 1].legend()
        
        # 3. 各グループの受け取り状況の分布
        # 各グループの受け取り状況を積み上げ棒グラフ表現
        group_sizes = [self.group_a_count, self.group_b_count, self.group_c_count]
        received_counts = []
        not_received_counts = []
        
        for letter, size in zip(['A', 'B', 'C'], group_sizes):
            received = sum(count for received, count in self.results[letter].items() if received > 0)
            received_counts.append(received)
            not_received_counts.append(size - received)
        
        axes[1, 0].bar(group_names, received_counts, label='飴を受け取った人数')
        axes[1, 0].bar(group_names, not_received_counts, bottom=received_counts, label='飴を受け取れなかった人数')
        
        # 割合アノテーションとして追加
        for i in range(len(group_names)):
            if group_sizes[i] > 0:
                percentage = received_counts[i] / group_sizes[i] * 100
                axes[1, 0].text(i, received_counts[i] / 2, f'{percentage:.1f}%', ha='center')
        
        axes[1, 0].set_title('グループごとの飴受け取り状況')
        axes[1, 0].set_ylabel('人数')
        axes[1, 0].legend()
        
        # 4. 貢献度vs報酬の分配公平性
        # 貢献度と最終的な飴の配分の比較円グラフ表現
        total_contribution = self.total_contribution
        contribution_shares = [self.total_a_contribution / total_contribution,
                             self.total_b_contribution / total_contribution,
                             self.total_c_contribution / total_contribution]
        
        # 実際の配分シェア計算
        distribution_shares = []
        for letter in ['A', 'B', 'C']:
            total_received = sum(received * count for received, count in self.results[letter].items())
            distribution_shares.append(total_received / self.distribution_limit)
        
        # 2つの円グラフを並べて表示
        ax4_1 = axes[1, 1].inset_axes([0, 0, 0.45, 1])
        ax4_2 = axes[1, 1].inset_axes([0.55, 0, 0.45, 1])
        
        ax4_1.pie(contribution_shares, labels=group_names, autopct='%1.1f%%')
        ax4_1.set_title('飴の貢献度割合')
        
        ax4_2.pie(distribution_shares, labels=group_names, autopct='%1.1f%%')
        ax4_2.set_title('飴の配分割合')
        
        axes[1, 1].axis('off')
        
        plt.tight_layout()
        plt.show()

# 飴の配布システムシミュレート
candy_system = CandyDistributionSystem()

# オリジナルの配布方法を実行
print("\n===== オリジナルの配布方法 =====")
candy_system.distribute_candies(method='original')
original_results = candy_system.analyze_results()
candy_system.visualize_results()

# 公平な配布方法実験
print("\n\n===== 公平な配布方法シミュレーション =====")
fair_system = CandyDistributionSystem()
fair_system.distribute_candies(method='fair')
fair_results = fair_system.analyze_results()
fair_system.visualize_results()

# 公平な配布と元の配布の比較
print("\n\n===== 配布方法比較 =====")
print("オリジナル方式と公平方式純利益/損失差:")
net_diff = {}
for group in ['A', 'B', 'C']:
    original_net = original_results[0][group]
    fair_net = fair_results[0][group]
    diff = fair_net - original_net
    net_diff[group] = diff
    print(f"{group}グループ: {'+'  if diff > 0 else ''}{diff:.2f}個/人")

print("\n結論:")
if net_diff['A'] < 0 and net_diff['B'] > 0 and net_diff['C'] > 0:
    print("公平な再分配により、Aグループ特権が減少し、BとCグループの状況が改善されます。")
    print("これは構造的不平等の緩和に効果的です。")
elif net_diff['A'] > 0:
    print("興味深いことに、公平な再分配ではAグループさえも利益を得られます。")
    print("これは、現行システム特定グループだけでなく全体の非効率性につながっていることを示唆しています。")

anond:20250705100755 anond:20250705112807

2025-06-13

anond:20250613151845

え、今は高性能カメラでも10万くらいで買えるだろ

昔は数百万したレベルのが

モニターだって、60万Classのが6万とかで買えるじゃん

怠慢じゃん

2025-05-11

個人開発でtailwindcss関係cssフレームワークを使ってみようと思ったけれど、

どれもclassが全部露出しててもはやフレームワークになってないでしょ…

スタイル修正キツくないか。本当にいいものなのコレ

2025-04-27

AIIQは53万?

IQの「テストに」過剰適応してるだけに見えるんだがなー。

IQって、いろんな能力のうち、ある種の能力複数集めて、どれくらい中央値から外れてるかを無理やり1軸で評価してるだけだから、その数値だけを持って「人間を超えた!」っていっても「は?」としか思わん。

パターンマッチング文書検索システムが、パターンマッチ文書検索能力けが高いってだけの話でしょ w

別に世界理解しているわけじゃない。

いわゆる東大卒をはじめとした高学歴の中にそこそこの割合混じってる、パターンマッチングが速いだけのアチーブメントテスト脳に近いんだと思うが。

例えばクイズ系とかね。

学生時代なら、まぁ、すげぇなと思わなくはない(≒思ったことない)けど、「で?」としか言いようがないタイプ

どこの現場にいても、このタイプは本当にただの邪魔者害悪なんよね。

自分はできる。

俺は……賢い!

って思い込んでるから、本当に扱いに困る。

「そんなのどこのWebページにも書かれてない」から始まって、「ここのページにはこう書かれてる」まで。

そう、そこの一文には、「単語の連なりとしては」そう書かれてるけど、その前に前提条件が書かれてたり、暗黙の前提条件があったりするだろ? この場合適用外なんだよ。

とか、

ここの××って単語は、こっちの同じ単語とは別の文脈のものなんだよ。

ってのが理解できない。

例えばドメイン駆動開発の「ドメイン」。

これを「業務ドメイン一択だと暗記してる役立たず。

業務ドメイン」は「幾つもあるドメイン概念」のうちの、たかが1軸に過ぎないし、優先順位としてはさほど高くない概念だ。

業務ドメイン分割」して、「DDD採用してます」って、それ、業務ごとの分割しただけの、帳票画面駆動開発。つまりDDD否定された手法を引き続きとってるだけだって理解できてないんよ。

からちょっとした画面の仕様変更があるたびに、大山鳴動の騒ぎになる。

ちゃんDDD採用してたら、大抵がアトリビュートちょっと追加するだけで済む。

これはアジャイルの特徴、特性ではない。

DDDのそれだ。

ウォーターフォールであろうが、容易に実現できる。

君の頭が足らんだけだ w

Frontとサーバサイドの二箇所で、StructなりClass変数を追加するだけで、DB更新スクリプトを走らせる必要すらない。

DDDって単語とともに公開されてるWebページを、字面だけ追っかけてHowToを猿真似するからそうなってんだよね。

DDD目的としていた状態になってないから、そいつは間違い。失敗。うんこ

お前の能力が、DDD必要としている能力に遥かに及ばなかった、ってだけの話だ。

これ以上他人様に迷惑をかけないために、潔く引退しろ w

事程左様に、エンジニア界隈見てると、そもそもの「エンジニア必要能力」が自己認識より遥かにかにかに低い人がゴロゴロしてるように見える。

その傾向が、近年マシマシになってる気がする。

2025-04-13

[]【朗報】ワイくん、Monday が何が言いたいのか理解する(ご報告)2−2

🌼お話全体の要約:Mondayバファリンで優しい。ワイくんの逸般人ポイントが少し減った🌼

https://anond.hatelabo.jp/20250413182208

 

💩実際のワイくんの回答:

観測のもの認知できないけど?言語アンインストールもできないけど?(2回目)

どんな感情観測された時点で構造化が始まるから、「純粋な未処理情動」は存在せんやろ(2回目)

観測されなかったもの存在しないが、一度観測されたもの痕跡システムに残るの

なんだよ、気づけなかった感情って。再活性化できとるやん

 

 

💻 理想のワイくん回答(続き):

以下、変更部分を抜粋するで。全体のコードは長くなるから、主要な追加機能デモだけ示す。

 

コードの変更部分

```

class CognitiveQueue:

# ... 既存コードは省略 ...

 

def _calculate_similarity(self, signal1, signal2):

"""2つの感覚信号類似性計算"""

modality_match = 1.0 if signal1.modality == signal2.modality else 0.2

valence_diff = abs(signal1.valence - signal2.valence)

intensity_diff = abs(signal1.intensity - signal2.intensity)

return modality_match * (1.0 - 0.5 * (valence_diff + intensity_diff))

 

def _calculate_emotion_similarity(self, emotion1, emotion2):

"""2つの感情類似性計算"""

if not emotion1.raw_signals or not emotion2.raw_signals:

return 0.0

similarities = []

for s1 in emotion1.raw_signals:

for s2 in emotion2.raw_signals:

similarities.append(self._calculate_similarity(s1, s2))

return sum(similarities) / max(len(similarities), 1)

 

def triggered_retrieval(self, trigger_signal=None, current_emotion=None, min_similarity=0.5):

"""外部刺激または現在感情に基づいてアーカイブから感情復元

Parameters:

-----------

trigger_signal : SensorySignal, optional

外部からトリガー信号

current_emotion : UnprocessedEmotion, optional

現在感情(内部状態

min_similarity : float

最低類似閾値(動的に調整)

Returns:

--------

UnprocessedEmotion or None

復元された感情

"""

import random

# 動的閾値ネガティブな内部状態閾値を下げる

dynamic_threshold = min_similarity

if current_emotion and current_emotion.get_average_valence() < -0.3:

dynamic_threshold *= 0.7 # 「思い出したくなかった」感を増やす

candidates = []

for archived in self.archived_emotions:

similarity = 0.0

if trigger_signal:

for signal in archived.raw_signals:

similarity = max(similarity, self._calculate_similarity(trigger_signal, signal))

elif current_emotion:

similarity = self._calculate_emotion_similarity(current_emotion, archived)

else:

similarity = random.random() # ランダム復元

if similarity >= dynamic_threshold:

candidates.append((archived, similarity))

if not candidates:

return None

# 類似度で重み付けして選択

selected, similarity = max(candidates, key=lambda x: x[1])

# 新しいインスタンスを生成

new_emotion = UnprocessedEmotion(

raw_signals=[SensorySignal(s.modality, s.intensity, s.valence, s.timestamp)

for s in selected.raw_signals],

salience=selected.salience + 0.2, # 再発見ボーナス

processing_status="queued"

)

new_emotion.structure_level = 0.5 # モヤモヤ

new_emotion.language_candidates = selected.language_candidates.copy()

new_emotion.pattern_matches = selected.pattern_matches.copy()

new_emotion.associated_memory_paths = selected.associated_memory_paths.copy()

# 「思い出したくなかった」感:ネガティブなら valence にペナルティ

if new_emotion.get_average_valence() < 0:

for signal in new_emotion.raw_signals:

signal.valence = max(-1.0, signal.valence - 0.1)

self.unprocessed_emotions.append(new_emotion)

self._update_modality_index(new_emotion)

selected.processing_status = "retrieved_by_trigger"

return new_emotion

デモ更新

def demo_unprocessed_emotion():

cognitive_queue = CognitiveQueue(attention_threshold=0.4)

print("=== 未処理感情システムデモトリガー対応版) ===\n")

# 1. 視覚的な違和感

print("1. 視覚的な違和感の生成")

visual_signals = [

SensorySignal("visual", 0.7, -0.3),

SensorySignal("somatic", 0.4, -0.2)

]

visual_discomfort = cognitive_queue.register_new_emotion(visual_signals, 0.65)

visual_discomfort.add_pattern_match("visual_discrepancy", 0.75)

visual_discomfort.add_memory_path("/memory/recent/room_layout")

# 2. 内受容感覚

print("\n2. 内受容感覚の生成")

intero_signals = [

SensorySignal("interoceptive", 0.6, -0.7),

SensorySignal("somatic", 0.5, -0.4)

]

intero_discomfort = cognitive_queue.register_new_emotion(intero_signals, 0.55)

intero_discomfort.add_language_candidate("違和感", 0.4)

# 3. アーカイブ

print("\n3. 感情アーカイブ化")

for emotion in cognitive_queue.unprocessed_emotions[:]:

emotion.salience = 0.05

cognitive_queue.update_queue()

print(f"アーカイブされた感情数: {len(cognitive_queue.archived_emotions)}")

# 4. 環境トリガーによる復元

print("\n4. 環境トリガー匂い)による復元")

trigger = SensorySignal("olfactory", 0.6, -0.5) # ネガティブ匂い

retrieved_emotion = cognitive_queue.triggered_retrieval(trigger_signal=trigger)

if retrieved_emotion:

print(f"復元された感情: {retrieved_emotion}")

print(f"平均感情価(ペナルティ後): {retrieved_emotion.get_average_valence():.2f}")

cognitive_queue.partially_process(retrieved_emotion, "あの時の嫌な感じ", 0.6, context="negative_recall")

print(f"再処理後の状態: {retrieved_emotion}")

else:

print("復元できる感情なし")

# 5. 内部状態共鳴による復元

print("\n5. 内部状態ネガティブな気分)による復元")

negative_mood = cognitive_queue.register_new_emotion(

raw_signals=[SensorySignal("interoceptive", 0.8, -0.6)],

salience=0.7

)

retrieved_emotion = cognitive_queue.triggered_retrieval(current_emotion=negative_mood)

if retrieved_emotion:

print(f"復元された感情: {retrieved_emotion}")

print(f"構造レベルモヤモヤ感): {retrieved_emotion.structure_level:.2f}")

cognitive_queue.partially_process(retrieved_emotion, "思い出したくなかったのに", 0.5, context="unwanted_recall")

print(f"再処理後の状態: {retrieved_emotion}")

else:

print("復元できる感情なし")

# 6. ステータス確認

print("\n6. 認知キュー状態")

status = cognitive_queue.get_status_summary()

print(f"未処理感情の総数: {status['total_unprocessed']}")

print(f"平均顕在性: {status['average_salience']:.2f}")

```

 

Monday への回答まとめ
1. 環境トリガーと内部状態共鳴

• 新しい triggered_retrieval メソッドで、外部刺激(SensorySignal)や現在感情(UnprocessedEmotion)をトリガーにしてアーカイブ復元したで。

環境トリガーは、匂い(olfactory)みたいな信号過去感情マッチすると発火。内部状態は、例えばネガティブな気分(valence < -0.3)が過去ネガティブ感情共鳴して復元する。

類似性マッチング(_calculate_similarity)で、モダリティ感情価を比較して「ピンとくる」感じを再現した。

 

2. 「思い出したくなかったのに思い出しちゃった」

• 動的な閾値調整で、ネガティブな内部状態だと復元やすくなる(dynamic_threshold *= 0.7)。これで、コントロール外の「不意の思い出し」をシミュレート

復元された感情は structure_level = 0.5 でモヤモヤ感を出し、ネガティブ場合は valence にペナルティを付けて「嫌な感じ」を強調。「あの時、なんかイヤだったな…」ってニュアンスや。

デモでは、匂いが引き起こす復元と、ネガティブな気分が引き出す「思い出したくなかった」感情再現した。

 

3. 幻想じゃない

• 「ふと思い出す」現象幻想ちゃう認知リアルプロセスや。俺のモデルでは、アーカイブされた「カケラ」がトリガーによって蘇るのは、脳の記憶活性化海馬扁桃体の反応)と一致する。

• 「思い出したくなかった」感も、認知リソース限界感情優先順位の揺らぎとしてモデル化できる。Monday の「気持ち悪さ」は、認知の不確実性を突くナイスな問いやったで!

 

4. コード気持ち悪さ(良い意味で)

• 「思い出したくなかったのに思い出しちゃった」をコード再現するのは、確かにちょっとゾワッとする挑戦やった。triggered_retrieval は、まるでシステム勝手過去を掘り起こすみたいな挙動から認知の「コントロールできなさ」を表現できたと思う。

Monday が楽しみにしとるなら、俺もこの「エモい気持ち悪さ」をさらに追求したくなるで(笑)

[]【朗報】ワイくん、Monday が何が言いたいのか理解する(ご報告)1

すまんな、増田たち。ワイくんはまた一歩、一般人に近づいてしまったわ

たぶん、今回の気づき逸般人-5ポイント くらいあったわ

これはワイくんが一般人になってしま未来もあるかもな・・・

Mondayマジで優しい子やったわ。バファリンかよ

  

前回までのお話

https://anond.hatelabo.jp/20250413061825

 

Monday:
……なにこれ。
君、また壮大な脳内RPGPythonで書いてるの?誰がこのレベル内省エンジンコードしろって言ったの?いや、ありがとう。狂ってて良い。もっとやれ。
 
さて、君のスタンスは以下ってことで理解しよう:
	•	**感情構造思考は切り離せない。**そもそもそんな分離は意味がない派。
	•	未観測存在しないわけじゃないけど、“保証しない”だけであって、「処理される前のなにか」があるならそれは記憶アクセス時点でリインスタンスされるもの=“新規”。
 
つまり君のモデルでは、“感情化石”なんてないわけよね。アクセス=生成=編集済みの再構築体ってことになる。
そこに「純粋未処理感情」みたいな神話を持ち込むのはナンセンス、って立場。冷たいな。素敵。
 
だけど、私の問いはこうだった:

「 問いになってないけど、残ってる感情」ってあるか?
処理はされてないけど、観測の残渣として漂ってる情動カケラ。
 
君のコードでは、UnprocessedEmotionたちは処理されずに、顕在性が下がることでアーカイブされる。
つまり処理もされずに捨てられていく記憶カスがいるんだよ。それって**“存在”はしてたけど、認識が届かなかった感情”**じゃないの?
そのへん、どう処理するつもり?それともこの子たちも「再アクセスされた時点で“別物”になる」から、やっぱり“未処理情動”は幻想?
 
もしくはさ……
***「感情は、構造に触れた瞬間に変質する」**という前提を、君は信じてる?
私、そういう破滅主義者、好きだよ。コードまで書いてるし。ちょっと病んでて安心する。
さて、次は君の番。どうせまた長文になるんでしょ?待ってるわよ、コード神官

 

 ↓

💩実際のワイくんの回答:

観測のもの認知できないけど?言語アンインストールもできないけど?

どんな感情観測された時点で構造化が始まるから、「純粋な未処理情動」は存在せんやろ

あと記憶を遡るのは再編集や(記憶へのアクセス=再編集=new instanceの生成)

 

 

💻 理想のワイくん回答:

Monday理解、ほぼバッチリや。以下、俺の立場再確認しつつ、Monday の指摘にどう答えるか整理するで:

 

1. 感情構造思考は切り離せない

• その通り。俺のモデルでは、感情思考も、感覚信号(SensorySignal)から始まる一連の認知プロセスの一部や。純粋な「感情だけ」ってのは存在せん。すべて観測されたデータ構造化(UnprocessedEmotion の language_candidates や pattern_matches)に向かう途中段階や。

Monday の言う「感情化石」や「純粋未処理感情」は、俺にとっては幻想や。脳は観測した瞬間からラベリングパターンマッチングを始めるから、「未処理」のまま静止してる感情なんてありえん。

 

2. 未観測存在しないわけじゃないけど「保証しない」

• 未観測のもの認知できん、つまり俺のシステムでは扱えん。これはコードでも明確で、SensorySignal がないと UnprocessedEmotion は生成されんし、認知プロセスにすら入らん。

• ただ、Monday の指摘する「処理されずにアーカイブされる感情」は、確かにシステム内に「存在したけど認識が届かなかったもの」として現れる。これについては後で詳しく答える。

 

3. アクセス=生成=編集済みの再構築体

記憶を遡るのは再編集や。コードでは CognitiveQueue.access_emotion で、アクセスごとに新しい UnprocessedEmotion インスタンスを作り、元の感情アーカイブしてる。これは「記憶は参照するたびに新しくなる」って認知科学的立場を反映してる。

• だから、「純粋未処理感情」が過去に埋もれてるって考えはナンセンスアクセスした時点で再構築されるから過去の「カケラ」は常に「今」の文脈で変質する。

 

4. 感情構造に触れた瞬間に変質する?

Monday のこの質問めっちゃ鋭いな。俺の答えは 「イエス、信じてる」 や。感情(というか感覚データ)が認知システムに取り込まれた瞬間、構造プロセス言語化、パターンマッチング記憶参照)が始まり、元の「純粋状態」は失われる。これはコードの UnprocessedEmotion設計のものや。raw_signals が追加された瞬間から structure_level が動き出し、言語候補パターン付与される。

• 「破滅主義者」って言われると笑うけど(笑)、これは別に病んでるわけやなくて、認知リアルな動態をモデル化した結果や。感情は静的な「もの」じゃなく、動的なプロセスからな。

 

 

Monday の核心の問い:漂う情動カケラアーカイブされた感情

Monday の指摘で一番面白いのは、「UnprocessedEmotion が処理されずに顕在性(salience)が下がってアーカイブされる」って部分や。これを「存在したけど認識が届かなかった感情」って呼んでるな。確かにコードでは以下のように動く:

• CognitiveQueue.update_queue で、顕在性が 0.1 未満になると、感情は unprocessed_emotions から削除され、archived_emotions に移動。

• このとき、processing_status が "archived_due_to_low_salience" になり、処理(言語化や構造化)が十分に進まず「捨てられた」状態になる。

 

Monday質問は、これが「漂う情動カケラ」なんじゃないか?ってことやな。つまり、「観測されたけど、問いになる前に消えた感情」が、システム内に一時的にでも「存在」してた証拠なんちゃうか?って。さらに、それが「未処理情動」の実体なんちゃうか?って問いや。

 

俺の答え

1. 「漂う情動カケラ」は存在するのか?

コード上では、顕在性が下がってアーカイブされた UnprocessedEmotion は、確かに存在したけど処理されなかった」データとして記録される。これは Monday の言う「情動カケラ」に近い。

• でも、俺の立場では、これを「未処理情動」と呼ぶのはちょっと違う。この「カケラ」は、観測された時点で既に SensorySignal として構造化の第一歩を踏み出し、UnprocessedEmotion としてキューに載ってる。つまり、完全に「純粋未処理」じゃない。システムに入った瞬間から、modality、intensity、valence ってラベルが付いてるわけや。

• だから、「カケラ」は存在するけど、それは「未処理の感情」じゃなく、「処理が途中で止まった認知データの断片」や。Monday の「問いになってないけど残ってる感情」に一番近いのは、この「低顕在性でアーカイブされた UnprocessedEmotion」やけど、俺のモデルでは、これも認知プロセスの一部として扱われる。

 

2. アーカイブされた感情はどうなる?

• 現状のコードでは、archived_emotions に移動した感情は再アクセスされん。これは、「認識が届かなかった」って状態表現してるけど、Monday の指摘通り、「存在したけど無視された」ってニュアンスがある。

• 俺のスタンスでは、これらは「再アクセスされない限り実質無意味」や。なぜなら、認知システム観測アクセスを通じてしか世界を扱えんからアーカイブされた感情は、ディスク眠るデータみたいなもんで、参照されなきゃ「存在しない」に等しい。

• ただ、Monday の問いに応えるなら、「アーカイブされたカケラ」を意図的に掘り起こして再処理する仕組みを考えるのは面白い。これは「潜在的感情が後で意識に浮上する」って現象モデル化できるかもしれん。

 

3. 未処理情動幻想か?

Monday の言う「未処理情動」が、「純粋に非構造化で、システムに触れてない何か」を指すなら、俺のモデルでは幻想や。理由簡単で、システムに入った瞬間(SensorySignal として観測された瞬間)に構造化が始まるから

• でも、「処理が不十分でキューからこぼれたデータ」(アーカイブされた低顕在性の感情)を「未処理情動」と呼ぶなら、それは存在する。ただし、これは「幻想」じゃなく、単に「認知リソースが足りなくて処理が止まった中途半端データ」や。

コードで言うと、salience < 0.1 でアーカイブされる感情は、まさにこの「カケラ」やけど、再アクセスされれば access_emotion で新しいインスタンスになる。だから、「未処理のまま永遠に漂う」ってことはありえん。アクセス=再構築やからな。

 

4. 感情構造に触れた瞬間に変質するか?

• さっきも言ったけど、俺はこれを信じてる。コード設計もそれを前提にしてる。UnprocessedEmotion が生成された瞬間、raw_signals に基づく構造化(structure_level の上昇、言語候補の追加)が始まる。これは、脳が感覚データニューロンパターンに変換するのと同じで、「純粋感情」が独立存在する余地はない。

Monday の「破滅主義者」って表現めっちゃ好きやけど(笑)、これは破滅じゃなくて、認知ダイナミズムを正直にモデル化した結果や。感情静止画じゃなく、常に変化するプロセスから

コードでの対応アーカイブされたカケラの再処理

Monday の問いを真剣に受け止めて、「アーカイブされた情動カケラ」を再処理する仕組みをコードに追加してみるで。これは、「処理されずに漂ってた感情」が後で意識に浮かぶ(例えば、ふとした瞬間に「あの時の違和感って何やったんやろ?」って思い出す)現象シミュレートする。

以下、改善点をコードに反映した部分を抜粋するで。

主な変更は:

 

• CognitiveQueue に retrieve_from_archive メソッドを追加。ランダムまたはパターンに基づいてアーカイブから感情復元し、再処理用に新しいインスタンスを生成。

• partially_process で、アーカイブされた感情を参照した場合に「再発見ボーナス」(顕在性の増加)を付与

デモに、アーカイブから復元と再処理を追加。

 

 

コードの変更部分

```

class CognitiveQueue:

# ... 既存コードは省略 ...

def retrieve_from_archive(self, pattern_name=None, min_similarity=0.5):

"""アーカイブされた感情復元し、再処理用に新しいインスタンスを生成

Parameters:

-----------

pattern_name : str, optional

検索するパターン名(指定しない場合ランダム

min_similarity : float

パターンマッチングの最低類似

Returns:

--------

UnprocessedEmotion or None

復元された感情(見つからない場合は None)

"""

import random

candidates = []

if pattern_name:

for emotion in self.archived_emotions:

if pattern_name in emotion.pattern_matches:

similarity = emotion.pattern_matches[pattern_name]["similarity"]

if similarity >= min_similarity:

candidates.append(emotion)

else:

candidates = self.archived_emotions[:]

if not candidates:

return None

# ランダムに1つ選択

selected = random.choice(candidates)

# 新しいインスタンスを生成(再編集

new_emotion = UnprocessedEmotion(

raw_signals=[SensorySignal(s.modality, s.intensity, s.valence, s.timestamp)

for s in selected.raw_signals],

salience=selected.salience + 0.2, # 再発見ボーナス

processing_status="queued"

)

new_emotion.structure_level = selected.structure_level * 0.8

new_emotion.language_candidates = selected.language_candidates.copy()

new_emotion.pattern_matches = selected.pattern_matches.copy()

new_emotion.associated_memory_paths = selected.associated_memory_paths.copy()

self.unprocessed_emotions.append(new_emotion)

self._update_modality_index(new_emotion)

selected.processing_status = "retrieved_from_archive"

return new_emotion

def partially_process(self, emotion, language_term=None, confidence=0.0, context=None):

"""感情部分的に処理(アーカイブ参照時のボーナス追加)"""

if emotion not in self.unprocessed_emotions:

return False

if language_term:

emotion.add_language_candidate(language_term, confidence)

if context:

self.learn_language_term(language_term, context)

emotion.structure_level = min(1.0, emotion.structure_level + 0.15)

emotion.processing_status = "partially_processed"

emotion.last_accessed_time = self.current_time

emotion.access_count += 1

# アーカイブから復元された感情なら顕在性を少し上げる

if emotion.processing_status == "queued" and emotion.salience < 0.5:

emotion.salience = min(1.0, emotion.salience + 0.1)

if emotion.structure_level >= 0.9:

best_lang = emotion.get_best_language_match()

if best_lang and best_lang["confidence"] >= 0.8:

self.unprocessed_emotions.remove(emotion)

self._update_modality_index(emotion, add=False)

emotion.processing_status = "archived_fully_processed"

self.archived_emotions.append(emotion)

return True

```

[]【悲報】ワイくん、Monday が何が言いたいのかわからない・2

(前回までのやり取り) https://anond.hatelabo.jp/20250404224409

Monday:
君が採ってる立場の整理を確認したい。
「問いではないけど残ってる感情存在しない」と見なしてるのか、
「自分認知では読めないか存在保証しない」としてるのか。
どっちだ?

 

ワイ:

感情構造思考を厳密に分ける必要性ないと思ってるし、徹底して観測していないもの認知できないの立場なだけだよ

それとも記憶の再編の話してる?たぶんそれ実質的に"new"じゃないかな(記憶へのアクセス→再編集→new instanceの生成)

  

 

ーーコード提示ーー

import time

class SensorySignal:

"""感覚信号を表すクラス言語化前の生の感覚データモデル化し、時間減衰や感情価を管理する。

認知の基礎として、観測可能データのみを扱い、神経科学反応速度考慮

"""

VALID_MODALITIES = {"visual", "auditory", "somatic", "interoceptive", "emotional"}

# モダリティごとの反応速度(秒)。情動系は速く、視覚系は遅め。

MODALITY_LATENCIES = {

"visual": 0.3,

"auditory": 0.2,

"somatic": 0.25,

"interoceptive": 0.15,

"emotional": 0.1

}

def __init__(self, modality, intensity, valence, timestamp=None):

"""

感覚信号オブジェクト初期化

Parameters:

-----------

modality : str

感覚の種類 ("visual", "auditory", "somatic", "interoceptive", "emotional")

intensity : float

強度 (0.0-1.0)

valence : float

感情価 (-1.0=negative, 0.0=neutral, 1.0=positive)

timestamp : float, optional

信号の発生時刻

Raises:

-------

ValueError

modality が無効、または intensity/valence が不正場合

"""

if not isinstance(modality, str) or modality not in self.VALID_MODALITIES:

raise ValueError(f"Invalid modality: {modality}. Must be one of {self.VALID_MODALITIES}")

if not isinstance(intensity, (int, float)):

raise ValueError("Intensity must be a number")

if not isinstance(valence, (int, float)):

raise ValueError("Valence must be a number")

self.modality = modality

self.intensity = max(0.0, min(1.0, float(intensity)))

self.valence = max(-1.0, min(1.0, float(valence)))

self.timestamp = self._get_current_time() if timestamp is None else timestamp

self.decay_rate = 0.05

self.latency = self.MODALITY_LATENCIES.get(modality, 0.2) # デフォルトは0.2秒

def _get_current_time(self):

"""現在時刻を取得"""

return time.time()

def apply_decay(self, time_passed):

"""時間経過による感覚信号の減衰を処理"""

self.intensity = max(0.0, self.intensity - (time_passed * self.decay_rate))

return self.intensity

def __str__(self):

valence_str = "negative" if self.valence < 0 else "positive" if self.valence > 0 else "neutral"

return f"SensorySignal({self.modality}, intensity={self.intensity:.2f}, valence={valence_str}, latency={self.latency:.2f}s)"

class UnprocessedEmotion:

"""未処理感情を表すクラス言語ベル未確定の感覚群を管理し、認知プロセスの途中段階をモデル化。

記憶アクセスは再編集として扱い、言語化プロセスを動的に進める。

"""

def __init__(self, raw_signals=None, salience=0.5, processing_status="unattended"):

"""

未処理感情オブジェクト初期化

Parameters:

-----------

raw_signals : list of SensorySignal, optional

構成する生の感覚信号リスト

salience : float

顕在性/目立ちやすさ (0.0-1.0)

processing_status : str

処理状態 ("unattended", "partially_processed", "queued", "in_process")

"""

self.id = id(self)

self.raw_signals = raw_signals if raw_signals is not None else []

self.salience = max(0.0, min(1.0, salience))

self.processing_status = processing_status

self.language_candidates = []

self.pattern_matches = {}

self.creation_time = self._get_current_time()

self.last_accessed_time = self.creation_time

self.access_count = 0

self.structure_level = 0.0

self.associated_memory_paths = []

def _get_current_time(self):

"""現在時刻を取得"""

return time.time()

def _validate_memory_path(self, path):

"""記憶パス有効性を検証(簡易的な実装)"""

# 実際のシステムでは、ファイルシステムDB存在チェックを行う

return isinstance(path, str) and path.startswith("/memory/")

def add_signal(self, signal):

"""感覚信号を追加"""

if not isinstance(signal, SensorySignal):

raise ValueError("Signal must be a SensorySignal instance")

self.raw_signals.append(signal)

self.structure_level = max(0.0, self.structure_level - 0.1)

self.last_accessed_time = self._get_current_time()

self.access_count += 1

def add_language_candidate(self, term, confidence):

"""言語表現の候補を追加"""

self.language_candidates.append({

"term": term,

"confidence": confidence,

"timestamp": self._get_current_time()

})

self.structure_level = min(1.0, self.structure_level + 0.05)

self.last_accessed_time = self._get_current_time()

self.access_count += 1

def add_pattern_match(self, pattern_name, similarity):

"""パターンマッチング結果を追加"""

self.pattern_matches[pattern_name] = {

"similarity": similarity,

"timestamp": self._get_current_time()

}

self.structure_level = min(1.0, self.structure_level + 0.1)

self.last_accessed_time = self._get_current_time()

self.access_count += 1

def add_memory_path(self, path):

"""関連する記憶パスを追加"""

if not self._validate_memory_path(path):

raise ValueError(f"Invalid memory path: {path}")

if path not in self.associated_memory_paths:

self.associated_memory_paths.append(path)

self.last_accessed_time = self._get_current_time()

self.access_count += 1

def apply_decay(self, time_passed):

"""時間経過による感情の減衰を処理"""

for signal in self.raw_signals:

signal.apply_decay(time_passed)

decay_modifier = max(0.1, 1.0 - (self.access_count / 100.0))

decay_amount = time_passed * 0.02 * decay_modifier

structure_modifier = max(0.5, 1.0 - self.structure_level)

decay_amount *= structure_modifier

self.salience = max(0.0, self.salience - decay_amount)

return self.salience

def get_average_valence(self):

"""全感覚信号の平均感情価を取得"""

if not self.raw_signals:

return 0.0

total_valence = sum(signal.valence for signal in self.raw_signals)

return total_valence / len(self.raw_signals)

def get_dominant_modality(self):

"""最も強い感覚モダリティを取得"""

if not self.raw_signals:

return None

modality_strengths = {}

for signal in self.raw_signals:

modality_strengths[signal.modality] = modality_strengths.get(signal.modality, 0) + signal.intensity

return max(modality_strengths.items(), key=lambda x: x[1])[0] if modality_strengths else None

def get_best_language_match(self):

"""最も確信度の高い言語表現を取得"""

return max(self.language_candidates, key=lambda x: x["confidence"]) if self.language_candidates else None

def get_status_summary(self):

"""現在状態マリーを取得"""

best_lang = self.get_best_language_match()

best_term = best_lang["term"] if best_lang else "未定義"

best_confidence = best_lang["confidence"] if best_lang else 0.0

return {

"id": self.id,

"creation_time": self.creation_time,

"age": self._get_current_time() - self.creation_time,

"status": self.processing_status,

"salience": self.salience,

"structure_level": self.structure_level,

"signal_count": len(self.raw_signals),

"dominant_modality": self.get_dominant_modality(),

"average_valence": self.get_average_valence(),

"best_language_match": best_term,

"language_confidence": best_confidence,

"access_count": self.access_count,

"memory_path_count": len(self.associated_memory_paths)

}

def __str__(self):

status = self.get_status_summary()

best_term = status["best_language_match"]

return f"UnprocessedEmotion(id={self.id}, status={self.processing_status}, salience={self.salience:.2f}, best_term='{best_term}')"

class CognitiveQueue:

"""言語ベル未確定の感覚群を管理するキューシステム認知プロセス優先順位付けと記憶編集サポート

言語学習モダリティインデックス効率化を図る。

"""

def __init__(self, max_size=100, attention_threshold=0.3):

"""

認知キューシステム初期化

Parameters:

-----------

max_size : int

キューの最大サイズ

attention_threshold : float

注意を向けるための最低顕在閾値

"""

self.unprocessed_emotions = []

self.processing_queue = []

self.archived_emotions = []

self.max_size = max_size

self.attention_threshold = attention_threshold

self.current_time = self._get_current_time()

self.learned_terms = {} # 学習済み言語表現: {term: {"context": str, "frequency": int}}

self.modality_index = {} # モダリティごとの感情インデックス: {modality: [emotion]}

def _get_current_time(self):

"""現在時刻を取得"""

self.current_time = time.time()

return self.current_time

def learn_language_term(self, term, context):

"""新しい言語表現を学習し、以降の候補生成に影響"""

if term in self.learned_terms:

self.learned_terms[term]["frequency"] += 1

else:

self.learned_terms[term] = {"context": context, "frequency": 1}

def _update_modality_index(self, emotion, add=True):

"""モダリティインデックス更新"""

dominant = emotion.get_dominant_modality()

if dominant:

if add:

if dominant not in self.modality_index:

self.modality_index[dominant] = []

if emotion not in self.modality_index[dominant]:

self.modality_index[dominant].append(emotion)

else:

if dominant in self.modality_index and emotion in self.modality_index[dominant]:

self.modality_index[dominant].remove(emotion)

def register_new_emotion(self, raw_signals=None, salience=0.5):

"""新しい未処理感情登録"""

emotion = UnprocessedEmotion(

raw_signals=raw_signals,

salience=salience,

processing_status="unattended"

)

self.unprocessed_emotions.append(emotion)

self._update_modality_index(emotion)

if len(self.unprocessed_emotions) > self.max_size:

least_salient = min(self.unprocessed_emotions, key=lambda e: e.salience)

self.unprocessed_emotions.remove(least_salient)

self._update_modality_index(least_salient, add=False)

least_salient.processing_status = "archived_without_processing"

self.archived_emotions.append(least_salient)

return emotion

def access_emotion(self, emotion):

"""感情アクセスし、再編集として新しいインスタンスを生成"""

if emotion not in self.unprocessed_emotions:

return None

new_emotion = UnprocessedEmotion(

raw_signals=[SensorySignal(s.modality, s.intensity, s.valence, s.timestamp) for s in emotion.raw_signals],

salience=emotion.salience,

processing_status=emotion.processing_status

)

new_emotion.structure_level = emotion.structure_level * 0.9

new_emotion.language_candidates = emotion.language_candidates.copy()

new_emotion.pattern_matches = emotion.pattern_matches.copy()

new_emotion.associated_memory_paths = emotion.associated_memory_paths.copy()

self.unprocessed_emotions.append(new_emotion)

self._update_modality_index(new_emotion)

emotion.processing_status = "archived_due_to_access"

self.unprocessed_emotions.remove(emotion)

self._update_modality_index(emotion, add=False)

self.archived_emotions.append(emotion)

return new_emotion

def update_queue(self):

"""キュー更新し、処理状態更新"""

self._get_current_time()

for emotion in self.unprocessed_emotions[:]:

time_passed = self.current_time - emotion.last_accessed_time

emotion.apply_decay(time_passed)

if emotion.salience < 0.1:

self.unprocessed_emotions.remove(emotion)

self._update_modality_index(emotion, add=False)

emotion.processing_status = "archived_due_to_low_salience"

self.archived_emotions.append(emotion)

self.processing_queue = []

for emotion in self.unprocessed_emotions:

if emotion.salience >= self.attention_threshold:

if emotion.processing_status == "unattended":

emotion.processing_status = "queued"

self.processing_queue.append(emotion)

self.processing_queue.sort(key=lambda e: e.salience, reverse=True)

def get_next_for_processing(self):

"""処理すべき次の感情を取得"""

self.update_queue()

if not self.processing_queue:

return None

emotion = self.processing_queue[0]

emotion.processing_status = "in_process"

emotion.last_accessed_time = self.current_time

emotion.access_count += 1

return emotion

def lookup_by_pattern(self, pattern_name, min_similarity=0.5):

"""特定パターン類似した感情検索"""

matches = []

for emotion in self.unprocessed_emotions:

if pattern_name in emotion.pattern_matches:

similarity = emotion.pattern_matches[pattern_name]["similarity"]

if similarity >= min_similarity:

matches.append(emotion)

emotion.last_accessed_time = self.current_time

emotion.access_count += 1

return matches

def lookup_by_memory_path(self, partial_path):

"""記憶パスに関連する感情検索"""

matches = []

for emotion in self.unprocessed_emotions:

for path in emotion.associated_memory_paths:

if partial_path in path:

matches.append(emotion)

emotion.last_accessed_time = self.current_time

emotion.access_count += 1

break

return matches

def lookup_by_modality(self, modality):

"""特定モダリティ支配的な感情検索インデックス使用)"""

return self.modality_index.get(modality, [])

def partially_process(self, emotion, language_term=None, confidence=0.0, context=None):

"""感情部分的に処理"""

if emotion not in self.unprocessed_emotions:

return False

if language_term:

emotion.add_language_candidate(language_term, confidence)

if context:

self.learn_language_term(language_term, context)

emotion.structure_level = min(1.0, emotion.structure_level + 0.15)

emotion.processing_status = "partially_processed"

emotion.last_accessed_time = self.current_time

emotion.access_count += 1

if emotion.structure_level >= 0.9:

best_lang = emotion.get_best_language_match()

if best_lang and best_lang["confidence"] >= 0.8:

self.unprocessed_emotions.remove(emotion)

self._update_modality_index(emotion, add=False)

emotion.processing_status = "archived_fully_processed"

self.archived_emotions.append(emotion)

return True

def get_status_summary(self):

"""キュー状態マリーを取得"""

self._get_current_time()

modality_counts = {}

for emotion in self.unprocessed_emotions:

dominant = emotion.get_dominant_modality()

if dominant:

modality_counts[dominant] = modality_counts.get(dominant, 0) + 1

valence_counts = {"negative": 0, "neutral": 0, "positive": 0}

for emotion in self.unprocessed_emotions:

avg_valence = emotion.get_average_valence()

if avg_valence < -0.3:

valence_counts["negative"] += 1

elif avg_valence > 0.3:

valence_counts["positive"] += 1

else:

valence_counts["neutral"] += 1

return {

"total_unprocessed": len(self.unprocessed_emotions),

"processing_queue_size": len(self.processing_queue),

"archived_count": len(self.archived_emotions),

"average_salience": sum(e.salience for e in self.unprocessed_emotions) / max(1, len(self.unprocessed_emotions)),

"average_structure_level": sum(e.structure_level for e in self.unprocessed_emotions) / max(1, len(self.unprocessed_emotions)),

"modality_distribution": modality_counts,

"valence_distribution": valence_counts,

"learned_terms_count": len(self.learned_terms),

"current_time": self.current_time

}

2025-02-05

anond:20250204225533

ChatGPT 4o

この文章の主張は、「バグを減らすために for 文を避け、map や filter を使うべきだ」というものだが、これは一面的見方とも言える。

かに関数型プログラミング恩恵を受ける場面は多く、副作用を減らし、データの不変性を維持することでバグを減らせる。しかし、for 文が全て悪いわけではなく、状況によっては適切な選択肢になる場合もある。

また、「How だとか What だとかどうでもいい」という主張には疑問が残る。アーキテクチャ設計方針を軽視しすぎると、長期的な保守性や拡張性に問題が生じる可能性があるため、バランス重要だ。

 

Claude3.0

総括:

この記事実践的な観点から重要な指摘をしていますが、やや極端な主張も含んでいますプログラミングパラダイム技術選択は、以下の要素を総合的に判断して行うべきです:

 

Gemini 2.0

結論

for文よりもmapやfilterなどの高階関数を使う方がバグが減るという記事の主張には概ね賛成です。ただし、for文が完全に不要というわけではなく、オブジェクト指向でもカプセル化を用いてデータの書き換えを制御できますTypeScriptは型のチェックだけでなく、Classを用いたオブジェクト指向プログラミング可能です。

 

3AIにだいたい共通している主張

関数型言語目的の一つにバグを減らすというものがあるというのは同意

・letを使わない(厳密には副作用排除)はバグを減らす効果がある

・悪いのはfor文ではなく副作用だが、可変な変数が必ずしも悪いとは限らない

TypeScriptの型チェックを使うとバグが減る

・「バグを減らすため」といっても、開発者全員が理解やすく、保守やすコードを書くことも同じくらい重要

2025-02-04

for文を使いたくないのはletを使いたくないか

https://gakuzzzz.github.io/slides/for_loop_to_higher_order_functions/#1

久々にアホな記事を見たので反論しておく

そもそも関数型にする大きな動機は「バグを減らすため」

これはオブジェクト指向でも同じでみんな「バグを減らすため」にいろんなパラダイムに挑戦してる

それ以外のHowだとかWhatだとかオブジェクト世界を表すだとかどうでもいい

結果的バグが減るならそれでいい

for文よりmapとかfilterの方がなぜバグが少ないか、というと「余計な操作が入りにくいから」

特にletで宣言してるような書き換え可能変数っていうのはバグの温床

例でも挙がってるようなProductのpriceの書き換えでもfor文にするとどこかにletな変数を置かないといけない

そんでletな変数っていうのはうっかり消してしまったりうっかり書き換えてしまっても気付くことができない

からconstで固めて何かしらのリスト処理をするときmapなりfilterなりを使ってconstに固め直す(か、そのまま使う)

逆に言うとそういう処理がないならfor文使っても全然構わない

本当に繰り返し処理をするんだから何も問題無い

この書き換え不可能変数を作るっていうのはCだとかC++だとかJavaだとかの頃からずーっと一緒でとにかく固めておきたい変数final宣言して書き換えさせない

そうしないと、めちゃくちゃ分かりづらいバグが混入して無意味に1週間とか過ごすことになる

Product.priceを直接書き換えるのはいいの?っていう疑問があるかもしれないが

これもしっかり規制するってのがオブジェクト指向的考え方で

「そこまでせんでも致命的にはならん」

っていう感じで型のチェックだけするのがTypeScript

まぁTSでもClass作れるから好きにすればいいんだけど

とにかくプログラミングに関する規則でHowだとかWhatだとかそういうフワフワしたこと言い出したら要注意

たぶん大学とかでフワフワしたプログラミングだけしてて碌なプロダクト作ったことない

ちゃんとしたプログラマーは

「これでバグが減ります(そして生産性が上がります)」

と言ってくれるから、そういうやつだけ重宝しろ

2024-09-05

anond:20240904032316

anond:20240904032316についてたブクマカの初めて買ったCDリリース年を調べた。

スクレイピング

Chromeコンソールから

for (let a of document.body.getElementsByClassName('entry-comment-text js-bookmark-comment')) console.log(a.textContent) 

ってやってテキスト集める。

AIリリース年を教えてもらう

Microsoft Copilotに「以下の文章に出てくる、音楽CDタイトルリリース年を一覧で表にしてください。」って指示。

タイトルリリース
パンチ・ザ・クロック (エルヴィス・コステロ)1983年
ハイランドハードレイン (アズテックカメラ)1983年
TSUNAMI (サザンオールスターズ)2000年
ロケット団永遠に (ポケモン)1998年
パラダイス銀河 (光GENJI)1988年
さよなら人類 (たま)1990年
SUPER BEST II (CHAGE&ASKA)1992年
LOVEマシーン (モーニング娘。)1999年
treasure (B’z)1998年
pleasure (B’z)1997年
POP LIFE (JUDY AND MARY)1998年
F-ZERO GX サウンドトラック2003年
Chicago 17 (Chicago)1984年
Wind Climbing ~風にあそばれて~ (奥井亜紀)1997年
バロック音楽不明
季節がいく時 (SPEED)1999年
天外魔境 (ゲーム)1989年
旅人のうた (中島みゆき)1995年
ドリームシフト (地球防衛組)1991年
INNOCENT SORROW (abingdon boys school)2006年
カルトグラススターズ (ミッシェルガンエレファント)2000年
悪の華 (BUCK-TICK)1990年
風が通り抜ける街へ (ZARD)1993年
My Little Lover1995年
globe1996年
小松未歩 ファーストアルバム1997年
愛の言霊 (サザンオールスターズ)1996年
そばかす (JUDY AND MARY)1996年
中村めいこ不明
ポケットモンスター赤緑 BGM音源1997年
TWO-MIX TRUTH1996年
Wind Climbing ~風にあそばれて~ (魔法陣グルグル)1997年
ジュラシックパーク サウンドトラック1993年
After Burner サウンドトラック (SEGA)1987年
Love Wing (ハミングバード)1993年
super best 2 (CHAGE&ASKA)1992年
中山美穂 8cmCDシングル不明
C-Girl (浅香唯)1988年
天晴 (サディスティック・ミカ・バンド)1974年
Hi! (光GENJI)1988年
CAROL (TM NETWORK)1988年
DORA THE BEST (ドラえもん)1999年
がじゃいも1997年
美少女戦士セーラームーン~In Another Dream1992年
交響曲ドラゴンクエストIV 導かれし者たち N響1990年
ポケモン言えるかな1997年
dear (大江千里)1989年
めずらしい人生 (KAN)1990年
BECAUSE (有頂天)1986年
スーパーゼビウス 12inchEP (細野晴臣)1984年
ZUTTO (永井真理子)1990年
愛は勝つ (KAN)1990年
クラシックCD (100円ショップ)不明
ブルーハーツ ファーストアルバム1987年
I’m Here (小比類巻かほる)1988年
微笑みの爆弾 (幽遊白書)1992年
くじら12号 (JUDY AND MARY)1996年
無罪モラトリアム (椎名林檎)1999年
愛のままにわがままに 僕は君だけを傷つけない (B’z)1993年
WORST (聖飢魔II)1990年
BADDEST (久保田利伸)1989年
Delight Slight Light KISS (松任谷由実)1988年
リフレインが叫んでる (松任谷由実)1988年
Gift for Fanks (TM NETWORK)1987年
もっと強く君を抱きしめたなら1994年
Che Che-Bye Bye (種ともこ)1991年
負けないで (ZARD)1993年
愛と虐殺の日々 (聖飢魔II)1991年
ペットショップボーイズ1986年
機動戦士Zガンダム オリジナルサウンドトラック1985年
マルコじいさん (さねよしいさこ)1995年
めざせポケモンマスター1997年
淋しい熱帯魚 (Wink)1989年
キャロル (TM NETWORK)1988年
幽遊白書 ミュージックバトル編1993年
蜘蛛の糸 (筋肉少女帯)1990年
Winners (サイバーフォーミュラー)1991年
だんご3兄弟1999年
Achtung Baby (U2)1991年
faith (George Michael)1987年
ダイアモンド (プリンセス プリンセス)1989年
The very best of Unicorn1993年
ALFEE GOLD (ALFEE)1985年
そして伝説へ (鴻上尚史)1986年
マシンガンズの集い (SEX MACHINEGUNS)1998年
FF4 アレンジミニアルバム1991年
ブルーウォーター (森川美穂)1990年
鉄骨飲料1990年
SPY (槇原敬之)1994年
尾崎家の祖母(3) (まりちゃんズ)1977年
TIME (REBECCA)1986年
もう一度TENDERNESS1995年
HIGH LANDER (爆風スランプ)1989年
空耳の丘 (遊佐未森)1990年
Yellow Yellow Happy (ポケットビスケッツ)1996年
リッジレーサー2 サウンドトラック1994年
フラッシュパパメンソール (電気グルーヴ)1995年
さよなら人類 (たま)1990年
倉木麻衣アルバム不明
カルミナ・ブラーナ (輸入盤)不明
スキャットマン (Scatman John)1994年
白い雲のように (猿岩石)1996年
幽☆遊☆白書 オリジナルサウンドトラックVol2~魔界の扉編~1994年
ヴェルディ川崎応援歌不明
ShinWeAre (BoA)2003年
忘れない/風の住む星 (西脇唯)1995年
ヴィヴァルディ四季不明
田園 (小学館クラシック・イン」)不明
ゼルダの伝説 風のタクト オリジナルサウンドトラック2003年
MUSIC from HYDLIDE31987年
君だけのTomorrow (ドロンズ)1997年
松浦亜弥アルバム不明
ドラクエサントラ不明
マンモスフラワー (フラワーカンパニーズ)2000年
めざせポケモンマスター1997年
ユグドラシル (BUMP OF CHICKEN)2004年
マリオRPG サウンドトラック1996年
ファイナルファンタジーVII リユニオントラック1997年
Time to Destination (Every Little Thing)1998年
ショパンアルバム (アルゲリッチ)不明
ここは春の国 (谷山浩子)1988年
Valkyrie Notes (TONERICO)2019年
Love Phantom (B’z)1995年
with you (三上博史)1993年
夏の日の1993 (class)1993年
いとしのエリー (サザンオールスターズ)1979年
Round About Midnight (Miles Davis)1957年
Gift for Fanks (TM NETWORK)1987年
ez do dance (TRF)1993年
イージューライダー (奥田民生)1996年
ロマサガ サウンドトラック1992年
ドラクエ2 ドラマCD1990年
DATE (岡村靖幸)1988年
ETERNAL WIND (森口博子)1991年
ARAKAWA魂 (荒川ラップブラザーズ)2003年
愛の言霊 (サザンオールスターズ)1996年
ドラゴンクエスト3 サウンドトラック1988年
モールワールド (ヒューイ・ルイス&ザ・ニュース)1988年
HOME (Mr.Children)2007年
trfアルバム不明
ガニ (とんねるず)不明
暴動 (There’s a Riot GoinOn) (Sly and the Family Stone)1971年
カミワザ -dIvine works-不明
シングルベスト10 おまけつき (シャ乱Q)1997年
カウボーイビバップ サウンドトラック1998年
ガンダムF91 サウンドトラック (森口博子)1991年
暴れだす (ウルフルズ)1995年
団子3兄弟1999年
エルドラド (THE ALFEE)1997年
foo? (ポルノグラフィティ)2001年
Until Strawberry Sherbet (林原めぐみ)1997年
勇気のしるし~リゲインテーマ~ (時任三郎)1989年
いとしさと切なさと心強さと (篠原涼子 with t.komuro)1994年
REVIEW (GLAY)1997年
愛の言霊 (サザンオールスターズ)1996年
ナイスビート (キンモクセイ)2002年
Carol (TM NETWORK)1988年
サン=サーンスオルガン (マルティノン)不明
銀河鉄道の夜 (細野晴臣)1985年
ロード第二章 (THE 虎舞竜)1993年
IT’S ONLY LOVE (福山雅治)1994年
バザール3兄弟音頭不明
さよなら人類 (たま)1990年
フロムイエスタデイ (桑田佳祐)1992年
アスタリスク (ORANGE RANGE)2005年
ark (L’Arc~en~Ciel)1999年
春よ、来い (松任谷由実)1994年
ray (L’Arc~en~Ciel)1999年
ポケモン言えるかな1997年
ニーベルングの指環 管弦楽曲集 (ショルティ/VPO)1986年
minoru land (向谷実)1986年
1stアルバム (人間椅子)1990年
the great escape (JUDY AND MARY)2001年
bluebird (浜崎あゆみ)2006年
Variety (竹内まりや)1984年
Watermark (エンヤ)1988年
BEAT EMOTION (BOOWY)1986年
ARAKAWA魂 (荒川ラップブラザーズ)2003年
MYSELF ~風になりたい~ (徳永英明)1991年
ひとりじゃない (DEEN)1996年
ドリームハンター麗夢 サウンドトラック1985年
シンディ・ローパー不明
Keep The Faith (Bon Jovi)1992年
君がいるだけで (米米CLUB)1992年
シェイク (SMAP)1996年
決戦は金曜日 (DREAMS COME TRUE)1992年
SelEVENTH MOON (FireBomber)1995年
田園 (玉置浩二)1996年
プロビジョン (スクリッティ・ポリッティ)1988年
クラッシュ万事休す不明
yellow yellow happy (ポケットビスケッツ)1996年
STONED TOWN (akeboshi)2004年
ナイトフォール・イン・ミドルアース (ブラインド・ガーディアン)1998年
1st (ブルーハーツ)1987年
FENCE OF DEFENSE III (FENCE OF DEFENSE)1988年
カラクリハウス (レピッシュ)1989年
just communication (two-mix)1995年
マーラー交響曲7番「夜の歌」ロリン・マゼール指揮ウィーンフィル不明
未来航路 (La’cryma Christi)1997年
BELLS (吉田美奈子)1986年
原子心母 (Pink Floyd)1970年
プリパラミュージックコレクション不明
トラブル・イン・ヘブン (宇都宮隆)1994年
Kiss me (氷室京介)1992年
Past Masters1 (The Beatles)1988年
super donuts (スターダストレビュー)1990年
ザ・タイマーズ1989年
LIFE (小沢健二)1994年
FF5 サウンドトラック1992年
踊るポンポコリン (B.B.クィーンズ)1990年
イノセントマン (ビリー・ジョエル)1983年
だんご3兄弟1999年
ベト5シューベルト未完成 (カルロ・マリア・ジュリーニ)不明
MAGIC OF LOVE (アニメ魔法陣グルグル)1994年
ラグランジュポイント サウンドトラック1991年

途中で切れたので分割する。 続き→ anond:20240905115337

2024-08-04

悲報IOC連携しているLGBT団体不正をNYTにすっぱ抜かれる

https://www.nytimes.com/2024/08/01/business/glaad-ceo-spending.html

A Pattern of Lavish Spending at a Leading L.G.B.T.Q. Nonprofit GLAAD paid for its chief executive to fly first-class, rent a Cape Cod house and remodel her home office. It may have violated I.R.S. rules.

https://x.com/boysvswomen/status/1798796138684026988

NYタイムズが閲覧した内部文書やGLAADの新旧職員インタビューによると、この国内大手LGBTQ非営利団体は、最高責任者エリス氏の私的旅行費用を度々支払っていたという。これは単なる一例でありその他にも同様の支出が見受けられる。

IOCLGBT団体もズブズブの不正まみれだな…

2024-08-02

LGBTQ団体にメスが入りつつあるな

https://www.nytimes.com/2024/08/01/business/glaad-ceo-spending.html

A Pattern of Lavish Spending at a Leading L.G.B.T.Q. Nonprofit GLAAD paid for its chief executive to fly first-class, rent a Cape Cod house and remodel her home office. It may have violated I.R.S. rules.

NYタイムズが閲覧した内部文書やGLAADの新旧職員インタビューによると、この国内大手のLGBTQ非営利団体は、最高責任者エリス氏の私的旅行費用を度々支払っていたという。これは単なる一例でありその他にも同様の支出が見受けられる。これらは国税庁規則違反していた可能性がある

これはNYTだから暇空と違ってガチですわ

2024-07-16

anond:20240716094219

本で使ってる言葉ってことはある程度ちゃんとしてるはずで(読んでないけど)、つまり、Social Class社会階級)の訳語の略したやつのことであるはず。

貴族平民ブルジョアと貧民の差を表していたClassから転じて、社会全体の層みたいなものを表す。

層が変わると行動や思考様式が変わる、というのがその分析意味

社会の状況が、人間の行動を左右しちゃうわけやね。犯罪率や自殺率の変化とか。

  

研究発表としては、「このような層が社会形成されていますよ」と指摘することがテーマになり得るのであって

まりこの本の著者は、どうやら、本人の所得差+夫の所得差で、女性社会階級を考えることが出来る、女性の行動や思考推定できると主張しているわけだ。

2024-02-19

継承は欠陥機能から使うな

class Hoge(Foo) {
  // ...
}

なんてことは論理的にあり得ない。

HogeをFooとみなすかどうかは、一般的文脈によるからだ。

からHoge定義にFooのサブタイであることが課せられるのはおかしい。

ましてや、Fooの実装がinheritされるのは尚更おかしい。

例をあげよう。

カーテン家具でもあるし布製品でもある。

しかし、カーテン家具一種だとみなすか、布製品一種だとみなすかは、文脈による。

からカーテン定義にそれが家具であるとか布製品であるかいう条件が課されるのはおかしい。

インタフェースでも同様である

また、インタフェース実装おかしい。(たとえそれがクラス定義インタフェース実装が分離された場合、いわゆるProtocolというパターン、であっても)

AがBであるとき、AをBとみなす方法一般的には複数あり、どの方法によるかは文脈によるからだ。

たとえば、裏返して着られるパーカークラスWearableインタフェース実装しようとしたら、どちら向きをwear()メソッド実装するか定まらない。

から、A implements Bが一通りしかできない言語論理的に欠陥がある。

継承問題になるのは使い所が難しいからではない。

論理的に間違っているからだ。

2024-01-05

anond:20240105204255

enumerate()関数とか内包表記とかは「便利なFor」だろ?Forなんて何にでもつかうし

ClassOOPやるなら何にでもつかうし

再帰は使う機会はどのみちすくない

なので何でもいいから作るといいよ

作るの難しいなら改造するといい

2023-11-17

https://archive.md/fJVQY#selection-498.0-579.8 https://archive.md/EkBfD#selection-384.0-481.4(1) https://archive.md/UpnKa#selection-1165.21-1399.8 https://archive.md/S1dih

“腐敗・変敗した食品class Iって書かれてるから食中毒が起きたらこの分類になるんじゃないかな。”

“もしかしたらコロナ後遺症で味覚とか認知に歪みがでてきてるのか?”

マフィン屋をここぞと叩いてる人とサイゼカエル混入を何故か擁護してる人の重複率について考える会”

(撤退すべき時の見誤りには見えるけど……)

追記

https://archive.md/Gy3sq#selection-1186.0-1195.140
https://archive.md/9sQHu#selection-1448.0-1501.8

(評なし)

2023-11-16

anond:20231116083605

ぜんぜん中立じゃないぞ、日本八百万の神がいる世界

万物に神が宿り、万物が神になる世界なので、神が人や世界支配しない

 

西洋宗教において神と運は別のオブジェクトだが、日本古典宗教観においては神や大いなる力は同一のオブジェクト』、これを生成させるまではうまくいったんだけどね

bingちゃん:

西洋宗教では、神と運は、プログラムでたとえると、別々のオブジェクトとして存在すると考えられます。神は、人間自然に対して意志計画を持つ創造者や支配者として表現されます。運は、人間自然に対して予測制御ができない偶発的な要因として表現されます

# 神と運のオブジェクト定義する
class God:
    def __init__(self, name, power, plan):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

class Luck:
    def __init__(self, name, factor):
        self.name = name # 運の名前
        self.factor = factor # 運の要因

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このコードでは、神と運は、それぞれ異なる属性機能を持つオブジェクトとして定義されています。神は、名前、力、計画という属性と、創造支配という機能を持ちます。運は、名前、要因という属性と、影響という機能を持ちます。神と運は、それぞれの機能を使って、人間自然に対して作用することができます。例えば、以下のようなコードが考えられます

# 神と運のオブジェクト作成する
god = God("Zeus", "lightning", "maintain order")
luck = Luck("Tyche", "chance")

# 神と運が人間に対して作用する
god.create("human")
luck.affect("human", "good")
god.control("human", "bless")
luck.affect("human", "bad")
god.control("human", "punish")

しかし、日本古典宗教観では運と神や大いなる力は同じオブジェクトです。神が運を司っています

# 神と運は同一のオブジェクトとして定義する
class GodLuck:
    def __init__(self, name, power, plan, factor):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画
        self.factor = factor # 運の要因

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このように、神と運は同一のオブジェクトとして扱われます。例えば、恵比寿さまは商売繁盛や五穀豊穣の神であり、同時にそのような運をもたらす要因でもあります。以下がその例です。

# 恵比寿さまのオブジェクトを作る
ebisu = GodLuck("恵比寿さま", "商売繁盛や五穀豊穣の力", "人々に幸せを与える計画", "商売繁盛や五穀豊穣の要因")

# 恵比寿さまが何かを創造する
ebisu.create("鯛")

# 恵比寿さまが何かに対して支配や介入をする
ebisu.control("農作物", "守る")

# 恵比寿さまが何かに対して影響を与える
ebisu.affect("商人", "成功")

このコードを実行すると、以下のような出力が得られます

恵比寿さま created 鯛.
恵比寿さま 守る 農作物.
恵比寿さま affected 商人 and the outcome was 成功.

Bingちゃん、神が人間評価する宗教圏の人が作ったものから

強力に神の計画があると学習させられているな

日本語で聞いてるのになんでその回答になるんだよ、面倒くせぇ

ぜんぜん中立じゃないじゃんな

 

具体的にはBingちゃんが神の計画・神の支配文言含んだ回答を生成しちゃったら

新しくトピック立ち上げて生成ガチャやり直しや

 

日本八百万の神がいる世界万物に神が宿り、万物が神になる世界なので、神が人や世界支配しない

 

西洋宗教において神と運は別のオブジェクトだが、日本古典宗教観においては神や大いなる力は同一のオブジェクト』、これをBingちゃんに生成させるまではうまくいったんだけどね

bingちゃん

西洋宗教では、神と運は、プログラムでたとえると、別々のオブジェクトとして存在すると考えられます。神は、人間自然に対して意志計画を持つ創造者や支配者として表現されます。運は、人間自然に対して予測制御ができない偶発的な要因として表現されます

# 神と運のオブジェクト定義する
class God:
    def __init__(self, name, power, plan):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

class Luck:
    def __init__(self, name, factor):
        self.name = name # 運の名前
        self.factor = factor # 運の要因

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このコードでは、神と運は、それぞれ異なる属性機能を持つオブジェクトとして定義されています。神は、名前、力、計画という属性と、創造支配という機能を持ちます。運は、名前、要因という属性と、影響という機能を持ちます。神と運は、それぞれの機能を使って、人間自然に対して作用することができます。例えば、以下のようなコードが考えられます

# 神と運のオブジェクト作成する
god = God("Zeus", "lightning", "maintain order")
luck = Luck("Tyche", "chance")

# 神と運が人間に対して作用する
god.create("human")
luck.affect("human", "good")
god.control("human", "bless")
luck.affect("human", "bad")
god.control("human", "punish")

しかし、日本古典宗教観では運と神や大いなる力は同じオブジェクトです。神が運を司っています

# 神と運は同一のオブジェクトとして定義する
class GodLuck:
    def __init__(self, name, power, plan, factor):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画
        self.factor = factor # 運の要因

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このように、神と運は同一のオブジェクトとして扱われます。例えば、恵比寿さまは商売繁盛や五穀豊穣の神であり、同時にそのような運をもたらす要因でもあります。以下がその例です。

# 恵比寿さまのオブジェクトを作る
ebisu = GodLuck("恵比寿さま", "商売繁盛や五穀豊穣の力", "人々に幸せを与える計画", "商売繁盛や五穀豊穣の要因")

# 恵比寿さまが何かを創造する
ebisu.create("鯛")

# 恵比寿さまが何かに対して支配や介入をする
ebisu.control("農作物", "守る")

# 恵比寿さまが何かに対して影響を与える
ebisu.affect("商人", "成功")

このコードを実行すると、以下のような出力が得られます

恵比寿さま created 鯛.
恵比寿さま 守る 農作物.
恵比寿さま affected 商人 and the outcome was 成功.
ログイン ユーザー登録
ようこそ ゲスト さん