הבלוג של ינון פרק

כמה זמן באמת לוקח לעבור מפייתון ל Java? מפייתון לרובי? האם הגיוני לגייס מפתח עם נסיון ב Rust לעבודת Java או להיפך?

נתחיל במובן מאליו - לכל אחד ייקח זמן שונה, פריימוורקים שונים בנויים אחרת ויכולים להשפיע על זמן הלמידה, יש פיצ'רים מיוחדים בשפות מסוימות שקשה ללמוד אם אתם באים משפה אחרת (כמו ניהול הזכרון של ראסט). אני רוצה להתמקד כאן במפתחים שנשארים באותו עולם לדוגמה מפתח Django שעובר ל Rails או מפתחת Rails שעוברת ל Laravel. במקרים האלה לכאורה ההבדל היחיד הוא השפה.

היום עם ה AI מאוד קל להריץ תרגום סימולטני, כלומר לתאר ל AI מה שאני צריך בשפה שאני מכיר מ Rails אולי אפילו עם דוגמת קוד רלוונטית ולהגיד לו לבנות את זה ב Django. מה זה משנה אם השפה היא רובי או פייתון, מה שחשוב שיהיה עוד נתיב, למשוך מידע מבסיס הנתונים, להריץ תהליך ברקע או לשלוח אימייל אחרי פעולת משתמש.

אבל אותו תרגום סימולטני הוא הטעות הכי גדולה של מפתחים שעוברים בין שפות. ההרגשה שזה "גג יומיים לימוד" ואפשר להיות פרודוקטיביים גורמת לנו לשאוף מאוד נמוך בהיכרות עם השפה החדשה ולא לאתגר את ה AI. בצורה כזאת אנחנו מקבלים פתרונות בסיסיים ואפילו לא מזהים שיש בעיה. יותר גרוע, בגלל השימוש הנרחב בתרגום סימולטני אנו מסתמכים על AI ואפילו לא צוברים ניסיון בשפה החדשה.

הפתרון אני חושב הוא לא בהכרח בשינוי שיטת העבודה אלא בשינוי נקודת המבט. במעבר בין שפות אנחנו לא נשארים באותה רמת מיומנות שהיינו. זה ממש בסדר להגיד הייתי מפתח פייתון מעולה ועכשיו אני מפתח רובי מתחיל. כמפתח אני עדיין מאוד מיומן, מכיר את עולם התוכן וקולט חומר חדש מהר. כמפתח רובי אני לא מכיר את האקוסיסטם מספיק טוב, אני לא מבין את ה Best Practices של השפה או של הפריימוורקס השונים, אני לא מכיר את התבניות ואת מקרי הקצה.

עדיין לא קראתי ספרים, עדיין לא ראיתי הרצאות, עדיין לא ניסיתי שיטות שונות, עדיין לא קראתי מספיק קוד של אחרים ועדיין לא דיבגתי מספיק בעיות מוזרות. בתור מפתח בשפה החדשה יש לי המון מה ללמוד ואני רק ארוויח אם אשקיע בזה במקביל לעבודה השוטפת.

הטעות של מפתחים שעוברים בין שפות היא אותה טעות שמשאירה מפתחים בינוניים גם בשפה אחת - הבחירה להיות יותר פרודוקטיביים ממקצועיים, לסיים מהר ולא ביסודיות, לייצר גרסה אחת של קוד עובד במקום להתלבט בין 5 גרסאות ולבחור את המתאימה ביותר למקרה הספציפי שלך. ללמוד לעבור בין שפות זה גם ללמוד להצטיין בשפה האחת.

את הבאג הזה מצאתי במקרה בקוד אמיתי שהשתמש בגרסה ישנה של הספריה ומאחר והוא לקח לי איזה שעתיים מהחיים חשבתי שהוא מצדיק גם פוסט. צריך להגיד ביושר שהאתגר היה להבין שיש בעיה בקומפוננטה חיצונית שבעצמה נטענה מתוך קומפוננטה חיצונית ואתם מקבלים פה רק את הצעד האחרון של האתגר.

מוכנים? הנה קוד קומפוננטת vue.js שאמורה להציג קוד צבוע אבל מתעלמת מפרמטר השפה שאני מעביר לה ותמיד מריצה זיהוי אוטומטי:

import { ref, h, computed, defineComponent, Plugin, watch } from 'vue'
import hljs from 'highlight.js/lib/core'
import { escapeHtml } from './lib/utils'

