विलोम क्यों?

फैंटम फ्रैंक भाइयों ( ब्रायन फ्रैंक, एंडी फ्रैंक ) द्वारा विकसित एक ऑब्जेक्ट-ओरिएंटेड, स्टेटिक-टाइप टाइप सामान्य भाषा है। फैंटम की प्रमुख विशेषताओं में से एक इसकी शक्तिशाली मानक लाइब्रेरी है, विशिष्ट वातावरण से अलग है जिसमें इसे निष्पादित किया जाएगा। वर्तमान में, Fantom में लिखे गए कोड को जावा रनटाइम एनवायरनमेंट (JRE), .NET कॉमन लैंग्वेज रनटाइम (CLR) में चलाया जा सकता है, या जावास्क्रिप्ट कोड में संकलित किया जा सकता है।

class HelloWorld { static Void main() { echo("Hello, World!") } } 

पोर्टेबिलिटी

फेंटम बनाने का मुख्य कारण सॉफ्टवेयर लिखना था जो दो जावा वीएम और .NET सीएलआर प्लेटफार्मों पर चल सकता है। वास्तविकता यह है कि अधिकांश कंपनियां इन प्लेटफार्मों में से एक के लिए अपने सॉफ़्टवेयर का विकास करती हैं। पायथन और रूबी जैसी गतिशील भाषाएं भी इनमें से एक वर्चुअल मशीन पर चलती हैं। एक वर्चुअल मशीन से दूसरे वर्चुअल पोर्टेबिलिटी की समस्या को हल करने के लिए फैंटम बनाया गया था। फनटॉम सोर्स कोड को fcode में संकलित किया गया है - एक बाइटकोड जिसे आसानी से जावा बाइटकोड या आईएल में अनुवाद किया जा सकता है। प्रसारण रनटाइम पर होता है, जो आपको एक अलग फ़ाइल के रूप में फेंटम मॉड्यूल को तैनात करने और किसी भी वीएम पर चलाने की अनुमति देता है।

पोर्टेबिलिटी का मतलब सिर्फ जावा या .NET से बहुत ज्यादा है। जैसा कि ऊपर बताया गया है, सुपरबॉम को ब्राउज़रों में काम करने के लिए जावास्क्रिप्ट में संकलित किया जा सकता है। इसी समय, फेंटम वहाँ नहीं रुकने वाला है, निम्नलिखित लक्ष्य iPhone, LLVM , तोता के लिए उद्देश्य-सी हैं।

सुरुचिपूर्ण एपीआई

यद्यपि वे स्वाद के बारे में तर्क नहीं देते हैं (सौंदर्य देखने वाले की आंखों में है), फेंटम के रचनाकारों को वास्तव में एक सुंदर और सुविधाजनक एपीआई के साथ जाना जाता है। फैंटम के बुनियादी सिद्धांतों में से एक। जावा और .NET में कार्यात्मक विभाजन को छोटी स्वतंत्र और अमूर्त इकाइयों (कक्षाओं) में अधिकतम करने की एक सामान्य प्रवृत्ति है। फैंटम का विपरीत दर्शन है - उनका मानना ​​है कि आप इकाइयों की एक छोटी लेकिन शक्तिशाली संख्या के साथ कर सकते हैं।



