സിഎൽയു (പ്രോഗ്രാമിങ് ഭാഷ)

വിക്കിപീഡിയ, ഒരു സ്വതന്ത്ര വിജ്ഞാനകോശം.
Jump to navigation Jump to search
CLU
ശൈലി:multi-paradigm: object-oriented, procedural
രൂപകൽപ്പന ചെയ്തത്:Barbara Liskov and her students
വികസിപ്പിച്ചത്:Massachusetts Institute of Technology
ഡാറ്റാടൈപ്പ് ചിട്ട:strong
പ്രധാന രൂപങ്ങൾ:Native CLU, Portable CLU,clu2c[1]
സ്വാധീനിച്ചത്:Ada, Argus, C++, Lua, Python,[2] Ruby, Sather, Swift[3]
വെബ് വിലാസം:www.pmg.lcs.mit.edu/CLU.html

മസ്സാചുസെറ്റ്സ് ഇൻസ്റ്റിറ്റ്യൂട്ട് ഓഫ് ടെക്നോളജിയിൽ (എം.ഐ.ടി) സ്ഥാപിച്ച പ്രോഗ്രാമിങ് ഭാഷയാണ് സിഎൽയു(CLU). 1974 നും 1975 നും ഇടയിൽ ബാർബറ ലിൽക്കോവും അവരുടെ വിദ്യാർത്ഥികളും ചേർന്നാണ് ഇത് രൂപപ്പെടുത്തിയെടുത്തത്. ഇത് വിപുലമായ ഉപയോഗത്തിലില്ലെങ്കിലും, ഇപ്പോൾ അത് വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്ന പല സവിശേഷതകളും അവതരിപ്പിച്ചു, ഒബ്ജക്റ്റ് ഓറിയെൻറഡ് പ്രോഗ്രാമിങ്ങിൻറെ (OOP) വികസനത്തിൽ ഒരു ഘട്ടം എന്ന നിലയിലാണ് ഇത് കാണുന്നത്.

അമൂർത്തമായ ഡാറ്റ തരങ്ങൾ, [4] കോൾ-ബൈ-ഷെയറിംഗ്, ഇറ്റേറ്റെർസ്, മൾട്ടിപ്പിൾ റിട്ടേൺ വാല്യൂസ് (ഒരു സമാന്തര അസൈൻമെൻറ്), ടൈപ്പ്-സുരക്ഷിതമായ പാരാമീറ്ററൈസ്ഡ് തരങ്ങൾ, ടൈപ്പ്-സേഫ് വേരിയൻറ് തരങ്ങൾ എന്നിവയാണ് പ്രധാന സംഭാവനകൾ. കൺസ്ട്രറ്ററുകളും രീതികളും ഉപയോഗിക്കുന്നതും, എന്നാൽ ഇൻഹെറിറ്റെൻസ് (Inheritance) ഇല്ലാത്തതുമാണ്.

ക്ലസ്റ്ററുകൾ[തിരുത്തുക]

ഏറ്റവും പുതിയ ഭാഷാ രൂപകൽപ്പനകൾക്ക് തുടക്കമിടാൻ ആൽഗോൾ(ALGOL) അടിസ്ഥാനമാക്കിയുള്ളതാണ് സിഎൽയുടെ സിൻറാക്സ്. ഒരു കൂട്ടം ക്ലസ്റ്റർ എന്ന ആശയം, സിഎൽയുടെ ടൈപ്പുചെയ്യൽ വിപുലീകരണവും ഭാഷയുടെ പേരിൻറെ റൂട്ട് (CLUster) ആണ്.[5]ക്ലസ്റ്ററുകൾ ഒരു ഒഒ (OO) ഭാഷയിലെ "ക്ലാസ്" എന്ന സങ്കല്പത്തിന് സാധാരണയായി യോജിക്കുന്നു, സമാന സിന്റാക്സ് ഉണ്ട്. ഉദാഹരണത്തിന്, സങ്കീർണ്ണ സംഖ്യകൾ കൊണ്ടുവരുന്ന ഒരു ക്ലസ്റ്ററിനായുള്ള സിഎൽയു സിൻറാക്സ് ഇതാണ്:

    complex_number = cluster is add, subtract, multiply, ...
        rep = record [ real_part: real, imag_part: real ]
        add = proc ... end add;
        subtract = proc ... end subtract;
        multiply = proc ... end multiply;
        ...
    end complex_number;

