ऑटोमेटा-आधारित प्रोग्रामिंग

For other uses, see Automata-based programming (Shalyto's approach).

ऑटोमेटा-आधारित प्रोग्रामिंग एक प्रोग्रामिंग प्रतिमान है जिसमें प्रोग्राम या उसके हिस्से को एक परिमित-राज्य मशीन (एफएसएम) या किसी अन्य (अक्सर अधिक जटिल) औपचारिक ऑटोमेटन (ऑटोमेटा सिद्धांत देखें) के मॉडल के रूप में माना जाता है। कभी-कभी संभावित राज्यों का एक संभावित अनंत सेट पेश किया जाता है, और ऐसे सेट में केवल एक गणना नहीं बल्कि एक जटिल संरचना हो सकती है।

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

निम्नलिखित गुण ऑटोमेटा-आधारित प्रोग्रामिंग के लिए प्रमुख संकेतक हैं:

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

ऑटोमेटा-आधारित कोड का संपूर्ण निष्पादन ऑटोमेटन चरणों का एक चक्र है।

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

उदाहरण

कार्य

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

पारंपरिक कार्यक्रम

C (प्रोग्रामिंग भाषा) में एक पारंपरिक प्रोग्राम जो उपरोक्त कार्य करता है वह इस तरह दिख सकता है:

#include <ctype.h>
#include <stdio.h>


int main(void) {
  int c;

  do {
    do {
      c = getchar();
    } while (isspace(c));

    while (!isspace(c) && c != EOF) {
      putchar(c);
      c = getchar();
    }
    
    while (c != '\n' && c != EOF) {
      c = getchar();
    }
    
    if (c == '\n') {
      putchar(c);
    }
  } while (c != EOF);

  return 0;
}

उदाहरण के लिए, उपरोक्त प्रोग्राम को इस इनपुट पर संकलित करना और चलाना:

$ clang program.c && (printf "\t\v\f\r \n\n\t\v\f\r foo bar baz\n\n\t\v\f\r qux quux corge" | ./a.out)

पैदावार:

foo
qux

ऑटोमेटा-आधारित प्रोग्राम

प्रक्रियात्मक

उसी कार्य को परिमित-राज्य मशीनों के संदर्भ में सोचकर हल किया जा सकता है। ध्यान दें कि किसी पंक्ति के विश्लेषण में तीन चरण होते हैं: प्रमुख रिक्त स्थान वर्णों को छोड़ना, पहले शब्द के वर्णों को प्रिंट करना और अनुगामी वर्णों को छोड़ना। आइए इन स्वचालित अवस्थाओं को कॉल करें BEFORE, INSIDE और AFTER. प्रोग्राम का ऑटोमेटा-आधारित संस्करण इस तरह दिख सकता है:

#include <ctype.h>
#include <stdio.h>

enum State {BEFORE, INSIDE, AFTER};


int main(void) {
  int c;
  enum State s = BEFORE;

  while ((c = getchar()) != EOF) {
    switch (s) {
      case BEFORE:
        if (!isspace(c)) {
          putchar(c);
          s = INSIDE;
        }
        
        break;
      case INSIDE:
        if (c == '\n') {
          putchar(c);
          s = BEFORE;
        } else if (isspace(c)) {
          s = AFTER;
        } else {
          putchar(c);
        }
          
        break;
      case AFTER:
        if (c == '\n') {
          putchar(c);
          s = BEFORE;
        }
        
        break;
    }
  }

  return 0;
}

हालाँकि यह कार्यक्रम अब लंबा दिखता है, लेकिन इसका कम से कम एक महत्वपूर्ण लाभ है: इसमें केवल एक ही रीडिंग है (अर्थात, कॉल करें)। getchar फ़ंक्शन) निर्देश। इसके अलावा, पारंपरिक संस्करण में मौजूद चार के बजाय केवल एक लूप है। का शरीर while लूप ऑटोमेटन चरण है और लूप स्वयं ऑटोमेटन चरण का चक्र है। कार्यक्रम राज्य आरेख में दिखाए गए एक परिमित-राज्य मशीन के कार्य को कार्यान्वित करता है।

प्रोग्राम की सबसे महत्वपूर्ण संपत्ति यह है कि ऑटोमेटन स्टेप कोड अनुभाग स्पष्ट रूप से स्थानीयकृत है। एक स्पष्ट कार्य के साथ step स्वचालन चरण के लिए, प्रोग्राम इस गुण को बेहतर ढंग से प्रदर्शित करता है:

