• Použít starší větev nixpkgs:

  nix shell nixpkgs/nixos-23.05#htop
  htop --version
  exit
  

• Použít libovolný commit z nixpkgs:

  • https://lazamar.co.uk/nix-versions/ – zkusíme verzi 3.0.5:

    nix-shell -p htop -I nixpkgs=https://github.com/NixOS/nixpkgs/archive/f8f124009497b3f9908f395d2533a990feee1de8.tar.gz
    nix shell nixpkgs/f8f124009497b3f9908f395d2533a990feee1de8#htop
    htop --version
    exit
    

• Použít aktuální nixpkgs, ale zkompilovat proti tomu starší verzi htopu
  • Musí se upravit atribut src v “definici” balíku

• Použít nástroj nix-init pro vytvoření kostry balíku.
  • Výstup předpokládá, že tvoříme balík pro nixpkgs, což je funkce, která bude zavolána v rámci callPackage z nixpkgs.
  • Pokud chceme balík mimo nixpkgs, můžeme nahradit parametr funkce ({...}:) za with import <nixpkgs> {};

• Zkusíme balík přeložit (pravděpodobně to nepůjde bez úprav):

  nix-build
  

• Výsledek uvidíme za symlinkem result:

  ls -l ./result/
  

• Typické úpravy default.nix:
  • Přidání závislostí (buildInputs, nativeBuildInputs, propagatedBuildInputs, …)
  • Nastavení parametrů pro ./configure, make, cmake, meson apod.
  • Instalace do $out
  • Patchování nekompatibilit s Nixem
• Neocenitelný pomocník: nix-shell (bez -p) nebo nix develop:

• Myšlenka NixOSu
  • Linuxová distribuce = balík, který závisí na jiných balících + konfigurační soubory, aby spolu balíky dobře fungovaly
  • Nix je dobrý v kompilaci balíků a řešení závislostí, abychom měli Linuxovou distribuci, potřebujeme vyřešit konfiguraci
  • NixOS = Nix kód pro automatické generování konfiguračních souborů

• Kontejnery se často generují z Alpine Linuxu – používá malou musl libc

• S Nixem můžete snadno docílit toho samého:

  nix-build --expr 'with (import <nixpkgs> {}); ministat'
  nix-tree ./result/              # 30 MB
  nix-build --expr 'with (import <nixpkgs> {}).pkgsMusl; ministat'
  nix-tree ./result/              # 3 MB
  nix-build --expr 'with (import <nixpkgs> {}).pkgsStatic; ministat'
  nix-tree ./result/              # 80 kB
  

• buildFHSEnv
• nix-ld
• envfs
• buildFHSEnv – binárky použitelné jinde
  • patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 a.out
• build proti staré glibc
  • Použít starší nixpkgs
  • Zkusit https://github.com/wheybags/glibc_version_header

https://nixos.org/

• Reproducible
  • Build exactly the same software on different systems.
• Declarative
  • Store your development environment in a simple file/git.
• “Reliable”
  • Nix ensures that installing or upgrading one package cannot break other packages.

• Collection of Nix expressions for building software
• Whole Linux distribution in one repository
• Ranks well in https://repology.org/ top repositories
• https://github.com/NixOS/nixpkgs/
• https://nixos.org/manual/nixpkgs/unstable/

• Nix expression is evaluated → low-level derivation

  nix-build '<nixpkgs>' -A gnuplot
  ls -l result
  nix-store --query --deriver result/
  nix show-derivation result/  # pretty format
  cat "/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
  

• Important attributes: builder, args
• Most attributes (and their values) are propagated to environment variables

nix-shell '<nixpkgs>' -A gnuplot
printenv
type genericBuild
type buildPhase
type configurePhase
unpackPhase
cd gnuplot-5.4.3
configurePhase
buildPhase

• invalidace hash (aby se projevil update)

• https://nix.dev/tutorials/building-and-running-docker-images

• https://nixos.org/manual/nixpkgs/unstable/#sec-pkgs-dockerTools

  { pkgs ? import <nixpkgs> {} }:
  
  pkgs.dockerTools.buildImage {
    name = "gnuplot";
    config = {
      Cmd = [ "${pkgs.gnuplot}/bin/gnuplot" ];
    };
  }
  