ഒരു ക്ലസ്റ്റർ എന്നത് ഒരു മൊഡ്യൂളാണ്, അതിൻറെ എല്ലാ ഘടകങ്ങളും സംഗ്രഹിക്കുന്നു, "is" ക്ലോസിൽ സ്പഷ്ടമായി പേരുള്ളത് ഒഴികെ. ഇത് സമീപകാല ഒഒ (OO) ഭാഷകളിൽ ഒരു ക്ലാസിലെ പൊതു ഘടകങ്ങളെ സൂചിപ്പിക്കുന്നു. ഒരു ക്ലസ്റ്റർ ക്ലസ്റ്ററിനു പുറത്ത് പേരുനൽകുന്ന ഒരു തരം ക്ലസ്റ്റർ കൂടി നിർവ്വചിക്കുന്നു (ഇവിടെ, "complex_number"), എന്നാൽ അതിൻറെ റെപ്രസെൻറേഷൻ ടൈപ്പ് (rep) ബാഹ്യ ക്ലയൻറുകളിൽ നിന്ന് മറഞ്ഞിരിക്കുകയാണ്.

ക്ലസ്റ്റർ പേരുകൾ ആഗോളമാണ്, മറ്റ് ക്ലസ്റ്ററുകൾക്കുള്ളിൽ "പ്രാദേശിക" ഗ്രൂപ്പുകൾ സൃഷ്ടിക്കാൻ നാമസ്പെയ്സ് സംവിധാനം ഏർപ്പെടുത്തിയിരുന്നില്ല.

സിഎൽയുവിന് ഇതര തരത്തിലുള്ള പരിവർത്തനങ്ങൾ സാധ്യമല്ല. ഒരു ക്ലസ്റ്ററിൽ, സ്പഷ്ട തരത്തിനും (explicit type) അവതരണത്തിനും ഇടയിലുള്ള വ്യതിരിക്തമായ തരങ്ങൾക്ക് (abstract type) വ്യത്യാസങ്ങൾ ഉണ്ടാകുന്നു. ഒരു സാർവത്രിക തരം ഉണ്ട്, ഒരു വസ്തു പ്രത്യേക തരം ആണെന്ന് പരിശോധിക്കാൻ force[] എന്ന നടപടിക്രമം ഉപയോഗിക്കുന്നു. ഒബ്ജക്ടുകൾ മൂട്ടബിൾ (mutable) അല്ലെങ്കിൽ ഇംമൂട്ടബിൾ (immutable) ആകാം, രണ്ടാമത്തേത്, ബേസ്, ബൂളിയനുകൾ, പ്രതീകങ്ങൾ, സ്ട്രിങ്ങുകൾ തുടങ്ങിയ അടിസ്ഥാന ഘടകങ്ങളാണ്.[5]

മറ്റ് സവിശേഷതകൾ[തിരുത്തുക]

സിഎൽയു ടൈപ്പ്സിസ്റ്റത്തിൻറെ മറ്റൊരു പ്രധാന സവിശേഷത ഇറ്ററേറ്റുകൾ (iterators) ആണ്, അവ സീരിയലിൽ നിന്ന് ഒബ്ജക്റ്റുകൾ തിരികെ നൽകുന്നു, ഒന്നിനുപുറകെ ഒന്നായി.[5] ഒരേപോലുള്ള ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇൻറർഫേസ് (എപിഐ) ഇറ്റർറേറ്ററുകൾ വാഗ്ദാനം ചെയ്യുന്നു, അവ ഉപയോഗിക്കുന്ന ഡാറ്റ എന്തുതന്നെയായാലും. അങ്ങനെ സങ്കീർണ്ണമായ_ സംഖ്യകളുടെ ശേഖരത്തിനായി ഇറ്ററേറ്ററുകൾ പൂർണ്ണസംഖ്യകളുടെ ഒരു അറേയ്ക്കായി അവയ്ക്ക് പരസ്പരം ഉപയോഗിക്കാനാകും. സിഎൽയു ഇറ്ററേറ്ററുകളുടെ ഒരു പ്രത്യേക സവിശേഷത അവ കോറൻഡീസിനെ പ്പോലെയാണ് നടപ്പാക്കപ്പെടുന്നത്, യീൽഡ് (yield) പ്രസ്താവന വഴി കോളറിനായി ഓരോ മൂല്യവും നൽകപ്പെടുന്നു. സിഎൽയുവിയിൽ ഉള്ള ഇറ്ററേറ്ററുകൾ ഇന്ന് പല ആധുനിക ഭാഷകളുടെ ഒരു പൊതു സവിശേഷതയാണ്, സി#, റൂബി, പൈത്തൺ എന്നീ പ്രോഗ്രാമിംഗ് ഭാഷകളിലും ഉപയോഗിക്കുന്നു, ഈയിടെയായി അവ പലപ്പോഴും ജനറേറ്ററായി അറിയപ്പെടുന്നു.