#include <ctype.h>
#include <stdio.h>

enum State {BEFORE, INSIDE, AFTER};


void step(enum State* const s, int const c) {
  switch (*s) {
    case BEFORE:
      if (!isspace(c)) {
        putchar(c);
        *s = INSIDE;
      }
      
      break;
    case INSIDE:
      if (c == '\n') {
        putchar(c);
        *s = BEFORE;
      } else if (isspace(c)) {
        *s = AFTER;
      } else {
        putchar(c);
      }
        
      break;
    case AFTER:
      if (c == '\n') {
        putchar(c);
        *s = BEFORE;
      }
      
      break;
  }
}


int main(void) {
  int c;
  enum State s = BEFORE;

  while ((c = getchar()) != EOF) {
    step(&s, c);
  }

  return 0;
}

प्रोग्राम अब ऑटोमेटा-आधारित कोड के मूल गुणों को स्पष्ट रूप से प्रदर्शित करता है:

• ऑटोमेटन चरण निष्पादन की समय अवधि ओवरलैप नहीं हो सकती है;
• पिछले चरण से अगले चरण तक भेजी गई एकमात्र जानकारी स्पष्ट रूप से निर्दिष्ट ऑटोमेटन स्थिति है।

एक परिमित ऑटोमेटन को एक राज्य-संक्रमण तालिका द्वारा परिभाषित किया जा सकता है, जिसकी पंक्तियाँ वर्तमान स्थितियों के लिए होती हैं, कॉलम इनपुट के लिए होते हैं, और कोशिकाएँ अगले राज्यों और प्रदर्शन करने के लिए क्रियाओं के लिए होती हैं।

State-transition table

Input Current state	newline	whitespace	other
before	before	before	inside/print
inside	before/print	after	inside/print
after	before/print	after	after

State diagram

The state diagram of a finite-state machine that prints the first word of each line of an input stream. The machine follows exactly one transition on each step, depending on the current state and the encountered character. The action accompanying a transition is either a no-operation or the printing of the encountered character, denoted with print.

सामान्यतया, एक ऑटोमेटा-आधारित प्रोग्राम स्वाभाविक रूप से इस दृष्टिकोण का उपयोग कर सकता है। एक स्पष्ट द्वि-आयामी सरणी के साथ transitions राज्य-संक्रमण तालिका के लिए, प्रोग्राम इस दृष्टिकोण का उपयोग करता है:

#include <ctype.h>
#include <stdio.h>

enum State {BEFORE, INSIDE, AFTER};


void nop(int const c) {}


void print(int const c) {
  putchar(c);
}


struct Branch {
  enum State const next_state;
  void (*action)(int);
};


struct Branch const transitions[3][3] = {
  //   newline         whitespace         other             Inputs/States
  {{BEFORE,   &nop}, {BEFORE, &nop}, {INSIDE, &print}},  // before
  {{BEFORE, &print}, {AFTER,  &nop}, {INSIDE, &print}},  // inside
  {{BEFORE, &print}, {AFTER,  &nop}, {AFTER,    &nop}}   // after
};


void step(enum State* const s, int const c) {
  int const row = (*s == BEFORE) ? 0 : (*s == INSIDE) ? 1 : 2;
  int const column = (c == '\n') ? 0 : isspace(c) ? 1 : 2;
  struct Branch const* const b = &transitions[row][column];
  *s = b->next_state;
  b->action(c);
}


int main(void) {
  int c;
  enum State s = BEFORE;

  while ((c = getchar()) != EOF) {
    step(&s, c);
  }

  return 0;
}

वस्तु-उन्मुख

यदि कार्यान्वयन भाषा ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग का समर्थन करती है, तो प्रोग्राम का एक सरल रिफैक्टरिंग ऑटोमेटन को एक ऑब्जेक्ट में एनकैप्सुलेशन (कंप्यूटर विज्ञान) करना है, इस प्रकार इसके कार्यान्वयन विवरण छिपाना है। ऑब्जेक्ट-ओरिएंटेड शैली का उपयोग करके C++ में प्रोग्राम इस तरह दिख सकता है:

#include <ctype.h>
#include <stdio.h>

enum State {BEFORE, INSIDE, AFTER};


struct Branch {
  enum State const next_state;
  void (*action)(int);
};


class StateMachine {
  public:
    StateMachine();
    void feedChar(int);

  protected:
    static void nop(int);
    static void print(int);

  private:
    enum State _state;
    static struct Branch const _transitions[3][3];
};


StateMachine::StateMachine(): _state(BEFORE) {}


