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

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

परिणाम यह है कि Lisp परियोजना की शुरुआत में, कोई स्रोत कोड नहीं हो सकता है; विकसित होती परिभाषा केवल मेमोरी इमेज में मौजूद होती है। यह वैसा ही है जैसे लोग शुरुआत में रिलेशनल डेटाबेस के साथ व्यवहार करते हैं—स्कीमा केवल चल रहे डेटाबेस में मौजूद होता है। अंततः, इसे संस्करण नियंत्रण के तहत एक फ़ाइल में डंप किया जाता है।

मैं Lisp डेवलपर नहीं हूँ, इसलिए मैं ईर्ष्यालु रहूँगा। लेकिन मुझे एहसास हुआ कि मैंने करीब आने की कोशिश नहीं की है। Haskell में, आंशिक जीत हैं: टाइप सिस्टम अपवादों को कम करता है, और Emacs के Eglot के साथ Haskell भाषा सर्वर (hls) बेहतर आत्मनिरीक्षण देता है। ghcid परिवर्तनों पर नज़र रखता है और जल्दी से पुनः संकलित करता है।