മറ്റ് ഭാഷകളിലുള്ള വിവിധ ശ്രമങ്ങളെ അടിസ്ഥാനമാക്കി; സിഎൽയുവിൽ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ (Exception handling) ഉൾപ്പെടുത്തയിരിക്കുന്നു. ഒഴിവാക്കലുകൾ സിഗ്നൽ ഉപയോഗിച്ച് ഉയർത്തുകയും അവയെ കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു. മറ്റ് മിക്ക ഭാഷകൾക്കും പുറമേയുള്ള ഒഴിവാക്കലുകൾ അത്ര സംക്ഷിപ്തമായല്ല കൈകാര്യം ചെയ്യുന്നത്. കൂടാതെ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യാവുന്ന മറ്റ് മിക്ക ഭാഷകളിൽ നിന്നും വ്യത്യസ്തമായി, സിഎൽയുവിൽ നിന്നുള്ള ഒഴിവാക്കലുകൾ സാധാരണ നിർവ്വഹണത്തിൻറെ ഭാഗമായി കണക്കാക്കപ്പെട്ടിരിക്കുന്നു, അവ ഒരു "സാധാരണ", ലൂപ്പുകളുടെ പുറത്താക്കൽ അല്ലെങ്കിൽ പ്രവർത്തനങ്ങളിൽ നിന്ന് മടങ്ങിവരാനുള്ള ഫലപ്രദമായ വഴികൾ; മറ്റ് വ്യവസ്ഥകൾ ബാധകമാകുമ്പോൾ "എപ്പോഴെങ്കിലും ഒഴികെ" മടക്കസന്ദേശങ്ങൾ നേരിട്ട് ലഭ്യമാക്കുന്നതിന് ഇത് അനുവദിക്കുന്നു.

ടൈപ്പ്-സുരക്ഷിത വേരിയൻറ് തരം ഉള്ള ആദ്യത്തെ ഭാഷയായി സിഎൽയു ഉപയോഗിക്കപ്പെടുന്നു, എംഎൽ(ML) ഭാഷക്ക് മുൻപുണ്ടായിരുന്നതിനെ വൺഓഫ്സ് (oneofs) എന്ന് വിളിച്ചിരുന്നു. സിഎൽയുവിലെ അന്തിമ സവിശേഷത സമാന്തര കർത്തവ്യം (ഒന്നിലധികം അസൈൻമെൻറ്) ആണ്, ഇവിടെ ഒരു അസൈൻമെൻറ് ഓപ്പറേഷൻറെ ഇടത് വശത്ത് ഒന്നിൽ കൂടുതൽ വേരിയബിളുകൾ ദൃശ്യമാകും. ഉദാഹരണത്തിന്, എഴുതുന്നത് ഇപ്രകാരമാണ് x,y := y,x x and y മൂല്യങ്ങൾ കൈമാറും. ഇതേപോലെ, പ്രവർത്തനങ്ങൾ x, y, z: = f (t) പോലുള്ള പല മൂല്യങ്ങളും നൽകാം. സമാന്തര അസൈൻമെൻറ് (മൾട്ടി റിട്ടേൺ വാല്യൂഷനുകളൊന്നും ഇല്ലെങ്കിലും) സി.എ.പി.എൽ (1963), ഒരേ സമയത്തുളള അസൈൻമെൻറ് [6] എന്ന പേരിലാണ് അറിയപ്പെട്ടിരുന്നത്, പക്ഷെ സിഎൽയു ജനകീയവൽക്കരിക്കപ്പെട്ടു. പിന്നീടുള്ള ഭാഷകളിലേക്ക് സമാന്തര അസൈൻമെൻറ് നയിക്കുന്ന നേരിട്ടുള്ള സ്വാധീനമായി പലപ്പോഴും ക്രെഡിറ്റ് നൽകിയിട്ടുണ്ട്.