void StateMachine::feedChar(int const c) {
  int const row = (_state == BEFORE) ? 0 : (_state == INSIDE) ? 1 : 2;
  int const column = (c == '\n') ? 0 : isspace(c) ? 1 : 2;
  struct Branch const* const b = &_transitions[row][column];
  _state = b->next_state;
  b->action(c);
}


void StateMachine::nop(int const c) {}


void StateMachine::print(int const c) {
  putchar(c);
}


struct Branch const StateMachine::_transitions[3][3] = {
  //   newline         whitespace         other             Inputs/States
  {{BEFORE,   &nop}, {BEFORE, &nop}, {INSIDE, &print}},  // before
  {{BEFORE, &print}, {AFTER,  &nop}, {INSIDE, &print}},  // inside
  {{BEFORE, &print}, {AFTER,  &nop}, {AFTER,    &nop}}   // after
};


int main() {
  int c;
  StateMachine m;

  while ((c = getchar()) != EOF) {
    m.feedChar(c);
  }

  return 0;
}

टिप्पणी। — लेख के विषय, इनपुट/आउटपुट से सीधे संबंधित न होने वाले परिवर्तनों को कम करने के लिए getchar और putchar C (प्रोग्रामिंग भाषा) की मानक लाइब्रेरी के फ़ंक्शंस का उपयोग किया जा रहा है।

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

#include <ctype.h>
#include <stdio.h>

class StateMachine;


class State {
  public:
    virtual void feedChar(StateMachine*, int) const = 0;
};


class Before: public State {
  public:
    static State const* instantiate();
    virtual void feedChar(StateMachine*, int) const override;

  protected:
    Before() = default;

  private:
    static State const* _instance;
};


class Inside: public State {
  public:
    static State const* instantiate();
    virtual void feedChar(StateMachine*, int) const override;

  protected:
    Inside() = default;

  private:
    static State const* _instance;
};


class After: public State {
  public:
    static State const* instantiate();
    virtual void feedChar(StateMachine*, int) const override;

  protected:
    After() = default;

  private:
    static State const* _instance;
};


class StateMachine {
  public:
    StateMachine();
    void feedChar(int);

  protected:
    void setState(State const*);

  private:
    State const* _state;
    friend class Before;
    friend class Inside;
    friend class After;
};


State const* Before::instantiate() {
  if (!_instance) {
    _instance = new Before;
  }

  return _instance;
}


void Before::feedChar(StateMachine* const m, int const c) const {
  if (!isspace(c)) {
    putchar(c);
    m->setState(Inside::instantiate());
  }
}


State const* Before::_instance = nullptr;


State const* Inside::instantiate() {
  if (!_instance) {
    _instance = new Inside;
  }

  return _instance;
}


void Inside::feedChar(StateMachine* const m, int const c) const {
  if (c == '\n') {
    putchar(c);
    m->setState(Before::instantiate());
  } else if (isspace(c)) {
    m->setState(After::instantiate());
  } else {
    putchar(c);
  }
}


State const* Inside::_instance = nullptr;


State const* After::instantiate() {
  if (!_instance) {
    _instance = new After;
  }

  return _instance;
}


void After::feedChar(StateMachine* const m, int const c) const {
  if (c == '\n') {
    putchar(c);
    m->setState(Before::instantiate());
  }
}


State const* After::_instance = nullptr;


StateMachine::StateMachine(): _state(Before::instantiate()) {}


void StateMachine::feedChar(int const c) {
  _state->feedChar(this, c);
}


void StateMachine::setState(State const* const s) {
  _state = s;
}


int main() {
  int c;
  StateMachine m;

  while ((c = getchar()) != EOF) {
    m.feedChar(c);
  }

  return 0;
}

स्वचालन और ऑटोमेटा

ऑटोमेटा-आधारित प्रोग्रामिंग वास्तव में स्वचालन के क्षेत्र में पाई जाने वाली प्रोग्रामिंग आवश्यकताओं से काफी मेल खाती है।

एक उत्पादन चक्र आमतौर पर इस प्रकार तैयार किया जाता है:

• इनपुट डेटा (कैप्टर्स से) के अनुसार चरणों का एक क्रम;
• वर्तमान चरण के आधार पर की जाने वाली क्रियाओं का एक सेट।

विभिन्न समर्पित प्रोग्रामिंग भाषाएँ ऐसे मॉडल को अधिक या कम परिष्कृत तरीकों से व्यक्त करने की अनुमति देती हैं।

