17 बिलियन इवेंट, 60 मिलियन उपयोगकर्ता सत्र और बड़ी संख्या में वर्चुअल डेट्स रोजाना बेथ में होती हैं। प्रत्येक घटना SQL और उसके बाद के विश्लेषण के लिए रिलेशनल डेटाबेस में बड़े करीने से संग्रहीत होती है।

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

आभासी मशीनों पर एक श्रृंखला में अंतिम लेख में, मैं दिलचस्प सत्रों को खोजने के लिए एक वैकल्पिक दृष्टिकोण के बारे में बात करूंगा - नियमित अभिव्यक्ति इंजन ( सुअर मैच ), जो घटनाओं के अनुक्रमों के लिए परिभाषित किया गया है।

वर्चुअल मशीन, बायोटेक और कंपाइलर मुफ्त में शामिल हैं!

भाग एक, परिचयात्मक
भाग दो, अनुकूलन
भाग तीन, लागू (वर्तमान)

घटनाओं और सत्रों के बारे में

मान लें कि हमारे पास पहले से ही एक डेटा वेयरहाउस है जो आपको उपयोगकर्ता सत्रों में से प्रत्येक की घटनाओं को जल्दी और क्रमिक रूप से देखने की अनुमति देता है।

हम "सभी सत्रों को गिनना चाहते हैं, जहां घटनाओं के एक निर्दिष्ट बाद", "किसी दिए गए पैटर्न द्वारा वर्णित सत्र के कुछ हिस्सों को खोजें" जैसे अनुरोधों के द्वारा सत्र ढूंढना चाहते हैं, "सत्र का वह हिस्सा जो किसी दिए गए पैटर्न के बाद हुआ है" या "कितने सत्रों में कुछ भागों की गणना करें" टेम्पलेट। " यह विभिन्न प्रकार के विश्लेषण के लिए उपयोगी हो सकता है: संदिग्ध सत्र, फ़नल विश्लेषण आदि की खोज करना।

वांछित अनुवर्ती किसी भी तरह वर्णित किया जाना चाहिए। अपने सरलतम रूप में, यह कार्य एक पाठ में एक विकल्प खोजने के समान है; हम एक और अधिक शक्तिशाली उपकरण चाहते हैं - नियमित अभिव्यक्ति। आधुनिक अभिव्यक्ति इंजन के आधुनिक कार्यान्वयन सबसे अधिक बार उपयोग करते हैं (आपने इसका अनुमान लगाया है!) वर्चुअल मशीन।

नियमित अभिव्यक्तियों के साथ मेल खाने वाले सत्रों के लिए छोटी आभासी मशीनों के निर्माण पर चर्चा की जाएगी। लेकिन पहले, हम परिभाषाएँ स्पष्ट करेंगे।

एक घटना में एक घटना प्रकार, समय, संदर्भ और प्रत्येक प्रकार के लिए विशिष्ट विशेषताओं का एक सेट होता है।

प्रत्येक घटना का प्रकार और संदर्भ पूर्वनिर्धारित सूचियों से पूर्णांक होते हैं। यदि घटनाओं के प्रकारों के साथ सब कुछ स्पष्ट है, तो संदर्भ है, उदाहरण के लिए, स्क्रीन की संख्या जिस पर दी गई घटना हुई है।

एक ईवेंट विशेषता एक मनमाना पूर्णांक है जिसका अर्थ ईवेंट के प्रकार से निर्धारित होता है। एक घटना में विशेषताएँ नहीं हो सकती हैं, या कई हो सकते हैं।

एक सत्र समय के अनुसार क्रमबद्ध घटनाओं का एक क्रम है।

लेकिन चलो अंत में व्यापार के लिए नीचे उतरो। जैसा कि वे कहते हैं, चर्चा, थम गया, और मैं मंच पर बाहर चला गया।

कागज के एक टुकड़े पर तुलना करें

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

आइए इंटरफ़ेस कार्यों को परिभाषित करें:

matcher *matcher_create(uint8_t *bytecode); match_result matcher_accept(matcher *m, uint32_t event); void matcher_destroy(matcher *matcher); 