• nixGL – running OpenGL apps from nixpkgs on other distros
• Remote builds
  • slow laptop?
  • nix --builders ssh://server --max-jobs 0
    • build on server, no local builds (except simple ones, i.e. runCommdnLocal)

• Nix vs. Docker
  • Docker solves problems of traditional package managers by building on top of them
  • Nix changes (fixes) the core of package management
• Nix is (largely) reproducible
• Declarative specifications of build/development/production environments
• Nix is difficult to learn
• Using unpackaged applications (especially proprietary) is more difficult
  • buildFHSUserEnv
  • nix-ld
  • autopatchelf-hook

https://julialang.org/

• New language – announced 2012
• Goal: Solve the “two language” problem
  • Prototype in Python, rewrite in C++ for speed
• Compiled language (LLVM)
• Good for interactive work (JIT)
• Dynamic types + type inference
• Garbage collected
• Multiple dispatch paradigm
  • one function can have different implementations based on type of all arguments
• Lisp-like macros
• Target domain:
  • Originally: Scientific computations
  • Nowadays: General purpose, Data Science, Visualisation, …

• distribution package managers
• download archive, unzip/untar, run
• console application

Special characters at the start of the line switch modes:

• Help

  ?atan
  

• Shell

  ;ls
  

• Package manager

  ]add IJulia
  

Return with backspace

Julia uses dynamic types + type inference.

typeof(1)
typeof(1.0)
typeof(Int8(1))
typeof("Hello world")

• Inspired by Lisp
• Work at abstract syntax tree level.
• Can rewrite/generate programs.
  • Often used for domain specific languages
• No separate macro language, macros are written in Julia itself.

Example of what is possible with the language. This is not builtin functionality. Everything is programmed in Julia.

• Plots supports multiple plotting backends (e.g. Python matplotlib).
• Infamous “Time to first plot” – much better today

using Plots
plot(sin.(0:0.1:2π))

• One of several available interfaces to Gnuplot.
• Faster than Plots

using Gnuplot
@gp sin.(0:0.1:2π) "with lines lw 5" "set grid"

• Fast development, breaking changes (packages with version < 1.0)
• Reproducible environments (projects)
  • Which packages and versions
  • Project.toml, Manifest.toml
• Needs manual setup

• Easy to use parallelism
• Similar to goroutines in Go

Direct call to a function from shared library:

# libc call
ccall(:clock, Int32, ())
# using other libraries
ccall((:zlibVersion, "libz"), Cstring, ()) |> unsafe_string

Python code can be called transparently from Julia:

using PyCall
math = pyimport("math")
math.sin(math.pi / 4) # returns ≈ 1/√2 = 0.70710678...

• Jupyter vs. Pluto.jl
  • Pluto is something between Jupyter and Excel

• Work with tabular data, named columns
• Easy import from CSV (CSV.jl)

• ➕ “Simple”, fast, versatile language
• ➕ A lot of packages available
• ➕ Active community
• ➖ Some packages are not mature, breaking changes
• ➖ Compilation can be slow (new session)

• Help

  ?atan
  @doc atan
  

• Shell

  ;ls
  

• Package manager

  ]add IJulia
  

Return with backspace

Julia uses dynamic types + type inference.

typeof(1)
typeof(1.0)
typeof(Int8(1))
typeof("Hello world")

Example of what is possible with the language. This is not a builtin functionality. Everything is programmed in Julia.

using Unitful
using Unitful.DefaultSymbols
using Unitful: hr

1m + 3cm |> cm |> float
float(cm(1m + 3cm))
1m + 3cm |> cm |> float
sin(90)
sin(90°)
sin(π/2)

15m/3s

10km/hr |> m/s
10km/hr |> m/s |> float
0°C |> K |> float

Plots supports multiple plotting backends.

using Plots
pyplot()
plot(sin.(0:0.1:2π)

One of several available interfaces to Gnuplot.

using Gaston
plot(sin.(0:0.1:2π)

• Inspired by Lisp
• Work at parse tree level.
• Can rewrite/generate programs.
• No separate macro language, macros are written in Julia itself.

Examples (see test suites of many Julia packages):

@testset
@test

• Easy to use parallelism

Direct call to a function from shared library:

ccall(:clock, Int32, ())
ccall((:clock, "libc"), Int32, ())

• ASCII by mělo být spíš UTF-8, ale to nezní tak „cool“ :-)
• O mě
  • Pracuji na ČVUT, FEL
  • Embedded systémy (≈ low-level stuff)
  • Emacs používám od r. 1998
  • Patřím k lidem, kteří v Emacsu žijí
  • Vim používám také a nic proti němu nemám :-)