स्वचालन कार्यक्रम

ऊपर प्रस्तुत उदाहरण इस दृश्य के अनुसार निम्नलिखित छद्म कोड में व्यक्त किया जा सकता है ('सेट' एक तर्क चर को सक्रिय करता है, 'रीसेट' एक तर्क चर को निष्क्रिय करता है, ':' एक चर निर्दिष्ट करता है, और '=' समानता के लिए परीक्षण करता है):

newline: '\n'
whitespace: ('\t', '\n', '\v', '\f', '\r', ' ')
states: (before, inside, after)


setState(c) {
  if before and (c != newline and c not in whitespace) then set inside
  if inside then (if c in whitespace then set after else if c = newline then set before)
  if after and c = newline then set before
}


doAction(c) {
  if before and (c != newline and c not in whitespace) then write(c)
  if inside and c not in whitespace then write(c)
  if after and c = newline then write(c)
}


cycle {
  set before

  loop until (c: readCharacter) = EOL {
    setState(c)
    doAction(c)
  }
}

एक तरफ चक्र की प्रगति को व्यक्त करने वाली दिनचर्या का पृथक्करण, और दूसरी तरफ वास्तविक क्रिया (इनपुट और आउटपुट का मिलान) स्पष्ट और सरल कोड की अनुमति देता है।

घटनाएँ

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

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

   एस: स्टेज सी: स्थिति
   
   एस 1
   |
   |-सी2
   |
   एस 2
   |
   ----------
   | |
   |-c31 |-c32
   | |
  एस31 एस32
   | |
   |-c41 |-c42
   | |
   ----------
   |
   एस 4

अनुप्रयोग

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

राज्यों और राज्य मशीनों की धारणाओं का उपयोग अक्सर औपचारिक विनिर्देशन के क्षेत्र में किया जाता है। उदाहरण के लिए, एकीकृत मॉडलिंग भाषा सॉफ़्टवेयर आर्किटेक्चर विकास प्रोग्राम के व्यवहार को निर्दिष्ट करने के लिए स्टेट डायग्राम#यूएमएल स्टेट डायग्राम का उपयोग करता है। इसके अलावा विभिन्न संचार प्रोटोकॉल अक्सर राज्य की स्पष्ट धारणा का उपयोग करके निर्दिष्ट किए जाते हैं (उदाहरण के लिए, RFC 793).

कुछ प्रोग्रामिंग भाषाओं के शब्दार्थ का वर्णन करने के लिए ऑटोमेटा (चरण और स्थिति) के संदर्भ में सोचने का भी उपयोग किया जा सकता है। उदाहरण के लिए, रिफ़ल भाषा में लिखे गए प्रोग्राम के निष्पादन को तथाकथित अमूर्त रिफ़ल मशीन के चरणों के अनुक्रम के रूप में वर्णित किया गया है; मशीन की स्थिति एक दृश्य है (चर के बिना एक मनमाना रिफ़ल अभिव्यक्ति)।

योजना (प्रोग्रामिंग भाषा) भाषा में निरंतरता के लिए चरणों और राज्यों के संदर्भ में सोचने की आवश्यकता होती है, हालांकि योजना स्वयं किसी भी तरह से स्वचालित-संबंधित नहीं है (यह पुनरावर्ती है)। कॉल/सीसी सुविधा को कार्यान्वित करना संभव बनाने के लिए, कार्यान्वयन को निष्पादन कार्यक्रम की संपूर्ण स्थिति को पकड़ने में सक्षम होना चाहिए, जो केवल तभी संभव है जब राज्य में कोई अंतर्निहित भाग न हो। ऐसी पकड़ी गई स्थिति को ही निरंतरता कहा जाता है, और इसे एक (अपेक्षाकृत जटिल) ऑटोमेटन की स्थिति माना जा सकता है। ऑटोमेटन चरण पिछले एक से अगली निरंतरता निकाल रहा है, और निष्पादन प्रक्रिया ऐसे चरणों का चक्र है।

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

STAT प्रणाली [1] ऑटोमेटा-आधारित दृष्टिकोण का उपयोग करने का एक अच्छा उदाहरण है; इस प्रणाली में, अन्य सुविधाओं के अलावा, STATL नामक एक एम्बेडेड भाषा शामिल है जो पूरी तरह से ऑटोमेटा-उन्मुख है।

इतिहास

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