एक अच्छा उदाहरण java.io पैकेज है, जिसमें 60 से अधिक कक्षाएं और इंटरफेस शामिल हैं; फेंटम में , आपको जो कुछ भी चाहिए वह चार वर्गों में निहित है: फ़ाइल , बुफ़ , इनस्ट्रीम और आउटस्ट्रीम । और इस तरह इसका उपयोग दिखता है:

 Void textIO() { f := File(`text-io.txt`) // write text file (overwrites existing) f.out.printLine("hello").close // append to existing text file f.out(true).printLine("world").close // read text file as big string echo(f.readAllStr) // read text file into list of lines echo(f.readAllLines) // read text file, line by line f.eachLine |line| { echo(line) } } 

टाइपिंग

पूरी दुनिया स्थिर और गतिशील टाइपिंग के समर्थकों में विभाजित हो गई है। फैंटम के रचनाकारों का मानना ​​है कि दोनों पक्ष एक-दूसरे के लिए अत्यंत महत्वपूर्ण हैं और उनके बीच का मध्य चुनते हैं - टाइपिंग सिस्टम के लिए एक मध्यम दृष्टिकोण।

स्थैतिक टाइपिंग के पक्ष से, फेंटम को फ़ील्ड्स और विधि हस्ताक्षरों के विवरणों की आवश्यकता होती है जो प्रकारों को दर्शाते हैं। घटकों के बीच संचार प्रारूप को ठीक करने के लिए यह अच्छा अभ्यास है। उदाहरण के लिए, अगर मैं एक ऐसी विधि लिखना चाहता हूं जो स्ट्रिंग और संख्या के साथ काम करती है, तो इसे सीधे कोड में तय किया जाना चाहिए। विधि और क्षेत्र हस्ताक्षरों के स्थिर टाइपिंग के विपरीत, कोड में अक्सर यह केवल हस्तक्षेप करता है, आपको अनावश्यक कोड लिखने के लिए मजबूर करता है। फैंटम में टाइप इंफ़ेक्शन इस समस्या से बचा जाता है। उदाहरण के लिए, जावा में बोझिल शब्दकोश निर्माण:

 Map<Integer, String> map = new HashMap<Integer, String>(); map.put(1, "one"); map.put(2, "two"); 

फैंटम में एक पंक्ति के बराबर:

 map := [1: "one", 2: "two"] 

लेकिन कभी-कभी आपको वास्तव में गतिशील टाइपिंग की आवश्यकता होती है, इसलिए फैंटम की प्रमुख विशेषताओं में से एक स्थिर या गतिशील टाइपिंग का उपयोग करके किसी विधि को लागू करना है। यदि आप "।" ऑपरेटर का उपयोग करते हुए विधि को कॉल करते हैं, तो कॉल को कंपाइलर द्वारा जांचा जाएगा और कुशल मशीन कोड में संकलित किया जाएगा।

वैकल्पिक रूप से, आप डायनामिक कॉल निर्दिष्ट करने के लिए "->" ऑपरेटर का उपयोग कर सकते हैं। वास्तव में, "->" को Obj.trap के लिए कॉल पर पुनर्निर्देशित किया जाएगा। डिफ़ॉल्ट रूप से, जाल "" की तरह काम करता है, लेकिन केवल रनटाइम पर। आप अपने डायनामिक डिज़ाइन को परिभाषित करके इस व्यवहार को बदल सकते हैं।

 if (a is Str) { return a->toInt } obj->foo // obj.trap("foo", [,]) obj->foo(2, 3) // obj.trap("foo", [2, 3]) obj->foo = 7 // obj.trap("foo", [7]) 

जेनरिक

दिलचस्प बात यह है कि जब फेंटम कोड को कम टाइप करने की कोशिश कर रहा है, तो जावा और सी # मजबूत टाइपिंग की ओर बढ़ रहे हैं, जेनरिक इस प्रवृत्ति का उदाहरण देते हैं। एक पूरी तरह से मानकीकृत प्रणाली सीधे सिस्टम की जटिलता से संबंधित है, इसलिए फेंटम अब लाभ और जटिलता के बीच संतुलन खोजने की कोशिश कर रहा है।

फैंटम के पास वर्तमान में जेनरिक के लिए सीमित समर्थन है - उपयोगकर्ता अपने स्वयं के उपयोग नहीं कर सकता है। हालांकि, तीन अंतर्निहित कक्षाएं सूची, मानचित्र और फ़ंक हो सकती हैं। उदाहरण के लिए, Fantom में पूर्णांक की एक सूची Int [] के रूप में घोषित की गई है। फैंटम के निर्माता मानते हैं कि वे बीच में हैं: जेनेरिक हैं, लेकिन सिस्टम को जटिल किए बिना।

दोष

किसी विषय क्षेत्र से कोड में एक मॉडल की तुलना करने का मुद्दा सॉफ्टवेयर विकास में सबसे अक्सर हल होने वाले मुद्दों में से एक है। आमतौर पर ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, इस वाक्यांश का अर्थ है मॉडलिंग कक्षाएं और इंटरफेस। जावा और सी # एक ही दृष्टिकोण का उपयोग करते हैं: कक्षाएं एकल वंशानुक्रम का समर्थन करती हैं, कई वंशानुक्रम को रोकती हैं, लेकिन कार्यान्वयन विरासत का समर्थन नहीं करती हैं।

हर कोई जिसने जावा या सी # के साथ काम किया है, वह जानता है कि कक्षा या इंटरफ़ेस बनाने के बीच चयन करना बहुत महत्वपूर्ण है। क्योंकि यदि आप एक वर्ग का चयन करते हैं, तो आप कार्यान्वयन को विरासत में देने के अपने एकमात्र अवसर का उपयोग कर रहे हैं। यदि आपके पास एक बड़ा और जटिल मॉडल है, तो इंटरफेस एक अतिरिक्त बोझ बन जाता है। उदाहरण के लिए, यदि दो वस्तुएं हैं जिनके अलग-अलग वारिस हैं और समान इंटरफ़ेस को समान रूप से लागू करते हैं, तो कार्यक्षमता को डुप्लिकेट करना होगा। दोहराव के अलावा, इंटरफ़ेस के संस्करण को बदलने की समस्या है जो सभी कार्यान्वयन को प्रभावित करती है।

जावा और सी # क्लास / इंटरफ़ेस मॉडल का उपयोग करने के कई अच्छे कारण हैं। मल्टीपल इनहेरिटेंस कई दरवाजे खोलती है, लेकिन यह बढ़ती जटिलता और बल्कि अप्रिय बारीकियों के कारण होता है। फैंटम फिर से मध्य पर कब्जा कर लेता है, जिसे मिक्सिंस कहा जाता है। अशुद्धताएं इंटरफेस हैं जो एक कार्यान्वयन स्टोर कर सकते हैं। एकाधिक उत्तराधिकार त्रुटियों से बचने के लिए, कुछ कार्य , जैसे राज्य भंडारण क्षेत्र, एक अशुद्धता के लिए प्रतिबंधित हैं। उदाहरण अशुद्धियाँ:

 mixin Audio { abstract Int volume Void incrementVolume() { volume += 1 } Void decrementVolume() { volume -= 1 } } class Television : Audio { override Int volume := 0 } 

यदि दिलचस्पी है, तो यहां जावा समकक्ष देखा जा सकता है ।

प्रतिरूपकता

आधुनिकता सॉफ्टवेयर का एक महत्वपूर्ण पहलू है जो एक आधुनिक प्रोग्रामिंग भाषा की आवश्यकता है।
दुर्भाग्य से, जावा में पिछले दशक में हम क्लासपाथ के साथ वास्तविक नरक का सामना कर रहे हैं। क्लासपाथ के साथ समस्याओं के अलावा, जावा ने गलत निर्णय लिया और आकार में 44Mb के J2SE मोनोलिथ पर स्विच किया, जिसने हमारे अनुप्रयोगों को काफी धीमा कर दिया।
.NET ने इस मुद्दे को बहुत गंभीरता से लिया, इसलिए संस्करण तंत्र, GAC और अन्य उपकरणों के लिए धन्यवाद, जावा से कुछ समस्याओं का समाधान किया गया। लेकिन वे ज़िप मॉड्यूल की सादगी को खो देते हैं और मॉड्यूल को DLL में पैक करना शुरू कर देते हैं जिसमें अभी भी कई अलग-अलग स्पेयर पार्ट्स होते हैं, जिससे मॉड्यूल के साथ काम करना मुश्किल हो जाता है।

फेंटम में, सब कुछ पॉड्स नामक मॉड्यूल पर बनाया गया है। जैसे जावा में, एक ज़िप फ़ाइल है, जिसे आप आसानी से देख सकते हैं। मेटा डेटा को एक विशेष फ़ाइल /meta.props में संग्रहीत किया जाता है, जो कि पॉड.नाम, पॉड.वर्सन, पॉड.पेंड्स, और इसी तरह की-वैल्यू एंट्री है। फली की निर्भरता उसके मेटाडेटा में संग्रहीत होती है और स्पष्ट और समझ में आने वाले तरीके से वर्णित की जाती है।

जावा में नाम स्थान में कोड को व्यवस्थित करने के लिए, पैकेज का उपयोग किया जाता है, और जार फ़ाइल को एक मॉड्यूल के रूप में माना जाता है। इन अवधारणाओं के बीच बेमेल एक बड़ी समस्या का कारण बनता है। आपके पास जावा क्लास का नाम है, लेकिन यह आपको यह नहीं बताएगा कि यह क्लास किस जार में रहती है और इसे कहां से लोड करना है।

फैंटम ने एक सरल नाम प्रबंधन समाधान बनाया: नाम में तीन पदानुक्रम स्तर "फली :: type.slot", अर्थात्। पहले स्तर पर, हमेशा पॉड का नाम, फिर टाइप नाम (जावा में क्लास का एनालॉग) और फिर स्लॉट (विधि या क्षेत्र) का नाम। नामस्थान में यह लगातार व्यवहार बड़ी प्रणालियों की विधानसभा प्रक्रिया को नियंत्रित करना आसान बनाता है।

कार्यात्मक प्रोग्रामिंग

जावा और सी # बंद होने के लिए पूर्ण समर्थन की ओर बढ़ रहे हैं, लेकिन खुद के बाद वे पुराने एपीआई के रूप में इतिहास पर एक बड़ा निशान छोड़ देते हैं। फैंटम को प्रारंभिक चरण में बंद करने के लिए समर्थन के साथ बनाया गया था। क्लोजर भाषा की एक प्रमुख विशेषता है जो हर जगह और हमेशा उपयोग की जाती है।

 // print a list of strings list := ["red", "yellow", "orange"] list.each |Str color| { echo(color) } // print 0 to 9 10.times |i| { echo(i) } // create a function that adds two integers add := |Int a, Int b->Int| { return a + b } nine := add(4, 5) // map Int to Str map := [0:"zero", 1:"one", 2:"two"] // empty Int:Str map Int:Str[:] // map [1, 2, 3].map { "f" + it * 2 } // ["f2", "f4", "f6"] //reduce ["2":2, "3":3, "4":4].reduce(0) |Int sum, Int v->Int| { sum + v } // 9 

घोषणात्मक विवरण

सबसे अच्छा वर्णन कुछ उदाहरण होगा:

 Window { title = "Example" size = Size(300, 200) content = EdgePane { center = Label { text = "Hello world"; halign = Halign.center } bottom = Button { text = "Close"; onAction.add { it.window.close } } } }.open homer := Person { name = "Homer Simpson" age = 39 children = [ Person { name = "Bart"; age = 7 }, Person { name = "Lisa"; age = 5 }, Person { name = "Maggie"; age = 1 } ] } 

समानता

वर्तमान में अधिकांश भाषाओं में थ्रेड्स के बीच एक सामान्य मॉडल है। इसका मतलब है कि डेवलपर को मेमोरी लॉक का ध्यान रखना चाहिए। गलत ब्लॉकिंग से अप्रिय त्रुटियां हो सकती हैं, जैसे गतिरोध, दौड़ की स्थिति आदि। यह सब समवर्ती प्रबंधन के लिए एक काफी निम्न स्तर है।

फंतासी निम्नलिखित तकनीकों का उपयोग करके संगामिति का समर्थन करती है:

1. अपरिवर्तनीय वस्तुएँ (सुरक्षा स्ट्रीमिंग)
   
   

    const class Point { new make(Int x, Int y) { this.x = x; this.y = y } const Int x const Int y } p := Point(0, 0) // ok px = 10 // throws ConstErr vowels := ['a','e','i','o','u'].toImmutable 

   
   
2. स्थैतिक क्षेत्र केवल अपरिवर्तनीय वस्तुओं को संग्रहीत कर सकते हैं, इसलिए विभिन्न थ्रेड साझा किए गए परिवर्तनशील डेटा तक नहीं पहुंच सकते हैं।
3. थ्रेड्स (एरलंग-शैली) के बीच संचार के लिए संदेश मॉडल (अभिनेता)
   
   

     echo("\n--- echoActor ---") // this actor just echos messages sent to it a := Actor(ActorPool()) |msg| { echo(msg); return msg } // send some messages and have them printed to console f1 := a.send("message 1") f2 := a.send("message 2") f3 := a.send("message 3") // now block for the result of each message echo("Result 1 = " + f1.get) // message 1 echo("Result 2 = " + f2.get) // message 2 echo("Result 3 = " + f3.get) // message 3 

   
   

सिंथेटिक चीनी

1. विकल्पों के लिए डिफ़ॉल्ट मान
   
   

    class Person { Int yearsToRetirement(Int retire := 65) { return retire - age } Int age } 

   
   
2. प्रकार का अनुमान - स्थानीय चर के प्रकार का अनुमान लगाया जा सकता है
3. इंप्लांटेड फील्ड एक्सेस
   
   

    class Thing { Int id := 0 { get { echo("get id"); return &id } set { echo("set id"); &id = it } } } 

   
   
4. शून्य प्रकार - उन प्रकारों को अलग करना जो शून्य को एक मूल्य के रूप में स्वीकार नहीं कर सकते हैं, और जो कर सकते हैं।
   
   

    Str // never stores null Str? // might store null x := str.size => x is typed as Int x := str?.size => x is typed as Int? 

   
   
5. सी # एंडर्स हेजेलबर्ग में हटाए गए अपवादों की भी जाँच की, उन्हें सक्षम नहीं किया (और यह सही था)
6. संख्यात्मक सटीकता - केवल 64 बिट इंट और फ्लोट समर्थन है

साधन

1. फैंटम एक्लिप्स-आधारित IDE F4
   
   
   
2. वेब एप्लीकेशन फ्रेमवर्क टेल्स
   

    //Hello world written in tales using tales class HelloWorld : Page{ @Route{uri="/hello-world"} Void main(){ response.writeStr("Hello World") } } 

   
   
3. तर्क-मुक्त टेम्पलेट इंजन मूंछें
   

    using mustache Mustache template := Mustache("Hello, {{ name }}!".in) template.render(["name":"world"]) 

   
   
4. फेंटम पॉड रिपॉजिटरी
   
   
   
5. fantom.org

निष्कर्ष

एक सामान्य गलती यह है कि फेंटम जावा का एक और बेहतर संस्करण है। लेकिन किसी को केवल अपने दर्शन और अवधारणाओं के साथ एक भाषा के रूप में इसे देखना होगा, जैसा कि आप इसके सभी आकर्षण को समझना शुरू करते हैं। स्थिरता के अलावा, फेंटम में कई विशेषताएं शामिल हैं जैसे कि एक अनुकूल समुदाय , पूरी तरह से खुला स्रोत कोड , एक अच्छा आईडीई और कई और अधिक सुखद चीजें।