const component = defineComponent({
    props: {
        code: {
            type: String,
            required: true,
        },
        language: {
            type: String,
            default: '',
        },
        autodetect: {
            type: Boolean,
            default: true,
        },
        ignoreIllegals: {
            type: Boolean,
            default: true,
        },
    },
    setup(props) {
        const language = ref(props.language)
        watch(() => props.language, (newLanguage) => {
            language.value = newLanguage
        })

        const autodetect = computed(() => props.autodetect || !language.value)
        const cannotDetectLanguage = computed(() => !autodetect.value && !hljs.getLanguage(language.value))

        const className = computed((): string => {
            if (cannotDetectLanguage.value) {
                return ''
            } else {
                return `hljs ${language.value}`
            }
        })

        const highlightedCode = computed((): string => {
            // No idea what language to use, return raw code
            if (cannotDetectLanguage.value) {
                console.warn(`The language "${language.value}" you specified could not be found.`)
                return escapeHtml(props.code)
            }

            if (autodetect.value) {
                const result = hljs.highlightAuto(props.code)
                language.value = result.language ?? ''
                return result.value
            } else {
                const result = hljs.highlight(props.code, {
                    language: language.value,
                    ignoreIllegals: props.ignoreIllegals,
                })
                return result.value
            }
        })

        return {
            className,
            highlightedCode,
        }
    },
    render() {
        return h('pre', {}, [
            h('code', {
                class: this.className,
                innerHTML: this.highlightedCode,
            }),
        ])
    },
})

const plugin: Plugin & { component: typeof component } = {
    install(app) {
        app.component('highlightjs', component)
    },
    component,
}

export default plugin

רואים את הבעיה? התשובה בשורה 30:

const autodetect = computed(() => props.autodetect || !language.value)

הקוד מוגדר לבצע זיהוי אוטומטי ולהתעלם ממאפיין השפה אם לא העברנו שפה (הגיוני) או אם המאפיין autodetect בעל ערך אמת. החלק השני היה יכול להיות סביר אלמלא אמת היתה ברירת המחדל למאפיין זה:

autodetect: {
    type: Boolean,
    default: true,
},

כלומר אם אני לא מעביר ערך false בצורה מפורשת לאותו autodetect ברירת המחדל שלו היא לזהות לבד את השפה ולהתעלם מערך ה language שהעברתי.

הסיבה שאני נתקעתי על הסיפור הזה יותר מדי זמן היא דף התיעוד של הספריה שמציג את הדוגמה הבאה:

<div id="app">
    <!-- bind to a data property named `code` -->
    <highlightjs autodetect :code="code" />
    <!-- or literal code works as well -->
    <highlightjs language='javascript' code="var x = 5;" />
</div>

שכמובן עובדת רק בגלל ש highlightjs מצליח לזהות אוטומטית בדיוק את אותה שפת javascript שמוגדרת ב language.

עכשיו תשאלו - אין לך איזה קלוד חכם בצוות שידע להסביר בדיוק את הבאג הזה? נו, יש קלוד חכם והוא הצליח להציע המון רעיונות מקוריים ולא נכונים. מסתבר שגם הוא לא חשב שתיעוד יכול להטעות ובאגים יכולים לקרות בספריות חיצוניות.

טריוי סורק את הפרויקטים שלכם כדי לבדוק שאין בעיות אבטחה. כמובן שכלי אבטחה הם מטרה מאוד מפתה לפורצים ולאחרונה למדנו שפורצים הצליחו להשיג את מפתחות הגישה של טריוי ולפרסם בשמם גרסאות מזויפות. הפרטים כאן:

https://github.com/aquasecurity/trivy/security/advisories/GHSA-69fq-xp46-6x23

מה שמעניין בסיפור הוא לא מי שנפגע אלא מי שלא נפגע. מתוך הדיווח אנחנו לומדים שלא נפגעו מי שהשתמשו ב trivy images referenced by digest - אבל מה זה אומר? ולמה גרסאות ה digest היו חסינות?

מאגר החבילות של טריוי מכיל את רשימת האימג'ים שהם פרסמו עם תגיות כמו canary, latest, 0.69.3 ותגיות ארוכות יותר שמתחילות ב sha256 כמו sha256:b39e145284f15252b2135abe0e24509d7ad2459d28c18f014e478c6ca0aee533.

כשאנחנו מריצים docker run aquasec/trivy אנחנו מריצים את הגרסה שיש עליה את התג latest. ואם נריץ docker run aquasec/trivy:canary נריץ את הגרסה המתויגת canary. וכמו שבטח הבנתם אם נפעיל:

docker run ghcr.io/aquasecurity/trivy:sha256-bcc376de8d77cfe086a917230e818dc9f8528e3c852f7b1aff648949b6258d1c

נריץ את הגרסה עם התג הארוך.

התגים הארוכים שמתחילים ב sha256 נקראים digest. גיטהאב מחשב אותם אוטומטית מתוך תוכן החבילה ולא ניתן ליצור אותם בצורה יזומה. כל שאר התגיות נועדו להיות "מדבקות", כלומר מזהים גמישים שאפשר להדביק על גרסה ואז להזיז לגרסה אחרת. זה הגיוני כשחושבים על תג כמו latest - כל פעם שיש לנו גרסה עדכנית חדשה אנחנו מזיזים את latest לגרסה החדשה.

כך ברור שהתוקפים שהשתלטו על פרטי ההזדהות של טריוי הצליחו בקלות לפרסם גרסאות זדוניות של המערכת ולדחוף תגיות כמו latest, canary וגם v0.69.4. אפילו שגרסאות כאלה כבר היו קיימות, כל מה שצריך זה לדחוף עדכון לתגים אלה כדי לדרוס את הסימון. מצד שני לא משנה מה יעשו התוקפים הם לא יצליחו להזיז את סימוני ה digest כי בשביל זה צריך ליצור גרסה זדונית שתוכנה ייתן את אותה תוצאת sha256 וזה כבר סיפור הרבה יותר מאתגר.

לקחים? לא משהו גדול, רק עוד מבט על המרחק בין אבטחת מידע לנוחות שימוש. אני יודע שבבלוגוספירה, במדריכים ואפילו בצ'אט תמיד נקבל את הגרסה הקלה לעיכול, אבל אל תשכחו שבפרודקשן הרבה אנשים כן משתמשים בגרסאות מקובעות של התלויות שלהם, בדיוק בשביל להימנע מכאבי ראש כאלה.

כמה תקלות שתיקנתי ללקוחות בתקופה האחרונה, כולן בקטגוריית "זה עבד לפני חודש ומאז לא נגענו"-

1. שינוי תשתית אצל ספק Third Party גרם לקוד הרגיל שלנו להפסיק לעבוד ודרש עדכון תוכנה מהצד שלנו כדי להתאים למנגנון החדש.

2. דיסק גיבוי שנגמר בו המקום גרם להשתלשלות אירועים מצערת שבסופה מערכת הפסיקה להגיב.

3. פג תוקף תעודה בחתימה עצמית שהופקה במקור לשנתיים. כן גם שנתיים עוברות בסוף, מה שהפיל את כל הקלאסטר.

4. ג'וב סינכרון בין בסיסי נתונים ש"אני בטוח שהיה שם" פשוט נעלם. הסינכרון הפסיק וממילא כולם כבר שכחו מהרפליקה עד שמישהו היה צריך דוח אנאליטיקס שיצא עם נתונים לא נכונים.

עכשיו יש סיפור כאילו סוכנים חכמים תכף הולכים לתפוס את כל מקומות העבודה של מהנדסי תוכנה ואנשי פרודקט שלא מבינים רק יכתבו פרומפטים כל היום. בכל אחד מארבעת האירועים ברשימה ה AI התחיל להיות מועיל רק אחרי שהבנתי מה מקור התקלה. בכל אחד מהאירועים אף מודל מהמודלים המובילים היום לא היה מסוגל לייצר תוכנית פעולה כדי להוריד את הסיכון להישנות תקלה כזו בפעם הבאה או לשפר את זמני התגובה שלנו כשזה קורה.

צ'אט ג'יפיטי הגדיל לעשות באחת השיחות מלאות התסכול שהיו לי איתו והציע לי להתייעץ עם איש DevOps. לך תסביר לו שאתה ה DevOps. אם יש משהו שהפער בין מהנדסי תוכנה לסוכני קידוד מלמד אותנו הוא שמהנדסי תוכנה לא הולכים לשום מקום.

נ.ב. דברים שנשברים פתאום הם תולדה של בעיה במערכת. הם לא נשברו פתאום זה תמיד היה שבור אבל עכשיו רק שמנו לב לזה כי היה פיצוץ. "איך הקוד הזה יישבר" היא עדיין השאלה הכי חשובה למפתחים על כל קוד שאנחנו כותבים.

