והפעם בסימן: הרשת הפתוחה

פיירפוקס OS עוד סיבוב של מוזילה במאבק על הרשת הפתוחה:

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

לכמה שנים היה נראה שהסיפור הזה מוכרע. ואז הגיע סטיב ג'ובס.

steve jobs

fast forward ל 2013: פלטפורמות סגורות, שחברות מסחריות שולטות בהם הפכו לנתיב החיבור המרכזי בין משתמשי הקצה לעולם המחשב. קרנו של הגן הסגור עלתה, זו של הפתוח יורדת. המרשתת עדיין משמשת כפלטפורמת הפצה מרכזית (בעיקר הפרוטוקולים שתחתיה: tcp/ip וHttp) אבל עם שומרי חומות, מתווכים ופחות ופחות גישה וגלישה ישירה של המשתמשים, כזו שאיננה באמצעות אפליקציות.

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

firefox vs apple

ואם כבר הזכרנו את הסיבוב ההוא, שבו מוזילה יצאה נגד המונופול של IE6 והובילה את הרשת (נכון, לפעמים גם נגררה אחרי כרום) לעולם הדפדפנים המודרני של היום, מתברר ש IE11, אולי הדפדפן התואם סטנדרטים ביותר שיצא מבית מיקרוסופט ומתחרה ראוי בשכונה של הדפדפנים המודרניים, שינה את הUser agent שלו. מה הביג דיל? שהוא שינה את זה כך שיזדהה כדפדפן של מוזילה (Like Gecko) והסיר הרבה מהסימנים המזהים של דפדפני מיקרוסופט, על מנת למנוע שימוש בקוד ייעודי (ובעייתי) לIE. בעיני יש ברגע הזה משהו סימלי, בנצחון הקטן והגיקי הזה. ניקולאס זאקאס כתב על זה וגם על עוד פיצ'רים שהשתנו בדפדפן החדש של מיקרוסופט.

מפתחים את הרשת הפתוחה וברת ההרחבה:

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

מניפסט הרשת ברת ההרחבה בעצם Hitch מהשורות הקודמות מבוסס על רעיון רחב יותר שמובילה חבורה של מפתחים ידועים (כולל יהודה כץ מEmber, rails, jQuery ומפורסמים אחרים) שמציע לשנות את התהליך הנוכחי של פיתוח הרשת. תהליך שמבוסס על איפיון API מורכבים ע"י כותבי הspec, אימוץ איטי (ושונה) ע"י הדפדפנים ואח"כ פידבק ממפתחים שאשכרה משתמשים בAPI הזה. ההצעה שלהם היא לאינטרנט (בעצם לדפדפנים) שהיא פתוח יותר לתהליך הרחבה והתפתחות שמגיע "מהשדה" – מהמפתחים עצמם ויהיה מבוסס JS. איך עושים את זה? הקמה וחשיפה של API מהLower level של הדפדפנים לג'אווסקריפט. כך שמפתחים יוכלו להשתמש בהם כדי להדגים רעיונות, ליישם פתרונות וPolyfills ובעצם ליצור פידבק מהיר יותר לתהליך הנוכחי של התפתחות הspec של Html5. שווה לקרוא ולהכיר את המניפסט. Hitch הוא דוגמא לקו הזה. ספרית Js שחושפת Api בסיסי שמאפשר לההתנסות בסלקטורים ניסיונים, חדשים ואפילו עוד לא קיימים של css. מגניב מאוד


Html5 חידושים מהחזית html5 logo

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

Console.snapshot עוד מגניבות קטנה , גם אם לא מועילה מדי. מאפשר לשמור תמונה מcanvas ישירות לconsole של chrome.

דמו של צ'טרולט מבוסס WebRTC אמנם (כרגע) בלי עירום פרונטלי. אבל עם דמו טכנולוגי מרשים מבוסס Html5. כן, אני יודע שזה לא שווה ערך.

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

prevent this page from creating

שליטה דינאמית בדפי cssטכניקה להוספת/הסרת/שינוי כללים מStylesheets בעזרת Js בקליינט סייד. האמת שלא הכרתי בכלל את האובייקט של CSSStyleSheet או את הcollection שקורא לאלו. כמו גם את המתודות המובנות. לא סגור באיזה מקרים זה כדאי, אולי אם יש המון css כך שנרצה לטעון אותו ולשנות אותו דינאמית בהתאם לפידבק מסויים מהמכשיר של המשתמש (או מהמשתמש עצמו). בכל מקרה טוב להכיר.

נשתמע ומועדים לשמחה.

רשימת קריאה:

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

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

iron_man_mug

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

מפתחים

למה אפליקציות ווב למובייל הן איטיות והאם זה סוף העולם שאנחנו מכירים כן, אני יודע שזה להכניס יד לקלחת הרותחת של ויכוחי Native Vs web, ואתם יודעים שאני בד"כ בצד של הווב. אבל זה ריטון (ארוך) מושקע, מבוסס ומעניין מאוד עם מלא מטריקות ומדידות. מסתבר שהשילוב בין חולשת המעבדים בנייד, מיעוט הזכרון הנדיף הזמין לאפליקציות רשת לאיטיות היחסית של שפות סקריפט מול שפות מקומפלות מייצר בעייה מורגשת במכשירים ניידים. בעיה שמייצרת, נכון להיום, תקרת זכוכית למה אפשר לעשות עם אפליקציית ווב במובייל. מסתבר שהפערים האלו, שבמחשבים שולחניים וניידים הפכו להיות זניחים בחווית המשתמשים, עדיין משמעותיים מאוד בנייד ובגלל המגבלות הטכנולוגיות (צריכת חשמל, גודל, התחממות) לא בטוח שאפשר לדלג אותם באותו הקצב שגדלו היכולות של מחשבים "רגילים" בעשורים האחרונים. אולי זו הדיסטופיה של "פוסט חוק מור", זה שקבע מנהל אינטל דאז, שכל שנתיים המעבדים מכפילים את המהירות שלהם. פוסט חוק מור, כי נראה, שלפחות במחשוב האולטרא נייד, עם מעבדי ARM, חוק מור נתקל במגבלות של הפיזיקה: חום, התנגדות, גודל מינימלי של המולקולות וכו'.

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

וובדב וחידושים מחזית הרשת הפתוחה

זה לא כפתור! ריטון על הנטייה להשתמש בdiv, spans, links ועוד בתור כפתורים, במקום פשוט, אתם יודעים, buttons. ולמה זה בעייתי – בעיקר מהכיוון של נגישות.

ארכיטקט עוד ספריית Js לטיפול וניהול web workers, הדרך שלנו לבצע תהליכים חישוביים ברגע בJs , שנראית מרשים ועם פוטנציאל. יצויין שכרגע יש הרבה "מתחרות" על להפוך להיות הסטנדרט בטיפול בווב וורקרס, API חשוב מאוד ביכולת לסחוט יותר מפלטפורמת הרשת אבל Api נמוך יחסית, כרגע קשה לראות מה יהפוך להיות הסטנדרט בתחום.

