विम क्रोकेट

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

परिचय

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

डेटा संग्रह

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

alias vim='vim -w ~/.vimlog "$@"' 

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

मैंने vim कमांडों को पार्स करने के लिए कई उम्मीदवारों की समीक्षा की, जिसमें औद्योगिक पुस्तकालय जैसे कि antler और parsec , साथ ही vim विशेषज्ञता परियोजना vimprint शामिल हैं । कुछ विचार के बाद, मैंने अपना खुद का टूल लिखने का फैसला किया, क्योंकि काफी जटिल पार्सर्स के अध्ययन पर बहुत समय बिताना इस कार्य के लिए अनुचित था।

मैंने व्यक्तिगत व्योम कमांड में एकत्रित कीस्ट्रोक्स को विभाजित करने के लिए हैस्केल पर एक नम लेक्सर लिखा। मेरा लेक्सर आगे के विश्लेषण के लिए लॉग से सामान्य मोड कमांड निकालने के लिए मोनोइड्स का उपयोग करता है । यहाँ लेक्सर स्रोत है:

 import qualified Data.ByteString.Lazy.Char8 as LC import qualified Data.List as DL import qualified Data.List.Split as LS import Data.Monoid import System.IO main = hSetEncoding stdout utf8 >> LC.getContents >>= mapM_ putStrLn . process process = affixStrip . startsWith . splitOnMode . modeSub . capStrings . split mark . preprocess subs = appEndo . mconcat . map (Endo . sub) sub (s,r) lst@(x:xs) | s `DL.isPrefixOf` lst = sub' | otherwise = x:sub (s,r) xs where sub' = r ++ sub (s,r) (drop (length s) lst) sub (_,_) [] = [] preprocess = subs meta . DL.intercalate " " . DL.words . DL.unwords . DL.lines . LC.unpack splitOnMode = DL.concat $ map (\el -> split mode el) startsWith = filter (\el -> mark `DL.isPrefixOf` el && el /= mark) modeSub = map (subs mtsl) split sr = filter (/= "") $ s `LS.splitOn` r affixStrip = clean . concat . map (\el -> split mark el) capStrings = map (\el -> mark ++ el ++ mark) clean = filter (not . DL.isInfixOf "[M") (mark, mode, n) = ("-(*)-","-(!)-", "") meta = [("\"",n),("\\",n),("\195\130\194\128\195\131\194\189`",n), ("\194\128\195\189`",n),("\194\128kb\ESC",n), ("\194\128kb",n),("[>0;95;c",n), ("[>0;95;0c",n), ("\ESC",mark),("\ETX",mark),("\r",mark)] mtsl = [(":",mode),("A",mode), ("a",mode), ("I",mode), ("i",mode), ("O",mode),("o",mode),("v", mode),("/",mode),("\ENQ","⌃e"), ("\DLE","⌃p"),("\NAK","⌃u"),("\EOT","⌃d"),("\ACK","⌃f"), ("\STX","⌃f"),("\EM","⌃y"),("\SI","⌃o"),("\SYN","⌃v"), ("\DC2","⌃r")] 

और यहाँ प्रसंस्करण से पहले और बाद में डेटा का एक उदाहरण है:

 cut -c 1-42 ~/.vimlog | tee >(cat -v;echo) | ./lexer `Mihere's some text^Cyyp$bimore ^C0~A.^C:w^M:q `M yyp$b 0~ 