• Pokud je Emacs označován jako operační systém, org-mode bychom mohli nazvat kancelářský balík
• Outliner
  • Základní funkcionalita; snaha je, aby další funkce nekomplikovaly použití org-mode jako outlineru.
• Značkovací jazyk (markup)
• Prostředí pro přípravu textových dokumentů
• Tabulkový kalkulátor
• Kalendář, plánovač, organizér
• a určitě mnoho dalšího…
• Dokumentace: «C-h i d m org RET»
• Nekonečné možnosti konfigurace
• «M-x customize-group RET org RET»

• Nadpisy ^*+
  • M-RET – nový nadpis
  • M-šipky, M-S-šipky – změny úrovně či pořadí
  • C-c C-u – o úroveň výš, C-c C-j – skok, info:org#Motion
  • Schovávání: TAB, S-TAB
• Seznamy
  • odrážkové, číslované, …
  • S-←,→
  • Mnohé klávesové zkratky stejné jako u nadpisů
• Konverze «C-c *», «C-c -»

• Tučné, kurzíva, podtrženo verbatim, přeskrtnuto, kód α,
• Tabulky – nejsnadnější zadávaní jednoduchých tabulek do počítače | xxx | yyy «TAB»
• Obrázky: [[./file.jpg]​]
• Příklady, zdrojáky se zvýrazňováním syntaxe
  • Zkratky: <e «TAB», <s «TAB»

Příklad

print("String " + number)

• [[cíl]​[popis]] nebo [​[cíl]]
• Web Installfestu «C-c C-l», «C-c C-o»
• Cíle odkazů
  • URL
  • ./soubor

  • interní odkaz [​[cíl]]

    • * Nadpis obsahující cíl
    • #+NAME: cíl
    • …

    3.3.1

  • Externí odkazy («C-c l»)
    • [[file:source.c::main(int]] argc
    • (tetris)
    • odkazy na emaily…

• „Rádiové cíle“: <<<rádio>>> rádio

  Příklad: Rádio bylo vynalezeno roku 1893.

• Todo – každý nadpis může být položkou „TODO“ «S-←,→»
• Seznam stavů je konfigurovatelný
• «C-c a t» – all TODOs = agenda
• Seznam souborů pro tvorbu agendy (např. jeden .org soubor pro projekt)
• Scheduled/deadline: C-c C-s, C-c C-d
  • «.» = dnes, «S-šipky»
  • Rozumí i textu: např. „May 1“ nebo „Wed“
• Záznam odpracovaného času na úkolech «C-c C-x C-i», «C-c C-x C-o»
  • (org-clock-report)
• Souhrn splnění podúkolů [/], [%]
• [ ] Checkboxy «C-c C-c»
• Tagy u nadpisů :tag:, «C-c C-c»
  • hledání podle tagů: «C-c a m»

• Vyžaduje konfiguraci
  • Globální klávesa «C-c c»
  • Šablony - předvyplněný obsah, kam se má „TODO“ uložit

(setq org-capture-templates
 '(("t" "Todo" entry (file+headline "~/org/gtd.org" "Tasks")
        "* TODO %?\n  %i\n  %a")
   ("j" "Journal" entry (file+datetree "~/org/journal.org")
        "* %?\nEntered on %U\n  %i\n  %a")))

• «C-c C-e»
• Plain text, HTML, OpenDocument, …
• Relativně snadná tvorba vlastních exportů (např. Doxygen)
• Nastavení exportu v hlavičce – «C-c C-e #»

• Práce se zdrojovými kódy
  • Podpora více jazyků v jednom dokumentu a interakce mezi nimi
• „Literate programming“
• „Reproducible research“ (executable documentation)

for i in $(seq 3); do date; sleep 1; done
ls -l

Výsledky vidíme níže:

