08/05/2026
Type System in programming Languages
လက်ရှိသုံးနေတဲ့ Programming Languages တွေအများကြီးရှိပါတယ်။ အဲ့ဒီ programming languages တွေရဲ. Type system တွေအကြောင်းဆွေးနွေးချင်ပါတယ်။ Type ဆိုတာက programming မှာတော့ programmer ကနေ define လုပ်လို.ရတဲ့ variable တွေ object တွေ ရဲ. အမျိုးအစားကို ပြောတာပါ။ ဥပမာ integer, float, string, object အစရှိသည်ဖြင့်ပေါ့။ Type တွေကိုဘာကြောင့် ပေးထားရသလဲဆိုတော့ programmer အနေနဲ. Higher abstraction ကိုမှန်မှန်ကန်ကန် နဲ.လွယ်လွယ်ကူကူတည်ဆောက်နိုင်အောင်ပါ။ ဒီနေရာမှာ Abstraction ဆိုတာ ကိုသိစရာမလိုတဲ့ inner details (eg memory representation of float in binary)ဖယ်ပြီး သုံးနိုင်တာကိုပြောချင်တာပါ။ ဆိုလိုချင်တာက machine language level မှာ float ရယ် integer ရယ်ဆိုပြီး ခွဲထားတာမရှိပါဘူး။ အဲ့တော့ programmer က float ကို represent လုပ်ဖို.အတွက် binary representation ကိုသိဖို.လိုလာပါပြီ။ နောက်ပြီး float နှစ်ခုပေါင်းမယ်ဆိုရင် floating point arithmetic(in binary)ကိုသိဖို.လိုလာပါပြီ။ programming language တွေက float လို data type မျိုးကို ထည့်သွင်းပေးထားတဲ့အတွက် programmer တွေဟာ ခုနကလို (binary arithmetic) လို low level detail သိစရာမလိုပဲ၊ higher abstraction ကိုသုံးပြီး program ရေးလို.ရသွားပါပြီ။ နောက်တခုက type နဲ.ပတ်သတ်တဲ့ error တွေကို low level အနေနဲ.ဆိုရင် ဖမ်းဖို.သိပ်မလွယ်လှပါဘူး ၊ဥပမာ float တန်ဖိုးသိမ်းထားတဲ့ memory location တခုကို string operation သွားလုပ်ချင်လဲလုပ်နိုင်ပါတယ် ၊အဲ့ဒါကို သိနိုင်တဲ့ နည်းမရှိပါဘူး။ ဒါကြောင့် high level programming language တွေမှာ type ကိုပေးထားတဲ့အပြင် type နဲ.ပတ်သတ်တဲ့ error တွေကိုပါ ဖမ်းပေးနိုင်တဲ့ အတွက် program ရေးရတာပိုမိုလွယ်ကူ လာတာပဲဖြစ်ပါတယ်။ ဥပမာ String နဲ. Integer နဲ.သွားမြှောက်တာမျိုး လုပ်လို.မရပါဘူး ၊ လုပ်ရင်လဲ compiler ကနေ error ပြမှာပါ။ ဒါဟာ type system ပေးထားတာရယ် type system မှာလိုက်နာရမဲ့ type နဲ.ဆိုင်တဲ့ rule တွေထုတ်ထားတာကြောင့်ဖြစ်ပါတယ်။ ယေဘုယျအားဖြင့် programming languages တွေကို သက်ဆိုင်ရာ type system အရ နှစ်မျိုးခွဲနိုင်ပါတယ်။ Statically Typed language နဲ. Dynamically Type language ဆိုပြီး ခွဲလို.ရပါတယ်။
Statically Typed Language
Statically Type language ဆိုတာ ဘယ်လို programming language အမျိုးလဲဆိုတော့ သူ. Language မှာရေးထားတဲ့ variable တွေရဲ. type ကို compile time မှာ သတ်မှတ်ခြင်းခံရရင် statically typed language လို.ဆိုရမှာပါ။ နောက်သိသာတဲ့ အချက်တစ်ခုက statically typed programming language မှာရှိတဲ့ variable တွေရဲ. Data type ဟာ တသမတ်တည်း မပြောင်းလဲပဲ တည်ရှိနေမှာပါ။ ဥပမာ ကျွန်တော်တို.က variable တစ်လုံးကို int( Integer) လို.ပေးထားမယ်ဆိုရင် သူ.ရဲ. type program အစကနေ အဆုံးထိ ဟာအမြဲတမ်း int ပဲဖြစ်နေမှာပါ။ run time (program execution)လုပ်နေတုံးအချိန်မှာလဲ ပြောင်းလဲခြင်းရှိမှာမဟုတ်ပါဘူး။ ထင်ရှားတဲ့ statically typed programming language တွေကတော့ C,C++, Java,C #,Scala,Go အစရှိတဲ့ programming language တွေဖြစ်ပါတယ်။ C # ကတော့နောက်ပိုင်းမှာ type inferencing , dynamic type တွေကိုပါ support လုပ်လာပါတယ်။ အဲ့တော့ C # ဟာ hybrid typed language လို.ပြောရင်တောင်ရပါတယ်။ ဥပမာ အောက်မှာပေးထားတဲ့ Java program ဟာ error ပြပါလိမ့်မယ်
public class TypingSystemDemo {
public static void main(String[] args) {
int a = 10;
a = "Hello";
}
}
ပထမ line မှာ a သည် integer အမျိုးအစား variable လို.ကြေငြာပါတယ်။သူ.ထဲကတန်ဖိုးကို 10 လို.ထဲ့ပါတယ်။ နောက်တကြောင်းမှာတော့ a ဟာ String type အဖြစ်ပြောင်းထဲ့ပါတယ် ၊ ဒါဆိုရင် statically typed language အဖြစ်တဲ့အတွက် compiler က error ပြမှာဖြစ်ပါတယ်။ Static typed language တွေမှာ type နဲ.ပတ်သတ်တဲ့ error တွေကို compile time(program ကိုရေးပြီး compile လုပ်သောအချိန်)မှာကတည်းက ပြပေးပါတယ်။ Type operation တွေဟာ invalid ဖြစ်နေတယ်ဆိုရင် program ဟာ compiled လုပ်လို.ရမှာမဟုတ်ပါဘူး။ compilation မအောင်မြင်နိုင်ပါဘူး။ type နဲ.ပတ်သတ်တဲ့ error တွေ (ဥပမာ Java မှာဆိုရင် int ထဲကို float ထဲ့တာမျိုး) (တခြားသော syntax error)တွေမှန်မှသာလျှင် program သည် successfully compile ဖြစ်ပါလိမ့်မယ်။ Statically typed language တွေရဲ. သဘောတရားအရ variable တွေကိုကြေငြာပြီးမှ (declaration လုပ်ပြီးမှ) ပေးသုံးလေ့ရှိပါတယ်။
Dynamically Type Language
Program မှာသုံးထားတဲ့ variable တွေရဲ. Type ကို compile time မှာ သတ်မှတ်တာမဟုတ်ပဲနဲ. Runtime ရောက်မှသတ်မှတ်ပေးရင် အဲ့ဒီလို language မျိုးကို dynamically typed language လို.သတ်မှတ်ပါတယ်။ နောက်ပြီး အဲ့ဒီ variable ရဲ. Type သည် program runtime မှာကြိုက်သလိုပြောင်းနေနိုင်ပါတယ်။ ဥပမာ variable တစ်ခုဟာ ပထမ integer type ဖြစ်နေပြီး နောက်မှ string ဒါမှမဟုတ် object type အနေနဲ.ဖြစ်ချင်လဲဖြစ်နေနိုင်ပါတယ်။ Variable declaration ကိုလဲ မကြေငြာပဲသုံးမယ်ဆိုရင်လဲ သုံးနိုင်ပါတယ်။ ထင်ရှားတဲ့ dynamically typed programming language တွေကတော့ Smalltalk, Ruby, Python, PHP, JavaScript,Dart အစရှိတာတွေဖြစ်ပါတယ်။ Dynamic typed language တွေဟာ runtime မှာ type နဲ.ပတ်သတ်တာတွေကို manage လုပ်ရတဲ့အတွက် Interpreter, ဒါမှမဟုတ် Virtual Machine အစရှိတာတွေကိုသုံးရပါတယ်။ အရင်ကတော့ dynamically typed language တွေဟာ statically typed language တွေထက် performance ကွာခြားချက် အများကြီးရှိပေမဲ့ အခုအချိန်မှာ virtual machine တွေ (JIT) နည်းပညာတွေတိုးတက်လာတာနဲ.အမျှ performance ကွာခြားချက်က ကျဉ်းမြောင်းလာပါပြီ။ အောက်က program လေးက JavaScript နဲ.ရေးထားတဲ့ dynamic typing demo program လေးပါ။
var a = 20;
console.log(typeof a);
a = "Hello";
console.log(typeof a);
ဒီကောင့်ကို firebug console မှာ ပဲဖြစ်ဖြစ် script tag ထဲမှာပဲဖြစ်ဖြစ် run လိုက်မယ်ဆိုရင်။ ပထမ console.log() ကနေ number ဆိုတာထုတ်ပေးမှာဖြစ်ပြီး ဒုတိယတခုကတော့ string ကိုထုတ်ပေးပါလိ့မ်မယ်။ ဒီ program ကဘာကိုပြသလဲဆိုတော့ dynamic language တွေရဲ. Nature ဖြစ်တဲ့ variable တွေရဲ. Type ကို runtime မှာ ပြောင်းလို.ရတယ် ဆိုတဲ့သဘာဝကိုပြတာပါ။ တကယ်လို. C # မှာ ခုနကကောင်ကို dynamic type သုံးပြီးရေးချင်ရင် ဒီလိုသုံးလို.ရပါတယ်။
using System;
namespace Dynamic
{
class DynamicDemo
{
static void Main(string []args)
{
dynamic d = 10;
Console.WriteLine( d.GetType() );
d = "Hello";
Console.WriteLine( d.GetType() ) ;
}
}
}
ဒီ C # program ကို compile ပြီး run လုပ်လိုက်မယ်ဆိုရင်
System.Int32
System.String
ထွက်လာမှာပါ။ ဒါဟာ C # ရဲ. Dynamic typing ကို support လုပ်တာကိုပြတာပါ။ dynamic ဆိုတဲ့ keyword ကိုသုံးရင် ကျွန်တော်တို.ဟာ C # မှာ type တွေကို runtime မှာပြောင်းပြီးရေးလို.ရပါတယ်။
Advantages and Disadvantage of Statically Typed Language and Dynamically Typed Language
Static typed language တွေဟာ type နဲ.ပတ်သတ်တဲ့ type error ကို compile time မှာကတည်းက သိနိုင်တဲ့ bug early detection ကိုပေးပါတယ်။ Dynamically language တွေကတော့ဒါကိုမပေးနိုင်ပါဘူး။ Type information ကို program code ထဲမှာ ထဲ့ရေးရတဲ့အတွက် static typed language တွေဟာ documentation ကိုပိုမိုကောင်းမွန်စေပါတယ်။ ဥပမာ method တခုရဲ. Parameter ကို static typed language တွေမှာ မဖြစ်မနေထဲ့ရအတွက် ဒီ method ဟာဘယ်လို parameter တွေလက်ခံမလဲဆိုတာသီးသန်. Comment သို.မဟုတ် documentation ရေးစရာလိုပဲနဲ.သိနိုင်ပါတယ်။ Dynamically typed language တွေကျတော့ comment သို.မဟုတ် documentation ထဲ့ရေးမှသာသိနိုင်မှာပါ။ Static typed language မှာ type information ကိုကြိုသိတဲ့အတွက် type အပေါ်မူတည်ပြီး efficient ဖြစ်တဲ့ code ကိုထုတ်ထားလို.ရပါတယ် ဥပမာ a+b ဆိုရင် a နဲ. b နှစ်ခုလုံးဟာ integer ဆိုရင် integer addition ၊ တခုခုက floating point ပါရင် float addition, string တခုခုပါရင် string concantenation ဆိုပြီး compile time မှာကတည်းက ထုတ်ပေးတဲ့အတွက် program ဟာ မြန်သွားပါလိမ့်မယ်(runtime မှာ ဘာမှလုပ်စရာမလိုတော့လို.ပါ)။ Dynamic language တွေမှာကျတော့ ဘယ် operation လုပ်ရမလဲဆိုတာ(ဥပမာ integer addition or float addition )ဆိုတာ runtime ရောက်မှသိရတဲ့အတွက် အဲ့ decision ကိုချနေရတဲ့အတွက် သာမာန်အားဖြင့် type အပေါ်မူတည်ပြီး ဘယ် operation လုပ်ရမလဲဆိုတာ စစ်နေရတဲ့အတွက်နှေးပါတယ်။ နောက်တခုက static type language တွေမှာ type information ပါနေတဲ့အတွက် tool တွေ IDE တွေကနေ အလုပ်လုပ်ရတာ support ပေးရတာ အဆင်ပြေပါတယ်။ ဥပမာ type က string ဆိုရင် . ခေါက်လိုက်တာနဲ. String နဲ.ပတ်သတ်တဲ့ method, property တွေ IDE ကခေါ်တင်ပေးရတာလွယ်ပါတယ်။
Dynamically Typed Language တွေမှာကျတော့အဲ့လောက်အဆင်မပြေပါဘူး။ နောက်တခုက Refactoring ။ Refactoring ဆိုတာ program code တခုကို မူလ meaning မပြောင်းသွားပဲနဲ. Program ကို design အားဖြင့်ပိုကောင်းအောင် လုပ်တာကို ဆိုချင်တာပါ။ ဥပမာ ဖတ်ရခက်တဲ့ variable တခုကို နာမည်ပြောင်းမယ် method တခုကို နာမည်ပြောင်းမယ်ဆိုတာမျိုး ။ အဲ့ဒီအချိန်မှာ တခုခုက မှားသွားရင် static typed language တွေမှာ ချက်ခြင်းသိပါတယ်။ program က compile လုပ်လို.မှမရတော့တာကိုး။ Dynamic Language တွေမှာတော့ ဒါမျိုးကိုသိနိုင်ဖို.အတွက် unit test code တွေရေးရပါတယ် ၊ အလုပ်ပိုရှုပ်ပါတယ်။ unit test code တွေရဲ. Power ကတော့ compiler type checking ထက်သာကောင်းသာနိုင်ပါတယ်။
အရာရာတိုင်းမှာ အားသာချက်ကြီးပဲရှိမနေနိုင်ပါဘူး အားနည်းချက်လဲရှိပါတယ်။ Static typed language တွေမှာ declaration တွေမလိုအပ်ပဲ type information တွေထဲ့ရေးနေရတဲ့အတွက် ပိုပြီး verbose(ရှုပ်ထွေး) ပါတယ်။Dynamic typed language တွေကျတော့ပို ရှင်းပါတယ်။ statically typed program တခုကို ပြင်ပြီးပြီဆိုရင် recompile လုပ်ရပါတယ်။ တချို. Programmer တွေကတော့ မကြိုက်ပါဘူး။ Dynamic Language တွေမှာတော့ recompile လုပ်စရာမလိုပဲ တန်း run ရုံပါပဲ။ Verbose ဖြစ်တာကိုပြင်ဖို.အတွက် modern programming language (C #,Scala) တို.မှာ type inferencing ကိုသုံးပါတယ်။ Type inferencing ဆိုတာ variable တခုရဲ. Type ကို compiler ကနေ အလိုအလျောက် ဆုံးဖြတ်တာကိုပြောတာပါ။ ဥပမာ ဒီ Java Statement ဆိုရင်
ArrayList arr = new ArrayList();
Type information က LHS မှာရော RHS မှာပါ ပါနေတာပါ။
C # မှာဆိုရင်
List lst = new List();
ဒီလိုကြေငြာလဲရပါတယ် တကယ်လို. Type inferencing သုံးမယ်ဆိုရင်
var lst = new List();
ဆိုပြီး သုံးလို.ရပါတယ် ပိုတိုပါတယ် ပိုလဲရှင်းသွားပါတယ်။ Scala မှာလဲ အဲလို type inferencing တွေပေးထားပါတယ်။ Static typed language တွေမှာမရတဲ့ နောက် dyamic language တွေရဲ. Feature တခုက method တွေ field တွေကို runtime မှာ change လို.ရတာပါ။ Self modifying code လိုကောင်မျိုးတွေရေးလို.လွယ်ပါတယ်။ အဲ့ဒီတော့ meta programming ကိုလွယ်လွယ်ကူကူ support လုပ်ပေးနိုင်ပါတယ်။ နောက်တခုက Duck Typing, ပါ duck typing ဆိုတာ ရှင်းပြထားတာတော့ အကောင်တကောင်က ဘဲလိုသွားမယ် ဘဲလိုအော်မယ်ဆို ဘဲပဲတဲ့။ ဆိုချင်တာက dynamic language တွေမှာ object တခုရဲ. Method တခုကို လှမ်းခေါ်မယ်ဆိုရင် (polymorphic operation)ပေါ့ အဲ့ဒီ object သည် ဘာ type ဖြစ်ရမယ် ဘယ်ကနေ implement လုပ်ရမယ် ဆိုတဲ့ (sub typing) restriction တွေမရှိပါဘူး။ Object တခုရဲ. Method ကိုလှမ်းခေါ်လို. အဲ့ဒီ object မှာ ခေါ်တဲ့ method ရှိရင် အလုပ်လုပ်မှာပါ။ Static typed language တွေမှာတော့ method name ရှိရုံနဲ.မပြီးပဲ (Subtype) ဖြစ်မှရမှာပါ။ နောက် Static typed language ရဲ.အားသာချက်တခုက Static Analysis Tool တွေနဲ.ကောင်းကောင်းအလုပ်လုပ်နိုင်တာပါပဲ။ Static Analysis Tool တွေက program တခုရဲ. Type information တွေကိုသုံးပြီး ဒီ program မှာဘယ်လိုဖြစ်နိုင်တဲ့ bug တွေရှိနိုင်လဲဆိုပြီးထုတ်ပေးနိုင်ပါတယ်။ Dynamic Language တွေအတွက်ကျတော့ type information ကို မရနိုင်တဲ့အတွက်အဆင်မပြေပါဘူး။ ဒါကို ကာကွယ်ဖို.အတွက် JavaScript မှာဆို TypeScript လိုကောင်မျိုး Microsoft ကထုတ်ထားပါတယ်။ TypeScript မှာ JavaScript statement အားလုံးရေးလို.ရပြီး Typed information ကိုအပိုဆောင်းထဲ့ပေးလို.ရပါတယ်။ အဲ့တော့ static type checking ပါလုပ်လို.ရသွားပါတယ်။ Dart မှာလဲထိုနည်းလည်းကောင်းပါပဲ။
Strongly Typed, Weakly Type, Memory Safe Language
Strongly typed language ဆိုတာ invalid type operation တွေကို compile time မှာရော runtime မှာပါ ဖမ်းပေးနိုင်တဲ့ language မျိုးကိုဆိုတာပါ။ ဥပမာ C #,Java,Scala တို.ပါ။ Invalid type operation ဆိုတာ များသောအားဖြင့် dangerous ဖြစ်တဲ့ type coercion (automatic type conversion ) ကိုပေးထားတာပါ။ ဥပမာ JavaScript မှာဆိုရင်ဒါမျိုးလုပ်လို.ရပါတယ်
var a ="10";
var b = a * 3;
a က string ပါ ဒါပေမဲ့ b ထဲကို a*3 လို.ထဲ့တဲ့အချိန်မှာ a ကို string ကနေ integer ပြောင်းပြီး multiplication လုပ်ပေးသွားတာပါ။ အပေါ်ယံကြည့်လို.ကောင်းတယ် အသုံးဝင်တယ်ထင်ရပေမဲ့ runtime မှာ a ထဲ ကstring သည် number တခုခုကို မပြောင်းနိုင်ရင် undefined ဖြစ်ပါလိမ့်မယ် undefined ကို a နဲ.မြှောက်ရင် b ရဲ.တန်ဖိုးက NaN (Not a Number) ရပါလိမ့်မယ်။ ဒါကြောင့် JavaScript က weakly typed language လို.ပြောရမှာပါ။
Memory Safe Language ဆိုတာ memory ပေါ်မှာရှိတဲ့ integer နေရာကို floating point တွေလာမထဲ့နိုင်အောင်(ဥပမာအနေဲ.ဆိုလိုတာပါ အဓိက ကတော့ invalid type operation on memoryပါ) ထိန်းပေးနိုင်တဲ့ language ကိုဆိုချင်တာပါ။ C,C++ မှာ pointer arithmetic ကိုသုံးပြီးတော့ memory ရှိတဲ့ int ကို float အနေနဲ.အသုံးပြုလို.ရပါတယ် Go မှာဒါမျိုးကို ကာကွယ်ပေးထားပါတယ်။ ဒါကြောင့် C,C++ ကို memory unsafe language လို.ပြောရမှာဖြစ်ပြီး Go ကို memory Safe Language လို.ပြောရမှာပါ။