लेक्सर मानक इनपुट से पढ़ता है और संसाधित कमांड को मानक आउटपुट में भेजता है। ऊपर दिए गए उदाहरण में, कच्चा डेटा दूसरी पंक्ति पर स्थित है, और प्रसंस्करण परिणाम निम्न पर है। प्रत्येक पंक्ति इसी क्रम में निष्पादित सामान्य मोड कमांड के एक समूह का प्रतिनिधित्व करती है। लेक्सर ने सही ढंग से निर्धारित किया कि मैंने `एम ' का उपयोग करके कुछ बफर में जाकर सामान्य मोड में शुरू किया, फिर यहाँ संपादन मोड में कुछ पाठ दर्ज किया, फिर लाइन को कॉपी / पेस्ट किया और कमांड में $ y का उपयोग करके लाइन के अंतिम शब्द की शुरुआत में गया $ b । फिर उन्होंने अतिरिक्त पाठ में प्रवेश किया और अंततः पूंजी कमांड 0 ~ के साथ पहले चरित्र की जगह, लाइन की शुरुआत में चले गए।

मुख्य उपयोग का नक्शा

प्रतिज्ञा किए गए डेटा को संसाधित करने के बाद, मैंने पैट्रिक विड द्वारा अद्भुत हीटमैप-कीबोर्ड परियोजना को बाहर निकाल दिया, और अपने स्वयं के कस्टम लेयर को लीकर आउटपुट पढ़ने के लिए जोड़ा। इस परियोजना ने अधिकांश मेटा-पात्रों को परिभाषित नहीं किया, उदाहरण के लिए, ईएससी, Ctrl और सीएमडी, इसलिए मुझे जावास्क्रिप्ट में डेटा लोडर लिखने और कुछ अन्य संशोधन करने की आवश्यकता थी। मैंने मेटा-पात्रों का उपयोग यूनिकोड में उपयोग किया और उन्हें कीबोर्ड पर पेश किया। यहां मुझे 500,000 के करीब कमांड की संख्या पर मिला है (रंग की तीव्रता कुंजियों के उपयोग की आवृत्ति को इंगित करता है)।



परिणामी मानचित्र से पता चलता है कि Ctrl कुंजी का सबसे अधिक बार उपयोग किया जाता है - मैं इसे कई नेविगेशन कमांड के लिए उपयोग करता हूं। उदाहरण के लिए, ControlP के लिए ^ p , या ^ j ^ k के माध्यम से खुले बफ़र्स पर एक लूप।

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

आदेशों के उपयोग की आवृत्ति

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

 $ sort normal_cmds.txt | uniq -c | sort -nr | head -10 | \ awk '{print NR,$0}' | column -t 1 2542 j 2 2188 k 3 1927 jj 4 1610 p 5 1602 ⌃j 6 1118 Y 7 987 ⌃e 8 977 zR 9 812 P 10 799 ⌃y 

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

टीम की कठिनाई

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

 #!/usr/bin/env python import sys from codecs import getreader, getwriter from collections import Counter from operator import itemgetter from math import log, log1p sys.stdin = getreader('utf-8')(sys.stdin) sys.stdout = getwriter('utf-8')(sys.stdout) def H(vec, correct=True): """Calculate the Shannon Entropy of a vector """ n = float(len(vec)) c = Counter(vec) h = sum(((-freq / n) * log(freq / n, 2)) for freq in c.values()) # impose a penality to correct for size if all([correct is True, n > 0]): h = h / log1p(n) return h def main(): k = 1 lines = (_.strip() for _ in sys.stdin) hs = ((st, H(list(st))) for st in lines) srt_hs = sorted(hs, key=itemgetter(1), reverse=True) for n, i in enumerate(srt_hs[:k], 1): fmt_st = u'{r}\t{s}\t{h:.4f}'.format(r=n, s=i[0], h=i[1]) print fmt_st if __name__ == '__main__': main() 

स्क्रिप्ट मानक इनपुट स्ट्रीम से पढ़ती है और उच्चतम एन्ट्रॉपी के साथ कमांड जारी करती है। मैंने एन्ट्रापी की गणना करने के लिए डेटा के रूप में लेक्सर आउटपुट का उपयोग किया:

 $ sort normal_cmds.txt | uniq -c | sort -nr | sed "s/^[ \t]*//" | \ awk 'BEGIN{OFS="\t";}{if ($1>100) print $1,$2}' | \ cut -f2 | ./entropy.py 1 ggvG$"zy 1.2516 

मैं उन टीमों का चयन करता हूं जिन्हें 100 से अधिक बार निष्पादित किया गया है, और फिर मैं उनमें से सबसे अधिक एन्ट्रापी वाली टीम ढूंढता हूं। विश्लेषण के परिणामस्वरूप, ggvG $ '' zy कमांड का चयन किया गया था, जिसे 45 दिनों में 246 बार निष्पादित किया गया था। कमांड को 11 नहीं बल्कि अनाड़ी कीस्ट्रोक्स का उपयोग करके निष्पादित किया जाता है और z को रजिस्टर करने के लिए पूरे वर्तमान बफर को कॉपी करता है। मैं आमतौर पर इस कमांड का उपयोग एक बफर की पूरी सामग्री को दूसरे में ले जाने के लिए करता हूं। बेशक, मैंने अपने कॉन्फ़िगरेशन में एक नया शॉर्टकट जोड़ा है

 nnoremap <leader>ya ggvG$"zy 

निष्कर्ष

मेरे विम क्रॉच मैच ने विम में कीस्ट्रोक्स की संख्या को कम करने के लिए 3 अनुकूलन की पहचान की:

• ^ E ^ Y के बजाय ^ U ^ D नेविगेशन कमांड का उपयोग करना
• ZR से बचने के लिए बफर में ऑटो-पतन पाठ को रोकें
• क्रिया ggvG $ '' zy कमांड के लिए एक शॉर्टकट बनाना

इन 3 सरल परिवर्तनों ने मुझे हर महीने हजारों अनावश्यक कीस्ट्रोक्स से बचाया।

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

 SHELL := /bin/bash LOG := ~/.vimlog CMDS := normal_cmds.txt FRQS := frequencies.txt ENTS := entropy.txt LEXER_SRC := lexer.hs LEXER_OBJS := lexer.{o,hi} LEXER_BIN := lexer H := entropy.py UTF := iconv -f iso-8859-1 -t utf-8 .PRECIOUS: $(LOG) .PHONY: all entropy clean distclean all: $(LEXER_BIN) $(CMDS) $(FRQS) entropy $(LEXER_BIN): $(LEXER_SRC) ghc --make $^ $(CMDS): $(LEXER_BIN) cat $(LOG) | $(UTF) | ./$^ > $@ $(FRQS): $(H) $(LOG) $(CMDS) sort $(CMDS) | uniq -c | sort -nr | sed "s/^[ \t]*//" | \ awk 'BEGIN{OFS="\t";}{if ($$1>100) print NR,$$1,$$2}' > $@ entropy: $(H) $(FRQS) cut -f3 $(FRQS) | ./$(H) clean: @- $(RM) $(LEXER_OBJS) $(LEXER_BIN) $(CMDS) $(FRQS) $(ENTS) distclean: clean