Wed  8 Mar 10:44:56 CET 2017
Wed  8 Mar 10:44:57 CET 2017
Wed  8 Mar 10:44:58 CET 2017
total 24
-rw-r--r-- 1 wsh wsh 6696 Mar  5 21:52 graph.png
-rw-r--r-- 1 wsh wsh 6232 Mar  8 10:42 index.org
-rw-r--r-- 1 wsh wsh 6232 Mar  8 10:44 org-mode.txt

• Editace: «C-c ’»
• Spuštění: «C-c C-c»
• Argumenty v hlavičce
  • :results verbatim drawer

Run the benchmark (shell script) on a remote server:

mbw -a -q 10 | awk '{ print $1, $3, $9 }'

Gnuplot code to plot the results of the above command.

set key right bottom Left
set grid
set title "mbw results"
set xlabel "Attempt"
set ylabel "Bandwidth [MiB/s]"
set style data lp
set yrange [0:]
plot "< grep MEMCPY ".data  using 1:3 title "MEMCPY", \
     "< grep DUMB ".data    using 1:3 title "DUMB", \
     "< grep MCBLOCK ".data using 1:3 title "MCBLOCK"

• «C-c C-x p»
• Key-value přiřazené k nadpisu
• Může měnit různé nastavení pro danou sekci
• Lze používat i jako jednoduchou databázi (hledání podle properties apod.)
• Column view «C-c C-x C-c»

• Všestranný textový editor
• Interpret Lispu (v jazyce C) + spousta Lispového kódu
  • C: 280 kLoC (20%), Lisp: 1 MLoC (80%)
  • Srovnání – Firefox: 6 MLoC C/C++, 3.6 MLoC JavaScript+HTML
• Emacs = Editor MACroS nebo Esc-Meta-Alt-Ctrl-Shift :)
• Plnohodnotný operační systém :) (M-x tetris, M-x doctor)
• Začal vznikat v 70. letech

• Poplatná době vzniku
• Buffer = otevřený soubor
• Okno (window) = část obrazovky editoru zobrazující buffer
  • Jedno okno zobrazuje právě jeden buffer
  • Jeden buffer může být zobrazován nula až N okny
• Frame = to čemu dneska říkáme okno
  • Může být grafický nebo textový (terminál)

• Mnoho jich je stejných jako v bashi
• Dobře se používají i na exotických klávesnicích (kámošův notebook, BT klávesnice k mobilu/tabletu, …)
• Notace: C = Control, M = Meta = Alt = Esc, S = Shift

• M-x <příkaz>
• Mini-buffer – většina klávesových zkratek stejná jako při editaci normálních bufferů (souborů)
• tab-completion
• completion “modes”
  • M-x ido-mode
  • M-x icomplete-mode
  • Helm (tutorial)
• Příkaz je lispovská funkce označená jako (interactive).
• Klávesové zkratky spouští příkazy – viz (global-set-key ...).

• V Emacsu se vše motá kolem “módů”
• Velký mód:
  • definuje zvýrazňování syntaxe,
  • definuje klávesové zkratky,
  • implementuje (automatické) zarovnávání kódu,
  • vybírá se automaticky podle přípony nebo obsahu souboru,
  • lze ho vybrat i manuálně (spuštěním příkazu *-mode; např. c-mode).
• Malý mód:
  • Implementuje dodatečnou funkcionalitu, kterou má smysl používat s vícero velkými módy.
  • Příklady:
    • flyspell-mode
    • auto-fill-mode
    • hide-show-mode
• Jaké módy jsou momentálně aktivní naznačuje Mode line.

• Emacs má poměrně dobrý systém nápovědy.
• C-h prefix key
  • C-h f – funkce
  • C-h v – proměnné
  • C-h k – klávesová zkratka
  • C-h m – mód
  • C-h i – prohlížeč info stránek (C-h i m Emacs <RET>)
    • Navigace: ‘n’, ‘p’, ’[’, ’]’
    • ’i’ – hledání v rejstříku (pak ’,’)
• M-x man

• Nové verze Emacsu (konečně) podporují výběr pomocí S-<šipky>.
• Tradičně: blok je oblast od “značky” ke kurzoru (point).
• C-SPC = polož značku
• Ctrl-C, Ctrl-V, Ctrl-X – standardně nefunguje, lze zapnout M-x cua-mode.
  • Ctrl-C koliduje s mnoha standardními zkratkami; cua-mode to částečně řeší.
