Operators in Java (part II)

කොහොමද යාලුවනේ? අද පාඩම පටන් ගන්න ඉස්සෙල්ල දෙයක් තියෙනව කියන්න. ඔන්න ඔයාලට මේ බ්ලොග් එකේ පලවන ලිපි ගැන ලේසියෙන්ම දැනගන්න අලුත් facebook group එකක් හදල තියෙනව. මේ group එකේ ලිපි docs ආකාරයෙන් ලිපියෙ පොඩි කොටසක් එක්ක ලිපිය සඳහා ලින්කුවක් සමග අපි පල කරනව. එතකොට ඕනෑම කෙනෙක්, group එකට පසුව එකතු වෙන කෙනෙක්ට වුනත් ඉතා පහසුවෙන් මුල සිට පල වූ ලිපි සොයාගන්න පුළුවන්. Group එකේ සම්පුර්ණ ලිපි පල කරන්න විදිහක් නෑ මොකද නැවත පින්තූර, code එහෙම upload කරල ලිපිය පිළිවෙලකට හදන්න සෑහෙන වෙලාවක් ගතවෙන නිසා. නමුත් ලිපියට ලින්කුවක් තියෙන නිසා ලේසියෙන්ම ඔයාලට බ්ලොග් එකට ඇවිල්ල අවශ්‍ය ලිපිය කියවන්න පුළුවන්. ඉතිං මේ group එකට ඔයාලත් join වෙලා ඔයාලගේ යාළුවන්වත් පුළුවන් තරම් එකතු කරන්න. මොකද නොමිලේම java පහසුවෙන් ඉගෙනගන්න පුළුවන් හොඳ අවස්තාවක් මේක. ඔය පහල තියෙන button එකෙන් ඔයාලට group එකට ගිහිල්ල join වෙන්න පුළුවන්.
 

JOIN WITH US

 
හරි අපි එහෙනම් පාඩම පටන් ගමු......

මතක ඇතිනෙ අපි කලින් ලිපියෙන් java වල තියෙන operators ගැන කතා කළා. ඒ ලිපියෙ අපි simple assignment operator, string concatenation operator, arithmetic operators හා equality and relational operators ගැන කතා කළා. අද ලිපියෙන් අපි කතාකරන්න යන්නෙ ඉතුරු operators ටික ගැන. මේ ලිපිය කලින් ලිපිය සමග සම්බන්ධ නිසා කාට හරි කලින් ලිපිය මගහැරුනනම් මෙතනින් ගිහිල්ල ඒ ලිපිය කියවන්න. අපි අද මුලින්ම කතාකරන්න යන්නෙ conditional operators ගැන.



Conditional Operators

Conditional operators 3ක් java වල තියෙනව. ඒ තමයි conditional-AND, conditional-OR සහ ternary operators. හැබැයි බොහෝ දෙනා මේ තුන හඳුන්වන්නෙ වෙන විදිහකට. AND සහ OR කියන operators දෙක logical operators කියල හඳුන්වනව. එතකොට conditional operator එක කියල හඳුන්වන්නෙ ternary operator එක. කොහොම හැඳින්වුවත් කමක් නෑ operator එකේ වෙන කාර්යය දන්නවනම්. Operator එකේ නම අපිට වැදගත් වෙන්නෙ නෑ. මම සඳහන් කරල තියෙන්නෙ oracle tutorials වල තිබුන විදිහට. මම java ඉගෙනගත්තෙ එතනින්නේ. හරි අපි මුලින්ම AND සහ OR operators දෙක ගැන බලමු.

AND/OR operators දෙක භාවිත වෙන්නෙ Boolean expression දෙකක සම්ප්‍රයුක්ත පිළිතුර එක ගන්න ඕන වුණාම. ඔයාල Boolean algebra ඉගෙනගෙන තියෙනවනම් මේ operators වල ක්‍රියාකාරිත්වය තේරුම ගන්න එච්චර අපහසු වෙන්නෙ නෑ. Electronics වලට උගන්වන logic gates වල තියෙන AND සහ OR gate වල ක්‍රියාකාරිත්වයට සමාන ක්‍රියාවක් තමයි මේ දෙකෙන් වෙන්නෙ. අපි මුලින්ම බලමු conditional-AND operator එක ගැන.

Conditional-AND Operator (&&)

