המפתחת החדשה מצטרפת לצוות המיינפריים. היא בילתה חמש שנים בכתיבת מיקרו-שירותי Java עם Git, GitHub, בקשות משיכה, ביקורות קוד ופיונל CI/CD. היא יודעת כיצד ליצור ענף מאפיינים, להגיש בקשת שיתוף פעולה (PR), לצפות בהרצת הבדיקות האוטומטיות, לקבל משוב מעמיתים ולמזג כאשר הבדיקות עוברות. ביום הראשון בצוות המיינפריים, היא לומדת את תהליך העבודה: לפתוח את ISPF, לנווט לקובץ ה-PDS המקורי, לערוך את החבר ישירות, לשמור אותו, לשלוח את בקשת הקומפילציה של JCL, לבדוק את ה-SYSOUT לאיתור שגיאות. אין ענף. אין היסטוריה מעבר למה שמספקים מספרי הרצף בעמודות 1-6. אין בקשת משיכה. אין שער בדיקה אוטומטי. אם היא ועמיתה עורכים את אותו חבר בו זמנית, השמירה השנייה דורסת את הראשונה ללא מיזוג, ללא אזהרה, ללא התנגשות, רק אובדן נתונים שקט.
זהו תהליך העבודה ש-GitOps למיינפריים נועד להחליף. לא את פלטפורמת z/OS, לא את שפת COBOL, לא את עיבוד הטרנזקציות המוכח שהמיינפריים מספק בזמינות של חמש-תשע, אלא רק את תהליך העבודה של ניהול קוד המקור שקדמה לבקרת גרסאות מבוזרת ולא עמדה בקצב הפעולה של צוותי תוכנה. המקרה העסקי הופך קונקרטי יותר ויותר: צוותי מיינפריים המאמצים זרימות עבודה מבוססות Git מדווחים על קליטה מהירה יותר של מפתחים חדשים (כולל הקבוצה הגדלה עם ניסיון בכלים מודרניים בלבד), נראות טובה יותר של היסטוריית השינויים לצורך תאימות וביקורת, שיתוף פעולה משופר בין צוותי פיתוח למיינפריים למבוזרים, והפחתת הסיכון מבעיית הכתיבה הכפולה של עריכה שתמיד הייתה לניהול ספריות ISPF.
בניית תוכניות מושפעות בלבד
SMART TS XL מזהה כל תוכנית הכוללת ספר עותקים שונה לפני שצינור ה-CI מחליט מה לקמפל.
גלו עוד…מה המשמעות האמיתית של GitOps עבור מיינפריים
GitOps הוא מודל תפעולי שבו Git הוא מקור האמת היחיד הן עבור קוד האפליקציה והן עבור תצורת התשתית. כל שינוי במערכת, בקוד, בתצורה ובהגדרת הפריסה, מתבצע באמצעות commit של Git. מאגר Git הוא הרשומה הסמכותית; המערכת הפועלת מתואמת כך שתתאים למה ש-Git אומר שהיא צריכה להכיל.
עבור מערכות מיינפריים, זה מתורגם לקבוצה ספציפית של התחייבויות:
Git הוא המקור המוסמך לקוד המקור של COBOL. ספריית PDS ב-z/OS היא ארטיפקט פריסה, מה שמקומפל ופועל בסביבת ייצור, לא מקור האמת. מקור האמת הוא מאגר Git. אם ה-PDS ומאגר Git חלוקים בדעתם, Git צודק.
כל שינוי עובר דרך בקשת משיכה (pull request). אין עריכות ישירות ב-PDS. אין צורך בקומפילציה וקידום חירום מחוץ לזרימת העבודה של Git. שינוי שנדרש באופן מיידי עובר תהליך PR מזורז, פוטנציאלית עם דרישות סקירה מופחתות במקרה חירום אמיתי, אך הוא עובר דרך Git.
צינורות אוטומטיים מטפלים בבנייה ובקידום. מפתח ממזג את ה-PR שלו; הצינור קומפיל את התוכניות המושפעות, מריץ בדיקות אוטומטיות ומקדם את מודולי הטעינה שעברו קומפילציה לספרייה המתאימה. המפתח אינו שולח את קובץ ה-JCL באופן ידני.
היסטוריית הקומיטים של Git היא נתיב הביקורת. כל שינוי בייצור ניתן למעקב אחר קומיט ספציפי, מחבר ספציפי, PR ספציפי, ואם תהליך העבודה של בקשת ה-pull מבוצע, קבוצה ספציפית של בודקים ותוצאות בדיקה.
זהו שינוי משמעותי בתהליך העבודה עבור צוותים המורגלים בפיתוח מבוסס ISPF. זהו גם, יותר ויותר, תהליך העבודה שארגונים צריכים כדי לגשר על פער הכישרונות: מפתחים חדשים שמכירים את Git ושום דבר אחר יכולים להשתתף בפיתוח COBOL מבלי ללמוד את מוסכמות ניהול הספריות של ISPF.
האתגרים הטכניים: מה שאף מאמר אחר לא מסביר
העברת קוד מקור COBOL לתוך Git אינה פשוטה כמו יצירת מאגר והעתקת קבצים פנימה. ארבעה אתגרים טכניים ספציפיים של z/OS מסבכים את ההעברה:
1. קידוד EBCDIC לעומת קידוד UTF-8
z/OS מאחסן נתוני תווים ב-EBCDIC (Extended Binary Coded Decimal Interchange Code), בעוד ש-Git מאחסן קבצים ב-UTF-8. כל קובץ שעובר בין המחשב המרכזי למאגר Git חייב לעבור קידוד מחדש. אם הקידוד מחדש אינו מטופל כהלכה, אם מניחים קידוד שגוי, אם ההמרה מתבצעת בצורה לא עקבית, או אם קבצים מועברים ללא המרה, מקור ה-COBOL נפגם בשקט.
שירותי מערכת יוניקס (USS) של z/OS הם הגשר: מקור COBOL ב-PDS עובר המרת קידוד ל-UTF-8 כאשר הוא נכתב למערכת הקבצים USS, שם Git יכול לפעול עליו. כאשר מאגר Git משוכפל ל-USS, הקבצים מתויגים בקידוד שלהם כך שכלי z/OS ידעו כיצד לפרש אותם.
לחבוט
# z/OS USS: correctly tag a Git-managed COBOL source file
chtag -t -c IBM-1047 CUSTPROC.cbl
# Verify the tag
ls -T CUSTPROC.cbl
# Output: t IBM-1047 T=on CUSTPROC.cbl
# The Git checkout hook should apply this automatically
# so developers don't have to tag files manually
2. סמנטיקה של מקור ועמודה בפורמט קבוע
קבצי מקור של COBOL משתמשים במבנה קבוע עם סמנטיקה ספציפית לעמודה:
Columns 1-6: Sequence numbers (optional; ISPF editors fill these automatically)
Column 7: Indicator (* = comment, - = continuation, D = debug line)
Columns 8-11: Area A (division/section/paragraph names, level numbers 01/77)
Columns 12-72: Area B (executable statements, clauses)
Columns 73-80: Identification (program name, historically used for card identification)
שינויים בקוד Git של מקור COBOL שמציגים שינויים בעמודות 73-80 בדרך כלל מציגים שינויים במספר הרצף או בשדה הזיהוי, ולא שינויים פונקציונליים בקוד. כלי diff שאינו מבין את הסמנטיקה של העמודות מייצר רעש שמסתיר שינויים אמיתיים. תצורת Git עבור מאגר COBOL צריכה לכלול... .gitattributes שמקשר קבצי COBOL עם מנהל התקן diff שמסיר או מתעלם משדה הזיהוי:
INI
# .gitattributes: configure COBOL-aware diff
*.cbl diff=cobol
*.cob diff=cobol
*.cpy diff=cobol
# .gitconfig (or repo-level config): define the cobol diff driver
[diff "cobol"]
xfuncname = "^[0-9A-Z][0-9A-Z -]+"
wordRegex = "[A-Z][A-Z0-9-]+"
3. מגבלות שם חבר PDS
שמות חברי PDS מוגבלים ל-8 תווים, אותיות גדולות, אותיות אלפאנומריות ועוד. $, #, @ב-Git, שם הקובץ הוא שם חבר ה-PDS (ללא סיומת, או עם סיומת סטנדרטית) .cbl (הרחבה שנוספה לפי המוסכמה). מגבלת 8 התווים יוצרת אילוץ מתן שמות: CUSTUPDT ממפה בצורה נקייה לחבר PDS; customer-account-update-processor לא.
המוסכמה שעובדת בפועל: שמור על שמות האיברים כשם הקובץ הבסיסי (8 תווים), הוסף א .cbl הרחבה ב-Git לזיהוי מקור, ושימוש במבנה ספריות ב-Git כדי לספק את מרחב השמות ש-PDS מתן שמות לא יכול:
repository/
├── CUSTMGMT/ # Logical application group (no PDS equivalent)
│ ├── CUSTUPDT.cbl # Maps to PDS member CUSTUPDT
│ ├── CUSTINQ.cbl
│ └── CUSTSRCH.cbl
├── COPYBOOKS/
│ ├── CUSTMSTR.cpy # Maps to PDS member CUSTMSTR
│ └── TRANREC.cpy
└── JCL/
├── CUSTNITE.jcl
└── CUSTMON.jcl
4. בעיית המקור הסמכותי
במהלך המעבר מפיתוח מבוסס PDS לפיתוח מבוסס Git, גם ה-PDS וגם ה-Git מכילים עותקים של קוד המקור. איזה מהם סמכותי? התשובה חייבת להיות חד משמעית לפני ביצוע כל שינוי ייצור דרך תהליך העבודה החדש.
איזו מערכת מכילה את המקור הסמכותי: גיט, מנהל הספרייה או הפלט שנוצר על ידי תהליך הסנכרון? כאשר תשובה זו אינה ברורה, צוותים משקיעים זמן בפתרון הבדלים בין מערכות במקום לספק ערך. מודל Git-first מספק תשובה ברורה יותר. גיט מכיל את המקור הסמכותי ומתעד את ההיסטוריה שלו. הצינור משתמש במקור זה כדי ליצור ארטיפקטים שנבדקו וניתנים למעקב לצורך פריסה.
רצף המעבר שפותר את העמימות הזו: יש לקבוע את מאגר Git כמקור הסמכותי בתאריך מסוים; לאחר תאריך זה, כל עריכה ב-PDS מהווה הפרת מדיניות שיש להסלים ולהעביר אותה חזרה ל-Git לפני סוף יום העסקים; תיקוני חירום חמים מקבלים זרימת עבודה ייעודית של PR בנתיב מהיר, ולא חריג לעריכת PDS. תקופת המעבר, כאשר שתי המערכות מתוחזקות, צריכה להיות קצרה ככל האפשר מבחינה תפעולית, מכיוון שכל יום של תחזוקה כפולה הוא יום של סטייה פוטנציאלית.
שרשרת הכלים של GitOps של מיינפריים
ארבע קטגוריות כלים מחברות את גיט לצינור האספקה של z/OS:
ניהול מקורות ו-IDE: IBM Developer for z/OS (IDz) מספק IDE מסורתי מבוסס Eclipse עם עריכה בסגנון ISPF, וכולל שילוב עם Git. לחלופין, VS Code עם ההרחבה Zowe Explorer מספק IDE מודרני שמתחבר ל-z/OS דרך מסגרת ה-API של Zowe מבלי לדרוש IDz. צוותים שרוצים למשוך מפתחים המכירים כלים מודרניים מעדיפים בדרך כלל VS Code.
מסגרת Zowe: Zowe היא מסגרת קוד פתוח המספקת ממשקי REST API עבור z/OS, וחושפת פעולות נתונים, הגשת משימות וגישה לקבצי USS דרך ממשקי HTTP סטנדרטיים שכלים סטנדרטיים של CI/CD יכולים לקרוא להם. ללא Zowe (או מקבילה מסחרית), אין דרך סטנדרטית עבור רץ GitHub Actions או סוכן Jenkins לתקשר עם z/OS.
בנייה מבוססת תלות של IBM (DBB): DBB הוא כלי הבנייה ש-IBM מספקת במיוחד עבור GitOps של מיינפריים. הוא מבין תלויות של קומפילציית COBOL, אילו ספרי עותקים כל תוכנית כוללת, אילו DBD ו-PSB נדרשים עבור תוכניות IMS, אילו BINDs נדרשים עבור Db2, ומשתמש בהבנת תלות זו כדי לקבוע מה יש לקמפל כאשר קבוצת קבצים נתונה משתנה.
ניהול שינויים ופריסה: ISPW (CA Brightside), UrbanCode Deploy, ו-Rocket Software ISPW מספקות את ניהול הקידום שמעביר מודולי טעינה מהורכבים מספריות פיתוח דרך סביבות בדיקה לייצור, עם זרימות עבודה לאישור ושבילי ביקורת הנדרשים על ידי סביבות מוסדרות.
| שכבת שרשרת כלים | קוד פתוח / אפשרות IBM | אלטרנטיבה מסחרית |
|---|---|---|
| IDE | VS Code + Zowe Explorer | IBM IDz, Broadcom IDz |
| גשר ה-API של z/OS | שכבת ממשק שורת פקודה (CLI) + API של Zowe | Rocket ConnectZen, קליפורניה ברייטסייד |
| בניית תזמור | IBM DBB | שולחן עבודה BMC Compuware Topaz |
| רץ CI/CD | ג'נקינס, פעולות גיטהאב | Azure DevOps, GitLab CI |
| שינוי הנהלה | פריסת Zowe + DBB | ISPW, פריסת UrbanCode |
| קידום מקורות | מיזוג גיט לענף הראשי | זרימת עבודה לקידום ISPW |
הצינור: מיחסי ציבור להפקה
צינור ה-GitOps מקצה לקצה עבור שינוי COBOL משתרע על פני פלטפורמת CI/CD מבוזרת וסביבת הביצוע של z/OS:
יאמל
# GitHub Actions: COBOL GitOps pipeline
name: Mainframe COBOL Pipeline
on:
pull_request:
paths:
- '**/*.cbl'
- '**/*.cpy'
- '**/*.jcl'
jobs:
impact-analysis:
runs-on: ubuntu-latest
outputs:
affected: ${{ steps.analyze.outputs.affected_programs }}
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Identify changed files
id: changes
run: |
CHANGED=$(git diff --name-only origin/main...HEAD \
| grep -E '\.(cbl|cpy|jcl)$')
echo "changed=$CHANGED" >> $GITHUB_OUTPUT
- name: Analyze dependency scope
id: analyze
# SMART TS XL or DBB dependency analysis determines
# which programs are affected by the changed files
run: |
echo "Resolving dependency scope for: ${{ steps.changes.outputs.changed }}"
# Output: the specific programs that must be compiled/tested
compile-and-test:
needs: impact-analysis
runs-on: [self-hosted, zos-runner] # Runner with z/OS connectivity
steps:
- uses: actions/checkout@v4
- name: Compile affected COBOL programs (via Zowe + DBB)
run: |
zowe dbb build \
--sourceDir ./CUSTMGMT \
--affected "${{ needs.impact-analysis.outputs.affected }}" \
--workDir /u/devops/builds/${{ github.run_id }}
- name: Run unit tests
run: |
zowe zunit run \
--programs "${{ needs.impact-analysis.outputs.affected }}" \
--results-dir /u/devops/results/${{ github.run_id }}
- name: Static compliance check (before promotion)
run: |
# Hardcoded credential check, FILE STATUS validation,
# naming convention compliance
zowe smart-ts-xl analyze \
--scope "${{ needs.impact-analysis.outputs.affected }}"
promote-to-test:
needs: compile-and-test
if: github.event_name == 'pull_request' && github.base_ref == 'main'
runs-on: [self-hosted, zos-runner]
steps:
- name: Promote to TEST library (via ISPW)
run: |
zowe ispw promote \
--programs "${{ needs.compile-and-test.outputs.compiled }}" \
--from DEV --to TEST \
--change-request ${{ github.event.pull_request.number }}
האלמנט הקריטי בצינור הזה הוא שלב ניתוח ההשפעה: קביעת אילו תוכניות COBOL יש לקמפל ולבדוק כאשר PR משנה קבוצה ספציפית של קבצי מקור. ללא שלב זה, הצינור מקמפל הכל (איטי ויקר) או מקמפל רק את הקבצים שהשתנו במפורש (תוכניות חסרות שתלויות בספרי עותקים שהשתנו).
פער התלות: מדוע ניתוח ההשפעה הוא החלק הקשה ביותר
גיט יודע בדיוק אילו קבצים השתנו בבקשת משיכה. מה שגיט לא יודע הוא אילו תוכניות אחרות מושפעות משינויים אלה.
יחסי ציבור שמשנים CUSTMSTR.cpy, ספר העותקים שמגדיר את פריסת רשומת האב של הלקוח, לא משנה דבר מבחינת ספירת הקבצים: קובץ אחד נערך. CUSTMSTR.cpy כלול ב-47 תוכניות COBOL. יש לקמפל מחדש את כל 47 התוכניות. אם רק הקובץ שהשתנה במפורש מקומפל, 46 תוכניות יישארו בתהליך ייצור עם הגדרת ספר עותקים שאינה תואמת עוד לקובץ הבינארי המקומפל שלהן. חוסר ההתאמה שותק עד שהתוכנית רצה ומנסה לקרוא רשומה באמצעות הפריסה הישנה כנגד נתונים שנכתבו עם הפריסה החדשה.
זהו פער התלות ב-GitOps של מיינפריים: מערכת הבנייה חייבת לדעת את גרף התלות כדי לקבוע את טווח הקומפילציה הנכון. IBM DBB מטפלת בכך עבור מאגרים חדשים שהוקמו על ידי בניית מפת תלות מפורשת כחלק מתהליך הבנייה שלה. עבור סביבות מדור קודם שבהן אלפי תוכניות קודמות ל-DBB, מפת התלות הראשונית חייבת להיבנות מניתוח סטטי של המקור הקיים.
ארבעת סוגי התלות החשובים לקביעת טווח של בניית COBOL:
פקודות COPY , התלות הנפוצה ביותר. שינוי בכל ספר עותקים הכלול דרך COPY דורש קומפילציה מחדש של כל תוכנית הכוללת אותו.
פקודות CALL , קריאות סטטיות לתת-תוכניות. אם הממשק של התוכנית הנקראת משתנה (פרמטרים, קודי החזרה), ייתכן שיהיה צורך לעדכן ולקמפל מחדש את הקוראים.
SQL INCLUDE , תוכניות SQL מוטמעות הכוללות איברי DCLGEN (מחוללי מחלקות נתונים עבור טבלאות Db2). שינוי בסכימת Db2 שיוצר DCLGEN חדש דורש קומפילציה מחדש של כל תוכנית הכוללת אותו.
הפניות למערכי נתונים של JCL DD , שינויים ב-JCL המפנים למערכי נתונים שונים או משתמשים בשמות תוכניות שונים משפיעים על הצינור התפעולי, לא רק על קומפילציית התוכנית.
זרימת העבודה הישנה לעומת זרימת העבודה של גיט
| אספקט | זרימת עבודה מבוססת PDS של ISPF | זרימת עבודה של GitOps מבוססת Git |
|---|---|---|
| מקור האמת | ספריית PDS במערכת הפעלה z/OS | מאגר Git |
| מנגנון עריכה | עורך ISPF, עריכה ישירה של חברי PDS | קוד VS / IDz עם אינטגרציה עם Git |
| שינוי מעקב | מספרי סידורי בעמודות 1-6 | היסטוריית commit של גיט עם מחבר, חותמת זמן, הודעה |
| עריכה בו זמנית | שמירה שנייה דורסת תחילה (אובדן שקט) | פיתוח מבוסס ענפים; זיהוי קונפליקט מיזוגים |
| ביקורת קוד | לא פורמלי, גשו לשולחן | בקשת משיכה עם סקירה ואישור מובנים |
| בנה טריגר | הגשה ידנית של JCL | אוטומציה באמצעות צינור ביחסי ציבור או מיזוג |
| חישוב היקף מושפע | ידע ידני; בנה מחדש הכל כברירת מחדל | ניתוח תלות קובע תוכניות מושפעות |
| מסלול ביקורת | יומן שינויים ידני; לא שלם | מטא-נתונים של Git log + PR; מלא וניתן לשאילתה |
| קליטת מפתחים חדשים | נדרשת הכשרת ISPF | קליטה בתקן גיט; IDE מודרני |
| שינויים דחופים | עריכה ישירה של PDS; לעתים קרובות לא עוקבים | זרימת עבודה מזורזת של יחסי ציבור; מעקב מלא |
השורה התחתונה היא המקום שבו מתרכז הסיכון התפעולי של זרימת העבודה של ISPF: שינויים דחופים שבוצעו ישירות ב-PDS של הייצור, תוך עקיפת תהליך ניהול השינויים, הם המקור השכיח ביותר לשינויים בייצור שלא עוקבים והממצא השכיח ביותר של ביקורת בסקירות בקרת שינויים במחשבים מרכזיים.
איך SMART TS XL מאפשר GitOps מדויק של Mainframe
פער התלות ב-GitOps של מיינפריים, הפער בין "Git יודע מה השתנה" לבין "הצינור יודע מה לקמפל", מטופל על ידי ניתוח סטטי של קוד המקור של COBOL שמייצר את גרף התלות.
SMART TS XL"S מיפוי תלות יישומים מייצר את גרף התלות המלא של COPY: כל ספר עותקים, כל תוכנית הכוללת אותו, כל קשר COPY מקונן וכל תלות CALL על פני התיק המלא. כאשר PR משנה CUSTMSTR.cpy, מפת התלות מייצרת מיד את הרשימה של 47 התוכניות הכוללות אותה, ומספקת את קלט היקף הבנייה שצינור ה-CI צריך כדי לקמפל את קבוצת התוכניות הנכונה, לא יותר ולא פחות.
מפת התלות הזו היא גם מה שהופך את המעבר לפיתוח Git-first לבטוחה: לפני הגדרת מאגר Git כמקור סמכותי, יש לדעת את גרף התלות המלא כך שמבנה המאגר הראשוני ישקף את יחסי התלות בפועל בין תוכניות וספרי עותקים. מבנה מאגר שמפריד בין ספרי עותקים לתוכניות הכוללות אותם ללא קשרי התלות המתועדים יוצר מאגר שנבנה כהלכה רק אם במקרה יודעים מה תלוי במה, מה שמבטל את מטרת בקרת הגרסאות.
יכולת ניתוח הקוד הסטטי מספקת את לוגיקת שער pre-commit: בדיקת תוכניות שהשתנו עבור אישורים מקודדים, הצהרות FILE STATUS חסרות, תאימות למוסכמות מתן שמות, ובדיקות איכות סטטיות אחרות שבתהליך עבודה של Git פועלות כשערי PR ולא כממצאים לאחר פריסה.
יכולת ניתוח ההשפעה עונה על שאלת סקירת ה-PR: "מהו ההיקף המלא של שינוי זה?" ל-PR שמשנה ספר עותקים יש היקף השפעה המשתרע על כל תוכנית הכוללת אותו וכל משימת JCL שמפעילה את התוכניות הללו. הפיכת היקף זה לגלוי בהקשר של סקירת ה-PR, לפני שהשינוי מתמזג, היא המידע המאפשר קבלת החלטות סקירה מושכלות, קביעת היקף בדיקות מתאים ורמות אישור מתאימות של מועצת הייעוץ לשינויים.
השמיים חיפוש ארגוני היכולת תומכת בדרישת מעקב הביקורת: למצוא כל שינוי בתוכנית ספציפית בטווח תאריכים (ניתן לשאילתה מיומן Git), כל תוכנית הכוללת ספר עותקים ספציפי (ניתן לשאילתה ממפת התלויות), כל תוכנית ששונתה על ידי מחבר ספציפי (ניתנת לשאילתה מ-Git). השילוב של היסטוריית ה-commit של Git ו- SMART TS XLהניתוח המבני של מייצר את נתיב הביקורת המלא והניתן לשאלות, הנדרש לצוותי תאימות ולוועדות מייעצות לשינוי.
המאגר צריך לדעת את מה שהקוד יודע
המפתחת שמצטרפת לצוות המיינפריים עם חמש שנות ניסיון ב-Git לא מבקשת מהמייןפריים להפוך לפלטפורמה מקורית לענן. היא מבקשת ממנו לתמוך בזרימות העבודה שכל צוות פיתוח מודרני משתמש בהן, בקרת גרסאות, סקירת קוד, בדיקות אוטומטיות, מעקב. זרימות עבודה אלו קיימות מסיבות שחלות באותה מידה על COBOL כמו על Java: מניעת שינוי עריכה כפולה, יצירת היסטוריה ניתנת לביקורת של כל שינוי ייצור, מתן אפשרות לסקירת קוד לפני פריסה, ואוטומציה של העבודה המכנית כך שמפתחים יוכלו להתמקד בעבודה המהותית.
האתגרים הטכניים אמיתיים, קידוד EBCDIC, מוסכמות מקור בפורמט קבוע, אילוצי מתן שמות ל-PDS, שאלת המקור הסמכותי. אף אחד מהם אינו בלתי פתיר. שרשרת הכלים, Zowe, DBB, VS Code עם Zowe Explorer, פלטפורמות ניהול השינויים, מטפלת ברובם. הפער שנותר הוא ניתוח התלות שהופך את בניית הצינור להיקף הנכון כאשר רכיב משותף משתנה.
המחשב המרכזי שמנהל את קוד המקור שלו ב-Git, בונה דרך צינור CI/CD, ופורס דרך זרימת עבודה אוטומטית לקידום אינו מחשב מרכזי אחר. זהו אותו מחשב מרכזי, שמפעיל את אותן תוכניות COBOL מוכחות, עם אותה אמינות של חמש תשיעיות, וכעת זהו מחשב מרכזי שמפתח עם חמש שנות ניסיון בכלים מודרניים יכול להצטרף אליו ולהיות פרודוקטיבי עד סוף השבוע הראשון.