ഒരു സിഎൽയു പ്രോഗ്രാമിലെ എല്ലാ വസ്തുക്കളുടെയും നിലനിൽപ് ഹീപ്പിലാണ്(program live in the heap), ഓട്ടോമാറ്റിക്കായി മെമ്മറി മാനേജ് ചെയ്യുന്നു. പരാമീറ്ററൈസ് തരത്തെ ഉപയോക്താവ് നിർവ്വചിച്ച ഡാറ്റ അബ്സ്ട്രാഷൻസ് സിഎൽയു പിന്തുണയ്ക്കുന്നു. യഥാർത്ഥ തരം ആർഗ്യുമെൻറുകളിൽ നിയന്ത്രണങ്ങൾ പ്രകടിപ്പിക്കുന്ന ഘടന ഉപയോഗിച്ച് ടൈപ്പ്-സുരക്ഷിതമായ നിയന്ത്രണമുള്ള പാരാമീറ്ററൈസ്ഡ് തരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്ന ആദ്യത്തെ ഭാഷയായിരുന്നു ഇത്.

മറ്റ് പ്രോഗ്രാമിങ് ഭാഷകളിൽ മേലുള്ള സ്വാധീനം[തിരുത്തുക]

പല ഭാഷകളിലും സിഎൽയു സ്വാധീനിച്ചിരിക്കുന്നു. ഏകദേശ കണക്ക് അനുസരിച്ച് അവയിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു:

  • സിഎൽയുവും അഡയും സി++ ടെംപ്ലേറ്റുകൾക്കുള്ള പ്രധാന പ്രചോദനങ്ങൾ ആയിരുന്നു.
  • സിഎൽയുവിൻറെ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ(Exception handling) സംവിധാനങ്ങൾ സി++, ജാവ എന്നിവ പോലുള്ള ഭാഷകളെ സ്വാധീനിച്ചു.
  • സാത്തർ, പൈത്തൺ, സി# എന്നിവയിൽ ഉപയോഗിക്കുന്ന ഇറ്ററേറ്ററുകൾ (iterators) ആദ്യം ഉപയോഗിച്ചത് സിഎൽയുവിലായിരുന്നു.
  • പേൾ ലൂഅ എന്നീ പ്രോഗ്രാമിംഗ് ഭാഷകൾ സിഎൽയുവിൽ ഉള്ള ഫംഗ്ഷൻ കോളുകളിൽ നിന്ന് ഒന്നിലധികം അസൈൻമെൻറുകളും മൾട്ടി റിട്ടേണുകളും എടുത്തിട്ടുണ്ട്.[7]
  • പൈത്തണും റൂബിയും സിഎൽയുവിൽ നിന്നും പല ആശയങ്ങളും കടം വാങ്ങി, യീൽഡ് പ്രസ്താവന, മൾട്ടിപ്പിൾ അസൈൻമെൻറ് എന്നിവ.

അവലംബം[തിരുത്തുക]

  1. Ushijima, Tetsu. "clu2c". clu2c. woodsheep.jp. ശേഖരിച്ചത് 2016-05-26.
  2. Lundh, Fredrik. "Call By Object". effbot.org. ശേഖരിച്ചത് 21 November 2017. replace "CLU" with "Python", "record" with "instance", and "procedure" with "function or method", and you get a pretty accurate description of Python's object model.
  3. Lattner, Chris (2014-06-03). "Chris Lattner's Homepage". Chris Lattner. ശേഖരിച്ചത് 2014-06-03. The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.
  4. Liskov, Barbara; Zilles, Stephen (1974). "Programming with abstract data types". Proceedings of the ACM SIGPLAN symposium on Very high level languages. pp. 50–59. CiteSeerX 10.1.1.136.3043. doi:10.1145/800233.807045.
  5. 5.0 5.1 5.2 Liskov, B.; Snyder, A.; Atkinson, R.; Schaffert, C. (August 1977). "Abstraction mechanisms in CLU". Communications of the ACM. 20 (8): 564–576. CiteSeerX 10.1.1.112.656. doi:10.1145/359763.359789.
  6. Barron, D. W.; Buxton, J. N.; Hartley, D. F.; Nixon, E.; Strachey, C. (1963). "The main features of CPL". Computer Journal. 6 (2): 134–143. doi:10.1093/comjnl/6.2.134.
  7. Ierusalimschy, R.; De Figueiredo, L. H.; Celes, W. (2007). "The evolution of Lua". Proceedings of the third ACM SIGPLAN conference on History of programming languages – HOPL III (PDF). pp. 2–1–2–26. doi:10.1145/1238844.1238846. ISBN 978-1-59593-766-7.