यदि सब कुछ matcher_create और matcher_destroy फ़ंक्शन के साथ स्पष्ट है, तो matcher_accept टिप्पणी करने के लायक है। Matcher_accept फ़ंक्शन को वर्चुअल मशीन और अगली घटना (32 बिट्स, जहां घटना के प्रकार के लिए 16 बिट्स और संदर्भ के लिए 16 बिट्स) का एक उदाहरण प्राप्त होता है, और एक कोड देता है जो यह समझाता है कि उपयोगकर्ता कोड को आगे क्या करना चाहिए:

 typedef enum match_result { //       MATCH_NEXT, //    ,      MATCH_OK, //       ,      MATCH_FAIL, //     MATCH_ERROR, } match_result; 

वर्चुअल मशीन opcodes:

 typedef enum matcher_opcode { //  ,      OP_ABORT, //      ( -  ) OP_NAME, //     ( -  ) OP_SCREEN, //    OP_NEXT, //    OP_MATCH, } matcher_opcode; 

एक आभासी मशीन का मुख्य लूप:

 match_result matcher_accept(matcher *m, uint32_t next_event) { #define NEXT_OP() \ (*m->ip++) #define NEXT_ARG() \ ((void)(m->ip += 2), (m->ip[-2] << 8) + m->ip[-1]) for (;;) { uint8_t instruction = NEXT_OP(); switch (instruction) { case OP_ABORT:{ return MATCH_ERROR; } case OP_NAME:{ uint16_t name = NEXT_ARG(); if (event_name(next_event) != name) return MATCH_FAIL; break; } case OP_SCREEN:{ uint16_t screen = NEXT_ARG(); if (event_screen(next_event) != screen) return MATCH_FAIL; break; } case OP_NEXT:{ return MATCH_NEXT; } case OP_MATCH:{ return MATCH_OK; } default:{ return MATCH_ERROR; } } } #undef NEXT_OP #undef NEXT_ARG } 

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

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

श्रृंखला में पहले लेख से उदाहरण , प्रभावी रूप से, रोलबैक (अंग्रेजी बैकट्रैकिंग) का उपयोग करके एक मैच को फिर से शुरू करने का अनुकरण करता है। उदाहरण में कोड, निश्चित रूप से, यहां दिए गए की तुलना में स्लिमर है, लेकिन समस्या दूर नहीं हुई है: प्रत्येक घटना को कई बार जांचना होगा।

आप ऐसे नहीं रह सकते

मुझे, मुझे फिर से और मुझे फिर से

आइए हम एक बार फिर समस्या को रेखांकित करते हैं: हमें आने वाली घटनाओं के साथ टेम्पलेट का मिलान करने की आवश्यकता है, प्रत्येक घटना से एक नई तुलना शुरू करना। तो हम ऐसा क्यों नहीं करते? आभासी मशीन को कई थ्रेड्स में आने वाली घटनाओं पर चलने दें!

ऐसा करने के लिए, हमें एक नई इकाई - एक धारा प्राप्त करने की आवश्यकता है। प्रत्येक थ्रेड एकल पॉइंटर को स्टोर करता है - वर्तमान निर्देश को:

 typedef struct matcher_thread { uint8_t *ip; } matcher_thread; 

स्वाभाविक रूप से, अब आभासी मशीन में हम स्पष्ट सूचक को संग्रहीत नहीं करेंगे। यह थ्रेड्स की दो सूचियों द्वारा प्रतिस्थापित किया जाएगा (नीचे उनके बारे में अधिक):

 typedef struct matcher { uint8_t *bytecode; /* Threads to be processed using the current event */ matcher_thread current_threads[MAX_THREAD_NUM]; uint8_t current_thread_num; /* Threads to be processed using the event to follow */ matcher_thread next_threads[MAX_THREAD_NUM]; uint8_t next_thread_num; } matcher; 

और यहाँ अद्यतन मुख्य लूप है:

 match_result matcher_accept(matcher *m, uint32_t next_event) { #define NEXT_OP(thread) \ (*(thread).ip++) #define NEXT_ARG(thread) \ ((void)((thread).ip += 2), ((thread).ip[-2] << 8) + (thread).ip[-1]) /*         - */ add_current_thread(m, initial_thread(m)); //         for (size_t thread_i = 0; thread_i < m->current_thread_num; thread_i++ ) { matcher_thread current_thread = m->current_threads[thread_i]; bool thread_done = false; while (!thread_done) { uint8_t instruction = NEXT_OP(current_thread); switch (instruction) { case OP_ABORT:{ return MATCH_ERROR; } case OP_NAME:{ uint16_t name = NEXT_ARG(current_thread); //  ,      ,    //     next_threads,    if (event_name(next_event) != name) thread_done = true; break; } case OP_SCREEN:{ uint16_t screen = NEXT_ARG(current_thread); if (event_screen(next_event) != screen) thread_done = true; break; } case OP_NEXT:{ //    , ..      // next_threads add_next_thread(m, current_thread); thread_done = true; break; } case OP_MATCH:{ return MATCH_OK; } default:{ return MATCH_ERROR; } } } } /*      ,    */ swap_current_and_next(m); return MATCH_NEXT; #undef NEXT_OP #undef NEXT_ARG } 

प्राप्त प्रत्येक घटना में, हम पहले current_threads सूची में एक नया थ्रेड जोड़ते हैं, बहुत शुरुआत से टेम्पलेट की जांच करते हैं, जिसके बाद हम निर्देशों का पालन करके प्रत्येक सूचक का अनुसरण करते हुए current_threads सूची का पता लगाना शुरू करते हैं।

यदि कोई अगला निर्देश सामने आया है, तो थ्रेड को अगली_शर्तों में सूची में रखा गया है, अर्थात यह प्राप्त होने वाली अगली घटना की प्रतीक्षा करता है।

यदि थ्रेड पैटर्न प्राप्त ईवेंट से मेल नहीं खाता है, तो ऐसे थ्रेड को बस नेक्स्ट_थ्रेड्स सूची में नहीं जोड़ा जाता है।

MATCH निर्देश तुरंत फ़ंक्शन से बाहर निकलता है, रिटर्न कोड की रिपोर्ट करता है कि पैटर्न सत्र से मेल खाता है।

धागे की सूची के क्रॉल के पूरा होने पर, वर्तमान और अगली सूचियों की अदला-बदली की जाती है।

दरअसल, बस इतना ही। हम कह सकते हैं कि हम वस्तुतः वही कर रहे हैं जो हम चाहते थे: उसी समय हम कई टेम्पलेटों की जाँच कर रहे हैं, प्रत्येक सत्र की घटनाओं के लिए एक नई मिलान प्रक्रिया शुरू कर रहे हैं।

टेम्पलेट्स में एकाधिक पहचान और शाखाएँ

घटनाओं के एक रैखिक अनुक्रम का वर्णन करने वाले टेम्पलेट के लिए खोज करना, निश्चित रूप से उपयोगी है, लेकिन हम पूर्ण नियमित अभिव्यक्ति प्राप्त करना चाहते हैं। और पिछले चरण में हमने जो प्रवाह बनाए, वे यहां भी उपयोगी हैं।

मान लीजिए कि हम दो या तीन घटनाओं का एक क्रम ढूंढना चाहते हैं जो हमारे लिए रुचि रखते हैं, कुछ इस तरह की तर्ज पर एक नियमित अभिव्यक्ति: "ए! बीसी"। इस क्रम में, प्रतीक "a" वैकल्पिक है। इसे बाइटकोड में कैसे व्यक्त करें? आराम से!

हम दो धागे शुरू कर सकते हैं, प्रत्येक मामले के लिए: प्रतीक "ए" और इसके बिना। ऐसा करने के लिए, हम एक अतिरिक्त निर्देश (एसपीएलआईटी प्रकार का एडीआर 1, एडीआर 2) पेश करते हैं, जो निर्दिष्ट पते से दो धागे शुरू करता है। SPLIT के अलावा, JUMP भी हमारे लिए उपयोगी है, जो सीधे सीधे निर्देश में निर्दिष्ट निर्देश के साथ निष्पादन जारी रखता है:

 typedef enum matcher_opcode { OP_ABORT, OP_NAME, OP_SCREEN, OP_NEXT, //     OP_JUMP, //         OP_SPLIT, OP_MATCH, //     OP_NUMBER_OF_OPS, } matcher_opcode; 

लूप खुद और बाकी निर्देश नहीं बदलते - हम सिर्फ दो नए हैंडलर पेश करते हैं:

 // ... case OP_JUMP:{ /*   ,      */ uint16_t offset = NEXT_ARG(current_thread); add_current_thread(m, create_thread(m, offset)); break; } case OP_SPLIT:{ /*        */ uint16_t left_offset = NEXT_ARG(current_thread); uint16_t right_offset = NEXT_ARG(current_thread); add_current_thread(m, create_thread(m, left_offset)); add_current_thread(m, create_thread(m, right_offset)); break; } // ... 

ध्यान दें कि निर्देश वर्तमान सूची में थ्रेड्स जोड़ते हैं, अर्थात वे वर्तमान घटना के संदर्भ में काम करना जारी रखते हैं। जिस धागे के भीतर शाखा होती है वह निम्नलिखित धागों की सूची में नहीं आता है।

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

घटनाओं पर नियमित अभिव्यक्ति

अब जब हमारे पास इसके लिए एक उपयुक्त वर्चुअल मशीन और उपकरण हैं, तो हम वास्तव में अपने नियमित अभिव्यक्तियों के लिए वाक्य रचना से निपट सकते हैं।

अधिक गंभीर कार्यक्रमों के लिए ऑपकोड की मैन्युअल रिकॉर्डिंग जल्दी से थक जाती है। पिछली बार, मैंने एक पूर्ण पार्सर नहीं किया था, लेकिन सच-ग्रू उपयोगकर्ता ने उदाहरण के रूप में पिगलेटेक मिनी-भाषा का उपयोग करके अपने रेड्सल लाइब्रेरी की क्षमताओं को दिखाया। मैं कोड की संक्षिप्तता से इतना प्रभावित था कि मैंने रेड्सल की मदद से पायथन में एक सौ या दो सौ में स्ट्रिंग्स के नियमित अभिव्यक्तियों का एक छोटा संकलक लिखा। इसके उपयोग के लिए संकलक और निर्देश GitHub पर हैं। असेंबली भाषा में कंपाइलर के परिणाम को एक उपयोगिता द्वारा समझा जाता है जो दो फाइलों (वर्चुअल मशीन के लिए एक कार्यक्रम और सत्यापन के लिए सत्र की घटनाओं की एक सूची) को पढ़ता है।

शुरू करने के लिए, हम खुद को घटना के प्रकार और संदर्भ तक सीमित रखते हैं। घटना के प्रकार को एक ही संख्या से दर्शाया जाता है; यदि आपको एक संदर्भ निर्दिष्ट करने की आवश्यकता है, तो इसे एक बृहदान्त्र के माध्यम से निर्दिष्ट करें। सबसे सरल उदाहरण:

 > python regexp/regexp.py "13" # ,     13 NEXT NAME 13 MATCH 

अब संदर्भ के साथ एक उदाहरण:

 python regexp/regexp.py "13:12" #  13,  12 NEXT NAME 13 SCREEN 12 MATCH 

क्रमिक घटनाओं को किसी तरह अलग किया जाना चाहिए (उदाहरण के लिए, रिक्त स्थान द्वारा):

 > python regexp/regexp.py "13 11 10:9" 08:40:52 NEXT NAME 13 NEXT NAME 11 NEXT NAME 10 SCREEN 9 MATCH 

अधिक दिलचस्प टेम्पलेट:

 > python regexp/regexp.py "12|13" SPLIT L0 L1 L0: NEXT NAME 12 JUMP L2 L1: NEXT NAME 13 L2: MATCH 

एक बृहदान्त्र के साथ समाप्त होने वाली रेखाओं पर ध्यान दें। ये टैग हैं। SPLIT अनुदेश दो थ्रेड बनाता है जो लेबल L0 और L1 से निष्पादन जारी रखता है, और निष्पादन की पहली शाखा के अंत में JUMP बस शाखा के अंत में आगे बढ़ता है।

कोष्ठक में अनुवर्ती समूहों द्वारा आप भावों की श्रृंखलाओं को और अधिक सही मायने में चुन सकते हैं:

 > python regexp/regexp.py "(1 2 3)|4" SPLIT L0 L1 L0: NEXT NAME 1 NEXT NAME 2 NEXT NAME 3 JUMP L2 L1: NEXT NAME 4 L2: MATCH 

एक मनमाने घटना को एक बिंदु द्वारा दर्शाया गया है:

 > python regexp/regexp.py ". 1" NEXT NEXT NAME 1 MATCH 

यदि हम यह दर्शाना चाहते हैं कि परवर्ती वैकल्पिक है, तो हम इसके बाद एक प्रश्न चिह्न लगाते हैं:

 > python regexp/regexp.py "1 2 3? 4" NEXT NAME 1 NEXT NAME 2 SPLIT L0 L1 L0: NEXT NAME 3 L1: NEXT NAME 4 MATCH 

बेशक, कई नियमित दोहराव (प्लस या तारांकन) नियमित अभिव्यक्तियों में भी सामान्य हैं:

 > python regexp/regexp.py "1+ 2" L0: NEXT NAME 1 SPLIT L0 L1 L1: NEXT NAME 2 MATCH 

यहां हम बस प्रत्येक चक्र पर नए थ्रेड शुरू करते हुए, कई बार SPLIT निर्देश को निष्पादित करते हैं।

इसी तरह एक तारांकन के साथ:

 > python regexp/regexp.py "1* 2" L0: SPLIT L1 L2 L1: NEXT NAME 1 JUMP L0 L2: NEXT NAME 2 MATCH 

परिप्रेक्ष्य

वर्णित वर्चुअल मशीन के अन्य एक्सटेंशन काम में आ सकते हैं।

उदाहरण के लिए, ईवेंट विशेषताओं की जाँच करके इसे आसानी से विस्तारित किया जा सकता है। एक वास्तविक प्रणाली के लिए, मुझे लगता है कि "1: 2 {3: 4, 5:> 3}" जैसे वाक्य-विन्यास का उपयोग किया जाता है, जिसका अर्थ है: घटना 1 का संदर्भ 2 में विशेषता 3 के साथ मान 4 और विशेषता मान 5 से अधिक 3 है। यहाँ विशेषताएँ आप इसे आसानी से matcher_accept फ़ंक्शन की सरणी में पास कर सकते हैं।

यदि आप matcher_accept की घटनाओं के बीच समय अंतराल भी पास करते हैं, तो आप टेम्पलेट भाषा में एक वाक्यविन्यास जोड़ सकते हैं जो आपको घटनाओं के बीच समय को छोड़ने की अनुमति देता है: "1 माइंडेल्टा (120) 2", जिसका अर्थ होगा: घटना 1, फिर कम से कम 120 सेकंड की अवधि, इवेंट 2 एक बाद के संरक्षण के साथ संयुक्त, यह आपको घटनाओं के दो बाद के बीच उपयोगकर्ता के व्यवहार के बारे में जानकारी एकत्र करने की अनुमति देता है।

अन्य उपयोगी चीजें जो जोड़ना आसान है, वे हैं: नियमित अभिव्यक्तियों के संरक्षण, लालची और साधारण तारांकन और प्लस ऑपरेटरों को अलग करना, और इसी तरह। ऑटोमेटा के सिद्धांत के संदर्भ में, हमारी आभासी मशीन एक नॉनडेटर्मिनिस्टिक परिमित ऑटोमोटन है, जिसके कार्यान्वयन के लिए ऐसी चीजों को करना मुश्किल नहीं है।

निष्कर्ष

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

यदि गति आपके लिए इतनी महत्वपूर्ण नहीं है, तो एक समान प्रणाली को पारंपरिक रिलेशनल डेटाबेस या वितरित फ़ाइल सिस्टम की तरह कुछ और मानक डेटा संग्रहण प्रणाली के विस्तार के रूप में डिज़ाइन किया जा सकता है।

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

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

यह बाइटकोड व्याख्याताओं और आभासी मशीनों के विभिन्न उपयोगों पर लेखों की एक श्रृंखला का समापन करता है। मुझे आशा है कि हेबर के पाठकों ने श्रृंखला को पसंद किया है और निश्चित रूप से, मुझे इस विषय पर किसी भी प्रश्न का उत्तर देने में खुशी होगी।

अनौपचारिक सन्दर्भ

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

व्यापक अर्थों में, एक अन्य पुस्तक आभासी मशीनों के लिए समर्पित है - "वर्चुअल मशीन: सिस्टम और प्रक्रियाओं के लिए लचीले प्लेटफार्म" ("वर्चुअल मशीन: सिस्टम और प्रक्रियाओं के लिए बहुमुखी प्लेटफार्म")। यह सामान्य रूप से भाषाओं, प्रक्रियाओं और कंप्यूटर आर्किटेक्चर के वर्चुअलाइजेशन को कवर करते हुए वर्चुअलाइजेशन के विभिन्न अनुप्रयोगों का परिचय है।

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

नियमित अभिव्यक्तियों का सिद्धांत संकलक पर सभी अकादमिक पाठ्यपुस्तकों में प्रस्तुत किया गया है। यह प्रसिद्ध "ड्रैगन बुक" को संदर्भित करने के लिए प्रथागत है, लेकिन मैं ऊपर दिए गए लिंक से शुरू करने की सलाह दूंगा।

इस लेख पर काम करते समय, मैंने पहली बार पायथन रेड्सल के लिए कंपाइलरों के तेजी से विकास के लिए एक दिलचस्प प्रणाली का इस्तेमाल किया, जो उपयोगकर्ता के सच-ग्रू (धन्यवाद, पीटर!) की कलम से संबंधित है। यदि आप किसी भाषा का प्रोटोटाइप बनाने या किसी तरह के डीएसएल को जल्दी से विकसित करने के काम का सामना कर रहे हैं, तो आपको इस पर ध्यान देना चाहिए।