• Tradičně:
  • Smazaný text se ukládá do “kill ringu” (např. C-k, M-d)
  • C-y (yank) vloží hodnotu z konce “kill ringu”
  • M-y (následující po C-y) vkládá starší hodnoty z “kill ringu”.
  • C-w = kill region
  • M-w = “copy” region
• Obdélníkové bloky
  • C-x r * – neintuitivní (aspoň pro mne)
  • C-x SPC = rectangle mark mode
    • M-x string-insert-rectangle – vloží stejný text na každou řádku bloku
  • CUA mode: C-RET = cua-set-rectangle-mark
    • string-insert-rectangle není potřeba; stačí začít psát
    • ve výjimečných případech se chová podivně

• Správa oken
  • není ideální
  • C-x 2, C-x 3 = rozděl okno vertikálně/horizontálně
  • C-x o = přesun na následující okno
  • Windmove package – pohyb mezi okny podle směru (např. S-<šipky>)
  • C-x 0 = smaž aktuální okno (ale ne buffer)
  • C-x 1 = smaž ostatní okna
• Přepínání bufferů
  • C-x <left>/<right>
  • C-x b = zadat název bufferu (použitelné s completion módy)
  • C-x C-b (polo) interaktivní výběr bufferu
  • M-x ibuffer = interaktivní výběr bufferu
  • M-x helm-buffer-list = dtto

• M-q = přeformátování odstavce (v mnoha módech inteligentní)
• C-s = interactive search, C-M-s = interactive regexp search
  • V příkazové řádce hledání:
    • C-s – minulé hledání
    • C-w – doplní slovo pod kurzorem
    • M-c – přepne rozlišování malých a velkých písmen
    • M-e – editace (např. minulého hledání po C-s C-s)
• M-% = nahrazení řetězce
• C-M-S-% = nahrazení regulárního výrazu
• M-/ = doplň rozepsané slovo podle předchozích slov
• Macros: F3 = začátek nahrávání, F4 = konec nahrávání/spuštění
• Nahrazení textu ve víc souborech najednou: M-x dired-mode, mark (m), Q
• M-x occur
• M-x rgrep
• M-; comment-dwim (do what I mean)
• C-M-a = beginning-of-defun, C-M-e = end-of-defun
• C-M-p, C-M-n, C-M-u = pohyb po závorkami ohraničených blocích (prev, next, up)
• C-u C-SPC – návrat na místa předchozí editace