הקדמה: למה Vim?

  1. כי זה הסטנדרט. ולפעמים תמצאו את עצמכם צריכים לערוך משהו ישירות על שרת לינוקס מוקשח עם Haiku edition, בלי x-windows (כלומר ממשק משתמש גרפי חלונות) ותרצולמות כי כלום לא יעבוד חוץ מVim, שכאמור, הוא הסטנדרט שמותקן בכל מקום.
  2. כי יש סיבה שזה הסטנדרט – הפרודוקטיביות המרשימה בעריכת וכתיבת קוד מקור ע"י משתמשי Vim מקצועניים.
  3. כי זה קוד פתוח וחופשי במובנים העמוקים של המילה, כי זה לא דורש להיות כבול לכלי ספציפי עם אקוספרה ספציפית שטובה רק למשהו ספציפי (מישהו אמר Webstorm שמגרילים רישיונות שלו בכל אתר ומפגש?), לכזה שדורש רישיון וכסף או לכזה שהמפתח יעלם מחר בבוקר.
  4. כי מצאתי את עצמי משקיע כל כך הרבה זמן ומאמץ בניסיון לעקוף את Vim כך שההשקעה בללמוד אותו נראתה לי פחותה. דוגמה מובהקת: שכחתי לצרף commit message בGit והופ נפתח מסך שחוץ מהקשות היסטריות בתקווה שמשהו יעשה "יציאה", לא הצלחתי לעשות בו כלום עד שהתייאשתי, סגרתי את חלון הטרמינל והתחלתי מחדש, כולל לאתחל את הVirtualenv ושאר כלי הפיתוח. בשלב מסויים למדתי להתקין במחשבי הפיתוח השונים שאני עובד עליהם את Gitpad מבית Github שמחליף את עורך ברירת המחדל של הcommit לNotepad. רק ש.. אז "רק הרצתי משהו" על מחשב של חבר ונתקעתי שוב באותה סיטואציה, ובכלל התלות בעוד כלי שצריך להתקין (וברוך השם יש הרבה להתקין גם ככה) על מחשבי פיתוח היא מבאסת. בקיצור תהליך, מבאס ודי דבילי כי יכלתי בשתי מקשים לצאת ו/או לכתוב Commit message ו/או לעוף לירח (וראו "זה הסטנדרט")
  5. כי הוא משחק יפה עם שורת הפקודה, ואם אני עורך וכותב תוכנה משורת הפקודה אני לא רוצה להצטרך להרים את היד לעכבר ואז מהממשק הגרפי לנווט חזרה לתיקייה שבה אני עובד. למשל שאני רוצה לעשות ככה: touch script.py && chmod 775 script.py && vim script.py
  6. כי אתם יודעים שמתכנתים הם "עצלים, חסרי סבלנות ומלאי היבריס" ואין כמו ללמוד vim בשביל להדגים היבריס.

vim

להתקין VIM

יש הוראות ברורות לכל הפלטפורמות באתר שלהם. ממליץ לחלונות ולינוקס להתקין gvim שנותן ממשק גרפי קצת נחמד יותר (ושכל הקסטום שלו משותף עם גרסת הטרמינל). אבל יש גם גרסה קצת יותר מקלה בשם Cream.

מה זה Vim?

Vim הוא עורך טקסט למתכנתים. יש לו גרסה עם Gui בשם Gvim וגרסת טרמינל. יש לו פורט לכל מערכת הפעלה קיימת כנראה (בהתחשב בזה שהפיתוח שלו התחיל בAmiga) והוא הסטנדרט לעריכת טקסט למתכנתים (אם פיספסתם את הנקודה).
ש: "הי, אבל שמעתי שEmacs הוא טוב יותר"
ת: אם מסובך יותר זה טוב יותר אז באמת יכול להיות. אבל אני חושב שבXkcd ענו על זה טוב יותר לפני:

Real programmers

אבל מי אני שאקבע? אתם יכולים ללכת גם עם Emacs. עקומת הלמידה היתה נראית, בשבילי לפחות, קשה מדי. מניח שאם אתם Lispers אז emacs הליספי הוא ברירת המחדל שלכם גם ככה.

איך מתחילים?:

יהודה כץ – מפתח שאחראי על Ember וsproutcore וcore dev בjQuery, rails ועוד כתב פוסט מצויין על "איך כל מי שניסה לשכנע אותי לעבור ל Vim טעה" ועל הקושי שלו לעבור לvim בדרך שהVim masters ממליצים עליה. וגם על איך הוא כן עבר בסופו של דבר ומה עבד בשבילו. רמז – ליהודה כץ אשכרה יש עבודה וזמן מוגבל לעקומת למידה קשוחה ועל כן הוא לא יכול להרשות לעצמו להיות "טהרן" ולהתעקש על מתודות שמאיטות משמעותית את הפרודקטיביות שלו. אז בהמשך לעצה של יהודה כץ, אם אנחנו מתחילים בVim עדיף לא להיות דוגמטי, לשכוח מהעכבר ומתנועה עם החיצים וכו', להשתמש בplugins מקילים כמו janus ולדעת שאם לא נעבוד עם זה בפועל נתקשה להתקדם. אני אגב גיליתי שהמתודה "הקלאסית" (לשכוח את העכבר, החיצים וללמוד את הכל מחדש) יחסית עובדת עבורי, אבל אם ליהודה כץ זה לא עובד, אז מי אני כאזוב קיר, אומר.

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

