நாம் ஒரு புதிய நிரலாக்க(கணினி) மொழியைக் கற்கத் தொடங்கும் போதெல்லாம், மாறிகளை வரையறுத்தல், ஒரு statementஐ எழுதுதல், வெளியீடுகளை மதிப்பீடு செய்தல் ஆகியவற்றில் மட்டுமே அதிக கவனம் செலுத்திடுவோம். அந்தக் கருத்துகளைப் பற்றி பொதுவான புரிதல் கிடைத்தவுடன், மீதமுள்ளவற்றை நாம் சொந்தமாகக் கண்டுபிடித்து தெரிந்துகொள்ள முடியும். பெரும்பாலான நிரலாக்க மொழிகளில் சில ஒற்றுமைகள் உள்ளன, எனவே நாம் ஏதேனும் ஒரு நிரலாக்க மொழியை நன்கு ஐயமற அறிந்தவுடன், அடுத்ததைக் கற்றுக்கொள்வதற்காக அந்தக்கணினி மொழியின் தனித்துவமான விவரங்களை மட்டும் கூடுதலாக கண்டறிந்து வேறுபாடுகளை மட்டும் தெரிந்துகொண்டால் மட்டும் போதுமானதாகம் அதனால் அந்த புதிய மொழியை கற்றுக்கொள்வது எளிதான செயலாகி விடுகின்றது. புதிய நிரலாக்க மொழியைப் பயிற்சி செய்ய , சில பரிசோதனை நிரல்களை எழுத விரும்புகின்றபோது. நாமெல்லோரும் அடிக்கடி எழுதும் பொதுவானதொரு மாதிரி நிரல் “guess the number” எனும் விளையாட்டாகும், அதில் கணினியானது ஒன்றுக்கும் 100 க்கும் இடையிலுள்ள ஒரு எண்ணை நம்மை யூகிக்கச் சொல்கிறது. நாம் சரியாக யூகிக்கும் வரை நிரலாக்கம் திரும்ப திரும்ப சுழன்று செயல்பட்டுகொண்டே யிருக்கிறது. இது மிகவும் எளிமையான நிரலாகும், ஏனெனில் இதில் பின்வருவதை போன்ற pseudocode பயன்படுத்துவதை காணலாம்:
1. கணினியானது 1 முதல் 100 வரை ஒரு சீரற்ற எண்ணை தெரிவுசெய்து கொள்கின்றது
2. பின்னர் அந்த சீரற்ற எண்ணை நாம் யூகிக்கும் வரை திரும்ப திரும்ப சுழன்று கொண்டே யிருக்கிறது
3. அதன்பின்னர் கணினியானது நம்முடைய யூகத்தைப் படிக்கிறது
4. நாம் யூகித்த எண்ணானது கணினி தெரிவுசெய்துவைத்துள்ள எண்ணைவிட குறைவாகவோ அல்லது அதிகமாகவோ இருந்தால் அந்த தகவலைமட்டும் நம்மிடம் கூறுகிறது
. ஒவ்வொரு கணினி மொழியிலும் ஒரே செயலை எவ்வாறு செய்வது என்பதை ஒப்பிட்டுப் பார்க்க இது ஒரு சுவாரஸ்யமான வாய்ப்பாகும். பெரும்பாலான நிரலாக்க மொழிகள் இதேபோன்ற செயல்களைச் செய்கின்றன என்பதையும் நாம் கணலாம், எனவே நமக்கு ஐயமற தெரிந்த கணினி மொழி தவிர வேறு எந்தவொரு நிரலாக்க மொழியையும் கற்றுக்கொள்வது என்பது பெரும்பாலும் அதனுடைய வேறுபாடுகளைக் கற்றுக்கொள்வது மட்டுமேயாகும்.
C. எனும் கணினிமொழி
. சி எனும் கணினிமொழியானது ஆரம்பகால பொது-நோக்கு நிரலாக்க மொழியாகும், இது 1972 இல் டென்னிஸ் ரிச்சியால் பெல் எனும் ஆய்வகத்தில் உருவாக்கப்பட்டது. இது மிகவும் பிரபலமான கணினிமொழி என்பதை நிரூபித்தது, தொடர்ந்து இது விரைவாக யூனிக்ஸ் கணினிகளில் ஒரு நிலையான நிரலாக்க மொழியாக மாறியது. அதன் புகழ் காரணமாக, பல நிரலாக்க மொழிகள் இதேபோன்ற நிரலாக்க தொடரியல் ஒன்றை ஏற்றுக்கொண்டன. அதனால்தான் C++, Rust, Java, Groovy, JavaScript, awk, Lua ஆகியவற்றைக் கற்றுக்கொள்வது எளிதாக இருக்கின்றன.
. எடுத்துக்காட்டாக, “guess the number”எனும் விளையாட்டின் முக்கிய படிமுறைகளை இந்த வெவ்வேறு நிரலாக்க மொழிகள் எவ்வாறு செயல்படுத்துகின்றன என்பதை இப்போது காண்போம். அடிப்படைகள் எவ்வாறு ஒத்தவை அல்லது வேறுபட்டவை என்பதில் கவனம் செலுத்திடு வதற்காக, தற்காலிக மாறிகள் ஒதுக்குவது போன்றவை தவிர வேறு சிலவற்றை தவிர்த்திடுக.
படிமுறை -1: கணினி ஒன்று முதல் 100 வரை ஒரு சீரற்ற எண்ணை தெரிவுசெய்தல்
இதில் அனைத்து கணினி மொழிகளிலும் ஏராளமான அளவிலான ஒற்றுமைகளைக் காணலாம். பெரும்பாலான நிரலாக்க மொழிகள் rand() போன்ற ஒரு செயலியைக் கொண்டு ஒரு சீரற்ற எண்ணை உருவாக்குகின்றன, அவற்றை நாம் சொந்தமாக ஒரு வரம்பில் வைக்கலாம். பெரும்பாலான கணினி மொழிகள் ஒரு சிறப்பு செயலியைப் பயன்படுத்துகின்றன, அதில் நாம் சீரற்ற மதிப்பிற்கான வரம்பைக் குறிப்பிடலாம்.
| C | Using the Linux getrandom system call: getrandom(&randval, sizeof(int), GRND_NONBLOCK); number = randval % maxval + 1; Using the standard C library: |
| C++ | int number = rand() % 100+1; |
| Rust | let random = rng.gen_range(1..101); |
| Java | private static final int NUMBER = r.nextInt(100) + 1; |
| Groovy | int randomNumber = (new Random()).nextInt(100) + 1 |
| JavaScript | const randomNumber = Math.floor(Math.random() * 100) + 1 |
| awk | randomNumber = int(rand() * 100) + 1 |
| Lua | number = math.random(1,100) |
படிமுறை -2:சீரற்ற எண்ணை நாம் யூகிக்கும் வரையிலான சுழற்சிகள்(Loops)
சீரற்ற எண்ணை நாம் யூகிக்கும் வரை while அல்லது do-while போன்ற flow-control எனும் தொகுப்பு மூலம் சுழற்சிகள் (Loops) செய்யப்படுகின்றன. ஜாவாஸ்கிரிப்ட்இல் இதனை செயல்படுத்திடு வதற்காக ஒரு சுழற்சியைப்(Loop) பயன்படுத்துவதில்லை, அதற்கு பதிலாக பயனாளர் மிகச்சரியாக அந்த எண்ணை யூகிக்கும் வரை HTML பக்கத்தை “live” என புதுப்பிக்கிறது.
Awk எனும் கணினிமொழி சுழற்சிகளை (Loops)ஆதரிக்கிறது, ஆனால் உள்ளீட்டைப் படிக்க சுழற்சியை(Loop) செய்வதில் அர்த்தமில்லை, ஏனெனில் awk என்பது தரவுகளின் pipelines என்பதன் அடிப்படையைச் சுற்றியே அமைந்துள்ளது, எனவே இது பயனாளரிடமிருந்து நேரடியாகப் பதிலாக ஒரு கோப்பிலிருந்து உள்ளீட்டைப் படிக்கிறது-2
| C | do { … } while (guess != number); |
| C++ | do { … } while ( number != guess ); |
| Rust | for line in std::io::stdin().lock().lines() { … break; } |
| Java | while ( guess != NUMBER ) { … } |
| Groovy | while ( … ) { … break; } |
| Lua | while ( player.guess ~= number ) do … end |
படிமுறை -3:கணினி நாம் யூகித்த எண்ணைப் படித்தல்
வெவ்வேறு நிரலாக்க மொழிகள் உள்ளீட்டை வித்தியாசமாகக் கையாளுகின்றன. எனவே இந்த படியமுறையில் சில மாறுபாடுகள் உள்ளன. எடுத்துக்காட்டாக, ஜாவாஸ்கிரிப்ட் ஒரு HTML படிவத்திலிருந்து நேரடியாக மதிப்புகளைப் படிக்கிறது, மேலும் awk ஆனது அதனுடைய தரவுகளின் pipelinஇலிருந்து தரவைப் படிக்கிறது.-3
| C | scanf(“%d”, &guess); |
| C++ | cin >> guess; |
| Rust | let parsed = line.ok().as_deref().map(str::parse::<i64>); if let Some(Ok(guess)) = parsed { … } |
| Java | guess = player.nextInt(); |
| Groovy | response = reader.readLine() int guess = response as Integer |
| JavaScript | let myGuess = guess.value |
| awk | guess = int($0) |
| Lua | player.answer = io.read() player.guess = tonumber(player.answer) |
படிமுறை -4:நாம் யூகித்த எண்ணானதுக் குறைவாகவோ அல்லது அதிகமாகவோ இருந்தால் அந்த விவரத்தை அறிவித்தல்
சி போன்ற நிரலாக்க மொழிகளில் ஒப்பீடுகள் மிகவும் சீரானவை, வழக்கமாக if statement மூலம். ஒவ்வொரு நிரலாக்க மொழியும் வெளியீட்டை எவ்வாறு அச்சிடுகிறது என்பதில் சில மாறுபாடுகள் உள்ளன, ஆனால் print statement ஆனது ஒவ்வொன்றிலும் அடையாளம் காணக்கூடியதாக உள்ளது.-4
| C | if (guess < number) { puts(“Too low”); } else if (guess > number) { puts(“Too high”); } … puts(“That’s right!”); |
| C++ | if ( guess > number) { cout << “Too high.\n” << endl; } else if ( guess < number ) { cout << “Too low.\n” << endl; } else { cout << “That’s right!\n” << endl; exit(0); } |
| Rust | _ if guess < random => println!(“Too low”), _ if guess > random => println!(“Too high”), _ => { println!(“That’s right”); break; } |
| Java | if ( guess > NUMBER ) { System.out.println(“Too high”); } else if ( guess < NUMBER ) { System.out.println(“Too low”); } else { System.out.println(“That’s right!”); System.exit(0); } |
| Groovy | if (guess < randomNumber) print ‘too low, try again: ‘ else if (guess > randomNumber) print ‘too high, try again: ‘ else { println “that’s right” break } |
| JavaScript | if (myGuess === randomNumber) { feedback.textContent = “You got it right!” } else if (myGuess > randomNumber) { feedback.textContent = “Your guess was ” + myGuess + “. That’s too high. Try Again!” } else if (myGuess < randomNumber) { feedback.textContent = “Your guess was ” + myGuess + “. That’s too low. Try Again!” } |
| awk | if (guess < randomNumber) { printf “too low, try again:” } else if (guess > randomNumber) { printf “too high, try again:” } else { printf “that’s right\n” exit } |
| Lua | if ( player.guess > number ) then print(“Too high”) elseif ( player.guess < number) then print(“Too low”) else print(“That’s right!”) os.exit() end |
சி-அல்லாத கணினிமொழிகளைப் பற்றி
C ஐ அடிப்படையாகக் கொண்ட நிரலாக்க மொழிகள் மிகவும் வித்தியாசமாக இருக்கின்றன, மேலும் ஒவ்வொரு படிமுறையும் செய்ய குறிப்பிட்ட தொடரியல் கற்க வேண்டியுள்ளது. Racketஎன்பது Lisp, Scheme இலிருந்து பெறப்பட்டது, எனவே இது Lisp இன் முன்னொட்டு குறிமுறைவரிகளையும் நிறைய அடைப்புக்குறிகளையும் பயன்படுத்துகிறது. சுழற்சிகள் (Loops) போன்ற தொகுதிகளைக் குறிக்க பைதான் அடைப்புக்குறிகளை விட இடைவெளியைப் whitespace மட்டுமே பயன்படுத்துகிறது. Elixir என்பது அதன் சொந்த தொடரியல் கொண்ட ஒரு செயலியின் நிரலாக்க மொழியாகும். Bashஆனது யூனிக்ஸ் அமைப்புகளிலிருந்து வருகின்ற Bourne shell ஐ அடிப்படையாகக் கொண்டது, இது Algol68— இலிருந்து கடன் வாங்குகிறது, மேலும் & & , “and.” போன்ற கூடுதல் சுருக்கெழுத்து குறியீட்டையும் ஆதரிக்கிறது. punchedஎனும் அட்டைகளைப் பயன்படுத்தி குறியீடு உள்ளீடு செய்யப்பட்டபோது Fortran எனும் கணினி மொழியானகு உருவாக்கப்பட்டது, எனவே இது 80 நெடுவரிசைகளின் தளவமைப்பை நம்பியுள்ளது, அதில் சில நெடுவரிசைகள் குறிப்பிடத்தக்கவை. பிற நிரலாக்க மொழிகள் எவ்வாறு வேறுபடுகின்றன என்பதை தெரிந்து கொள்வதற்காக, ஒரு மதிப்பு மற்றொன்றை விடக் குறைவாகவோ அல்லது அதிகமாகவோ இருக்கிறதா என்பதைப் பார்த்து பயனாளருக்கு பொருத்தமான செய்தியை அச்சிடும் “if” statement ஐ ஒப்பீடுசெய்தால் அவை பின்வருமாறு அமைந்திருக்கும்.-5
| Racket | (cond [(> number guess) (displayln “Too low”) (inquire-user number)] [(< number guess) (displayln “Too high”) (inquire-user number)] [else (displayln “Correct!”)])) |
| Python | if guess < random: print(“Too low”) elif guess > random: print(“Too high”) else: print(“That’s right!”) |
| Elixir | cond do guess < num -> IO.puts “Too low!” guess_loop(num) guess > num -> IO.puts “Too high!” guess_loop(num) true -> IO.puts “That’s right!” end |
| Bash | [ “0$guess” -lt $number ] && echo “Too low” [ “0$guess” -gt $number ] && echo “Too high” |
| Fortran | IF (GUESS.LT.NUMBER) THEN PRINT *, ‘TOO LOW’ ELSE IF (GUESS.GT.NUMBER) THEN PRINT *, ‘TOO HIGH’ ENDIF |