מרגע המצאת פרוטוקול MCP הוא התפשט כאש בשדה קוצים. כל מוצר, כל יצרן, כל API הרגיש שהוא חייב להפיץ MCP כדי שכלי AI יוכלו להתחבר לאותו המוצר. אז יש לנו MCP של ג'ירה בעזרתו המודל יכול לקרוא טיקטים, ו MCP של פיגמה בעזרתו המודל יכול לקרוא את העיצובים וגם MCP של פליירייט איתו אפשר לשלוט בדפדפן ועוד אינסוף אפשרויות. MCP הוא בסך הכל אוסף "כלים", כלומר אוסף של פקודות שהמודל יכול להפעיל. לכל פקודה יש תיאור משלה ודרך הפעלה משלה. דוגמאות לפקודות שמגיעות מ MCP יהיו "קרא קובץ מריפו בגיט", "שכפל את הריפו המרוחק", "הפעל דפדפן וגלוש לכתובת מסוימת", "החזר רשימה של האוביקטים בפריים מסוים".

חסרון אחד של MCP הוא שהרבה אנשים התקינו אותם אבל מעט אנשים כתבו אותם. זה היה יותר סיפור תרבותי מאשר מגבלה טכנולוגית כי באמת שלא מסובך לכתוב שרתי MCP אבל זה היה המצב. חסרון שני של MCP היה שכל MCP שאני מתקין "תופס מקום" בחלון הקונטקסט של המודל ולכן בתחילת כל שיחה היינו צריכים לבחור באיזה שרתי MCP אנחנו מסכימים להשתמש בשיחה זו.

מנגנון חלופי שצובר תאוצה ועוזר לפתור בעיה דומה נקרא Skills. בניגוד ל MCP, ה Skill הוא מודולרי. המודל מקבל תיאור כללי של ה Skill ומחליט לבד אם לטעון אותו או לא, כלומר טעינת ה Skill היא הפעלת כלי שהמודל יוזם. הבדל נוסף מ MCP הוא ש Skill הוא הרבה יותר חופשי - אני כותב את התיאור בקבצי Markdown ואת הקוד בקבצי סקריפט באיזה פורמט שאני בוחר. התוצאה היא שהרבה יותר קל לכתוב Skill וגם לקרוא את הקוד שלו.

דוגמה? בטח. בואו ניתן למודל שלנו אופציה לחפש ב npm חבילות הרחבה. ה Skill מורכב בסך הכל מקובץ הוראות ומסקריפט חיפוש אותם אני שם בתיקייה עם שם מיוחד בתיקיית הבית.

נפתח תיקיה חדשה ~/.claude/skills:

mkdir -p ~/.claude/skills/npm-search

בתוך התיקייה אני יוצר קובץ בשם SKILL.md עם התוכן הבא:

  ---
  name: npm-search
  description: Use this skill whenever implementing a feature or adding functionality to a JavaScript/TypeScript/Node.js project. Before writing custom code, always run npm search to find existing libraries that can solve the problem. This prevents reinventing the wheel and leverages the npm ecosystem.
  ---

  # NPM Search Guide

  ## Overview

  Before implementing any feature in a JavaScript/TypeScript/Node.js project, search npm for existing libraries that can solve the problem. This ensures you leverage the ecosystem rather than reinventing the wheel.

  ## When to Search npm

  Use npm search before implementing:
  - Data processing or transformation utilities
  - HTTP clients or API helpers
  - Date/time manipulation
  - Validation libraries
  - Authentication/authorization
  - File handling (CSV, JSON, XML, PDF, etc.)
  - Database connectors
  - Testing utilities
  - UI components (for frontend projects)
  - Any common utility or pattern

  ## Running npm Search

  Use the provided script to search for packages:

  ```bash
  ./scripts/npm-search.sh <search-term>

Or run directly: bash npm search

### Example Searches

  # Looking for a date library
  ./scripts/npm-search.sh date format manipulate

  # Looking for a validation library
  ./scripts/npm-search.sh schema validation zod joi

  # Looking for an HTTP client
  ./scripts/npm-search.sh http client axios fetch

  # Looking for a CSV parser
  ./scripts/npm-search.sh csv parse stream

## Evaluating Packages

When reviewing search results, consider:

1. Downloads: Higher weekly downloads indicate community trust
2. Version: Recent versions suggest active maintenance
3. Description: Clear descriptions indicate well-documented packages
4. Dependencies: Fewer dependencies mean smaller bundle size

## Installation

Once you've identified a suitable package:

  npm install <package-name>
  # or
  pnpm add <package-name>
  # or
  yarn add <package-name>

## Implementation

After installation, read the package's README or documentation before using it. Look for: - Basic usage examples - Configuration options - Common patterns and best practices ```