इस पर शुरुआती पत्रों में से एक जॉनसन एट अल., 1968 द्वारा लिखा गया है। एक सामान्य तकनीक के रूप में ऑटोमेटा-आधारित प्रोग्रामिंग का सबसे पहला उल्लेख पीटर नौर, 1963 के पेपर में पाया जाता है। लेखक इस तकनीक को ट्यूरिंग मशीन दृष्टिकोण कहते हैं, हालाँकि पेपर में कोई वास्तविक ट्यूरिंग मशीन नहीं दी गई है; इसके बजाय, चरणों और अवस्थाओं पर आधारित तकनीक का वर्णन किया गया है।

अनिवार्य और प्रक्रियात्मक प्रोग्रामिंग के साथ तुलना

राज्य (कंप्यूटर विज्ञान) की धारणा ऑटोमेटा-आधारित प्रोग्रामिंग की विशिष्ट संपत्ति नहीं है। सामान्यतया, राज्य (या प्रोग्राम राज्य) किसी भी कंप्यूटर प्रोग्राम के निष्पादन के दौरान सभी सूचनाओं के संयोजन के रूप में प्रकट होता है जो निष्पादन के दौरान बदल सकते हैं। उदाहरण के लिए, एक पारंपरिक अनिवार्य प्रोग्रामिंग प्रोग्राम की स्थिति में शामिल हैं

• सभी चरों के मान और गतिशील मेमोरी में संग्रहीत जानकारी;
• रजिस्टरों में संग्रहीत मूल्य;
• स्टैक सामग्री (स्थानीय चर के मान और वापसी पते सहित);
• निर्देश सूचक का वर्तमान मूल्य।

इन्हें स्पष्ट भाग (जैसे चर में संग्रहीत मान) और अंतर्निहित भाग (वापसी पते और निर्देश सूचक) में विभाजित किया जा सकता है।

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

वस्तु-उन्मुख प्रोग्रामिंग संबंध

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

इस प्रकार, एक ओर, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग की वस्तुओं को ऑटोमेटा (या ऑटोमेटा के मॉडल) के रूप में माना जा सकता है, जिनकी स्थिति निजी क्षेत्रों का संयोजन है, और एक या अधिक तरीकों को चरण माना जाता है। ऐसी विधियों को न तो एक-दूसरे को कॉल करना चाहिए और न ही स्वयं, न तो प्रत्यक्ष और न ही अप्रत्यक्ष रूप से, अन्यथा ऑब्जेक्ट को ऑटोमेटा-आधारित तरीके से कार्यान्वित नहीं माना जा सकता है।

दूसरी ओर, ऑब्जेक्ट ऑटोमेटन के मॉडल को लागू करने के लिए अच्छा है। जब ऑब्जेक्ट-ओरिएंटेड भाषा के भीतर ऑटोमेटा-आधारित दृष्टिकोण का उपयोग किया जाता है, तो एक ऑटोमेटन मॉडल आमतौर पर एक वर्ग द्वारा लागू किया जाता है, राज्य को वर्ग के निजी क्षेत्रों के साथ दर्शाया जाता है, और चरण को एक विधि के रूप में लागू किया जाता है; ऐसी विधि आम तौर पर कक्षा की एकमात्र गैर-निरंतर सार्वजनिक विधि होती है (कंस्ट्रक्टर और डिस्ट्रक्टर के अलावा)। अन्य सार्वजनिक विधियाँ राज्य से पूछताछ कर सकती हैं लेकिन इसे बदलें नहीं। सभी द्वितीयक विधियाँ (जैसे विशेष राज्य हैंडलर) आमतौर पर कक्षा के निजी भाग में छिपी होती हैं।

यह भी देखें

• सेलुलर ऑटोमेटन
• गैर-नियतात्मक प्रोग्रामिंग
• राज्य पैटर्न
• एस्टरेल, एक ऑटोमेटा-आधारित भाषा
• भरना, जावा और सी++ में ऑटोमेटा जोड़ने का एक उपकरण

बाहरी संबंध

• J. V. Noble. «Finite State Machines in Forth» — automata-based programming in Forth
• Harel, David (1987). "Statecharts: A Visual Formalism for Complex Systems" (PDF). Sci. Comput. Programming. 8 (3): 231–274. doi:10.1016/0167-6423(87)90035-9.
• Harel, David; Drusinsky, D. (1989). "Using Statecharts for Hardware Description and Synthesis". IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems. 8 (7): 798–807. doi:10.1109/43.31537. S2CID 8754800.
• Polikarpova N. I., Shalyto A. A. Automata-based programming SPb.: Piter. 2009 (rus)
• ITMO University, "Programming Technology" department