"נפתח vim (או Vi האח הקטן והמפגר) שלא הכנסנו commit message ולמרות שניסינו לכתוב לא הצלחנו לעשות כלום" וואלה, זה נכון. כי Vim נפתח בNormal mode שהוא גם מצב האב של "מצב פקודות – command mode". רק שהמצב "הנורמלי" הוא ממש לא נורמלי למי שהתרגל לעבוד בעורך טקסט בשלושים השנים האחרונות. אז מה הם המצבים של Vim? 1. המצב ה"נורמלי"" שבו **אי אפשר להקליד טקסט אלא רק לבצע פעולות על הטקסט המוקלד כבר. איזה פעולות? למשל: ניווט, החלפה, חיפוש, מחיקה, הדבקה, פתיחת וסגירת קובץ וכו'. מהמצב הנורמלי תוכלו לכתוב : ולדברים אחרים / ותכנסו למצב פקודה בשורה שבתחתית העורך. בפוסט הזה אתייחס ל: כחלק מהפקודה (אם כי זה לא מדוייק)
2. **מצב "עריכת טקסט". שאליו תוכלו להכנס עם a לעריכה אחרי הטקסט או i לעריכה לפני הטקסט. לחזור למצב פקודות תוכלו עם esc או עדיף עם Ctrl+[
3. יש לVim גם מצב בחירה ויזואלי (שתכנסו אליו עם.. נכון: v) ומצב בלוק- ויזואלי, אולי הדבר הכי דומה לגזור/הדבק בעורך טקסט רגיל שבו גם יש מקום לעכבר ועוד. אבל נתחיל מזה.
אז לסיכום המצבים, כדאי לדעת ש i או a יקחו אותכם למצב עריכה (כן, זו כפירה לכתוב את זה ככה, אבל זה פשוט) וesc חזרה למצב פקודה. ועם :q תוכלו לצאת. הדבר השני והמוזר בVim הוא הניווט.

מקשי הניווט הבסיסים בvim (שפועלים כמובן במצב הנורמלי ולא במצב עריכה, עוד משהו להתרגל אליו) הם הצירוף המוזר משהו של h,j,k,l. שh זה שמאלה (כי שמאל מכולם), l זה ימינה (ובניגוד למילה left שמתחילה בו..) j למטה (כי הוא לכאורה מזכיר חץ למטה) ו k למעלה.
אגב, ברוב המקרים (אלא אם אתם בvi, או בcompatible mode אליו) גם החיצים הרגילים יעבדו, אבל אומרים שצירוף ברירת המחדל הוא צירוף המקשים המהירים ביותר לניווט, אז שווה להתרגל אליו.
אז עד כאן התמודדות עם הפחד הראשוני מvim ואם הגעתם לפוסט הזה בניסיון נואש לצאת ממצב פקודות שנקלעתם אליו אז הנה הפתרון. עכשיו ננסה לחפור קצת יותר.

Vimtutor – ללמוד Vim 101

נקודת פתיחה טובה לvim היא פשוט להריץ את קובץ vimtuter משורת הפקודה. אם במקרה ההתקנה לא צירפה את vim לPath שלכם אז הוא נמצא בספריית vim. בעצם מדובר בקובץ טקסט (שאפשר גם לפתוח ישירות, הדבר היחידי שהקובץ עושה הוא לייצר אותו כעותק, כדי לא לדרוס את המקור) שמכיל הדרכה בסיסית, אבל מקיפה ונותנת התמצאות ראשונית לVim. מדובר על בערך שעה. כולל לבצע את התרגילים וכו'. אחרי זה יהיה לכם מושג מה אתם עושים.
עוד אופציות טובות להתחלה הם מדריכי הוידאו המומלצים האלו כמו גם שתי ניסיונות (אחד מהם בתשלום אחרי כמה רמות) למשחק את לימוד vim. vim adventures והמדריך האינטראקטיבי לvim.

פקודה – מספר – תנועה

זה הריקוד הבסיסי של עריכת טקסט בVim וחלק משמעותי מהכוח שלו. להרבה מהפקודות עריכה (למשל מחיקה: d) יש אפשרות לביצוע בצירוף תנועה. מה זו תנועה? תנועה היא מקש ניווט בתוך הטקסט כמו שלמדנו עליו מקודם. למשל dw – מחוק את המילה הבאה. או cw ערוך טקסט להחלפה של המילה הבאה. ומה שייך המספר באמצע? כאמור, הוא לא חובה, אבל הוא מאפשר לקבוע כמה פעמים לחזור על הפעולה. מה שמאפשר לדייק בחירת/עריכת/מחיקת טקסט היישר מהמקלדת, בלי שימוש מסורבל בעכבר. כך למשל: d5w ימחוק את 5 המילים הבאות ו y5w יעתיק אותן.
נוכל גם להשתמש ב5w בלי פקודה רק כדי לנוע 5 מילים קדימה.
אני לפחות (ואולי זה אומר משהו עלי?) מוצא משהו כיפי ביכולת להתייחס לתנועה בטקסט כ"מיני סקריפט" כמעט.

לקסטם לקסטם לקסטם:

.vimrc (או _vimrc בחלונות) היא התוכנית (שאמורה להיות בתיקיית Home שלכם) היא הקובץ שבו משנים ומגדירים את "הכל" בvim. הרבה מהפקודות שאתם יכולים להריץ ב"מצב פקודות" אפשר פשוט לכתוב ב.vimrc (כמובן בלי : לפני). יש טוטוריאל מובנה בvim לקנפוג הראשוני בהרצה של הפקודה :help vimrc וגם example שאפשר פשוט להעתיק. אפשר גם להשתמש באחת מהאופציות "האולטימטיביות" עד שתרגישו יותר בבית לכתוב אחת כזו בעצמכם. אחרי שתרגישו קצת יותר בבית תגלו שיש המון מפתחים ששומרים את הDot files שלהם בGithub. אפשר לעיין ולהתרשם. (מנהג שימושי שעוברים בין מחשבי פיתוח, סביבות vagrant וירטואליות ועוד).
עוד מקור יכול להיות בvimbits אתר שמציג ומדרג snippets של vimrc. יש עוד עולם שלם של קסטום Vim, כולל יקום חלופי של פלאגינים, קבצי .before_vimrc ו.after_vimrc ושפת תכנות בשם vimscript שמאפשרת ליצור את הפלאג ינים, סקריפטים וכו'. נשאיר את זה למדריך מתקדם יותר.
הפנייה ראשונית לפלאגינים מומלצים (ועל כל אחד כזה יהיה ויכוח) יש במדריכי הוידאו של Nettuts.
לפני הכל מומלץ להתקין את Pathogen מבית Tim pope מפתח הplugins הסופר פורה לvim (מהר מאוד תתמכרו אליהם). Pathogen או אחיו הגדול Vundle מאפשרים התקנת plugins פשוטה לVim.

רגע של עברית

השימוש בעברית בVim הוא לא חוויה מענגת. נכון, זה עובד קצת יותר טוב מSts2 המהולל והאהוב, אבל עדיין חוויה "קצת" מפוקפקת. יש אפשרות לעשות :set למצב מימין לשמאל שיציג את העברית (אך לא האנגלית) נכון. אבל כל עוד אנחנו בעברית קיצורי המקלדת לא ממש יעבדו לנו. בכל מקרה הנה ההמלצות מויקיפדיה לvim בשפת הקודש ויש גם hspell לאיות אם תתעקשו.

Vim כIde

Vim הוא עורך טקסט למתכנתים. זה בא לידי ביטוי בכמה מקומות מעבר לפרודקטיביות של עריכת טקסט מהירה במיוחד. בראש ובראשונה בSyntax highlighting (שיש מובנה לרוב שפות התכנות, ולאלו שלא באות מובנה, סביר שמישהו כבר כתב כזה, כי זה אחד הדברים הראשונים שמתכנתים מקצועיים שמפתחים שפה עושים. גם אם לא, אתם יכולים לכתוב כזה בVimscript לשפה שהמצאתם זה עתה). אבל גם בקבצים שמלמדים את vim להתייחס לקונווציות העריכה של שפות שונות. אפשר לבחור סינטקס ספציפי ולעקוף את ברירות המחדל. אפשר גם לציין לvim להתייחס לקובץ שטרם נשמר, או שהוא לא זיהה אוטומטית כסינטקס מסויים. יש כמובן גם פלאגינים ייחודיים לכל שפה שמוסיפים השלמת טקסט, איתור שגיאות, קמפול, התייחסות לקונוונציות מסוימות (pep8 בפייטון למשל) ועוד. בגדול, לפני שאתם כותבים שורה בVimscript תחשבו לעצמכם, שכמה מיליוני מפתחים בעשרות השנים האחרונות כבר בטח ניסו לעשות מה שאתם עושים עכשיו ומישהו מהם טרח וכתב את הסקריפט הזה לפניכם, או שהפקודה בכלל מוטמעת בVim, שווה לגגל.

Vim למגניבים

או – איך נעשה שזה יראה קצת יותר כמו Sublime Text 2?

#!vim
vim set background=dark  
colorscheme monokai  
set guifont=Ubuntu_Mono:h12 
"need to install ubunto fonts from:fonts.ubuntu.com

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

buffers, טאבים וחלונות

הכנסו לשורת הפקודה ופתחו קובץ טקסט עם vim:

#!bash
vim textfile.txt

כעת, בקובץ שיפתח בצעו כמה פעולות עריכה ואז ממצב הפקודה הקישו

#!vim
:e anotherfile.txt

והופ – נפתח קובץ חדש! אבל הי ? איפה הקובץ הקודם שעבדנו עליו? מה קרה לו? אם נכנס לשורת הפקודה בvim ונכתוב:

#!vim
:buffers "או גם 
:ls 

נגלה את רשימה הbuffers הפתוחים. ונוכל לעבור ביניהם עם הפקודה

#!vim
:buffer 2 "בשביל להכנס לבאפר מספר 2 
" או לחילופין:
 :b 2

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

#!vim
:tabe newfile.txt "this would go for a new tab

אבל אין קשר הכרחי בין בפארים לטאבים. יכולים להיות באפרים שלא מוצגים באף טאב/חלון כרגע ויכולים שתי טאבים להציג את אותו באפר.

על חלונות (שיכולים להתפצל לאורך או לרוחב) תקראו כבר לבד..

והנה הסבר טוב יחסית למה זה buffers ומה ביניהם לטאבים, חלונות ועוד ומשם גם תמונה מממחישה:

תמונת אילוסטרציה: טאבים, באפרים וחלונות

]16 תמונת אילוסטרציה: טאבים, באפרים וחלונות