• Možnosti konfigurace jsou nekonečné
• Předkonfigurovaný Emacs: Emacs Prelude
• Standardní konfigurační soubor ~/.emacs nebo ~/.emacs.d/init.el.
  • Nastavování proměnných
  • Konfigurace klávesových zkratek (global-set-key (kbd "C-c w") 'toggle-truncate-lines)
  • Definice vlastních příkazů
  • Zapínání minor módu
• Customization
  • User Hacker-friendly konfigurace
  • +GUI+TUI pro konfiguraci skoro všeho
  • M-x customize
  • M-x customize-{variable,face,group}
  • Není potřeba ručně editovat ~/.emacs

• Konfiguraci Emacsu lze ukládat i do editovaných souborů.
• Podobně je možné konfiguraci uložit do souboru .dir-locals.el a pak bude platit pro všechny soubory v daném adresáři a jeho podadresářích.
• M-x add-file-local-variable
• M-x add-dir-local-variable

/* Local Variables: */
/* compile-command: "make CFLAGS='-g -O0 -Wall" */
/* End: */

• Odsazování
  • většinou automatické, nebo po <TAB>
  • inteligentní zarovnávání všeho
    • ’M-q’ v komentáři zarovná komentář
• Kompilace
  • M-x compile, M-x recompile
  • M-x next-error (skáče na chyby, detekce mnoha kompilátorů/formátů chybových hlášení)
• Doplňování kódu
  • auto-complete-mode
  • company-mode (asi lepší)
  • yasnippet (TextMate snippets in Emacs)
• Často možnost interakce s interpretrem skriptovacích jazyků (např. v M-x python-shell-send-defun)
• Verzovací systémy
  • vc – stejné klávesové zkratky pro všechny VCS (např. C-x v = – diff aktuálního souboru)
  • magit – speciální mód pro práci s gitem

• auctex – pokročilý editor na *TeXové dokumenty
  • navigace po sekcích, promote/demote sekcí
  • integrace s BibTeXem pro snadné hledání/vkládání citací
  • náhledy rovnic a obrázků přímo v editovaném textu
• org-mode – tvorba a organizování poznámek, TODO seznamů, plánování projektu, tvorba dokumentů atd.
  • tato prezentace je v org módu
• dired-mode – správa souborů
  • C-x d, C-x C-f (adresář)
  • mazání souborů: označit ‘d’, smazat ‘x’
• TRAMP
  • vzdálená editace (kompilace, …) souborů
  • SSH, sudo, …
• notmuch – lokální “gmail” (rychlé vyhledávání), GUI v Emacsu
• shell, eshell – práce s příkazovou řádkou bez opuštění Emacsu

Instalace balíků třetích stran:

• M-x list-packages
• MELPA repozitář balíků

• Emacs většinou dlouho startuje
• Doba startu záleží na uživatelské konfiguraci
  • Inicializace balíků při startu vs. autoload
• Emacs lze pustit jako “server” (emacs --daemon) a připojovat se k němu pomocí programu emacsclient.

  • Nic se nemusí konfigurovat, emacsclient si spustí emacs sám:

    #!/bin/sh
    exec emacsclient -a '' "$@"
    

• K jednomu serveru se lze připojit současně z různých terminálů (lokálně X-windows, vzdáleně přes SSH).

• (Emacs) Lisp
  • C-h i m Elisp <RET>
  • Je jednodušší než např. Common Lisp
  • Program i data vypadají stejně (S-výrazy/S-expressions/sexp)
  • Vyhodnocení výrazu:
    • číslo je číslo, řetězec je řetězec

    • seznam: první prvek udává jméno funkce, ostatní prvky jsou parametry.

      (message "Ahoj")
      (message (concat "Ahoj" "Installfest"))
      

  • Proměnné:

    • globální:

      (defvar xyz 0)
      

    • lokální:

      (let (a b)
        <kód>)
      

  • Funkce:

    (defun fs-czech ()
      "Starts flyspell with czech dictionary"
      (interactive) ; Způsobí, že fs-czech se dá spustit pomocí M-x
      (flyspell-mode)
      (ispell-change-dictionary "czech")
      (flyspell-buffer))
    

• Navigace po framech v LaTeX beameru

  (defconst latex-beamer-frame-re         ; Regulární výraz, který budeme hledat
    "\\\\\\(frametitle\\|section\\){")    ; '\' se musí 2x escapovat
  
  (defun is-outside-of-comment ()
    (null (nth 8 (syntax-ppss))))
  
  (defun latex-beamer-previous-frame ()
    (interactive)
    (while (progn
             (re-search-backward latex-beamer-frame-re)
             (not (is-outside-of-comment))))
    (recenter 0))
  
  (defun latex-beamer-next-frame ()
    (interactive)
    (when (looking-at-p latex-beamer-frame-re)
      (forward-char))
    (while (progn
             (re-search-forward latex-beamer-frame-re)
             (not (is-outside-of-comment))))
    (goto-char (match-beginning 0))
    (recenter 0))
  
  (add-hook 'LaTeX-mode-hook (lambda ()
    (local-set-key (kbd "M-p") 'latex-beamer-previous-frame)
    (local-set-key (kbd "M-n") 'latex-beamer-next-frame)))
  

• C-x C-e = vyhodnoť výraz před kurzorem (point)
• Kusy elispu lze vkládat do komentářů programů v jiných jazycích a spouštět přímo tam.

\chapter*{List of Acronyms}

% Sort acronyms: (let ((sort-fold-case t)) (sort-regexp-fields nil "^[[:space:]]*\\\\acro\{\\([^}]*\\)\}.*$" "\\1" (search-forward "\\begin{acronym}") (search-forward "\\end{acronym}")))
\begin{acronym}[XXXXX]
  \acro{AC}{Access Category}
  \acro{ACK}{Acknowledge}
  \acro{BFQ}{Budget Fair Queuing}
\end{acronym}