ארכיון

ארכיון לקטגוריה ‘concept’

שמירה על קבצי mxml מסודרים על ידי שימוש ב-ViewHelpers

20 אוגוסט, 2010 אבי צוראל View Comments

כמתכנתי פלקס, אנחנו עובדים המון עם קבצי mxml. קבצים אלה נועדו להוות את הview שלנו בדיוק כמו ש-html מהווים את ה-markup של דפי אינטרנט.

היות ואפליקציות פלקס מכילות לוגיקה שקשורה ל-view, לוגיקה שקשורה ל-services וכן הלאה, אני תמיד בעד לשמור דברים מסודרים ונקיים, כחלק מהעקרונות של clean code. לכן, אני מאוד אוהב שקבצי ה-mxml שלי מכילים אך ורק קוד mxml ללא קוד actionscript כלל וכלל.

איך אני עושה את זה?

אני עושה שימוש במשהו שאני קורא לו ViewHelper. אין להתבלבל אגב עם המימוש של Cairngorm ל-ViewHelper מכיוון שזה לא אותו הדבר, אני עושה שימוש ב-custom class רק כדי לשמור על קוד מאורגן ונקי.

את השיטה הזו אפשר לממש ללא קשר לפריימוורק mvc שאתם עושים בו שימוש (אני אגב משתמש ב-RobotLegs).

מה השימוש לViewHelper?

השימוש הוא בעצם לשמור את כול קוד הActionScript מחוץ לקבצי הmxml שלנו. כמו כן, ליצור משהו גנרי שאנחנו יכולים להשתמש בו דרך כול האפליקציה ושתהיה שפה משותפת. כך למשל, אפשר שהViewHelper יכיל אוסף של ולידציות שאפשר להוסיף לView, כמו כן הוא יכיל Event Listeners שקשורים לאותו View וכו'.

אוקיי, אז איך נראית אפליקציה לדוגמא?

כך נראה מבנה הקבצים שלנו בתוך Flash Builder 4

Screen shot 2010-08-19 at 5.26.08 PM

ניתן לראות שיש לנו את האקליקציה המרכזית, יש לנו View component יש לנו את ה helper של ה view component הזה ויש לנו את הקלאס BaseViewHelper שמכיל את כול השדות והפקודות שכול ViewHelper יורש מהן.

אז בואו נראה איך נראה הקוד של BaseViewHelper

אגב, מדובר בגרסא מופשטת של הקלאס, באפליקציות שלי בד"כ הקלאס הזה כולל עוד מספר דברים כמו למשל ולידציות addFieldToValidation וכו'.

package com.kensodev.core
{
	import mx.core.UIComponent;

	public class BaseViewHelper
	{
		private var _view:UIComponent;

		public function BaseViewHelper()
		{

		}

		public function init():void
		{

		}

		public function set view(v:UIComponent):void
		{
			_view = v;
		}

		public function get view():UIComponent
		{
			return _view;
		}
	}
}

אז כמו שאפשר לראות יש לנו כאן referance לview שיכול להיות כול uiComponent וזה בערך הכול, אפשר להרחיב את הhelper לכול צורך שאתם רואים, למשל להצמיד לכול View מודל מסוים או dataProvider שצריך להיות bindable ועוד.

עכשיו, איך נראה ViewHelper שיורש מה base class שלנו?
כך


package com.kensodev.views.helpers
{
	import com.kensodev.core.BaseViewHelper;
	import com.kensodev.views.MyViewComponent;

	public class MyViewComponentHelper extends BaseViewHelper
	{
		public function MyViewComponentHelper()
		{
			super();
		}

		public function get myView():MyViewComponent
		{
			return MyViewComponent(this.view);
		}

		public override function init():void
		{
			//TODO Auto-generated method stub
			super.init();
		}

		public function myButton_clickHandler(event:MouseEvent):void
		{
			// TODO Auto-generated method stub
		}
	}
}

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

עכשיו לחלק האחרון, כך נראה הView שלנו

<?xml version="1.0" encoding="utf-8"?>
<mx:Canvas xmlns:mx="http://www.adobe.com/2006/mxml"
		   width="400"
		   height="300"
		   creationComplete="helper.init()"
		   xmlns:helper="com.kensodev.views.helpers.*">

	<mx:Script>
		<![CDATA[

		]]>
	</mx:Script>

	<helper:MyViewComponentHelper view="{this}" id="helper" />

	<mx:Button id="myButton" click="helper.myButton_clickHandler(event)"

</mx:Canvas>

כמו שאפשר לראות, אנחנו כוללים את הhelper בתוך הview מה שגורם לו להיות "מופעל", כמו כן ניתן לראות שבקליק על הכפתור אני מפעיל פונקציה בתוך הhelper במקום לכתוב את הפונקציה ישירות על אותו הקובץ

דרך אגב, יש מוסכמה על השמות, כך שבעצם קל מאוד למצוא את הקבצים האלה במערכת
אם יש לכם view שנקרא myViewComponent אז הhelper שלו יקרא myViewComponentHelper והמודל שלו יקרא myViewComponentModel והקומנד יקרא myViewComponentCommand וכן הלאה.

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

Screen shot 2010-08-19 at 5.36.53 PM

קוד המקור של האפליקציה נמצא בgit, תרגישו חופשי להוריד ולראות איך זה בנוי.
http://github.com/KensoDev/view-helper-example

על אמנות ביצירת תוכנה – Software Craftsmanship

27 יולי, 2010 אבי צוראל View Comments

לאחרונה חתמתי על המניפסטו של Software Craftsmanship.

הקדמה

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

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

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

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

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

האומנות ביצירת תוכנה, מה זה?

Software Craftsmanship היא מעבר לכול גישה או פילוסופיה, יש לה המון נקודות משותפות עם xp (extreme programming), אבל כפי שכבר אמרתי, זוהי לא מתודולוגיה, היא לא מגדירה עקרונות low level בפיתוח תוכנה כמו tdd או refactoring.

ישנו ספר שעוסק בנושא, אני מאוד ממליץ על קריאה שלו: הנה לינק אליו

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

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

ממשיכים…

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

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

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

ממשיכים…

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

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

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

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

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

רגע רגע, אני מתכנת .net, זה רלוונטי לי?

הממ, האמת היא שחשבתי הרבה על זה, בכול הפוסטים שמדברים על זה מדברים על זה שאין שום טכנולוגית open source שלא מתאים להחיל עליה softwre craftsmanship.

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

יש לי צוות של 20, האם אני יכול להגיד שהם עובדים תחת הכללים של software craftsmanship?

לא

האמת, לא

ושוב, לא

כאן, אני מסכים לגמרי עם מי שכתבו את הmanifesto, מדובר על צוותים קטנים בהם יש 1-2 craftsman ועוד 3-4 מתמחים, העבודה בצוותים קטנים מאפשרת להדגיש את העקרונות הנחים בצורה טובה יותר, אין שום בעיה ש20 איש יעבדו כך, אבל הם צריכים להיות מחולקים לצוותים קטנים יותר עם מספר מומחים קטן ומספר מתמחים גדול יותר בכול צות פיתוח קטן.

מה הקשר לדוד בוב?

uncle bob (חפשו בגוגל, אל תהיו עצלנים) הוא אחד הspeakers הטובים ביותר שיש לנו בתחום, הוא הגדיר את הפילוסופיה כ"חזרה לבסיס" או "לעשות את הבחירות הנכונות". בוב אגב, הוא הכותב של הספר clean code (עוד המלצה).

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

סיכום

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

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

כמובן, שאני כאן לכול שאלה ואשמח לעזור, רק תשאירו תגובה ואני אענה