අපි හිතමු Boolean expression දෙකක් තියෙනව කියල expr1 හා expr2 කියල. මේ දෙක අපිට AND operator එක භාවිතයෙන් සම්බන්ධ කරන්න පුළුවන් පහත දැක්වෙන ආකාරයට.

expr1 && expr2

දැන් මේක තනි Boolean expression එකක් විදිහට තමයි ක්‍රියා කරන්නෙ. AND operator එක භාවිත කරන විට මෙම සම්පූර්ණ expression එකේ අගය true වෙන්නෙ expr1 හා expr2 කියන expression දෙකම වෙන වෙනම true වෙනවනම් පමණයි. අපි උදාහරණයක් අරගෙන බලමු.

int x = 3, y = 4;
boolean b = (x < 4) && (y > 4);

මේ code segment එකේ b variable එකට assign කරල තියෙන්නෙ AND operator එක මගින් සම්බන්ධ කරපු Boolean expression එකක්. මේකෙ expr1 ලෙස (x<4) යන්නත් expr2 ලෙස (y>4) යන්නත් ආදේශ කරගන්න පුළුවන්. අපි දැන් expr1 හා expr2 වෙන වෙනම සලකමු.
 
expr1 වෙනම ගත්තම ඒක සත්‍යයි (true). මොකද x හි අගය 4ට වඩා කුඩා නිසා. නමුත් expr2 සලකුවම එම ප්‍රකාශනය අසත්‍ය (false) බව පැහැදිලිව පේනව. මම කිව්ව AND operator එක භාවිත වෙන අවස්ථාවක එහි සම්ප්‍රයුක්ත අගය true වෙන්නෙ දෙපැත්තෙ තියෙන expression දෙකම true නම් පමණයි කියල. නමුත් මේ අවස්තාවෙදි දකුණු පැත්තෙ ප්‍රකාශනය අසත්‍යයි (false). ඒ නිසා මේ සම්පූර්ණ ප්‍රකාශණයෙ අගය වෙන්නෙ false. එම නිසා b හි අගය වෙන්නෙත් false.

Conditional-OR Operator (||)

AND operator එක හරියට තේරුම් ගත්තනම් මේක තේරුම් ගන්න එක එච්චර අපහසු වෙන්නෙ නෑ. මේකෙ තියෙන්නෙ පොඩි වෙනසයි. මම කිව්වනෙ දෙපැත්තෙ ප්‍රකාශන දෙකම සත්‍ය නම් විතරයි && භාවිත වෙනකොට ප්‍රකාශනයක් සත්‍ය වෙන්නෙ කියල. නමුත් OR (||) operator එක භාවිතයෙන් ප්‍රකාශන දෙකක් සම්බන්ධ කරද්දි ප්‍රකාශන දෙකම හෝ ඕනෑම එකක් සත්‍ය වන අවස්ථාවකදී සම්පූර්ණ ප්‍රකාශනයේ අගය සත්‍ය (true) වෙනව. මේක අසත්‍ය වෙන්නෙ දෙපැත්තෙ ප්‍රකාශන දෙකම අසත්‍ය වූ විට පමණයි. අපි ඉස්සෙල්ල භාවිත කරපු උදාහරණයම ගමු. එතන && operator එක වෙනුවට අපි දැන් භාවිත කරන්න යන්නෙ || operator එක.

int x = 3, y = 4;
boolean b = (x < 4) || (y > 4);

අපි දැනටමත් දන්නව මෙතන වම්පැත්තෙ ප්‍රකාශනය විතරයි සත්‍ය වෙන්නෙ. නමුත් මෙතන ප්‍රකාශන දෙක සම්බන්ධ කරල තියෙන්නෙ OR operator එක බැවින් මේ සම්පූර්ණ ප්‍රකාශනයෙ අගය සත්‍යයි (true).
මේ AND සහ OR operators ක්‍රියාකරන්නෙ short circuit ක්‍රමයට කියල අපි කියනව. ඒකට හේතුව තමයි මේ operators දෙකෙන් සම්බන්ධ කරන ලද ප්‍රකාශන දෙකක සම්ප්‍රයුක්ත අගය හොයනකොට පළවෙනි ප්‍රකාශනය (වම්පස ප්‍රකාශනය) පමණක් සැලකීමෙන් සම්පූර්ණ ප්‍රකාශනයේ අගය නිගමනය කරන්න පුළුවන්නම්, program එක run වෙද්දි දෙවන ප්‍රකාශනය සලකන්නෙ නෑ. උදාහරණයක්‌ විදිහට ගත්තොත් අපි දන්නව AND operator එක තියෙනකොට ප්‍රකාශන දෙකම නිවැරදිනම් පමණයි පිළිතුර සත්‍ය වෙන්නෙ. පළවෙනි ප්‍රකාශනය අසත්‍ය නම්, දෙවන ප්‍රකාශනය කුමක් වුනත් පිළිතුර false කියල අපිට නිගමනය කරන්න පුළුවන්. මේ නිසා program එක execute වීම වේගවත් වෙනව. පහල තියෙන code එක බලල ඒක වෙනස් කරල බැලුවම මේ ගැන තවත් පැහැදිලි වෙයි.

