Pascal உடனான ஒப்பீடு

"வணக்கம். என் பெயர் லாகா பிலாபோ. நான் ஒரு வேற்றுகிரகவாசி, இந்தக் கலத்தின் மருத்துவர். நாம் நல்ல நண்பர்களாக இருப்போம் என்று நம்புகிறேன்."

"நானும்."

"எனது சொந்த கிரகத்தில், பின்தங்கிய Java மொழிக்கு பதிலாக மேம்பட்ட Pascal நிரலாக்க மொழியைப் பயன்படுத்துகிறோம். Java மற்றும் Pascal குறிமுறையின் இந்தப் பக்கவாட்டு ஒப்பீட்டைப் பாருங்கள்:"

public class MyFirstClass
{
   public static void main(String[] args)
   {
      int a, b, c;
      String s1, s2;
      System.out.println("Enter two numbers");
      a = new Scanner(System.in).nextInt();
      b = new Scanner(System.in).nextInt();
      c = a + b;
      System.out.println("The sum is " + c);
   }
}

Program MyFirstProgram;
Var
   a, b, c: Integer;
   s1, s2: String;
Begin
   WriteLn("Enter two numbers");
   ReadLn(a);
   ReadLn(b);
   c := a + b;
   WriteLn("The sum is ", c);
End.

"இது இரண்டு வெவ்வேறு மொழிகளில் எழுதப்பட்ட ஒரே நிரல். நீங்கள் பார்ப்பதைப் போல், இது Pascal குறைவான வரிகளைக் கொண்டுள்ளது, இது Java வை விட Pascal உயர்ந்தது என்பதற்கான சான்று."

"இதற்கு முன்பு நீங்கள் Pascal நிரலைப் பார்த்ததில்லை என்றால், இந்த உதாரணம் Java-வை நன்கு புரிந்துகொள்ள உதவும் என்று நினைத்தேன்."

"இல்லை, நான் பார்த்ததில்லை. ஆனாலும், இந்த இரண்டு நிரலாக்க மொழிகளை ஒப்பிடுவது சுவாரஸ்யமாக உள்ளது."

"அப்படியென்றால் சரி. நான் தொடருகிறேன்."

"Pascal இல், நிரலின் உடல், செயல்முறைகள் அல்லது செயல்பாடுகளில் குறிமுறையை வைக்கிறோம். Java-வில், இந்தச் செயல்முறை எளிமைப்படுத்தப்பட்டுள்ளது: நிரல் உடல், செயல்முறைகள் மற்றும் செயல்பாடுகள் அனைத்தும் வழிமுறைகள் எனப்படும் செயற்கூறுகளால் (functions) மாற்றீடு செய்யப்படுகின்றன."

public static void main(String[] args)
{
   System.out.println("Ho-ho-ho!");
}

Begin
   WriteLn("Ho-ho-ho!");
End.

double sqr(double a)
{
   return a * a;
}

Function Sqr(a: Real): Real
Begin
   Sqr := a * a;
End;

void doubleWrite(String s)
{
   System.out.println(s);
   System.out.println(s);
}

Procedure DoubleWrite(s: String);
Begin
   WriteLn(s);
   WriteLn(s);
End;

"Pascal நெடுவரிசையில், 'நிரல் உடல்', 'செயற்கூறு' மற்றும் 'செயல்முறை' என்ற சொற்களை நான் காண்கிறேன். ஆனால் Java-வில் அவை அனைத்தும் வழிமுறைகள் என்று அழைக்கப்படுகின்றன. அது கொஞ்சம் வித்தியாசமானது."

"ஆம், வேற்று கிரகவாசிகளான நாம் அதை மிகவும் வித்தியாசமாகக் காண்கிறோம். ஆனால் மனிதர்கள் எல்லாவற்றையும் ஒன்றிணைக்க விரும்புகிறார்கள்."

"Java-வில், எல்லா குறிமுறைகளும் ஒரு வழிமுறையின் பகுதியாகும், எனவே ஒரு வழிமுறையை அறிவிக்க Pascal இல் செய்வதுபோல Function என்ற வார்த்தையைய எழுத தேவையில்லை."

"இது எல்லாமே மிகவும் எளிது. குறிமுறையின் ஒரு வரி Type + Name போலத் தோன்றினால், அது ஒரு வழிமுறை அல்லது மாறியின் அறிவிப்பு ஆகும். ஒரு பெயரைத் தொடர்ந்து அடைப்புக்குறிகள் வந்தால், அது ஒரு புதிய வழிமுறையின் அறிவிப்பாகும். எந்த அடைப்புக்குறிப்புகளும் இல்லை என்றால், அது ஒரு மாறியின் அறிவிப்பு."

"Java-வில் மாறிகள் மற்றும் வழிமுறைகளின் அறிவிப்புகள் ஒரே மாதிரி இருக்கும். நீங்களே பாருங்கள்:"

String name;

String getName()
{
}

"ஆனால், அது மட்டுமல்ல. Java-வில், வழிமுறைகள் தனியாக இருக்காது. அவைக் கட்டாயம் கிளாஸிற்குள் இருக்க வேண்டும். ஆகவே, Java-வில் மனிதர்கள் ஒரு சிறிய நிரலை எழுத வேண்டியிருக்கும் போது, அவர்கள் முதலில் ஒரு கிளாஸை உருவாக்கி, அதில் ஒரு main வழிமுறையை அறிவித்த பின்னர்தான் தங்கள் குறிமுறையை வழிமுறையில் எழுதமுடியும். இந்த அனைத்துமே மிகவும் வித்தியாசமானவை!"

"டியாகோ இன்று முன்னதாக வந்து, இந்தப் பணிகளை உங்களுக்கு வழங்கும்படி என்னிடம் கேட்டுக்கொண்டார். நீங்கள் அவற்றை விரும்புவீர்கள் என்று நம்புகிறேன்."