Vim לקצת יותר מתקדמים

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

Vim, במקום סיכום

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


Vim בקיצור – נספח לטובת קוראינו העצלנים וחסרי הסבלנות לטקסטים ארוכים באנגלית:


הנה תקציר, מעבר למה שכתבנו קודם.

ניווט בטקסט.

מעבר לשימוש ב h,j,k,l הסטנדרטי, vim מאפשר להשתמש בטקסט עצמו לניווט. הפקודות המרכזיות לתנועה קשורות בטקסט עצמו. w למילה הבאה, b לתחילת המילה או לקודמת, e לסוף המילה (וגרסאות הקפיטל של כולן יעשו משהו דומה, אך קצת שונה). יש עוד המון פקודות כאלו (ועוד המון צירופים שיושבים על הפקודות) אבל זה בסיס. כדאי לשים לב שvim מתייחס שונה לאות/טקסט שהוא מזהה כמילה/מילה בלי הרווחים וסימני ניקוד/משפט/שורה/שורה אמיתית (שיש בסופה סימן "שורה חדשה") ויש לו פקודות בהתאמה לכל אחד מהמקרים (ובטח גם לעוד כמה)

איפה אני

לחיצה על הצירוף ctrl-g תגלה במהירות באיזו שורה וטור אני נמצא. לחיצה למשל על 45G תיקח אותי לשורה 45. שעה ש gg יקח אותי לסוף הטקסט וG להתחלה שלו

החלפת טקסט

`r ``` מאפשרת להחליף את האות שאתם עליה באות אחרת. אבל גם בלהכניס טקסט מbuffer כזה או אחר
בשביל החלפה גדולה יותר נשתמש ב c
לא עובדת בפני עצמה, אלא יחד עם תנועה. כך למשלcw יאפשר לנו עריכה מחליפה של המילה הבאה.

מחיקה

x מוחק את האות שמתחת לסמן. d הוא פקודת מחיקה (וגם העתקה לregister בעצם) מלאה שצריכה להתלוות אליה גם פקודת כיוון. למשל dw ימחוק עד המילה הבאה וd$עד סוף השורה. לחסרי הסבלנות יש גם dd שימחוק שורה שלמה. אגב, כל פקודות עריכת הטקסט בכפול יבצעו פעולה על שורה שלמה. למשל yy יעתיק שורה שלמה.

בצע שנית

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

חיפוש