public class ConditionalDemo1 { public static void main(String[] args){ int x = 5, y = 10; boolean result; result = (x*2 == y) && (y/2 == x); System.out.println(result); //true result = (x < y) && (y == x); System.out.println(result); //false result = (x < y) || (y == x); System.out.println(result); //true result = (x > y) || (y/2 > x); System.out.println(result); //false } }

Ternary Operator

මේ operator එක ටිකක් වෙනස් operator එකක්. මේක සාමාන්‍යයෙන් භාවිත වෙන්නෙ Boolean expression එකක result එක අනුව variable එකකට අගයක් assign කිරීමට. මේ operator එක භාවිත කරන ක්‍රමය (syntax) එක බලන්නකො.

variable = (expression) ? value1 : value2;

අමුතු syntax එකක් නේද? මේක වැඩකරන්නෙ මෙහෙමයි. මුලින්ම expression එක evaluate කරනව. Expression එක සත්‍ය නම් ප්‍රශ්නාර්ථ ලකුණට පසුව තියෙන අගය variable එකට assign වෙනව, අසත්‍ය නම් colon (:) ලකුණෙන් පසුව තියෙන අගය variable එකට assign වෙනව. අපි උදාහරණයක් අරගෙන බලමු.

int marks = 60;
String result = (marks >= 50) ? "pass" : "fail";

මේ තියෙන්නෙ ternary operator එක භාවිත කරලා තියෙන උදාහරණයක්‌. මෙතැන marks හි අගය අනුව result variable එකේ අය වෙනස් වෙනව. marks, 50 හෝ 50ට වැඩිනම් result එක pass, marks 50ට අඩුනම් result එක fail. ඔයාල මේ operator එක යොදාගෙන program කරලා බලන්නකො. මොනවහරි ගැටළුවක් අවොත් comment කරන්න. දැන් fb group එකකුත් තියෙන නිසා ඒකෙ post එකක් විදිහට ගැටළු පල කරන්නත් පුළුවන්.

Unary Operators

අපි මෙච්චර වෙලා කතා කරපු operators වලට වඩා unary operators වල වෙනසක් තියෙනව. මේ operators වර්ගයේ නමින්ම ඒක කියවෙනව. අපි කලින් කතා කරපු සියලුම operators operands දෙකක් සම්බන්ධ කිරීම සඳහා තමයි භාවිත වුණේ. අපි ඒ වගේ operators වලට කියනව binary operators කියල. ඒවයෙන් සිදුකරන කාර්යයන් වලටත් කියන්නෙ binary operations කියල. නමුත් මේ unary operators පාවිච්චි වෙන්නෙ එක operand එකක් එක්ක. අපි බලමු කොහොමද කියල.

Unary operators ගැන කතා කරනකොට මුලින්ම අපිට හමුවෙන්නෙ plus (+) / minus (-) operators දෙක. මේ දෙක සාමාන්‍යයෙන් ගණිතයේ භාවිත වන විදිහට ධන හා සෘණ සංඛ්‍යා පෙන්වන්න තමයි භාවිත වෙන්නෙ. සාමාන්‍යයෙන් අපි ධන සංඛ්‍යා සඳහා ඉදිරියෙන් + සලකුණ යොදන්නෙ නෑනෙ. ඒ නිසා unary plus operator එක භාවිත කිරීම අත්‍යවශ්‍ය වෙන්නෙ නෑ.

ඊළඟට අපිට හමුවෙනවා increment (++) හා decrement (--) operators දෙක. මේ දෙකෙන් වෙන්නෙ variable එකක අගය එකකින් වැඩි හෝ අඩු වෙන එක. මෙතනදි ගොඩක් වැදගත් කරුණක් තියෙනව කියන්න මේ operators දෙක යම්කිසි variable එකකට යෙදුවොත් එම variable එකේ original value එකත් වෙනස් වෙනව. මේ කියපු දේ අපි program කරනකොට තේරුම් ගන්න පුළුවන්.

ඊළඟට තියෙනව logical complement operator එක. මේකෙන් කරන්නෙ Boolean value එකක් වෙනස් කරන එක. ඒ කියන්නෙ true එකක් false කරනව, ඒ වගේම false එකක් true කරනව. පහල මම දාල තියෙනව මේ operators යොදාගෙන කරපු program එකක්. එකත් අධ්‍යනය කරල බලන්න.

class UnaryDemo { public static void main(String[] args){ int result = +1; // result is now 1 System.out.println(result); result--; // result is now 0 System.out.println(result); result++; // result is now 1 System.out.println(result); result = -result; // result is now -1 System.out.println(result); boolean success = false; System.out.println(success); // false System.out.println(!success); // true } }

ඔයාලට පේනව ඇති ඉහත program එකේ increment සහ decrement operators භාවිත කරල තියෙන විදිහ. Operand එකට පස්සෙ තමයි අපි operator එක යොදල තියෙන්නෙ. මෙහෙම operator එක යොදනකොට අපි කියනව post increment/decrement operator කියල. මේ වගේම අපිට මේ operators දෙක operand එකට ඉදිරියෙන් යොදන්නත් පුළුවන්. මේ වගේ, ++result / --result එතකොට අපි කියනව pre increment/decrement operator එක කියල. මේ දෙකේ වෙනසක් තියෙනව. ඒ ගැන ඉගෙනගන්න පහල තියෙන program එක බලන්නකො.

public class Test { public static void main(String[] args){ int y = 1; int x = --y; //x == 0, y == 0 int z = y++; //z == 0, y == 1 int a = y++ + ++x; //a == 2, x == 1, y == 2 int b = ++z + y--; //b == 3, z == 1, y == 1 System.out.println("y = "+y+"\nx = "+x+"\nz = "+z+"\na = "+a+"\nb = "+b); } }

මම මුලින්ම පැහැදිලි කරන්නම් pre/post දෙකේ වෙනස. වෙනස තමයි pre operator එක භාවිත කරනකොට statement එක evaluate වෙන්න ඉස්සෙල්ල increment/decrement එක සිදුවෙනව නමුත් post operator එකේදි statement එක ඉවර වුණාට පස්සෙ තමයි increment/decrement එක සිදුවෙන්නෙ.
අපි program එකේ දෙවැනි statement එක ගමු,

int x = --y;

මෙතන භාවිත කරලා තියෙන්නෙ pre decrement operator එක. මම කලින් කිව්ව වගේ මෙතනදි decrement එක මුලින් සිද්දවෙනව. Y හි අගය විදිහට මුලින් තිබුනෙ 1. මේ operator එකෙන් ඒ අගය 1කින් අඩු කරනව, ඒ කියන්නෙ y ගෙ දැන් අගය 0යි. Decrement එක වුණාට පස්සෙ දැන් statement එක evaluate වෙනව. මේ statement එකෙන් කරන්නෙ දකුණු පැත්තෙ operand එක වම් පැත්තෙ එකට assign කරන එකනෙ. අපි assignment operator එක කලින් ඉගෙනගත්තනේ. ඒ නිසා දකුණු පැත්තෙ අගය වෙන 0, x ට assign වෙනව.
අපි දැන් ඊළඟ statement එක ගනිමු,

int z = y++;

මෙතන භාවිත කරලා තියෙන්නෙ post increment operator එක. මෙතනදි මුලින් වෙන්නෙ statement එක evaluate වෙන එක. y වල දැන් අගය 0යි. මතකනෙ කලින් statement එකේදි decrement එකක් වුනානෙ. ඒ නිසා z ට 0 assign වෙනව. දැන් තමයි increment එක වෙන්නෙ. Increment එකෙන් yහි අගය 1කින් වැඩි වෙනව. ඒ නිසා දැන් yගෙ අගය 1යි.

ඊළඟ statement දෙකත් මේ විදිහට හිතල කරලා බලන්න මම දාල තියෙන අගයන් එනවද කියල.

Bitwise and Bit Shift Operators

අපි දැන් කතාකරන්න යන bitwise and bit shift operators වලත් අනිත් ඒවට වඩා ලොකු වෙනස්කමක් තියෙනව. අපි කලින් කතා කරපු සියලුම operators ක්‍රියාත්මක වුණේ සම්පූර්ණ operand එකම එකක් විදිහට සලකල. නමුත් මේ operators වර්ගය operand එකේ bit එකෙන් එකට වෙන වෙනම ක්‍රියාත්මක වෙනව.
මුලින්ම අපි ගමු bitwise complement (~) operator එක. මේක unary operator එකක්. ඒ කියන්නෙ මේක ක්‍රියාත්මක වෙන්නෙ එක operand එකක් සඳහා. මේකෙන් සිද්ධ වෙන ක්‍රියාවලිය logical complement operator එකේ ක්‍රියාවට සමානයි. නමුත් වෙන විදිහ වෙනස්. මම උදාහරණයකින්ම පැහැදිලි කරන්නම්.

අපි ගමු 7 කියන සංඛ්‍යාව. මේක දෙකේ පාදයෙන් අපිට ලියන්න පුළුවන් 0111 කියල. මේක තමයි 7 කියන සංඛ්‍යාවේ bit pattern එක. අපි මේ සංඛ්‍යාවට complement operator එක යෙදුවොත් (~7) මේ bit pattern එක reverse වෙනව. ඒ කියන්නෙ 1 තියෙන තැන් 0 වෙලා 0 තියෙන තැන් 1 වෙනව (1000). මේ ක්‍රියාව සියලුම bit වලට වෙන වෙනම වෙනව. එකයි අපි මේවට bitwise operators කියන්නෙ.

ඊළඟට තියෙන්නෙ bitwise AND (&) සහ bitwise OR (|) operators. අපි conditional AND සහ OR operators වල සංකේත ලෙස භාවිත කලේ & සලකුණු 2ක් (&&) හා | සලකුණු 2ක් (||). Bitwise AND සහ OR සඳහා භාවිත වෙන්නෙ එම සලකුණු 1 බැගින්. ඒ නිසා පටලවගන්න එපා. මෙතනදිත් තියෙන එකම වෙනස තමයි මේ operation එක bit එකෙන් එකට වෙන වෙනම සිදුවීම. උදාහරණයක් විදිහට අපි 7 සහ 5 සංඛ්‍යා ගමු. මේ දෙක binary විදිහට ලිව්වම ලැබෙන්නෙ මෙහෙම, 

7 -> 0111
5 -> 0101
 

මේ දෙක මෙහෙම එක යට එක ලියාගත්තම, 1 ඒව 2ක් තියෙනවනම් පිළිතුර 1 නැත්තම් 0. ඒ නිසා (7 & 5) කියන එකේ පිළිතුර විදිහට ලැබෙන්නෙ 0101 ඒ කියන්නෙ 5. ඇත්තටම මෙතනදි පිළිතුර විදිහට ලැබෙන්නෙ මේ දෙකේ පාදයේ සංඛ්‍යා දෙකේ ගුණිතය. මේ වගේම තමයි bitwise OR ක්‍රියාකරන්නෙත්. මම OR operator එක ක්‍රියාත්මක වෙන විදිහ කලින් කියල දීල තියෙන නිසා නැවතත් මෙතැනදී කියල දෙන්නේ නෑ. නමුත් ඔයාලට මොනවහරි අපැහැදිලිතාවයක් තියෙනවනම් කොමෙන්ටුවක් දාන්න. AND එකේදි ගුණිතය වගේ OR එකේදි ලැබෙන්නෙ binary සංඛ්‍යා දෙකේ එකතුව.

ඊළඟට අපිට හමුවෙනව bitwise exclusive OR operator (^) එක. මේකත් OR operator එක විදිහටම තමයි ක්‍රියා කරන්නෙ නමුත් මේකෙදි එකිනෙකට වෙනස් අගයන් දෙකක් තිබුනොත් විතරයි පිළිතුර 1 වෙන්නෙ. උදාහරණයක් විදිහට (7^5) ගත්තොත් අපිට පිළිතුර විදිහට ලැබෙන්නෙ 0010 ඒ කියන්නෙ 2. මෙතන තියෙන වෙනස තමයි 1 ඒව 2ක් තියෙන අවස්ථාවේත් ලැබෙන්නෙ 0 වීම.

හරි ඊළඟට අපිට කතාකරන්න තියෙන්නෙ bit shift operators ගැන. මේවයෙන් කරන්නෙ සංඛ්‍යාවක් අපි දෙනලද bit සංඛ්‍යාවකින් විස්ථාපනය කිරීමයි. අපි මුලින්ම ගමු left shift operator (<<) එක. මේකෙදි කරන්නෙ වම්පැත්තෙ operand එකේ සියලුම bits දකුණුපැත්තෙ operand එකේ සඳහන් ප්‍රමාණයකින් වමට විස්ථාපනය කිරීම. මෙහිදී අගට 0 එකතු වෙනවා. පහත තියෙන පින්තුරය බලන්නකො.

මෙතන අපි 7 (00111) කියන සංඛ්‍යාව bit 1කින් වමට shift කරල තියෙනව. අපිට ලැබෙන පිළිතුර තමයි 14. මේ operator එකෙන් අපිට ලැබෙන පිළිතුර හොයාගන්න ලේසි ක්‍රමයක් තියෙනවා. අපි සංඛ්‍යාවක් bit 1කින් shift කලොත් අපිට ලැබෙන්නෙ සංඛ්‍යාව 2න් ගුණ කලාම එන අගය. bit 2කින් shift කලොත් සංඛ්‍යාව 4න් ගුණකරන්න ඕනෙ, තුනකින් විෂ්ඨාපනය කලොත් 8න්. ඔය විදිහට අපිට පිළිතුර හොයාගන්න පුළුවන්. Right shift operator එකත් මේ විදිහටම තමයි ක්‍රියා කරන්නෙ. පහල පින්තුරය බලන්නකො.

මම මේක ගැන වැඩිය පැහැදිලි කරන්නෙ නෑ. මේකෙන් පිළිතුර විදිහට ලැබෙන්නෙ සංඛ්‍යාව 2න්, 4න්, 8න් බෙදුවම ලැබෙන සංඛ්‍යාවේ පුර්ණ සංඛ්‍යාත්මක අගය.




ඊළඟට තියෙන්නෙ signed right shift operator (>>>) එක. මෙය ක්‍රියාකරන්නෙත් right shift operator එක වගේමයි. වෙනසකට තියෙන්නෙ සංඛ්‍යාවෙ ධන, සෘණ බව හඳුනාගන්න තියෙන bit එකත් shift වීමයි. ඒ නිසා මේ operator එක භාවිත කරනකොට සංඛ්‍යාවේ ලකුණ වෙනස් වෙන්න පුළුවන්.

මම bitwise operators භාවිත කරලා කරපු උදාහරණයක් පහල තියෙනව. එකත් හොඳට අධ්‍යනය කරන්න.

public class BitwiseOperators { public static void main(String args[]){ int a = 11; //1 0 1 1 int b = 12; //1 1 0 0 System.out.println("a & b : "+(a & b)); System.out.println("a | b : "+(a | b)); System.out.println("a ^ b : "+(a ^ b)); System.out.println("~a : "+(~a)); System.out.println("a << b : "+(a << b)); System.out.println("a >> b : "+(a >> b)); System.out.println("a >>> b : "+(a >>> b)); } }

එහෙනම් යාලුවනේ අපි operators ගැන කතා කරලා ඉවරයි. ලොකු පාඩමක් වගේම වැදගත් පාඩමක්. අපි අපේ පාඩමෙන් innstanceof operator එක ගැන කතා කලේ නෑ. ඒකට හේතුව තමයි ඒ operator එක පාවිච්චි වෙන්නෙ Objects එක්ක. අපි තාම objects ගැන දන්නෙ නැති නිසා අපි ඒක එතකොට කතා කරමු. අපි ඊළඟ ලිපියෙන් හමුවෙන්නෙත් ගොඩක් වැදගත් පාඩමක් එක්ක. ඒ තමයි flow control statements. අපි තවම විවිධ දේවල් ඉගෙනගත්තට හරියට programming කලේ නෑනෙ. නමුත් ඊළඟ පාඩමෙන් පස්සෙ අපිට ගොඩක් programs ලියන්න පුළුවන් වෙනව. එහෙනම් යාලුවනේ ඉක්මනට හමුවෙමු අලුත් පාඩමෙන්. අමතක කරන්නෙ නැතුව අදම අපේ facebook group එකට join වෙලා ඔයාගෙ යාලුවන්වත් ඒකට add කරන්න. එහෙනම් සුභ දවසක්!!!