Obsah
1. Kite – polointeligentní automatické doplňování kódu založené na AI a ML
2. Integrace Kite s IDE a programátorskými textovými editory
5. Dokončení grafické části instalace
6. Plugin pro Visual Code Studio
7. Spuštění Vimu s pluginem pro Kite
8. Konfigurace pluginu Kite v textovém editoru Vim
9. Polointeligentní automatické doplňování kódu
10. Ukázka doplňování jmen balíčků ve Visual Studio Code
11. Odvození proměnné použité jako parametr při volání funkce či metody
12. Zobrazení podrobnější nápovědy
14. Plugin Kite v textovém editoru Vim
17. Příloha: omnicompletion ve Vimu
1. Kite – polointeligentní automatické doplňování kódu založené na AI a ML
V uplynulých (přibližně) pěti letech můžeme sledovat stále častější nasazování technologií AI (umělé inteligence) a ML (strojové učení) i do oblasti vývoje aplikací, popř. jejich testování. Jsou vyvíjeny například nástroje určené pro analýzu zdrojových kódů, poloautomatické hledání chyb, provádění penetračních testů atd. Zapomenout nesmíme ani na překladače, ať již na AOT (ahead-of-time), tak i JIT (just-of-time), do kterých se AI+ML taktéž pomalu zavádí. Ovšem některé z těchto nástrojů dokážou přímo pomáhat programátorům při vývoji a postupně tak nahradit či možná spíše doplnit klasické technologie typu IntelliSense. Mezi tento typ nástrojů patří i Kite, s nímž se ve stručnosti seznámíme v dnešním článku. Cílem současné verze nástroje Kite je především zajištění „inteligentního“ automatického doplňování kódu, dále zpřístupnění příkladů použití volané funkce či metody a v neposlední řadě taktéž zpřístupnění dokumentace, a to i v případě, že daná knihovna vůbec není nainstalována na počítači vývojáře.
Všechny zmíněné operace jsou v Kite implementovány právě s využitím dnes tak populárních (a někdy i dosti přeceňovaných) technologií AI a ML, tedy umělé inteligence a strojového učení. V tomto ohledu se Kite podobá například známějšímu nástroji Visual Studio IntelliCode, kterému bude věnován samostatný článek. V současnosti je většina funkcionality nabízené nástrojem Kite soustředěna okolo programovacího jazyka Python a v mnohem menší míře i okolo jazyka Go. Další programovací jazyky nejsou v současnosti podporovány, i když se do dalších verzí plánuje jejich alespoň částečná podpora.
2. Integrace Kite s IDE a programátorskými textovými editory
Nástroj Kite je možné v současnosti integrovat s několika programátorskými IDE, popř. s programátorskými textovými editory (ovšem rozdíly mezi IDE a „pouhými“ programátorskými editory se postupně stírají, což je dobře vidět například na projektu VS Code). Podporovány jsou tyto aplikace:
- Atom
- IntelliJ (pro kód psaný v Pythonu)
- PyCharm (bude fungovat i v GoLandu)
- Spyder
- Sublime Text
- Vim
- Visual Studio Code
Obrázek 1: Textový editor Emacs ve funkci integrovaného vývojového prostředí.
V dnešním článku si základní možnosti nabízené projektem Kite ukážeme na příkladu integrace s programátorskými editory Vim a Visual Studio Code nainstalovanými na Linuxu (konkrétně na Fedoře, ale v tomto ohledu žádné zásadní rozdíly ve fungování Kite nečekejte). Přitom Linux je sice projektem Kite oficiálně podporován, ovšem některé vlastnosti prozatím nejsou implementovány. Týká se to především možnosti spuštění interaktivního pomocníka programátora nazvaného Copilot pomocí ikony v nástrojovém pruhu.
3. Architektura projektu Kite
Architektura kterou používá nástroj Kite se v mnoha ohledech přibližuje architektuře, s níž jsme se již dříve seznámili v souvislosti s nástrojem Jedi. Konkrétně to znamená, že na pozadí je spuštěn proces nazvaný Kite engine, který implementuje veškerou logiku, spravuje data použitá při analýze apod. Přes k tomu určený plugin je Kite engine propojen s programátorským textovým editorem, popř. s integrovaným vývojovým prostředím. Samotné uživatelské rozhraní je již prakticky plně v režii editoru/IDE – to znamená, že způsob zobrazení menu s automatickým doplňováním, nápovědy atd. je závislý na možnostech daného editoru. Ovšem kromě toho lze prakticky nezávisle na editoru/IDE spustit takzvaného copilota, což je samostatně běžící desktopová aplikace s grafickým uživatelským rozhraním, která dokáže zprostředkovat nápovědu k mnoha (skutečně mnoha) knihovnám programovacího jazyka Python, příklady skutečného použití (získané ML modulem) atd. Copilot sice běží v samostatném okně, ovšem může sledovat programový kód zapisovaný uživatelem a ihned (bez nutnosti provádění dalších operací) zobrazit kontextovou nápovědu, což je – nutno říci – vysoce užitečná a současně i návykové chování.
Obrázek 2: Plugin jedi-vim komunikující se serverem Jedi používá podobnou architekturu jako Kite.
Obrázek 3: jedi-vim – zobrazení parametrů funkce se zvýrazněním právě zadávaného parametru.
4. Instalace nástroje Kite
Samotná instalace nástroje Kite je – zejména s ohledem na to, že se v ní řeší i integrace s editory a IDE – až překvapivě snadná. Vzhledem k tomu, že Kite s velkou pravděpodobností nenaleznete v repositáři vámi používané linuxové distribuce, je nutné nejdříve stáhnout instalační skript dostupný na adrese https://linux.kite.com/dls/linux/current:
$ wget -q https://linux.kite.com/dls/linux/current
a následně (po základním prozkoumání, co se uvnitř děje), tento skript spustit. Pokud v tomto ohledu bezmezně věříte autorům projektu Kite, lze vše provést jediným příkazem:
$ bash -c "$(wget -q -O - https://linux.kite.com/dls/linux/current)"
Obrázek 4: Spuštění instalace příkazem vypsaným nad tímto screenshotem. Instalace se provádí pro aktivního uživatele, nikoli pro roota.
Obrázek 5: Úpravu souboru /etc/sysctl.d je možné přeskočit – instalátor Kite tak ani na chvíli nedostane práva roota.
Kite používá lokální databázi s analyzovanými daty používanými při automatické nápovědě atd. I z tohoto důvodu je při instalaci vyžadováno přes půl gigabajtu diskového prostoru (další desítky megabajtů zaberou jednotlivé pluginy do textových editorů a IDE):
Running /home/ptisnovs/kite-installer install [installer] no previous kite installation found [installer] latest version is 2.20200310.0, downloading now... [installer] Downloading Kite: 99.9% of 370MiB [installer] verifying checksum [installer] validating signature [installer] installing version 2.20200310.0 [installer] installed ~/.config/autostart/kite-autostart.desktop [installer] installed ~/.config/systemd/user/kite-updater.service [installer] installed ~/.config/systemd/user/kite-updater.timer [installer] installed ~/.local/share/applications/kite-copilot.desktop [installer] installed ~/.local/share/applications/kite.desktop [installer] installed ~/.local/share/icons/hicolor/128x128/apps/kite.png [installer] installed ~/.local/share/kite/kited [installer] installed ~/.local/share/kite/uninstall [installer] installed ~/.local/share/kite/update [installer] activating kite-updater systemd service [installer] registering kite:// protocol handler [installer] kite is installed! launching now! happy coding! :) [installer] run /home/ptisnovs/.local/share/kite/kited [installer] or launch it using the Applications Menu Removing kite-installer
5. Dokončení grafické části instalace
Druhá část instalace, která plynule navazuje na část popsanou v předchozí kapitole, je již plně grafická a je postupně popsána na dalších screenshotech.
Obrázek 6: Vyplnění základních údajů a volba, že instalátor má detekovat všechny editory a IDE, které jsou podporovány.
Ve skutečnosti není zadání e-mailové adresy striktně vyžadováno a dokonce není nutné se nikam registrovat. Na rozdíl od předchozích verzí Kite se navíc zdrojové kódy analyzují přímo na počítači uživatele a nikam se neposílají.
Obrázek 7: Korektně se našly pouze dva podporované editory, do nichž bude vzápětí doinstalován příslušný plugin.
Pro odinstalaci nástroje Kite poslouží následující příkaz:
$ ./.local/share/kite/uninstall
6. Plugin pro Visual Code Studio
Dále je vhodné do Visual Studia Code (což je jeden v tomto článku použitých programátorských editorů) doinstalovat ještě jeden plugin – Kite Python Autocomplete. Instalace je snadná, prakticky okamžitá a provede se přímo přes standardní panel „Extensions“ (dostupný na levém pruhu s ikonami):
Obrázek 8: Nalezení pluginu Kite Python Autocomplete.
Obrázek 9: Po nainstalování pluginu Kite Python Autocomplete – kontrola nainstalovaných pluginů a rozšíření Visual Studio Code.
7. Spuštění Vimu s pluginem pro Kite
Ještě si pro úplnost ukažme, jak vlastně vypadá první spuštění textového editoru Vim ihned poté, co byl nainstalován nástroj Kite. Žádné ruční zásahy do konfigurace Vimu nebyly a ani nemusely být provedeny, což je zvláštní, protože moje .vimrc má velikost přes padesát kilobajtů a instalace jiných pluginů si většinou žádá určité netriviální úpravy.
Obrázek 10: První informace o tom, že je Vim integrován s Kite. Výběrem možnosti 1 v zobrazeném menu se v novém tabu zobrazí podrobnější informace.
Obrázek 11: Podrobnější informace o propojení Vimu a Kite.
Dále je vhodné nastavit volby statusline a laststatus způsobem, který je ukázán níže (tato možnost není provedena automaticky):
set statusline=%<%f\ %h%m%r%{kite#statusline()}%=%-14.(%l,%c%V%)\ %P
set laststatus=2 " always display the status line
Po nastavení těchto voleb (můžete si je přidat do .vimrc) bude zajištěno, že se na stavovém řádku, popř. na pravítku zobrazí mj. i stav Kite enginu. Je tak možné zjistit, zda je engine vůbec spuštěn, zda nezpracovává data o projektu (což může zpočátku nějakou dobu trvat) a kdy je engine plně připraven poskytovat (přes plugin editoru) všechny potřebné služby.
Způsob integrace s Vimem si podrobněji popíšeme v navazujících kapitolách.
Obrázek 12: Test, zda běží Kite engine. Tento test proveďte pokaždé, když se zdá, že plugin Kite z nějakého důvodu nefunguje.
8. Konfigurace pluginu Kite v textovém editoru Vim
Chování pluginu Kite v textovém editoru Vim je možné ovlivnit pomocí několika voleb. Jedná se o globální proměnné nastavované například přímo v souboru .vimrc:
| # | Volba | Význam volby |
|---|---|---|
| 1 | g:kite_auto_complete | povolení či zákaz automatického doplňování bez použití další klávesové zkratky |
| 2 | g:kite_snippets=0 | povolení či zákaz zobrazení úryvků kódů (code snippets) |
| 3 | g:kite_tab_complete=1 | rozhodnutí, zda se má pro automatické doplnění použít Tab nebo Ctrl-Y (výchozí volba) |
| 4 | g:kite_previous_placeholder=‚<C-K>‘ | klávesové zkratky použité pro doplnění automaticky vygenerovaných úryvků kódů |
| 5 | g:kite_next_placeholder='<C-J>` | klávesové zkratky použité pro doplnění automaticky vygenerovaných úryvků kódů |
| 6 | g:kite_documentation_continual=1 | povolení automatického zobrazení dokumentace v Copilotovi bez nutnosti používat klávesovou zkratku K |
Pro nepřímou interakci s nástrojem Kite by měly postačovat následující klávesové zkratky:
| Klávesová zkratka | Význam zkratky |
|---|---|
| <C-X><C-U> | doplnění jména funkce, metody, třídy, balíčku atd.(omnicomplete) |
| <C-y> | doplnění v režimu omnicomplete (viz volbu g:kite_tab_complete) |
| Tab | doplnění v režimu omnicomplete (viz volbu g:kite_tab_complete) |
| K | zobrazení informace o funkci/metodě/třídě v Copilotovi (ve výchozím nastavení se zobrazí manuálová stránka) |
Obrázek 13: První spuštění Copilota.
9. Polointeligentní automatické doplňování kódu
Jedním z důvodů pro instalaci nástroje Kite je vylepšené automatické doplňování kódu, které nám může po delší práci připadat „polointeligentní“ (v kladném významu tohoto slova – tedy spíše inteligentní, než strojově stupidní), ovšem skutečně se jedná především o důsledek sběru velkého množství dat. Autoři Kite porovnávají automatické doplnění (resp. přesněji řečeno nabídku všech možností pro automatické doplnění) s PyCharmem a taktéž s výše zmíněným nástrojem Jedi. Nejdříve se na toto porovnání podívejme:
Obrázek 14: Porovnání nabídky identifikátorů PyCharmem, nástrojem Jedi a nástrojem Kite.
Zdroj: oficiální video o Kite
Můžeme zde vidět, že PyCharm (a s ním i mnoho dalších jednodušších doplňovačů) nabízí identifikátory v abecedním pořadí. Totéž platí o Jedi, v němž se ovšem identifikátory začínající podtržítkem a tedy většinou určené pro interní použití zobrazují až na konci. Naproti tomu Kite zpočátku nabízí identifikátory v takovém pořadí, v jakém jsou použity v reálných projektech. A pokud velikost aktuálně vyvíjeného projektu přesáhne určitou hodnotu, budou se nabízet identifikátory i na základě jejich použití v tomto projektu.
10. Ukázka doplňování jmen balíčků ve Visual Studio Code
Jak však vypadá ono zmíněné poloautomatické doplňování kódu v praxi? Podívejme se na několik příkladů:
Obrázek 15: Zdánlivě běžná nabídka balíčku pro import. Balíček Json je nejpoužívanější. Povšimněte si informace o tom, jaký modul menu zobrazuje.
Obrázek 16: Opět nabídka seřazená podle reálného použití modulů začínajících na „req“.
Obrázek 17: Modul Kite nabízí i zkrácenou verzi nápovědy k doplňovanému symbolu (zde názvu balíčku).
Obrázek 18: Toto už je zajímavější a užitečnější funkcionalita – nabídka nejpoužívanějšího podbalíčku, ovšem současně i pojmenování. A skutečně import matplotlib.pyplot as plt je používáno v mnoha projektech a dokonce i v oficiální dokumentaci. Projekt tedy bude používat všeobecně známé idiomy.
11. Odvození proměnné použité jako parametr při volání funkce či metody
Další užitečnou vlastností projektu Kite je schopnost v některých případech odvodit proměnnou, která má být použita jako parametr při volání funkce či metody (v Go je možné namísto proměnné použít i konstantu). Opět se podívejme, jak se tato vlastnost projeví při práci ve Visual Code Studiu:
Obrázek 19: Podle očekávání se po zápisu znaku „g“ nabídne nejpoužívanější funkce – get.
Obrázek 20: Zobrazení nápovědy k funkci get.
Obrázek 21: Nyní budeme chtít zavolat právě funkci get.
Obrázek 22: Nástroj Kite nám nabídne, že se má použít proměnná nazvaná stejně, jako výchozí parametr funkce get.
Obrázek 23: Podobně to funguje i ve složitějším případě u funkce s větším počtem parametrů.
Obrázek 24: Složitější příklad, tentokrát používající jména parametrů a nikoli jména proměnných.
12. Zobrazení podrobnější nápovědy
Další užitečnou funkcí nástroje Kite je zobrazení podrobnější nápovědy k importovanému balíčku, konstruované třídě, volané funkci či metodě. Opět si nejdříve toto chování ukážeme na příkladu Visual Code Studia:
Obrázek 25: Běžný pokus o zavolání nějaké funkce.
Obrázek 26: Zobrazení dokumentace k modulu, z něhož chceme funkci volat.
*** image ***
Obrázek 27: Další dokumentaci – plně formátovanou a s hypertextovými odkazy – lze zobrazit v Copilotovi, který je automaticky zobrazen přímo z editoru.
Obrázek 28: Tento modul nemám nainstalovaný, přesto k němu je možné zobrazit nápovědu.
Obrázek 29: Možnost zobrazení dokumentace k funkci, která se již ve zdrojovém kódu používá (přes kontextové menu).
13. Copilot
S Copilotem jsme se již setkali. Jedná se o samostatnou aplikaci s vlastním grafickým uživatelským rozhraním, která dokáže vyhledat a zobrazit dokumentaci k vybraným balíčkům, třídám, metodám a funkcím. I když se jedná o samostatnou aplikaci, lze ji spárovat s IDE či s programátorským textovým editorem, což jsme ostatně již viděli v předchozích kapitolách. Důležitá je volba follow cursor, díky níž může Copilot sledovat zapisovaný text a ihned reagovat změnou svého obsahu. Ideální je tedy mít Copilota zobrazeného na jedné straně monitoru (když už mnohdy musíme jako vývojáři používat monitory navržené pro zcela jiný segment trhu).
Obrázek 30: Grafické uživatelské rozhraní Copilota.
14. Plugin Kite v textovém editoru Vim
Nyní si můžeme ukázat, jak je nástroj Kite integrován se známým programátorským textovým editorem Vim. Již dopředu je vhodné říci, že z pohledu funkcí nabízených Kite se od sebe Vim a Visual Code Studio vlastně nijak zásadně neliší – jiné je jen ovládání a samozřejmě i vzhled.
Obrázek 31: Nabídka modulu pro import a současně i ukázka, jak import provádí jiní programátoři. Povšimněte si loga projektu Kite – jedná se o znak dvou trojúhelníků vzdáleně připomínajících draka.
Obrázek 32: Nabídka funkcí, pochopitelně opět setříděná podle toho, jak často jsou funkce používány.
Obrázek 33: Automatické doplňování parametrů volané funkce.
Obrázek 34: Automatické doplňování parametrů volané funkce.
15. Vim a Copilot
Vim/GVim/KVim je pochopitelně možné použít i s Copilotem, a to dvěma způsoby – buď se Copilot zobrazí po stisku klávesy K (namísto zobrazení manuálové stránky), nebo se bude zobrazovat nápověda k textu pod kurzorem (musí být povolena volba sledování kurzoru).
Obrázek 35: První zobrazení Copilota na „náhodném“ místě na obrazovce.
Obrázek 36: Umístění Copilota na okraj monitoru. Povšimněte si, že je zapnuta volba sledování kurzoru.
Obrázek 37: Nabídka nejčastěji volaných funkcí balíčku numpy + nápověda v Copilotovi
Obrázek 38: Nabídka nejčastěji volaných funkcí balíčku numpy + nápověda v Copilotovi
16. Závěr
V současnosti je nástroj Kite stabilní a poměrně dobře použitelný, i když se (zdaleka) nejedná o finální produkt. Oproti variantě, kdy se zdrojové kódy posílaly na analýzu na vzdálený stroj je lokální běh (podle mého názoru) vylepšením a samotná existence procesu kited je na běžném tři roky starém notebooku zcela bezproblémová, dokonce i při otevření většího projektu (zde je ovšem nutné při prvním otevření čekat na analýzu, a to jednotky až desítky sekund). V článku jsem se zaměřil na použití Kite společně s Pythonem, protože podpora pro Go prozatím není zdaleka tak propracovaná – podle mého názoru pro Go zatím nemá tento projekt větší význam, což se ovšem v budoucnosti pravděpodobně změní.
17. Příloha: omnicompletion ve Vimu
V příloze se zmíníme o velmi užitečné vlastnosti textového editoru Vim, která je nástrojem Kite využita. Jedná se o technologii nazvanou „omni completion“ (někdy se setkáme i s jednoslovným zápisem „omnicompletion“). Tato technologie, která se ve Vimu objevila až v jeho sedmé verzi, rozšiřuje možnosti automatického doplňování kódu (či obecně textu) o externí nástroje. Připomeňme si, že Vim nabízí ve vkládacím a přepisovacím režimu klávesovou zkratku Ctrl+P (previous) pro nalezení a doplnění slova nacházejícího se před kurzorem a taktéž zkratku Ctrl+N (next), která slouží ke stejnému účelu, ovšem hledá slovo pro doplnění v textu za kurzorem (pokud je k dispozici více možností, zobrazí se v kontextovém menu). V praxi tedy postačuje napsat jen začátek slova a stlačit Ctrl+P nebo Ctrl+N. Rozsah vyhledávání se specifikuje volbou complete popsanou zde a samozřejmě i ve vestavěné nápovědě.
Obrázek 39: Doplňování kódu nebo libovolného textu pomocí příkazů CTRL+P a CTRL+N zavolaných v režimu zápisu (insert mode).
Ovšem možnosti automatického doplňování kódu jsou ve skutečnosti daleko větší a textový editor Vim pro ně dokonce nabízí samostatný režim vyvolávaný z vkládacího či přepisovacího režimu klávesovou zkratkou Ctrl+X (právě z tohoto důvodu se tento režim nazývá ^X-mode nebo též CTRL-X mode). Po stlačení této klávesové zkratky se v příkazové řádce objeví řádkové menu s příkazy platnými pro režim doplňování:
Všechny dostupné příkazy jsou vypsány v tabulce níže:
| # | Příkaz | Význam |
|---|---|---|
| 1 | Ctrl+X Ctrl+L | nalezení a doplnění celého (shodného) řádku, užitečné především v případě editace některých typů konfiguračních souborů |
| 2 | Ctrl+X Ctrl+N | doplnění slova, které se nalézá v aktuálně editovaném souboru |
| 3 | Ctrl+X Ctrl+K | podobné Ctrl+N, ovšem slova se hledají v souborech specifikovaných pomocí konfiguračního parametru dictionary (jedná se o běžný textový soubor se seznamem slov) |
| 4 | Ctrl+X Ctrl+T | podobné Ctrl+T, ovšem slova se hledají v souborech specifikovaných pomocí konfiguračního parametru thesaurus |
| 5 | Ctrl+X Ctrl+I | podobné Ctrl+N, ovšem prohledávají se i všechny vkládané (included) soubory |
| 6 | Ctrl+X Ctrl+] | vyhledávání v seznamu značek |
| 7 | Ctrl+X Ctrl+F | doplnění názvu souboru a/nebo cesty, postačuje například zadat text ~/ za nímž následuje klávesová zkratka Ctrl+X Ctrl+F a zobrazí se výpis souborů v domácím adresáři |
| 8 | Ctrl+X Ctrl+D | vyhledání definice makra a doplnění jména tohoto makra |
| 9 | Ctrl+X Ctrl+U | zavolání funkce zadané v konfiguračním parametru completefunc, které se předá právě editovaný text |
| 10 | Ctrl+X Ctrl+O | vyvolání funkce omni completion (dostupné od Vimu 7) |
Obrázek 40: Doplnění názvu souboru v pracovním adresáři pomocí příkazu CTRL+X CTRL+F.
18. Odkazy na Internetu
- Stránky projektu Kite
https://kite.com/ - Kite Autocomplete Plugin for Vim
https://kite.com/integrations/vim/ - Visual Studio IntelliCode
https://visualstudio.microsoft.com/services/intellicode/ - Vote for Kite's Next Language
https://kite.com/letmeknow/ - Pair programming
https://en.wikipedia.org/wiki/Pair_programming - Intelligent code completion
https://en.wikipedia.org/wiki/Intelligent_code_completion - Atom: moderní textový editor
https://www.root.cz/clanky/atom-moderni-textovy-editor/ - Atom: moderní textový editor (dokončení)
https://www.root.cz/clanky/atom-moderni-textovy-editor-dokonceni/ - PyCharm
https://www.jetbrains.com/pycharm/ - Stránky projektu Atom
https://atom.io/ - Sublime Text
https://www.sublimetext.com/ - Spyder
https://www.spyder-ide.org/ - Vim
https://www.vim.org/ - Visual Studio Code
https://code.visualstudio.com/ - IDEA
https://www.jetbrains.com/idea/ - Kite – Linux install issues
https://help.kite.com/article/106-linux-install-issues - The Kite Copilot
https://kite.com/copilot/ - How Kite works
https://help.kite.com/article/55-how-kite-works - Knihovna Jedi: doplňování kódu a statická analýza kódu v Pythonu
https://www.root.cz/clanky/knihovna-jedi-doplnovani-kodu-a-staticka-analyza-kodu-v-pythonu/ - Knihovna Jedi: doplňování kódu a statická analýza kódu v Pythonu (dokončení)
https://www.root.cz/clanky/knihovna-jedi-doplnovani-kodu-a-staticka-analyza-kodu-v-pythonu-dokonceni/ - Visual Studio IntelliCode (na marketplace)
https://marketplace.visualstudio.com/items?itemName=VisualStudioExptTeam.VSIntelliCode - Použití Language Server Protocolu v textovém editoru Vim
https://www.root.cz/clanky/pouziti-language-server-protocolu-v-textovem-editoru-vim/ - How to use the Copilot
https://help.kite.com/article/63-using-the-copilot - Kite Python Plugin for Vim/Neovim
https://github.com/kiteco/plugins/tree/master/vim - Textový editor Vim jako IDE (12.část: konfigurace pravítka a stavového řádku)
https://www.root.cz/clanky/textovy-editor-vim-jako-ide-12-cast-konfigurace-pravitka-a-stavoveho-radku/ - Langserver.org
https://langserver.org/ - Language Server Protocol
https://microsoft.github.io/language-server-protocol/ - Language Server Protocol Specification
https://microsoft.github.io/language-server-protocol/specification - Implementations Language Servers
https://microsoft.github.io/language-server-protocol/implementors/servers - JSON-RPC 2.0 Specification
https://www.jsonrpc.org/specification - Why You Should Know the Language Server Protocol
https://tomassetti.me/what-is-the-language-server-protocol/ - Language Server Protocol: A Language Server For DOT With Visual Studio Code
https://tomassetti.me/language-server-dot-visual-studio/ - Python Language Server
https://github.com/palantir/python-language-server - Jedi – an awesome autocompletion/static analysis library for Python
https://github.com/davidhalter/jedi - What is lsp
https://www.reddit.com/r/vim/comments/7lnhrt/which_lsp_plugin_should_i_use/ - Vim-lsp
https://github.com/prabirshrestha/vim-lsp - Using LSP & clangd in Vim
https://jonasdevlieghere.com/vim-lsp-clangd/ - Seriál Textový editor Vim jako IDE
https://www.root.cz/serialy/textovy-editor-vim-jako-ide/ - Seriál VIM na plný výkon
https://www.root.cz/serialy/vim-na-plny-vykon/ - What about a Common Debug Protocol?
https://kichwacoders.com/2017/07/28/what-about-a-common-debug-protocol/ - Example – Debug Adapter
https://code.visualstudio.com/docs/extensions/example-debuggers - Konfigurační volba complete
http://vimdoc.sourceforge.net/htmldoc/options.html#‚complete‘ - Konfigurační volba completeopt
http://vimdoc.sourceforge.net/htmldoc/options.html#‚completeopt‘ - Make Vim completion popup menu work just like in an IDE
http://vim.wikia.com/wiki/Make_Vim_completion_popup_menu_work_just_like_in_an_IDE
ČLÁNKY DO MAILU