/searchword אחרי זה . יש גם אופציות (שתוכלו לחפש בקלות בvimrc של הארת הטקסט שמחפשים וחיפוש אינקרמנטלי, כזה שמציג את תוצאות החיפוש תוך כדי כתיבה. בשביל לעבור לתוצאה הבאה תוכלו לנוע עם n או למעלה N.

חיפוש והחלפה

/s/old/new הוא הנתיב הנכון לפעולה, כל השאר דומה לחיפוש כולל n וכו.

גזור/העתק/הדבק

בעצם מחיקה עם d היא גזירה, לא מאמינים? הקלידו את הפקודה :registers ותקבלו כל מה שנמחק לאחרונה. אם נרצה רק להעתיק נוכל להשתמש בy, קיצור של Yank, הביטוי הוימי להעתקה (עם איזו וריאציה שלא הבנתי). להדבקה נשתמש בput או בקיצור p. שנוכל גם להדביק רגיסטר ספציפי שנגזר עם שמו pa למשל להדביק את מה שבregister עם השם a.

יציאה/שמירה/פתיחה

:q היא פקודת היציאה. אפשר גם לאכוף יציאה גם אם לא שמרנו שינויים (או לא שינינו כלום) עם :q!. :w היא פקודת write out – כלומר שמירת הטקסט. אם הקובץ הוא ללא שם נתבקש לתת לו שם כעת. אם כי אפשר כבר בפקודה :w somename. בשילוב עם היציאה אפשר :wq שמתרגם ל"שמור וסגור" בשביל לפתוח קובץ חדש מתוך העורך (כי מחוץ לעורך אפשר פשוט לקרוא vim somefile) נשתמש ב:e קיצור לedit. ולאחריו שם הקובץ. טריק מעניין הוא שvim תומך בכל השלמות שורת הפקודה (עם tab) כך למשל שאפשר לנווט את הPath לקובץ שאנחנו רוצים, עם מעט מאוד קליקים.

Undo!

u יבצע את רצף הundo הרגיל ו ctrl-r את הredo. שימו לב שU (עם קפיטל) זו פקודה אחרת לגמרי שעושה "כאילו" undo לשורה שלמה. אפשר לעשות לה Undo עם u.

הרצת פקודות מהטרמינל

:! commandname יפתח מסך טרמינל ויריץ את הפקודה שהרצנו. האפשרות הזו פותחת בפנינו גם עוד אופציית Debugging מעניינת. כי אפשר גם להשתמש בטקסט שהוא הפלט של פקודת הshell שהרצנו ישירות לתוך vim . כך למשל נכניס את הפלט של פקודת ls לתוך הקובץ שאנחנו עובדים עליו במסך: :r !ls וזה כמובן רק רמז קטן לאפשרויות. אפשר לדוגמא גם להריץ פקודת shell, כמו sed, grep, sort וחברים נוספים על הטקסט בתוך vim ולהוציא פלט לBuffer אחר.

עריכה לפני

אופציה מובילה אחת של מצב עריכה – לחיצת i. תכניס אותכם לInsert mode לפני הטקסט שהסמן עליו. אם תלחצו על I (capital i) לעומת זאת תכנסו למצב עריכה לפני הסמן ובתחילת השורה.

עריכה אחרי

האופציה המובילה השנייה של מצב עריכה – לחיצת a (מ – Append) תכניס אותם למצב עריכה אחרי הטקסט שהסמן עליו. גם כאן גרסת הA תעשה אותו דבר אבל בסוף השורה. אפשר גם להשתמש בo בשביל להתחיל שורה חדשה אחרי מיקום הסמן ובמצב עריכה או O בשביל לעשות את זה לשורה לפני השורה הנוכחית ובמצב עריכה.

ויש גם cheetsheet

ושוב לסיכום, בדיוק כמו שהמלצתי עם vimtutor, אי אפשר ללמוד Vim מקריאה, אלא רק מכתיבת ועריכת טקסט, תכניסו את עצמכם למוד הזה בהצלחה!

בעקבות שתי מפגשים בILTechTalks שבהם Wix וOutbrain הציגו את הגרסה שלהם לפיתוח מוטה CI/CD (אינטגרציה והקמה מתמדת) החלטתי להתנסות בעצמי בטכנולוגיה המלהיבה הזו ולכתוב על שרת הקוד פתוח Travis-CI – שרת הCI שמשרת רבים מהפרוייקטים בקוד פתוח כחלק מסדרת כלי הDevops שאנחנו עושים פה.

מה זה בכלל שרת CI ?

על איזה צורך הוא עונה בעצם? CI == Continuous Integration או "אינטגרציה מתמשכת" בשפת הקודש. כלומר כלי/שירות שמסייע לנו לשחרר כל הזמן קוד איכותי. החלופה? לחכות לשחרור "גרסאות" גדולות או מינוריות. לpush מרכזי לdeployment וכו'. שרת CI מאפשר לנו תמונה בפידבק קצר יחסית של מה הקוד שכתבנו עושה/לא עושה. הוא גם מאפשר להפעיל סדרה אוטומטית של פעולות בהתאם לתוצאות תהליך האינטגרציה (הBuild), כמו להעלות את הקוד לאתר/שירות וכו'. הוא גם נדרש במיוחד בפרוייקטים שבהם אנחנו מקבלים קוד מממפתחים/צוותים אחרים שלאו דווקא עובדים במשותף או במסונכרן. למשל בפרוייקטים של קוד פתוח שמקבלים Pull request ממפתח שעבד על הפרוייקט שלנו. איך נבדוק שהcommits שלו לא שוברים את הקוד? בדיוק! עם שרת אינטגרציה שיריץ עבורנו אוטומטית את הבדיקות הנדרשות מול כל commit.

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

וטראוויס החביב? הוא בדיוק שרת CI כזה. רק עם גרסה פתוחה וחינמית לפרויקטים של קוד פתוח שמתוחזקת ע"י תרומה של הקהילה והworkers שמניעים אותה נתרמים ע"י חברות טכנולוגיה שונות מהשרתים בתת ניצול שלהם (וזה גם אומר שאל תבזבזו את המשאבים האלו סתם, יש פירוט בהמשך). גם Travis-CI הוא פרוייקט קוד פתוח (וכן, עם פאצ' קטנטן שלי). travis ci

איך מתחילים

1.בדיקות. איך מה לעשות עם שרת אינטגרציה אם אין Build. נכון, טכנית בשפות דינאמיות אין Build כי אין קמפול אבל למעשה אנחנו מתייחסים כאן לבדיקות האוטומטיות של הקוד כ Build, כמו גם לעצם שרשרת ההתקנות והתלויות (Dependencies). כל אלו יכולים להצליח או להכשל ומכאן ששרת האינטגרציה יכול לבדוק אותם

2.פותחים חשבון ומגדירים Repo עושים לוגין עם החשבון GitHub שלכם ל Travic-CI ואחרי שרשימת הrepos שלכם מתרעננת בוחרים מהגדרות החשבון repo (או רבים) שטראוויס ינטר. טראוויס יסדר אוטומטית את הגדרות הhooks המתאימות בGithub. כמובן שאתם יכולים גם לשלוט בזה ידנית. (שימו לב שבחלק מהמדריכים הישנים מוסבר שצריך ללכת לGithub ולהגדיר את זה ידנית, זה כבר לא נכון)

travis add repo 3..travis.yml. מוסיפים לבסיס (root) של הפרוייקט שלכם קובץ .travis.yml שמכיל את ההגדרות לשרת האינטרגציה. איזו שפה בודקים? ובאיזה גרסאות שלה?, מה משתני המערכת הנוספים (למשל גרסאות שונות של התלויות). מה צריך להתקין בשביל להריץ את הקוד? ומה סקריפט הבדיקה הרצוי.

language: python

python:
  - "2.6"
  - "2.7"
 env:
  - DJANGO=Django==1.5.1
  - DJANGO=Django==1.4.3
  - DJANGO=https://www.djangoproject.com/download/1.6b1/tarball/

matrix:
  # since isn't a Django release
  allow failures:
  - env: DJANGO=https://www.djangoproject.com/download/1.6b1/tarball/
 #the only version of django that's supposed to support 3.3
 #Note we are adding another test to the matrix this way.
 #we could also exclude a test from the matrix this way
  include:
  - python: "3.3"
    env: DJANGO=https://www.djangoproject.com/download/1.6b1/tarball/


install:
  - pip install -q $DJANGO --use-mirrors
  - pip install -r requirements.txt --use-mirrors
  - pip install -q django-setuptest --use-mirrors

script:
  - python setup.py test

בואו נפרק את זה רגע:
אנחנו מגדירים שפה (אם לא נגדיר ברירת המחדל תהיה ruby), אנחנו מגדירים משתני סביבה בenv שישתנו בין הבדיקות. אנחנו מגדירים מה להתקין לפני הבדיקה ואיזה סקריפט בדיקה בדיוק להריץ. שימו לב שיש לא מעט אמצעי בדיקות וסביבות שבאים מותקנים מראש בruntime של travis אבל אם אין אז צריך להתקין אותם ברירת המחדל היא מטריקס בדיקות שכולל את כל ההצלבות השונות בין הגרסאות שפה לגרסאות משתני הסביבה, אבל אפשר לקסטם גם את זה.
למשל נוכל להגדיר (כמו בדוגמא) שיש הצלבות שלא נרצה לעשות כי הן לא שימושיות. או בדיקות שנרצה לעשות כדי לדעת מה התוצאה אבל לא להחשיב את התוצאה שלהם בעובר/לא עובר.

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

שימו לב! גם אם הגדרתם הכל, עד שתעשו Git push השרת לא יתחיל להריץ את סט הבדיקות.

מה עכשיו?

עכשיו תתחילו לקבל דיווחים במייל או באתר עצמו על מצב הbuild. travis build status כל Job שמוצג בMatrix הוא ההצלבה בין המשתנים השונים שהגדרנו בקובץ ואפשר בלחיצה עליו לראות את הconsole ממש (וככה להבין אם עשינו שגיאה בהגדרות, כמו שקרה לי לפחות לא מעט)

travis job console

טיפים ודגשים

  • בדיקת סינטקס: כלי נוסף שיכול לסייע הוא הLinter של Travic-ci . בעצם בודק תקפות של ה.travis-ci יש גרסה וובית וגרסת gem שיודעת לעשות את זה משורת הפקודה. האמת שהוא לא תמיד "תופש" את כל השגיאות עדיין (והוביל אותי כך לטעות די מביכה) אבל אני בטוח שזה ישתפר בקרוב.
  • קירות שקופים כל מי שיושב ובוהה במסך של טראוויס יכול לראות את הBuild שלכם נבנה. אם אתם בStealth mode עם הפרוייקט שלכם (אפילו עם פרוייקט קוד פתוח סודי) כדאי שלא תלכו לכיוון הזה (או אם אתם מתחזקים פרוייקט קוד פתוח חשוב במיוחד שיש סיבה שיהיה סודי עד ההשקעה צרו איתם קשר, אני מכיר מקרה אחד לפחות, שזה עבד). אבל אני חושב שעצם ההתנסות בשרת כזה היא חשובה ותתן לכם/לכן כלים להטמיע כזה אח"כ בתוך הארגון שלכם. בכל מקרה, אם העניין שדורש פרטיות וסודיות הוא מפתחות הפעלה כאלו ואחרים אז Travis כן מאפשר להצפין מחרוזות כאלו אם תתקינו את הGem שלו ולהשתמש במחרוזות האלו ב.travis.yml שלכם. אגב, אם יש לכם Private repo (אבל לא Github enterprise מקומי) יש אפשרות לשירות בתשלום שלא יהיה גלוי.

  • לדווח אחורה אפשר להגדיר ב.travis.yml אמצעי יצירת קשר שונים. ברירת המחדל היא שתקבלו אימייל עם עדכון לאימייל שמחובר לחשבון github שלכם, אבל אפשר להגדיר עוד אימיילים, IRC, webhooks שיגעו בurl מיוחד שבניתם וכו'

  • no ci לא כל קומיט צריך להריץ בדיקה. לפעמים זה סתם תיקון בטקסט של האתר שלא משנה כלום. לפעמים זה קומיט אחרי שינוי קוד גדול שאנחנו עוד רוצים להריץ בדיקות מקומיות לפני הטראוויס. סתם אנחנו רוצים לחסוך משאבים לקהילה (וכאמור, מדובר במשאבים שהקהילה מממנת) במקרה הזה נוסיף להודעת הcommit את הצירוף: [no ci]. חוץ מזה: בדיקות סינטקס פשוטות וlint בסיסי אולי כדאי לעשות בתוך git pre-commit hook ולא כחלק מחבילת הבדיקות הכללית. איך? זה כבר עניין לפוסט אחר.
  • אין עבר טראוויס מבודד את הבדיקות זו מזו, אין קשר בינהם, אין מידע שנשמר, אין תלויות שמותקנות לכמה בדיקות. הכל מחדש בכל פעם. בדרך כלל זה משרת אותנו מצויין ומונע מאיתנו ליפול בטעות שנובעת מState שנשמר על המכונה שלנו. אם נרצה יותר state נצטרך שהסקריפטים של הבדיקות ישדרו תוצאות לשירות אחר וידעו למשוך משם את הstate הקודם.

דוגמא

הפרוייקט לדוגמא שהוספתי לו בדיקה בTravis-ci הוא Django-localflavor-il (בפורק שלי) חבילת הקסטום לעברית של הולידטורים של טפסי Django. פייטוניסטים יכולים להעזר במדריך להוספת סביבת בדיקות עצמאית מול Travis-ci (בלי התקנת django מלאה מסביב) לdjango app שאפשר למצוא כאן שמתבסס על STUB שמשלים את הנתונים החסרים לdjango להרצת הבדיקות.

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

רשימת קריאה

האינטרנט בשירות הקידמה החברתית אוקי, זה טקקראנצ' שהם תמיד "האינטרנט, האינטרנט, האינטרנט" אבל דווקא כתוב היטב ומבוסס עובדות, גרפים והשוואות. ממוקד בעיקר באיך הרשת והאופן שהיא עובדת סייע לשרת את המאבק בחקיקה האנטי גאה של DOMA ותיקון 8. ויש גם "ביצת הפתעה" של גוגל לרגל הפסיקה (אנגלית). all for freedom

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

עם מות

אף פעם לא שמעתי, עד השבוע שחלף, על דאג אנגלברט. אבל עכשיו שהוא מת, השם שלו מופיע בכל מקום, רק גוגל דודל חסר ואני מניח שכזה יופיע בשנים הקרובות ביום השנה/יומההולדת. החגיגה סביבו היא כי ב1968 הוא (יחד עם עוד 17 חוקרים) הציגו לכ 1000 חוקרים ואנשי מחשב דמו פועל לעתיד המחשוב כפי שהם ראו. הדמו הזה, שזכה מאוחר יותר לכינוי "אם כל הדמואים" (ואפשר לראות קטעים ממנו כאן) הפך את אנגלברט לאחד הדמויות המשפיעות כנראה בהיסטוריה המוקדמת של עולם המחשבים המודרני. מה היה בו: מחשבים שמחוברים ברשת (שתהפוך להיות ארפא נט – האמא של האינטרנט) ושולחים זה לזה הודעות עיבוד תמלילים ממוחשב וגם משותף. פרוטוטיפ של העכבר, מסך משותף, שיחת וידאו ועוד. כמובן שלא הכל טוב, בעשרות השנים האחרונות לחייו הוא לא הצליח לקבל מימון למחקר שלו (עוד "הצלחה" של עולם המחקר מונע התעשייה הפרטית). ההצלחה הגדולה של המחשב האישי (שהשתמש בעכבר ובקונספט התוכנות שהוא הציג) דחקה הצידה הרבה ממה שנלמד בעידן המחשוב המרכזי. גם האידיאולוגיה מאחורי המחשוב האישי – הPc, ליברטיאנית וללא "סוציאליזם" של חלוקת מחשבי מחשוב משותפים (נוסח מה שהיה במחשוב המיינפריים באוניברסיטאות של אז) התאימה לעידן רייגן וחיסול מדינת הרווחה כמו גם לתפישה העצמית "היזמית" של עמק הסיליקון. רק בעשור האחרון אנחנו חוזרים לעידן המחשוב המשותף, מה שהיום נקרא "הענן" ובעצם הוא חוות שרתים משותפות שהרבה ממחשבי המחשוב שלנו רצים עליהם. המחשב האישי/הטבלט/הסמרטפון הם כולם תחנות עבודה של מערכות שרתים כאלו. רק שהמחשוב המשותף הזה הוא היום בשליטת חברות פרטיות: המידע שלנו שייך לגוגל, השירותים רצים על שרתים של אמזון, מערכת הפעלה סגורה מניעה את מנוע הרווחים המונופלי של Apple , ענקית האלקטרוניקה של דורנו. המחשוב המשותף חזר אבל הוא בשליטה פרטית. פרטית ושל מישהו אחר (אם שם המשפחה שלכם הוא בזוס אני מתנצל מראש).דיסטופיה ממוחשבת של השוק הפרטי עם פיקוח של האח הגדול בדמות Prism. האם אפשר לחזור לחלום של מחשוב משותף שלא מתבסס על השוק הפרטי? החלום שהניע את תחילת המחקר האקדמי בתחום ואת תנועת התוכנה החופשית. לעתיד פתרונים.

קוד פתוח

רולטת קוד פתוח כשמה כן היא, רולטה ששולפת Pull requests מפרוייקטים ומעיפה אותם על מפתחים מתנדבים לreview, בדיקה ושיפור.

מפתחים

איך להשאר מעודכן בטכנולוגיית רשת מודרנית. אתר/רשימה עם הפניה למקורות, אנשים, אתרים וכו'

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

Ascii standard code

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

Sublime Text 3! שוחרר! הנה שחרור שחיכינו לו כבר ה ר ב ה מאוד זמן. מעבד הטקסט מהעתיד מקבל יכולות חדשות ומהירות עוד יותר מרושעת. #מעולה

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

עם קורטוב מלח – כבר כתבנו בעבר על Salt מערכת לניהול קונפיגורציה לשרתים (והכוונה ל"הרבה" שרתים) כתחליף חדש ופייטוני לPuppet וChef שהן הסטנדרט נכון להיום בתעשייה. בקישור פוסט מוצלח שמסביר איך מתחילים.

טבלאות פיבוט טבלאות Pivot הן אחד מהפיצ'רים רבי העצמה והמוצלחים באקסל, כלי עבודה שאני משתמש בו כל יום לחיתוך ועיבוד אינטראקטיבי של סדרות נתונים. Pivottable.js מביאה את זה לדפדפן, בJS.

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

Html5 חידושים מהחזית (והפעם: קצת מסביב) html5 logo

קומוניסטים דואגים לעובדים. וקומוניסטה היא ספריה שמקלה על ההתעסקות עם העובדים בjs. הלא הם ה Web workers. הספריה מספקת Api ידידותי מאוד ומבוסס Promises.

שימוש בLocalstorage יחד עם הMV* פריימוורק באפליקציות ווב. Localstorage הוא מהחידושים המועילים של Html5 (אם כי לא בטוח שטכנית הוא חלק מהSpec הזה) תחליף נקי ומודרני לשימוש בעוגיות ושאר מרעין בישין לשמור מידע בצד הclient. פוסט של אלכס יאנג מDailyJS על איך לשלב שימוש בLocalstorage בJs framework הדומיננטיות היום: Backbone וAngular.js (אין התייחסות לember בפוסט) ואולי לעוד כמה.

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

מדריך שנכתב תוך כדי תנועה, תוך כדי ההכרות שאני עושה עם Vagrant.

מה זה בכלל Vagrant

אפשר להסתכל על Vagrant רק כעוד הפשטה של התקנת מכונה וירטואלית ללא ממשק המשתמש הגרפי. כותבים פקודה פשוטה בטרמינל והופ. יש לנו מכונה וירטואלית (כאמור, Headless) שאפשר לעשות אליה וממנה ssh, port forwarding וכו'. אבל בעצם מדובר על משהו שימושי ומתקדם יותר. Vagrant משלבת בהקמת המכונה הוירטואלית כלי הקמה (provisioning) מתקדמים: מShell scripts לאלתור מהיר ועד הסטנדרט בתעשייה של Puppet וChef. כך שאנחנו יכולים בקלות להקים את המכונה הוירטואלית עם כל התוכנות שאנחנו רוצים שהיא תריץ – בפקודה אחת! וכמובן לשכפל אותה בין המפתחים השונים בצוות. בעצם מדובר בכלי לניהול Dependencies וקונפיגורציה ברמת מערכת ההפעלה עצמה. כלי שמתמודד עם בעיית "אני לא מבין מה הבעיה, במכונה שלי זה פעל מעולה".
vagrantup

עוד שימוש אפשרי לVagrant הוא בדיקה של תסריטי Provisioning שונים. כיוון שאותה מכונה יכולה להיות מוקמת גם בAmazon וגם על המחשב שלי אנחנו יכולים לדייק את סקריפט ההקמה בפשטות של פיתוח מקומי (וללא העלות הנוספת של אחזקת שרתי הניסוי) ורק אח"כ להשתמש בסקריפט להקים את השרתים המבוקשים. הי, יש אפילו plugin לVagrant שמאפשר להקים שרת ישירות באמזון כולל ssh, תיקיות משותפות (Via Rsync) וכו'.

בעצם Vagrant הוא חלק מהתפישה החדישה של "תשתית כקוד" (Infrastructure as code) של ניהול התשתית וההקמה לתשתית ע"י מערכות קוד (ושמירת קוד – כמו Git) בדיוק כמו התוכנות שרצות עליהם.

התקנה

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

השלב הבא הוא התקנת Vagrant, תורידו את הגרסה האחרונה שמתאימה למערכת ההפעלה שלכם (לינוקס, מק, חלונות), נכון לכתיבת שורות אלו מדובר בגרסה 1.2.2 ותתקינו. ההתקנה אוטומטית ברובה ולא דורש התאמצויות מיוחדות, בחלונות כן נדרש Restart אחרי ההתקנה. בודקים שהכל עובד בשלב זה. פשוט בלפתוח את הטרמינל שלנו (שורת הפקודה) ולכתוב: $vagrant --version ונקבל:
Vagrant version 1.2.2 (או גרסה אחרת)

הקמת מכונה וירטואלית

בשפה של Vagrant, התבניות להקמת מכונה וירטואלית נקראות קופסאות: Box. יש המוני Box מוכנות שבאות מהקופסה. ויש חברות או אתרים שמספקים כאלו באינטרנט (וגם אתם יכולים, אבל זה נושא מתקדם יותר מהמדריך הזה) עם פרה קונפיגורציה מסויימת. למשל האתר Getting started with Django מספק VM ארוז כזה לVagrant שמקים סביבת פיתוח לינוקסית מתאימה לDjango. אפשר להוריד מראש Box למחשב שלנו עם הפקודה vagrant box add ואפשר גם לטעון אותה כחלק מההקמה. כמו שנעשה במדריך הזה (וכמו שעושים במדריך של Vagrant)

אז איך מתחילים?

$mkdir myfirst_vagrant (או כל שם אחר) $cd myfirstvagrant
$agrant init precise32 http://files.vagrantup.com/precise32.box

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

ותקבלו: A `Vagrantfile` has been placed in this directory.
You are now ready to `vagrant up` your first virtual environment!
Please read the comments in the Vagrantfile as well as documentation on `vagrantup.com` for more information on using Vagrant.

אם תעיינו עכשיו בתיקייה תוכלו לראות שנוצרה שם Vagrantfile.

ה Vagrantfile

נפתח עם העורך את הVagrantfile ונעיין בה. הVagrantfile היא המקום שנשמרת בו הקונפיגורציה שלנו. היא נוצרת עם פקודת vagrant init (ועם נוסיף משתנים מסויימים לפקודה היא גם תטען אותם ישירות לתוכנית) אפשר לראות שכיוון שטענו ישירות Box בפקודת הInit יש אליה כבר התייחסות בvagrantfile. אפשר גם לראות שיש שם מקום לטפל בport forwarding ובתסריטי ההקמה (provisioning) ולמיקום התיקיות המשותפות בין הVM למחשב הפיתוח שלכם (כן, ברור שיש כאלו, ומומלץ להשתמש בהם אלא אם אתם רוצים לערוך בNano את התוכניות שלכם, או משהו בסגנון. כרגע לא נתעסק עם זה ונעשה:

 vagrant up 

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

 vagrant ssh 

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

הסתיימה ההורדה וההתקנה והופ, נכנסתם לטרמינל של המכונה הוירטואלית שהותקנה. פשוט לא? כדאי לשים לב שעצם היציאה עם exit מהטרמינל יוצא מהמכונה הוירטואלית אבל היא ממשיכה לרוץ ברקע. פקודות נוספות יכולות לטפל במצבים שונים של כיבוי, הקפאה והשמדה של המכונה (vagrant halt, vagrant suspend, vagrant destroy) שתוכלו לקרוא עליהם בתיעוד.

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

ממשק שורת הפקודה

זו אולי הזדמנות להתעכב רגע על ממשק שורת הפקודה של vagrant.

עוד לא סיימנו

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

הפניית פורטים (ישירות מהתיעוד הרשמי)

תמצאו את השורה עם network:forwarded_port ותתקנו בהתאם למה שאתם רוצים (וכמובן תורידו את הcomment מתחילת השורה).
Vagrant.configure("2") do |config| # other config here
config.vm.network :forwarded_port, guest: 80, host: 8080

שיתוף תיקיות

ברירת המחדל של vagrant היא להגדיר את תיקיית הroot של הפרוייקט במחשב המארח כתיקייה משותפת, במקרה של הדוגמא שלנו מדובר על תיקיית: myfirst_vagrant במחשב המארח שתמופה ל /vagrant במחשב הוירטואלי. סביר שנרצה לעשות משהו חכם יותר עם ההגדרה הזו ואז (שוב תחת אותה שורת כותרת כמו בדוגמא הקודמת) נעשה uncomment לשורה הזו ונתקן אותה בהתאם:

config.vm.synced_folder "../data", "/vagrant_data"

לא לשכוח להוריד את הקומנט מתחילת שורת ההגדרה הקודמת

שהפרמטר הראשון הוא התיקייה על המחשב המארח והשני איפה יופיע במחשב הוירטואלי

תסריטי הקמה

תכלס, זו עיקר החגיגה נכון? הסיבה שאנחונ משתמשים בתוכנה הזו. vagrant מגיע מהבית עם תמיכה ב4 אפשרויות מרכזיות לתסריטי הקמה: Shell – כלומר קובץ bash להרצה כלשהו. ansible (שלא שמעתי עליה עד היום) וכמובן Puppet וChef. שניהם גם בפורמט הstandalone וגם תחת שרת אב.

עולם תסריטי ההקמה חורג ממגבלות המדריך הזה (ונקדיש לPuppet את אחד הפוסטים הבאים) אבל כמו שאתם יכולים לנחש הוא נשלט מהvagrantfile. הנה דוגמא מהתיעוד לקריאה לShell script חיצוני מתוך הvagrantfile:
config.vm.provision :shell, :path => "script.sh"

והנה מדריך נחמד לvagrant עם puppet (סדרה בעצם) לגבי האחרים, מוזמנים לתיעוד.

מתקדמים

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

אז יש עוד הרבה vagrant ורצוי להתקדם לתיעוד הרשמי שלהם. או ללמוד יותר על כלי הprovisioning כמו Puppet או chef.

יש גם כלים שמקצרים חלק מהעובדה עם Vagrant כמו Rovi.io אתר שמאפשר להוריד קונפיגורציות chef/vagrant מוכנות לתסריטים פופולריים (כרגע רק Lamp וRails) או לבנות כזה בממשק וובי נוח בלי להכיר פקודות chef. מניח שבקרוב (אולי כפפה שמישהו כאן רוצה להרים?) ישולבו גם כלי תסריטי הקמה נוספים כמו Salt.

טיפים לפתרון בעיות

  • לפעמים vagrant תתקע בהעלאת המכונה (ראו הערה קודמת על חלונות כמערכת מארחת שעוברת למצב שינה) – נכון שאפשר תמיד לעשות Destroy למכונה ולהקים מחדש אבל לא תמיד נרצה לעשות את זה (בפרט אם היתה לנו קונפיגורציה שבוצע "בטעות" שלא דרך הVagrantfile. דרך לדבג את הבעיה יכולה להיות לעשות Uncomment לשורות שמגדירות את vb.gui ואז המכונה הוירטואלית תפתחת עם ממשק המשתמש שלה, לפעמים נוכל לראות שם מה תוקע את המערכת ומה צריך לתקן. יש עוד פתרונות לבעיות נפוצות בwiki של vagrant .ב Github.

שיהיה בהצלחה!

רשימת קריאה

AEmoji_E010פוסט קוד פתוח – דור הGITHUB אומר לא לתנועת התוכנה החופשית (טוב לא בדיוק). הזיהוי הוא לא חדש מדי, הדור החדש של מפתחים מורגלים מאוד בכלים של קוד פתוח אבל לא כל כך מדברים את השפה של התוכנה החופשית. הם מעדיפים רישיונות פתוחים יותר ו/או מתעלמים משאלת הרישיון בכלל. לאן זה מוביל? לא בטוח שלטכנו – אוטופיה של כותבי הקוד.



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

אילוסטרציה: "לא" תת המעמד הלא אקזוטי.

אילוסטרציה: "לא" תת המעמד הלא אקזוטי.

נכון, יש לי בעיה עם הנטאי הליברטריאני של המאמר, גם באנטי ממשלה וגם בטכנו – אוטופיזם. אבל אני חושב שהוא מוסיף תובנה חשובה.

ברשת

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

KPCB Internet Trends 2013 from Kleiner Perkins Caufield & Byers

והאטלנטיק גם גם מסכמים עם 11 שקופיות מעניינות במיוחד לשיטתם.

(אם אתם לא רואים תרפרשו, הembed של slideshare בוורדפרס גרוע במיוחד)

למפתחים

pile of pooיוניקוד! או הדרך מAscii לאייקונים של קקי פוסט/הרצאה עם שקופיות. שעושות את המסלול המרתק מהמצאת הascii והבעיות שהיוניקוד ניסה לפתור ועד חמש ויכוחי יוניקוד גדולים כולל אימוטיקונים, דגלים וכן, ערימת קקי ומלון האהבה (את הפוסט היום מלווים אימאג'ים מהגדרות היוניקוד החדשות)

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

AEmoji_E356ספינת קוד עוד שירות שמצטרף לרשימת כלי האינטגרציה המתמדת (Continuous_integration) וההרצה המתמדת (Continuous deployment) כשירות. מה שקוראים כאן: "מבוססי מחשוב ענן". מובנה עם Github, heroku אבל עם עוד ערימה של שירותים נוספים. בתשלום, אבל רובד בסיסי חינמי.

React.js מבית פייסבוק עוד שחרור קוד פתוח של פייסבוק (אחרי Hiphop לקמפול מPhP לc++, טורנדו, שרת הפייטון המתחרה בnode.js שנולד שם, thrift ועוד). הפעם של ספריית קליינט סייד מבוססת קומפוננטות, כמו שאופנתי עכשיו. האמת, יש מצב שזה לא לגמרי חדש (כי כבר בגרסה 0.3) אבל אני חושב ש נתקלתי בזה רק עכשיו. מחד מעניין, גם בעצם גישת הקומפוננטות וגם בשימוש ב JSX, פורמט שהם המציאו ואמור להיות "xml לרשת", שמתקמפל לאובייקטים ומתודות של Js.

AEmoji_E1DDאבל אני לא בטוח שאני רץ לזה .. נראה לי שפייסבוק התרחקו מדי מטכנולוגיות הרשת הסטנדרטית של עולם הHTML והJS בניסיון לעשות את הרשת xmlית יותר, ניסיון שכמו שחלקנו עוד זוכרים כשל לגמרי עם XHTML 2.0. ובכלל: כמו שמראה ולאד יאזבין בפוסט ההשוואה שכתב בין Angular.js לReact.js. אפילו את הדוגמה מהמדריך של React אפשר לכתוב בהרבה פחות שורות והרבה יותר ברור עם Angular.
כך שלא נראה, לפחות בעיני, שיש בReact את מה שצריך: ערך מוסף ייחודי, כזה שנדרש בכדי לתפוש מקום רציני בשוק הצפוף גם ככה של js framework וfull frontal frameworks שכבר קיים היום. אולי למי שממש מרגיש יותר נוח עם XML (כמובן, אין איך להרגיש נוח עם XML, זה שווה ערך לחיתול מבוגרים).

Dimple.js מנסה להציע Api פשוט יותר לאובייקטים של ספריית הגרפים והויזואליזציה הלוהטת D3.

עד כאן, נשתמע

הרשמה

קבל כל פוסט חדש ישירות לתיבת הדואר הנכנס.