נשים לב שרק החלק העליון של המארקדאון נטען כברירת מחדל לקלוד קוד. רק אם המודל יחליט לטעון את הסקיל הוא יקרא את הקובץ המלא.

לסיום אני יוצר סקריפט בשם scripts/npm-search.sh בתוך אותה תיקייה עם התוכן הבא:

#!/bin/bash
# npm-search.sh - Search npm for packages
# Usage: ./scripts/npm-search.sh <search-terms>

if [ $# -eq 0 ]; then
    echo "Usage: $0 <search-terms>"
    echo "Example: $0 date format manipulate"
    echo "         $0 csv parse stream"
    exit 1
fi

SEARCH_QUERY="$*"

echo "🔍 Searching npm for: $SEARCH_QUERY"
echo "----------------------------------------"

npm search "$SEARCH_QUERY"

וזה הכל. עכשיו כשאני אבקש מקלוד קוד לממש פיצ'ר בפרויקט ווב הוא יחפש קודם ב npm search אם קיימת חבילה ואם ימצא חבילה רלוונטית הוא ישתמש בה.

סך הכל הסקיל מורכב משני הקבצים:

ynonp@ynons-MacBook-Air ~/.claude/skills/npm-search (main?) $ tree
.
├── scripts
│   └── npm-search.sh
└── SKILL.md

2 directories, 2 files

שיפור לעומת MCP? בהחלט:

1. קל יותר לכתיבה - כל הטקסטים יושבים בקובץ markdown מסודר במקום בתיאור של tool-ים. סקריפטים יכולים להיכתב בכל שפה ואפילו אפשר לשלב מספר שפות.

2. חוסך מקום בחלון הקונטקסט - הטקסטים נטענים לפי דרישה ובצורה דינמית, וכמובן אתם יכולים לטעון אותם גם בצורה יזומה באמצעות פקודת / ושם הסקיל במקרה שלנו /npm-search.

אפשר למצוא עוד דוגמאות לסקילים בריפו של אנטרופיק כאן:

https://github.com/anthropics/skills

או במאגר הסקילים של קודקס:

https://github.com/openai/skills/tree/main/skills/.curated

אגב מבחינת ראנרים אחרים אז גם קופיילוט וגם opencode יקראו סקילז מאותה תיקיית ~/.claude/skills. קודקס יחפש אותם ב ~/.codex/skills.

ספריות קוד פתוח תמיד היוו מעין קרש קפיצה מהיר לפיתוח. צריך תיבת בחירה יפה עם חיפוש ובחירה מרובה? יש קומפוננטה לזה. צריך להוריד קבצים מהאינטרנט עם אופציה להזדהות וטיפול בנסיונות חוזרים? יש ספריה לזה.

אני עדיין משתמש בספריות קוד פתוח, אבל הרבה פחות. ככל שיותר קוד נכתב על ידי סוכני קידוד הסוכן משתמש בספריות שהוא "מכיר" או "מעדיף", ומקודד מאפס את הרכיבים שהוא לא מכיר. שימוש בספריית קוד פתוח בפרויקט אומר שסוכן הקידוד צריך להתאמץ יותר בשביל לבנות את הפיצ'ר הבא או לתקן באג. ככל שהספריה פחות מתועדת או פופולרית לסוכן יהיה יותר קשה לעבוד איתה וכל שינוי ידרוש העמסה של תיעוד רלוונטי לתוך חלון הקונטקסט.

מה הפסדנו פה? אני לא בטוח. שלחתי את לאבבל לבנות לי משחק תרגול צלילים בגיטרה. זה כאן אם אתם רוצים לנסות. המעניין שם זה שאת צוואר הגיטרה לאבבל צייר לבד באמצעות SVG. בעולם הישן ציור צוואר גיטרה ב SVG היה בעיניי האופציה האחרונה. קודם הייתי מחפש ספריית קוד פתוח ובמקרה הגרוע מצייר את זה ב HTML ו CSS. הסוכן יצר קומפוננטה של גיטרה שנראית ממש אחלה ועובדת עבור המשחק לא פחות טוב מ react-fretboard או react-guitar, עם קוד ציור יפה ב SVG. אפשר לראות את הקוד שלו כאן:

https://github.com/ynonp/fret-play-learn/blob/main/src/components/GuitarFretboard.tsx

המשחק היותר משמעותי בפרידה מספריות קוד פתוח הוא השאלה "מי יתחזק את זה?". גם כאן אין לי דעה חד משמעית. מצד אחד כשהעולם משתנה ומתגלות בעיות אבטחה נוח שיש אנשים אחרים שמתחזקים את ספריית הקוד הפתוח האהובה עליי ומעלים גרסה חדשה וטובה יותר. מצד שני הרבה מהשדרוגים בספריות קוד פתוח הם תוספת של פיצ'רים שאני לא צריך ויוצא שאני מבזבז זמן על התאמות לממשק של גרסה חדשה שבכלל לא ביקשתי.

בינתיים דוגמת הקומפוננטה של הגיטרה לימדה אותי שמאוד נוח כשהסוכן בונה מאפס את הרכיב המדויק שאני צריך. כן כדאי להקפיד לבקש מהסוכן כשצריך שישים לב כשיש קומפוננטה לשימוש חוזר ויבנה אותה בצד בתור קומפוננטה נפרדת. בפיתוחים חדשים ובמצב תכנון הוא יראה את זה לבד. בתיקוני באגים הרבה יותר קשה לו לשים לב.

חבילת httpx בפייתון היא סוג של הדור הבא של requests עם תיעוד יותר מעודכן ותמיכה בכתיבה אסינכרונית. בואו נראה איך זה עובד דרך תוכנית קצרה וגם נשווה זמנים בין גרסה טורית, מקבילית ואסינכרונית.

בשביל הדוגמה לקחתי 4 ספרים מפרויקט גטנברג ובניתי 4 פונקציות שמורידות את ארבעת הספרים, כל אחת בדרך אחרת. הקוד מתחיל ב import-ים והגדרת רשימת הספרים:

import httpx
from timeit import timeit
from multiprocessing.dummy import Pool
import asyncio

book_urls = [
        "https://www.gutenberg.org/cache/epub/84/pg84.txt",
        "https://www.gutenberg.org/cache/epub/45304/pg45304.txt",
        "https://www.gutenberg.org/cache/epub/2701/pg2701.txt",
        "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
        ]

הפונקציה הראשונה פשוט מפעילה get ארבע פעמים אחת אחרי השניה:

def download_and_print_size(client, url):
    r = client.get(url, timeout=60.0)
    size = len(r.text)
    print(f"Url: {url}; size: {size}")

def serial():
    print("=== serial ===")
    for url in book_urls:
        download_and_print_size(httpx, url)

נשים לב ש httpx מגדירה timeout ברירת מחדל של 5 שניות ועבור פרויקט גטנברג זה לא תמיד מספיק אז הגדלתי לדקה. הגדרתי גם פונקציית הורדה נפרדת כדי לחסוך כפל קוד בדוגמאות הבאות.

פונקציה שניה כבר משתמשת ב client של httpx שזה מנגנון שלהם ששומר את החיבור לאתר פתוח כדי להוריד מספר קבצים:

def client_serial():
    print("=== client_serial ===")
    with httpx.Client() as client:
        try:
            for url in book_urls:
                download_and_print_size(client, url)

        finally:
            client.close()

בגרסה השלישית רציתי לראות איך הסיפור הזה יעבוד מכמה תהליכונים במקביל כי שמעתי שכשמורידים קובץ במקביל הזמנים מתקצרים. פה כתבתי שתי גרסאות אחת עם client והשניה בלי:

def parallel():
    print("=== parallel ===")
    with Pool(5) as p:
        p.map(lambda url: download_and_print_size(httpx, url), book_urls)

def client_parallel_threads():
    print("=== client_parallel_threads ===")
    with httpx.Client() as client:
        try:
            with Pool(5) as p:
                p.map(lambda url: download_and_print_size(client, url), book_urls)

        finally:
            client.close()

ולסיום הורדה אסינכרונית. כאן לא ראיתי דרך בלי client אז הגדרתי אותו וגם בגלל שמדובר בקלאיינט אסינכרוני כבר אי אפשר היה להשתמש באותה פונקציית download שכבר כתבתי ולכן בניתי גרסה אסינכרונית שלה גם:

async def download_and_print_size_async(client, url):
    r = await client.get(url, timeout=60.0)
    size = len(r.text)
    print(f"Url: {url}; size: {size}")


async def client_parallel():
    print("=== client_parallel ===")
    async with httpx.AsyncClient() as client:
        try:
            await asyncio.gather(*[download_and_print_size_async(client, url) for url in book_urls])

        finally:
            await client.aclose()

לסיום פונקציית main שמריצה את כל העסק וגם מודדת זמנים:

def main():
    print(timeit(lambda: serial(), number=1))
    print(timeit(lambda: client_serial(), number=1))
    print(timeit(lambda: parallel(), number=1))
    print(timeit(lambda: client_parallel_threads(), number=1))
    print(timeit(lambda: asyncio.run(client_parallel()), number=1))


if __name__ == "__main__":
    main()

אלה התוצאות:

=== serial ===
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
32.953853541985154
=== client_serial ===
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
12.404891041107476
=== parallel ===
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
6.713048083242029
=== client_parallel_threads ===
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
11.749367957934737
=== client_parallel ===
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
7.422760541085154

מופתעים? גם אני הופתעתי קצת. כלומר ברור למה הגרסה הראשונה מאוד איטית אבל אני מודה שגרסת התהליכונים בלי client הפתיעה לטובה ועקפה גם את הגרסה האסינכרונית. זה לא החזיק מעמד ובהרצה אחרת קיבלתי את התוצאה הזו:

=== serial ===
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
24.061222000047565
=== client_serial ===
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
14.5340595417656
=== parallel ===
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
8.315202291123569
=== client_parallel_threads ===
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
7.089039749931544
=== client_parallel ===
Url: https://www.gutenberg.org/cache/epub/1342/pg1342.txt; size: 763083
Url: https://www.gutenberg.org/cache/epub/84/pg84.txt; size: 446583
Url: https://www.gutenberg.org/cache/epub/45304/pg45304.txt; size: 1356681
Url: https://www.gutenberg.org/cache/epub/2701/pg2701.txt; size: 1260594
5.17865683324635

סך הכל הניסוי מוכיח מה שכבר ידענו - שעדיף להוריד קבצים במקביל מאשר בטור אבל שאין יתרון משמעותי להרצה אסינכרונית על פני שימוש בתהליכונים.

מעניין גם לשים לב לתקורה בשימוש בקוד אסינכרוני: גם הרצה עם asyncio.run, גם שימוש ב asyncio.gather בשביל להריץ דברים במקביל וגם אי אפשר היה להשתמש בקוד הסינכרוני הקיים וצריך היה לכתוב מחדש את פונקציית ההורדה. אני הרצתי על פייתון 3.14 והרצתי כמה פעמים התוצאות כל הרצה כמובן קצת שונות אבל מבחינת השוואת מהירות בין האופציות התוצאה עקבית.

ביקשתי מקלוד קוד לתקן בעיה לפני כמה ימים ועל דעת עצמו הוא גם עשה קומיט והוסיף להודעת הקומיט את הסיומת

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

סך הכל זה חמוד שהם עושים לעצמם פרסומת למרות שצריך להגיד את האמת המודל שעשה את התיקון היה חיקוי סיני בשם qwen ולא קלוד אופוס. פתיחת הודעת הקומיט בגיטהאב מראה בשדה "מחבר הקומיט" את השם שלי ושל claude ואפילו את התמונה של שנינו. הודעת הקומיט עצמה כללה הסבר מאוד שטחי על הפיצ'ר עם דגש על "מה בוצע" ולא "למה בוצע", מה שאומר שמי שיגיע אליה בעתיד יצטרך לקרוא הרבה טקסט בלי לקבל הרבה תובנות.

גם בעבודה עם גיט היכרות עם הכלים יכולה לעזור לנו להגיע לתוצאות טובות יותר וגם לתקן טעויות של סוכני קידוד ובעיקר להרגיש פחות אבודים כשסוכן קידוד עושה פעולה בשמנו. אלה פקודות גיט הכי שימושיות בעיניי בעבודה עם סוכני קידוד. לא מכירים אחת מהן? אל תתביישו לבקש מ AI החביב עליכם הסברים ודוגמאות:

בשביל לזהות טקסט AI בקטע ספרותי משתמשים במקפים המיוחדים שלהם שרק AI אוהב לכתוב. בשביל לזהות קוד שיוצר על ידי AI אנחנו נרצה לשים לב לשימוש יתר בתבניות וערבוב עדין בין תבניות. זה נראה יפה במבט ראשון אבל משהו קטן צורם שם. הדוגמה של היום היא בדיקה בתוכנית ריילס:

context 'when multi-part SMS - first chunk' do
  it 'stores in Redis and schedules delayed job' do
    allow(Vonage::InboundSmsService).to receive(:new).and_return(double(create_message: nil))
    allow(described_class).to receive(:set).and_return(described_class)
    allow(described_class).to receive(:perform_later)

    freeze_time

    described_class.handle_concatenated_chunk(params)

    expect(described_class).to have_received(:set).with(wait: 2.minutes)
  end
end

הקוד מטפל בסמסים שמגיעים בחלקים כי ההודעה ארוכה ורוצה לבדוק שאחרי החלק הראשון שמנו משימה ל-2 דקות קדימה שתאסוף את החלקים. החשיבות של משימה כזו היא לצורך טיפול בהודעה חלקית, כלומר אם כל החלקים הגיעו אז החלק האחרון יאסוף את כולם ויחבר אותם להודעה אחת. אבל אם רק חלק מהחלקים הגיעו אנחנו צריכים לזהות שעבר מספיק זמן מהחלק הראשון, להניח שההמשך כבר לא יגיע ולחבר את מה שיש. פה מוגדר פרק זמן של 2 דקות המתנה אבל אפשר לשחק עם זה. בכל מקרה מה שחשוב לסיפור שלנו הוא לא הקוד האמיתי אלא הבדיקה.

הבדיקה מנסה לוודא שאחרי הפעלת הפונקציה handle_concatenated_chunk נשלחת הודעה מתוזמנת לשתי דקות קדימה כדי לטפל בהודעות החלקיות. אבל היא עושה את זה באמצעות ערבוב של שתי תבניות:

1. דרך אחת לזהות שמשימה מתוזמנת נשלחה היא להסתכל על הקריאות לפונקציות של המשימה - אנחנו מצפים שהפונקציה set תקרא עם פרמטר של שתי דקות המתנה ובשביל זה אנחנו דורסים חלק מהפונקציות ומוודאים הפעלה.

2. דרך שניה לזהות שמשימה מתוזמנת נשלחה היא לא לדרוס מימושים אלא להסתכל בתור המשימות המתוזמנות ולראות שיש שם משימה מתוזמנת לשתי דקות קדימה. מי שירצה לעשות את זה יגלה שיש פער זמן קטן בין המשימה המתוזמנת בתור לבין "שתי דקות קדימה" מרגע הבדיקה, כי עברו כמה מילי שניות מהרגע שיצרנו את המשימה המתוזמנת לרגע בו בדקנו אותה. בשביל זה אנחנו נוהגים להקפיא את הזמן לפני הקריאה לפונקציה.

כלומר בגישה הראשונה נכתוב את הבדיקה הזו:

context 'when multi-part SMS - first chunk' do
  it 'stores in Redis and schedules delayed job' do
    allow(Vonage::InboundSmsService).to receive(:new).and_return(double(create_message: nil))
    allow(described_class).to receive(:set).and_return(described_class)
    allow(described_class).to receive(:perform_later)

    described_class.handle_concatenated_chunk(params)

    expect(described_class).to have_received(:set).with(wait: 2.minutes)
  end
end

ובגישה השנייה נכתוב את הבדיקה הזו:

context 'when multi-part SMS - first chunk' do
  it 'stores in Redis and schedules delayed job' do
    freeze_time

    expect do
      described_class.handle_concatenated_chunk(params)
    end.to have_enqueued_job(described_class).at(2.minutes.from_now)
  end
end

והגישה המעורבבת? רק עוד סימן לקוד שנכתב בלי השגחה.

בני אדם אומרים "אני לא יודע".

בני אדם שואלים לשלומי ומתכוונים לזה.

בני אדם לא נכנסים ללולאה ובדרך כלל לא מוחקים את כל בסיס הנתונים מתוך יאוש.

בני אדם שואלים בני אדם אחרים ומשתמשים בהגיון כדי לסנן מידע נכנס.

בני אדם מוצאים פתרונות יצירתיים שאף אחד אף פעם לא חשב עליהם.

בני אדם ישאלו "מה התכוונת לעשות שם" לפני שיעזרו לי להתקדם בדרך הלא נכונה.

בני אדם לא יגידו "זה מסובך מדי אני אממש בינתיים פתרון חלקי" כשהם מקבלים משימה.

עדיין דואגים שמכונות יחליפו אתכם? כל מה שצריך זה להשקיע באותן תכונות שהופכות אתכם לבני אדם. חלק לא מבוטל מהזמן לדבר עם בן אדם זה מה שאנחנו צריכים.