RSSPaper

v₁ · Unparalleled financial education.

(icomplete-mode +1)
(add-hook 'icomplete-mode-hook #'icomplete-vertical-mode)

(setq icomplete-scroll t)

(setq icomplete-show-matches-on-no-input t)

(icomplete-mode +1)
(add-hook 'icomplete-mode-hook #'icomplete-vertical-mode)

(setq icomplete-scroll t)

(setq icomplete-show-matches-on-no-input t)

Zaragoza, Ávila, Murcia, Albacete...

Albacete, Murcia, Zaragoza, Ávila...

import re
import functools

def order_ignore_accents(queryset, column):
    """Order Queryset ignoring accents"""

    def remove_accents(raw_text):
        """Removes common accent characters."""
        sustitutions = {
            "[àáâãäå]": "a",
            "[ÀÁÂÃÄÅ]": "A",
            "[èéêë]": "e",
            "[ÈÉÊË]": "E",
            "[ìíîï]": "i",
            "[ÌÍÎÏ]": "I",
            "[òóôõö]": "o",
            "[ÒÓÔÕÖ]": "O",
            "[ùúûü]": "u",
            "[ÙÚÛÜ]": "U",
            "[ýÿ]": "y",
            "[ÝŸ]": "Y",
            "[ß]": "ss",
            "[ñ]": "n",
            "[Ñ]": "N",
        }
        return functools.reduce(
            lambda text, key: re.sub(key, sustitutions[key], text),
            sustitutions.keys(),
            raw_text,
        )

    return sorted(queryset, key=lambda x: remove_accents(eval(f"x.{column}")))

towns = Town.objects.all().order_by('name')

towns_order = order_ignore_accents(Town.objects.all(), 'name')

Albacete, Ávila, Murcia, Zaragoza...

composer require "twig/twig:^3.0"

mkdir templates

Hola {{ nombre }},
gracias por escribirnos desde {{ email }} con el asunto "{{ asunto }}".
¡Nos vemos!

<h1>Hola {{ nombre }},</h1>
<p>gracias por escribirnos desde {{ email }} con el asunto "{{ asunto }}".</p>
<p>¡Nos vemos!</p>

// Cargamos todas las extensiones. En este caso solo disponemos de Twig
require_once('vendor/autoload.php');
// Indicamos en Twig el lugar donde estarán las plantillas.
$loader = new \Twig\Loader\FilesystemLoader('templates');
// Cargamos las plantillas al motor de Twig
$twig = new \Twig\Environment($loader);
// Definimos las variables que deseamos rellenar en las plantillas.
$variablesEmail = [
    'nombre' => 'Cid',
    'email' => 'cid@campeador.vlc',
    'asunto' => 'Reconquista'
];
// Renderizamos con la plantilla 'contacto.txt'
$plantillaPlana =  $twig->render('contacto.txt', $variablesEmail);
// Renderizamos con la plantilla 'contacto.html'
$plantillaHTML =  $twig->render('contacto.html', $variablesEmail);

echo $plantillaPlana;
/**
Hola Cid,
gracias por escribirnos desde cid@campeador.vlc con el asunto "Reconquista".
¡Nos vemos!
**/

echo $plantillaHTML;
/**
<h1>Hola Cid,</h1>
<p>gracias por escribirnos desde cid@campeador.vlc con el asunto "econquista".</p>
<p>¡Nos vemos!</p>
**/

TOKEN=123456789
USER=TUX
PASSWORD=qwe123

export $(cat .env | egrep -v "(^#.*|^$)" | xargs)

echo $TOKEN

123456789

$token = getenv('TOKEN');
$user = getenv('USER');
$password = getenv('PASSWORD');

echo $token;
// 123456789

import os

token = os.getenv('TOKEN')
user = os.getenv('USER')
password = os.getenv('PASSWORD')

(def token (System/getenv "TOKEN"))
(def user (System/getenv "USER"))
(def password (System/getenv "PASSWORD"))

[environ "0.5.0"]

(require [environ.core :refer [env]])

(def token (env :TOKEN))
(def user (env :USER))
(def password (env :PASSWORD))

(ql:quickload '("alexandria" "serapeum" "bordeaux-threads" "lparallel" "dexador" "hunchentoot" "quri" "ltk" "cl-ppcre" "mito"))

;; provided you installed quicklisp in ~/quicklisp/
(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname))))
  (when (probe-file quicklisp-init)
    (load quicklisp-init)))

`
editor:bind-key
editor:defcommand
editor:current-point
editor:with-point  ;; save point location
editor:move-point
editor:*buffer-list*
editor:*in-listener* ;; returns T when we are in the REPL
…

;; Indent new lines.
;; By default, the point is not indented after a Return.
(editor:bind-key "Indent New Line" #\Return :mode "Lisp")

;; Insert pairs.
(editor:bind-key "Insert Parentheses For Selection" #\( :mode "Lisp") ;;
(editor:bind-key "Insert Double Quotes For Selection" #\" :mode "Lisp")

(editor:defcommand "Move Over ()" (p)
  "Move past the next close parenthesis.
Any indentation preceeding the parenthesis is deleted."
  "Move past the next close parenthesis."
  ;; thanks to Thomas Hermann
  ;; https://github.com/ThomasHermann/LispWorks/blob/master/editor.lisp
  (declare (ignore p))
  (let ((point (editor:current-point)))
    (editor:with-point ((m point))
      (cond ((editor::forward-up-list m)
	     (editor:move-point point m)
             (editor::point-before point)
             (loop (editor:with-point ((back point))
                     (editor::back-to-indentation back)
                     (unless (editor:point= back point)
                       (return)))
                   (editor::delete-indentation point))
	     (editor::point-after point))
	    (t (editor:editor-error))))))

(editor:bind-key "Move Over ()" #\) :mode "Lisp")

(editor:setup-indent "if" 1 4 1)

CL-USER 4 > (defun my-abs (x) (cond ((> x 0) x) ((< x 0) (- x)) (t 0)))
CL-USER 5 > (step (my-abs -5))
(MY-ABS -5) -> :s
   -5 -> :s
   -5
   (COND ((> X 0) X) ((< X 0) (- X)) (T 0)) <=> (IF (> X 0) (PROGN X) (IF (< X 0) (- X) (PROGN 0)))
   ;; Access to the local variables:
   (IF (> X 0) (PROGN X) (IF (< X 0) (- X) (PROGN 0))) -> (format t "Is X equal to -5? ~a~&" (if (equal x -5) "yes" "no"))
Is X equal to -5? yes
   (IF (> X 0) (PROGN X) (IF (< X 0) (- X) (PROGN 0))) -> :s
      (> X 0) -> :s
         X -> :s
         -5
         0 -> :s
         0
      NIL
      (IF (< X 0) (- X) (PROGN 0)) -> :s
         (< X 0) -> :s
            X -> :s
            -5
            0 -> :s
            0
         T
         (- X) -> :s
            X -> :s
            -5
         5
      5
   5
5

:s       Step this form and all of its subforms (optional +ve integer arg)
:st      Step this form without stepping its subforms
:si      Step this form without stepping its arguments if it is a function call
:su      Step up out of this form without stepping its subforms
:sr      Return a value to use for this form
:sq      Quit from the current stepper level
:bug-form <subject> &key <filename>
         Print out a bug report form, optionally to a file.
:get <variable> <command identifier>
         Get a previous command (found by its number or a symbol/subform within it) and put it in a variable.
:help    Produce this list.
:his &optional <n1> <n2>
         List the command history, optionally the last n1 or range n1 to n2.
:redo &optional <command identifier>
         Redo a previous command, found by its number or a symbol/subform within it.
:use <new> <old> &optional <command identifier>
         Do variant of a previous command, replacing old symbol/subform with new symbol/subform.

(defclass person ()
  ((name :accessor name
         :initarg :name
         :initform "")
   (lisper :accessor lisperp
           :initform t)))

;;; Safety = 3, Speed = 1, Space = 1, Float = 1, Interruptible = 1
;;; Compilation speed = 1, Debug = 2, Fixnum safety = 3
;;; Source level debugging is on
;;; Source file recording is  on
;;; Cross referencing is on

(ql:quickload "swank")
;; or
(load "~/.emacs.d/elpa/slime-20xx/swank-loader.lisp")

(swank:create-server :port 9876)
;; Swank started at port: 9876.
9876

(setq button
      (make-instance 'capi:push-button
                     :data "Button"))
(capi:contain button)

ls

ls -l

ls -a

mkdir nueva_carpeta

mkdir -p carpeta1/carpeta2

less archivo.txt

touch archivo.txt

cd carpeta

cd ..

cd ..

cd ~

cd -

file paris.jpg

find carpeta-donde-buscar -name feliz.jpg

find carpeta-donde-buscar -type d -name vacaciones

pwd

mv fichero_original.txt fichero_nuevo_nombre.txt

cp texto.txt texto_copiado.txt

cp -r carpeta carpeta_copiada

rm archivo.txt

rm -r carpeta

date

date -r 1619018708

whoami

ls | grep texto

cat archivo.txt | grep texto

chmod 744 script.sh

chmod a-w first.txt

chmod u+x script.sh

chmod debian:debian archivo.txt

cat archivo1.txt archivo2.txt

echo archivo.txt

man ls

history

clear

sudo reboot

sudo shutdown now

htop

nano archivo.txt

emacs -nw archivo.txt

curl programadorwebvalencia.com

tail archivo.txt

ip address show eth0

lsof -i tcp:80

df -h

du -d 1 -h

journalctl -f

journalctl -f -u ssh

journalctl -u ssh

journalctl -n 20

journalctl --vacuum-size=1G

journalctl --vacuum-time=1years

!!

sudo !!

apt update && \
apt upgrade -y && \
apt dist-upgrade

apt install -y build-essential fail2ban iptables-persistent msmtp-mta python3-dev python3-pip libcurl4-openssl-dev libssl-dev htop git neovim wget curl zsh tmux && \
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" && \
apt autoremove -y

iptables -A INPUT -p tcp --dport 80 -j ACCEPT &&
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

update-alternatives --config editor

ln -fs /usr/share/zoneinfo/Europe/Madrid /etc/localtime && \
dpkg-reconfigure -f noninteractive tzdata

apt install -y unattended-upgrades apt-listchanges && \
echo unattended-upgrades unattended-upgrades/enable_auto_updates boolean true | debconf-set-selections && \
dpkg-reconfigure -f noninteractive unattended-upgrades

useradd --shell /bin/zsh -m debian

su debian

ssh-keygen -t rsa
exit

usermod -a -G sudo debian

visudo

%sudo   ALL=(ALL:ALL) NOPASSWD:ALL

cp /root/.ssh/authorized_keys /home/debian/.ssh/ && \
chown debian:debian /home/debian/.ssh/authorized_keys

dd if=/dev/urandom of=balloon.txt bs=1MB count=1000

nano /etc/systemd/journald.conf

SystemMaxUse=1Gb

systemctl restart systemd-journald

apt update && \
apt install -y \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release && \
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg && \
echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
apt update && \
apt -y install docker-ce docker-ce-cli containerd.io docker-compose

sudo apt install zram-tools

sudo nano /etc/default/zramswap

PERCENTAGE=50
ALLOCATION=4096 #4Mb
ALLOCATION=8192 #8Mb

sudo apt install snapd

 (require 'orderless)
 (setq completion-styles '(orderless))

 (require 'vertico)
 (vertico-mode +1)

 (require 'orderless)
 (setq completion-styles '(orderless))

 (require 'vertico)
 (vertico-mode +1)

tar -cvf nombre.tar carpetas-o-archivos

tar -czvf futuro-comprimido.tar.gz carpetas-o-archivos-a-comprimir

tar -cjvf futuro-comprimido.tar.bz2 carpetas-o-archivos-a-comprimir

tar -xvf comprimido.tar.gz

├── emacs
│   ├── config.org
│   └── init.el
└── scripts
(require 'package)

(setq package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
                         ("melpa" . "https://melpa.org/packages/")))

(package-initialize)

(package-refresh-contents)

;; this is required to highlight code blocks properly
(package-install 'htmlize)

(require 'org)

(require 'htmlize)

;; For some reason the default value `inline-css' doesn't apply syntax highlighting correctly
;; in the resulting html file so we need to change the value to `css'
(setq org-html-htmlize-output-type 'css)
#!/bin/sh

# read the docs based theme
echo "#+SETUPFILE: https://raw.githubusercontent.com/fniessen/org-html-themes/master/org/theme-readtheorg.setup" > index.org
cat ../emacs/config.org >> index.org

emacs index.org --batch -Q --load org-render-html-minimal.el -f org-html-export-to-html --kill

# output will be the directory uploaded to the render repository so we have to put all the resulting files inside that folder
mkdir output
mv index.html output/
name: CI

on:
  push:
    branches: [ master ]

jobs:
  build-emacs-config-page:
    runs-on: ubuntu-latest
    container: alpine:3.13.4
    steps:
      - uses: actions/checkout@v2
      - name: Install emacs
        run: apk --update add emacs
      - name: Render config into html
        run: cd scripts && sh render-emacs-config-to-html.sh
      - name: Pushes to destination repository
        uses: cpina/github-action-push-to-another-repository@cp_instead_of_deleting
        env:
          API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }}
        with:
          source-directory: 'scripts/output'
          destination-github-username: 'YOUR_GITHUB_USERNAME'
          destination-repository-name: 'YOUR_NEW_REPOSITORY_NAME'
          user-email: bot@emacs.bot
sudo apt install postgresql-server
sudo su - postgres
postgres=# CREATE USER django WITH ENCRYPTED PASSWORD 'secret';

postgres=# CREATE DATABASE django WITH OWNER django;
postgres=# CREATE USER phoenix WITH ENCRYPTED PASSWORD 'secret';

postgres=# CREATE DATABASE phoenix WITH OWNER phoenix;
django.domain.com {
    root * /opt/django

    @notStatic {
        not path /static/*
    }

    reverse_proxy @notStatic localhost:8000
    file_server
}
phoenix.domain.com {
    reverse_proxy localhost:4000
}
cd simple-django-project-with-docker
docker build -t registry.mycompany.com/django:v1 .
docker push registry.mycompany.com/django:v1
cd simple-phoenix-project-with-docker
docker build -t registry.mycompany.com/phoenix:v1 .
docker push registry.mycompany.com/phoenix:v1
version: "2"
services:
  web:
    image: registry.mycompany.com/django:v1
    restart: always
    network_mode: host
    environment:
      ALLOWED_HOSTS: "django.domain.com"
      DEBUG: "0"
      DATABASE_URL: "postgres://django:secret@localhost:5432/django"
      DJANGO_SETTINGS_MODULE: "config.settings"
      SECRET_KEY: "a 32 long secret key"
    volumes:
      - ./static:/app/static
    ports:
      - "127.0.0.1:8000:8000"
version: "2"
services:
  web:
    image: registry.mycompany.com/phoenix:v1
    restart: always
    network_mode: host
    environment:
      DATABASE_URL: "postgres://phoenix:secret@localhost:5432/phoenix"
      MIX_ENV: prod
      HOST: "phoenix.domain.com"
      SECRET_KEY_BASE: "a 32 long secret key"
    ports:
      - "127.0.0.1:4000:4000"
docker-compose up -d
# Run database migrations
docker-compose exec -T web python manage.py migrate

# Collect all static files and place them in our STATIC_ROOT folder which will be served by Caddy
docker-compose exec -T web python manage.py collectstatic --no-input
docker pull NEW_DJANGO_IMAGE

sed -i "s/image.*/image:\ NEW_DJANGO_IMAGE/" docker-compose.yml

docker-compose up -d --force-recreate

docker-compose exec -T web python manage.py migrate

docker-compose exec -T web python manage.py collectstatic --no-input
docker pull NEW_PHOENIX_IMAGE

sed -i "s/image.*/image:\ NEW_PHOENIX_IMAGE/" docker-compose.yml

docker-compose up -d --force-recreate
body {
	scroll-behavior: smooth;
}

<script>
	document.addEventListener('DOMContentLoaded', () => {	

	    	//===
		// SCROLL SMOOTH
		//===
		// Variables
		const links = document.querySelectorAll('a[href *= "#"]:not([href = "#"])');

		/**
		 * Event scroll
		 */
		function clickHandler(event) {
		  event.preventDefault();
		  const href = this.getAttribute("href");
		  const offsetTop = document.querySelector(href).offsetTop;

		  scroll({
		    top: offsetTop,
		    behavior: "smooth"
		  });
		}

		// Add event all links
		links.forEach((link) => link.addEventListener("click", clickHandler));
	});
</script>

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
<script>
	$(function() {
	    $('a[href *= "#"]:not([href = "#"])').click(function() {
				if (location.pathname.replace(/^\//, '') == this.pathname.replace(/^\//, '') || location.hostname == this.hostname) {
					let target = $(this.hash);
		    target = target.length ? target : $('[name = ' + this.hash.slice(1) + ']');
		    if (target.length) {
			$('html, body').animate({
			    scrollTop: target.offset().top
			}, 1000);
			return false;
		    }
		}
	    });
	});
</script>

(defun my/run-hlint ()
  "Run  hlint over the current project."
  (interactive)
  (let ((default-directory (projectile-project-root)))
    (compile "hlint .")))
(with-eval-after-load 'compile
  (define-key compilation-mode-map (kbd "g") nil)
  (define-key compilation-mode-map (kbd "r") 'recompile)
  (define-key compilation-mode-map (kbd "h") nil))
(with-eval-after-load 'compile
  ;; set cursor to follow compilation output
  (setq compilation-scroll-output t))
(require 'ansi-color)

(defun colorize-compilation-buffer ()
  (let ((inhibit-read-only t))
    (ansi-color-apply-on-region (point-min) (point-max))))

(add-hook 'compilation-filter-hook 'colorize-compilation-buffer)
(evil-leader/set-key "R" 'recompile)
(global-set-key (kbd "C-c C-r") 'recompile)
(defun my/parrot-animate-when-compile-success (buffer result)
  (if (string-match "^finished" result)
      (parrot-start-animation)))

(use-package parrot
  :ensure t
  :config
  (parrot-mode)
  (add-to-list 'compilation-finish-functions 'my/parrot-animate-when-compile-success))
lem --eval "(lem-lisp-mode:start-lisp-repl t)"

 ros install cxxxr/lem

brew install roswell  # macos or linuxbrew
yay -S roswell
scoop install roswell  # windows

# Debian package:
curl -sOL `curl -s https://api.github.com/repos/roswell/roswell/releases/latest | jq -r '.assets | .[] | select(.name|test("deb$")) | .browser_download_url'`
sudo dpkg -i roswell.deb

potencias: list[int]

potencias[:14]    ==  [2,3,4,5,7,9,11,13,16,17,19,23,25,29]
potencias[60]     ==  241
potencias[10**6]  ==  15476303

from primes import primes

potencias = sorted(p**2**k for p in primes[:14] for k in range(0, 14))
print(potencias[:14])

[2, 3, 4, 5, 7, 9, 11, 13, 16, 17, 19, 23, 25, 29]

from itertools import count

from primes import primes

potencias = ((p**2**k for p in primes) for k in count())

p0 = next(potencias)
p1 = next(potencias)
next(p1)  # --> 4
next(p0)  # --> 4
next(p0)  # --> 9

from collections.abc import Iterator
from itertools import count

from primes import primes

def potencias_gen(k: int) -> Iterator[int]:
    yield from (p**2**k for p in primes)

potencias = (potencias_gen(k) for k in count())

# tipo para secuencias ordenadas
SortedIterator = Iterator[int]

def zipsort(s1: SortedIterator, s2: SortedIterator) -> SortedIterator:
    x = next(s1)
    y = next(s2)
    while True:
        if x <= y:
            yield x
            x = next(s1)
        else:
            yield y
            y = next(s2)

zipsort(zipsort(s1, s2), s3)

def flat(iterators: Iterator[SortedIterator]) -> SortedIterator:
    it1 = next(iterators)
    it2 = flat(iterators)
    yield from zipsort(it1, it2)

potencias = flat(potencias_gen(k) for k in count())

def flat(iterators: Iterator[SortedIterator]) -> SortedIterator:
    it1 = next(iterators)
    yield next(it1)
    yield from zipsort(it1, flat(iterators))

potencias = flat(potencias_gen(k) for k in count())

from collections.abc import Iterator
from itertools import count
from typing import TypeVar

from lazyseq import LazySortedSequence
from primes import primes

SortedIterator = Iterator[int]

def join(s1: SortedIterator, s2: SortedIterator) -> SortedIterator:
    x = next(s1)
    y = next(s2)
    while True:
        if x <= y:
            yield x
            x = next(s1)
        else:
            yield y
            y = next(s2)

def flat(it: Iterator[SortedIterator]) -> SortedIterator:
    s1 = next(it)
    yield next(s1)
    yield from join(s1, flat(it))

def mkiter(k):
    yield from (p ** 2 ** k for p in primes)

potencias = LazySortedSequence(flat(mkiter(k) for k in count()))

>>> potencias[:14]
[2, 3, 4, 5, 7, 9, 11, 13, 16, 17, 19, 23, 25, 29]
>>> potencias[60]
241
>>> potencias[10 ** 6]
15476303
>>> primes.size
999432

cuadrados = [x**2 for x in range(1, 100)]
resultado = [y for y in cuadrados if y < 100]

cuadrados = (x**2 for x in range(1, 100))
resultado = [y for y in cuadrados if y < 100]

from itertools import takewhile

cuadrados = (x**2 for x in range(1, 100))
resultado = list(takewhile(lambda y: y<100, cuadrados))

>>> r = range(2,100,3)
>>> r[10]
32

>>> len(r)  # obtener el tamaño
33
>>> r[20:30]  # obtener un rango
range(62, 92, 3)
>>> r[30:20:-1]  # obtener un rango inverso
range(92, 62, -3)
>>> r[::-1]  # la misma secuencia invertida
range(98, -1, -3)
>>> r[20:30:-1]  # umm, secuencia vacía???
range(62, 92, -3)
>>> r[::2]  # una nueva secuencia con distinto paso
range(2, 101, 6)
>>> 3 in r  # comprobar si contiene un elemento
False
>>> r.index(65)  # buscar la posición de un elemento
21

from collections.abc import Sequence
from typing import Union

class SquaresRange(Sequence):
    def __init__(self, start=0, stop=None, step=1) -> None:
        if stop is None:
            start, stop = 0, start
        self._range = range(start, stop, step)

    @staticmethod
    def from_range(rng: range) -> "SquaresRange":
        """
        Constructor de SquaresRange a partir de un rango
        """
        instance = SquaresRange()
        instance._range = rng
        return instance

    def __len__(self) -> int:
        return len(self._range)

    def __getitem__(self, idx: Union[int, slice]) -> Union[int, "SquaresRange"]:
        i = self._range[idx]
        return i ** 2 if isinstance(i, int) else SquaresRange.from_range(i)

    def __repr__(self) -> str:
        r = self._range
        return f"SquaresRange({r.start}, {r.stop}, {r.step})"

>>> for i in SquaresRange(-10, 1, 3):
...     print(i)
...
100
49
16
1
>>> list(SquaresRange(-1, 50, 4)[:30:2])
[1, 49, 225, 529, 961, 1521, 2209]
>>> SquaresRange(100)[::-1]
SquaresRange(99, -1, -1)
>>> 16 in SquaresRange(-10, 1, 3)
True

from abc import abstractmethod
from collections.abc import Sequence
from typing import Type, Union

class GenericRange(Sequence):
    def __init__(self, start=0, stop=None, step=1) -> None:
        if stop is None:
            start, stop = 0, start
        self._range = range(start, stop, step)

    @abstractmethod
    def getitem(self, pos: int) -> int:
        """
        Método abstracto.
          Función para calcular un elemento a partir de la posición
        """
        return pos

    @classmethod
    def from_range(cls: Type["GenericRange"], rng: range) -> "GenericRange":
        """
        Constructor de un GenericRange a partir de un rango
        """
        instance = cls()
        instance._range = rng
        return instance

    def __len__(self) -> int:
        return len(self._range)

    def __getitem__(self, idx: Union[int, slice]) -> Union[int, "GenericRange"]:
        i = self._range[idx]
        return self.getitem(i) if isinstance(i, int) else self.from_range(i)

    def __repr__(self) -> str:
        classname = self.__class__.__name__
        r = self._range
        return f"{classname}({r.start}, {r.stop}, {r.step})"

class SquaresRange(GenericRange):
    def getitem(self, i):
        return i ** 2

class CubicsRange(GenericRange):
    def getitem(self, i):
        return i ** 3

>>> for i in SquaresRange(-10, 1, 3):
...     print(i)
...
100
49
16
1
>>> for i in CubicsRange(-10, 1, 3):
...     print(i)
...
-1000
-343
-64
-1
>>> list(CubicsRange(-1, 50, 4)[:30:2])
[-1, 343, 3375, 12167, 29791, 59319, 103823]
>>> SquaresRange(100)[::-1]
SquaresRange(99, -1, -1)
>>> SquaresRange(100).index(81)
9

(defn destr [& {:keys [a b] :as opts}]
  [a b opts])

(destr :a 1)
->[1 nil {:a 1}]

(destr {:a 1 :b 2})
->[1 2 {:a 1 :b 2}]
T = TypeVar("T", covariant=True)

class LazySequence(Iterator[T]):
    def __init__(self, iterator: Iterator[T]):
        self._cache: list[T] = []
        self.iterator = iterator

    def __next__(self) -> T:
        x = next(self.iterator)
        self._cache.append(x)
        return x

    @singledispatchmethod
    def __getitem__(self, idx):
        return NotImplemented

    @__getitem__.register
    def __getitem_int__(self, idx: int) -> T:
        if idx < 0:
            raise OverflowError
        elif idx >= self.size:
            self._cache.extend(islice(self.iterator, idx - self.size + 1))

        return self._cache[idx]

    @__getitem__.register
    def __getitem_slice__(self, sl: slice) -> list[T]:
        rng = range(INFINITE)[sl]
        return [self[i] for i in rng]

    def __iter__(self) -> Iterator[T]:
        yield from self._cache
        yield from (self[i] for i in range(len(self._cache), INFINITE))

Ord = TypeVar("Ord", bound=int, covariant=True)

class LazySortedSequence(LazySequence[Ord]):
    def insertpos(self, x: int) -> int:
        if self.size > 0 and x <= self.last:
            idx = bisect_left(self._cache, x)
        else:
            while x > next(self):
                pass
            idx = self.size - 1

        return idx

    def __contains__(self, x: int) -> bool:
        idx = self.insertpos(x)
        return x == self._cache[idx]

    def index(self, x: int) -> int:
        idx = self.insertpos(x)
        if x == self._cache[idx]:
            return idx
        raise ValueError(f"{x} is not in {self.__class__.__name__}")

@final
class Primes(LazySortedSequence[Prime]):
    def __init__(self):
        super().__init__(self.__genprimes())
        self._cache.extend([2, 3])

    def __genprimes(self) -> Iterator[Prime]:
        _primes = self._cache
        start = 5
        top = 1
        while True:
            stop = _primes[top] ** 2
            for n in range(start, stop, 2):
                for p in islice(_primes, 1, top):
                    if n % p == 0:
                        break
                else:
                    yield n

            start = stop + 2
            top += 1

    def __contains__(self, n: int) -> bool:

        if n <= self.last:
            return super().__contains__(n)

        root = isqrt(n)
        _primes = self._cache

        top = self.size if root > self.last else self.insertpos(root)

        if any(n % prime == 0 for prime in islice(_primes, 1, top)):
            return False

        # "one-shot" check
        if any(n % i == 0 for i in range(self.last + 2, root + 1, 2)):
            return False

        return True

class GenericRange:
    def __init__(self, start=0, stop=None, step=1) -> None:
        ...

    def __len__(self) -> int:
        ...

    def __getitem__(self, idx: Union[int, slice]) -> Union[int, "GenericRange"]:
        ...

>>> from collections.abc import Sized
>>> issubclass(GenericRange, Sized)
True

>>> from collections.abc import Sequence
>>> issubclass(GenericRange, Sequence)
False

from __future__ import annotations

    def __getitem__(self, idx: Union[int, slice]) -> Union[int, "GenericRange"]:
        i = self._range[idx]
        return self.getitem(i) if isinstance(i, int) else self.from_range(i)

from functools import singledispatchmethod

class GenericRange(Sequence):
    ...

    @singledispatchmethod
    def __getitem__(self, idx):
        return NotImplemented

    @__getitem__.register
    def _(self, idx: int) -> int:
        i = self._range[idx]
        return self.getitem(i)

    @__getitem__.register
    def _(self, idx: slice) -> "GenericRange":
        i = self._range[idx]
        return self.from_range(i)

@GenericRange.__getitem__.register
def _(self, idx: slice) -> GenericRange:
    i = self._range[idx]
    return self.from_range(i)

from abc import abstractmethod
from collections.abc import Sequence
from typing import Type, Union
from functools import singledispatchmethod
from __future__ import annotations

class GenericRange(Sequence[int]):
    def __init__(self, start=0, stop=None, step=1) -> None:
        if stop is None:
            start, stop = 0, start
        self._range = range(start, stop, step)

    @abstractmethod
    def getitem(self, pos: int) -> int:
        """
        Método abstracto.
          Función para calcular un elemento a partir de la posición
        """
        return pos

    @classmethod
    def from_range(cls: Type[GenericRange], rng: range) -> GenericRange:
        """
        Constructor de un GenericRange a partir de un rango
        """
        instance = cls()
        instance._range = rng
        return instance

    def __len__(self) -> int:
        return len(self._range)

    @singledispatchmethod
    def __getitem__(self, idx):
        return NotImplemented

    @__getitem__.register
    def _(self, idx: int) -> int:
        i = self._range[idx]
        return self.getitem(i)

    def __repr__(self) -> str:
        classname = self.__class__.__name__
        r = self._range
        return f"{classname}({r.start}, {r.stop}, {r.step})"

@GenericRange.__getitem__.register
def _(self, idx: slice) -> GenericRange:
    i = self._range[idx]
    return self.from_range(i)

> take 100 primes
[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,
107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,
223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,
337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,
457,461,463,467,479,487,491,499,503,509,521,523,541]

> primes!!90000
1159531

> isPrime (2^31-1)
True

Prime = int  # un alias para números primos

def isprime(n: int) -> bool:
    return not any(n % i == 0 for i in range(2, n))

def primes(to: int) -> list[Prime]:
    return [i for i in range(2, to+1) if isprime(i)]

import sys
from collections.abc import Generator, Iterable
from itertools import islice

INFINITE = sys.maxsize  # una aproximación 'mala' para infinito
Prime = int  # un alias para números primos

# lista de números primos que vayamos obteniendo
primes: list[Prime] = [2, 3]

def isdivisible(n: int, divisors: Iterable[int]) -> bool:
    """
    Comprobar si 'n' es divisible por
    los elementos de un iterable ordenado
    """

    divisible = False
    for d in divisors:
        if n % d == 0:
            divisible = True
            break
        if d * d > n:
            break
    return divisible

def isprime(n: int) -> bool:
    """Comprobar si 'n' es un número primo"""

    if n <= primes[-1]:
        return n in primes

    # probando primos como divisores
    if isdivisible(n, primes):
        return False

    # seguir con el resto de números impares
    start = primes[-1] + 2
    return not isdivisible(n, range(start, n, 2))

def genprimes() -> Generator[Prime, None, None]:
    """Generador de números primos"""

    start = primes[-1] + 2
    for n in range(start, INFINITE, 2):
        if not isdivisible(n, primes):
            primes.append(n)
            yield n

import sys
from collections.abc import Generator, Iterable
from itertools import islice
from typing import Union

INFINITE = sys.maxsize  # una mala aproximación de infinito
Prime = int  # un alias para los primos

def isdivisible(n: int, divisors: Iterable[int]) -> bool:
    """
    Comprobar si 'n' es divisible por
    los elementos de un iterable ordenado
    """

    divisible = False
    for d in divisors:
        if n % d == 0:
            divisible = True
            break
        if d * d > n:
            break
    return divisible

def nth(it: Iterable, n: int):
    """Obtener de un iterable el elemento en la posición 'n'"""
    return next(islice(it, n, None))

class Primes:
    """
    Collection of primes numbers
    """

    def __init__(self):
        self._primes: list[Prime] = [2, 3]

    @property
    def last(self) -> Prime:
        return self._primes[-1]

    @property
    def size(self) -> int:
        return len(self._primes)

    def __len__(self) -> int:
        return INFINITE

    def __contains__(self, n: int) -> bool:
        """Comprobar si 'n' es un número primo"""

        if n <= self.last:
            return n in self._primes

        # probando primos como divisores
        if isdivisible(n, self._primes):
            return False

        # seguir con el resto de números impares
        start = self.last + 2
        return not isdivisible(n, range(start, n, 2))

    def genprimes(self) -> Generator[Prime, None, None]:
        """Generador de números primos"""

        start = self.last + 2
        for n in range(start, INFINITE, 2):
            if not isdivisible(n, self._primes):
                self._primes.append(n)
                yield n

    def __getitem__(self, idx: Union[int, slice]) -> Prime:
        if isinstance(idx, int):
            if idx < 0:
                raise OverflowError

            return (
                self._primes[idx]
                if idx < self.size
                else nth(self.genprimes(), idx - self.size)
            )
        else:
            rng = range(INFINITE)[idx]
            return [self[i] for i in rng]

# Secuencia de los números primos
primes = Primes()
isprime = primes.__contains__

>>> from primes import primes, isprime
>>> print(primes[:100])
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157,
 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241,
 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347,
 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439,
 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541]
>>> primes[90000]
1159531
>>> isprime(2**31-1)
True
>>> (2**31-1) in primes._primes
False
>>> primes.last
1159531

from bisect import bisect_left

def bs_contains(lst: list, x) -> bool:
    idx = bisect_left(lst, x)
    return idx < len(lst) and lst[idx] == x

def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

>>> fib(10)
>>> fib.cache_info()
CacheInfo(hits=8, misses=11, maxsize=None, currsize=11)

>>> fib(10000)
...
RecursionError: maximum recursion depth exceeded in comparison

>>> [fib(n) for n in range(16)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]

from itertools import count, islice
from functools import lru_cache

ℕ = count(0)
suc_fib = (fib(n) for n in ℕ)
fib10k = next(islice(suc_fib, 10000, None))

def fibcache(f):
    cache = []
    def wrap(n):
        for i in range(len(cache), n + 1):
            cache.append(f(i))
        return cache[n]

    wrap.cache = cache

    return wrap

@fibcache
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

>>> fib(10000)
3364476487643178326662161200510754331030214846068006390656476997468008144216....
...
>>> fib.cache[10000]
3364476487643178326662161200510754331030214846068006390656476997468008144216....
...

from collections.abc import Iterable

def ℕ() -> Iterable[int]:
    n = 0
    while 1:
        yield n
        n += 1

from itertools import count

ℕ = count(0)

from itertools import islice

print(list(islice(ℕ, 100)))

[100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]

from collections.abc import Iterable, Iterator

def enumerate(it: Iterable) -> Iterator:
    ℕ = count(0)
    return zip(ℕ, it)

ℕ = count(0)
cuadrados = (n**2 for n in ℕ)
res = [x for x in cuadrados if 100<=x<200]

from itertools import dropwhile, takewhile

ℕ = count(0)
cuadrados = (n ** 2 for n in ℕ)
mayores_100 = dropwhile(lambda x: x < 100, cuadrados)
menores_200 = takewhile(lambda x: x <= 200, mayores_100)
res = list(menores_200)

1
1
1+1 -> 2
1+2 -> 3
2+3 -> 5
...

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

from collections.abc import Iterator
from itertools import islice

def fib() -> Iterator[int]:
    a, b = 1, 1
    while True:
        yield a
        a, b = b, a+b

# primeros 20 elementos
print(list(islice(fib(), 20)))

>>> next(islice(fib(), 1000, None))
70330367711422815821835254877183549770181269836358732742604905087154537118196933
57974224949456261173348775044924176599108818636326545022364710601205337412127386
7339111198139373125598767690091902245245323403501

class FibRange(GenericRange):
    def getitem(self, n):
        sqrt5 = 5**(1/2)
        φ = (1 + sqrt5) / 2
        return int(φ**n/sqrt5 + 1/2)

>>> list(FibRange(100,110))
[354224848179263111168,
 573147844013818970112,
 927372692193082081280,
 1500520536206901248000,
 2427893228399983329280,
 3928413764606884839424,
 6356306993006868692992,
 10284720757613753532416,
 16641027750620622225408,
 26925748508234379952128]

asdf plugin add erlang
asdf plugin add elixir
export ASDF_ELIXIR_VERSION=1.10.3-otp-22
export ASDF_ERLANG_VERSION=22.3
erlang 23.0.2
elixir 1.10.4-otp-23
export KERL_CONFIGURE_OPTIONS="--disable-debug --without-javac"
config :my_app, Repo,
  database: "ecto_simple",
  username: "postgres",
  password: "postgres",
  hostname: "localhost"
config :my_app, Repo,
  url: "postgres://postgres:postgres@localhost/ecto_simple"
export ERL_AFLAGS="-kernel shell_history enabled"
alias MyApp.Contexts.Authentication.User
defmodule Mix.Tasks.Foo do
  @moduledoc false
  use Mix.Task

  def run(_args) do
    Application.ensure_all_started(:my_app)
    IO.puts("runnning...")
  end
end
defmodule MyApp.MixProject do
  use Mix.Project

  def project() do
    [
      app: :my_app,
      version: "0.0.1",
      elixir: "~> 1.0",
      deps: deps(),
    ]
  end

  def application() do
    []
  end

  defp deps() do
    [
      {:ecto, "~> 2.0"},
      {:postgrex, "~> 0.8.1"},
      {:ecto_sql, path: "ecto_sql_local_path"}
    ]
  end
end
defmodule Recompiler do
  def run do
    modules_to_recompile = [
      Ecto.Migrator,
      Ecto.SomeOtherModule
    ]

    for module <- modules_to_recompile do
      IEx.Helpers.r(module)
    end
  end
end
export VIRTUAL_ENV=/Users/erick/.virtualenvs/demo
export PATH=/Users/erick/.virtualenvs/demo/bin:$PATH
def incr(n):
    def aux(x):
        return x + n

    return aux

inc5 = incr(5)

print(inc5(10))  # -->15

def count():
    num = 0

    def aux():
        num += 1
        return num

    return aux

c1 = count()

c1()  # --> 1
c1()  # --> 2
c1()  # --> 3

def count():
    num = 0

    def aux():
        nonlocal num
        num += 1
        return num

    return aux

def count():
    num = [0]

    def aux():
        num[0] += 1
        return num[0]

    return aux

def count():
    num = 0
    while True:
        num += 1
        yield num

c1 = count()
next(c1)  # --> 1
next(c1)  # --> 2

c1 = count()
c2 = count()

next(c1)  # -->1
next(c1)  # -->2
next(c2)  # -->1
next(c2)  # -->2
next(c1)  # -->3

class Count(object):
    def __init__(self):
        self.num = 0

    def __call__(self):
        self.num += 1
        return self.num

c1 = Count()
c1()  # -->1
c1()  # -->2
c1()  # -->3

def recorr(lista, maximo):
    total = 0
    for i in lista:
        if i % 2 != 0:
            if total + i < maximo:
                total += i
                yield i
            else:
                break

recorr([3, 6, 7, 8, 11, 23], 30) #-->[3,7,11]

class RecorrFunc(object):
    def __init__(self, maximo):
        self.maximo = maximo
        self.total = 0

    def filter(self, item):
        res = item % 2 != 0 and self.total + item < self.maximo
        if res:
            self.total += item
        return res

    def __call__(self, lista):
        return [x for x in lista if self.filter(x)]

recorr = RecorrFunc(30)
recorr([3, 6, 7, 8, 11, 23])  # -->[3,7,11]
print(recorr.total)  # -->21

    i = 1
    add_one = lambda x: x + i

    lista1 = [add_one(i) for i in [0, 1, 2]]

    i = 0
    lista2 = [add_one(i) for i in [0, 1, 2]]

    i = 2
    lista3 = [add_one(i + 1) for i in [0, 1, 2]]

  i = 1
  add_one = lambda x, i=i: x + i

  add_one = lambda x, i=1: x + i

(defun mu-project-find-refs ()
  "Use `project-find-regexp' to search for thing at point."
  (interactive)
  (if-let (tap (thing-at-point 'symbol))
      (project-find-regexp tap)
    (message "Nothing at point to search for")))

(defun mu-embark-live-occur-after-input ()
  "Ensure only `embark-live-occur-after-input' is active."
  (remove-hook 'minibuffer-setup-hook #'embark-live-occur-after-delay)
  (add-hook 'minibuffer-setup-hook #'embark-live-occur-after-input))

(defun mu-project-find-refs ()
  "Use `project-find-regexp' to search for thing at point."
  (interactive)
  (if-let (tap (thing-at-point 'symbol))
      (project-find-regexp tap)
    (message "Nothing at point to search for")))

(defun mu-embark-live-occur-after-input ()
  "Ensure only `embark-live-occur-after-input' is active."
  (remove-hook 'minibuffer-setup-hook #'embark-live-occur-after-delay)
  (add-hook 'minibuffer-setup-hook #'embark-live-occur-after-input))

[code]sudo nano /etc/pulse/default.pa[/code]
[code]### Modules to allow autoloading of filters (such as echo cancellation)
### on demand. module-filter-heuristics tries to determine what filters
### make sense, and module-filter-apply does the heavy-lifting of
### loading modules and rerouting streams.
load-module module-filter-heuristics
load-module module-filter-apply[/code]
[code]### Modules to allow autoloading of filters (such as echo cancellation)
### on demand. module-filter-heuristics tries to determine what filters
### make sense, and module-filter-apply does the heavy-lifting of
### loading modules and rerouting streams.
load-module module-filter-heuristics
load-module module-filter-apply
load-module module-echo-cancel[/code]
[code]pulseaudio -k[/code]
[code]lspci |grep -E "VGA|3D"[/code]
[code]01:00.0 VGA compatible controller: NVIDIA Corporation TU106 [GeForce RTX 2060 Rev. A] (rev a1)[/code]
[code]chmod +x /Descargas/NVIDIA-Linux-*.run[/code]
su -

## O ##

sudo -i
[code]dnf update[/code]
reboot
dnf install kernel-devel kernel-headers gcc make dkms acpid libglvnd-glx libglvnd-opengl libglvnd-devel pkgconfig
[code]echo "blacklist nouveau" >> /etc/modprobe.d/blacklist.conf[/code]
## Fedora 34 BTRFS ##

GRUB_CMDLINE_LINUX="rhgb quiet rd.driver.blacklist=nouveau"

## O CON LVM ##

GRUB_CMDLINE_LINUX="rd.lvm.lv=fedora/swap rd.lvm.lv=fedora/root rhgb quiet rd.driver.blacklist=nouveau"
## BIOS y UEFI ##

grub2-mkconfig -o /boot/grub2/grub.cfg

[code]dnf remove xorg-x11-drv-nouveau[/code]
## Copia de seguridad antigua imagen nouveau ##

mv /boot/initramfs-$(uname -r).img /boot/initramfs-$(uname -r)-nouveau.img"

## Crear nueva imagen initramfs ##

dracut /boot/initramfs-$(uname -r).img $(uname -r)"

systemctl set-default multi-user.target

reboot

su -

## O ##

sudo -i
./NVIDIA-Linux-*.run

## O ruta completa ##

/home/usuario/Descargas/NVIDIA-Linux-x86_64-xxx.xxx.xx.run
systemctl set-default graphical.target

reboot
[code]sudo dnf install vdpauinfo libva-vdpau-driver libva-utils[/code]
[code]sudo dnf versionlock delete kernel-x.x.xx-xx.xxx[/code]
(defun mu-flymake-mode-activate ()
  "Activate `flymake-mode' only in my projects."
  (project--ensure-read-project-list)
  (let ((known-projects (project-known-project-roots))
        (pr (or (locate-dominating-file "." ".git")
                default-directory)))
    (if (and (eq buffer-read-only nil)
             (member pr known-projects))
        (flymake-mode +1)
      (flymake-mode -1))))

(defun mu-flymake-mode-activate ()
  "Activate `flymake-mode' only in my projects."
  (project--ensure-read-project-list)
  (let ((known-projects (project-known-project-roots))
        (pr (or (locate-dominating-file "." ".git")
                default-directory)))
    (if (and (eq buffer-read-only nil)
             (member pr known-projects))
        (flymake-mode +1)
      (flymake-mode -1))))

(cl-defmethod project-root ((project (head local)))
  (cdr project))

(defun mu--project-files-in-directory (dir)
  "Use `fd' to list files in DIR."
  (let* ((default-directory dir)
         (localdir (file-local-name (expand-file-name dir)))
         (command (format "fd -t f -0 . %s" localdir)))
    (project--remote-file-names
     (sort (split-string (shell-command-to-string command) "\0" t)
           #'string<))))

(cl-defmethod project-files ((project (head local)) &optional dirs)
  "Override `project-files' to use `fd' in local projects."
  (mapcan #'mu--project-files-in-directory
          (or dirs (list (project-root project)))))

(defun mu-project-try-local (dir)
  "Determine if DIR is a non-Git project.
DIR must include a .project file to be considered a project."
  (let ((root (locate-dominating-file dir ".project")))
    (and root (cons 'local root))))

(defun mu--backend (dir)
  "Check if DIR is under Git, otherwise return nil."
  (when (locate-dominating-file dir ".git")
    'Git))

(defun mu-project-try-vc (dir)
  "Determine if DIR is a project.
This is a thin variant of `project-try-vc':
- It takes only Git into consideration
- It does not check for submodules"
  (let* ((backend (mu--backend dir))
         (root
          (when (eq backend 'Git)
            (or (vc-file-getprop dir 'project-git-root)
                (let ((root (vc-call-backend backend 'root dir)))
                  (vc-file-setprop dir 'project-git-root root))))))
    (and root (cons 'vc root))))

(cl-defmethod project-root ((project (head local)))
  (cdr project))

(defun mu--project-files-in-directory (dir)
  "Use `fd' to list files in DIR."
  (let* ((default-directory dir)
         (localdir (file-local-name (expand-file-name dir)))
         (command (format "fd -t f -0 . %s" localdir)))
    (project--remote-file-names
     (sort (split-string (shell-command-to-string command) "\0" t)
           #'string<))))

(cl-defmethod project-files ((project (head local)) &optional dirs)
  "Override `project-files' to use `fd' in local projects."
  (mapcan #'mu--project-files-in-directory
          (or dirs (list (project-root project)))))

(defun mu-project-try-local (dir)
  "Determine if DIR is a non-Git project.
DIR must include a .project file to be considered a project."
  (let ((root (locate-dominating-file dir ".project")))
    (and root (cons 'local root))))

(defun mu--backend (dir)
  "Check if DIR is under Git, otherwise return nil."
  (when (locate-dominating-file dir ".git")
    'Git))

(defun mu-project-try-vc (dir)
  "Determine if DIR is a project.
This is a thin variant of `project-try-vc':
- It takes only Git into consideration
- It does not check for submodules"
  (let* ((backend (mu--backend dir))
         (root
          (when (eq backend 'Git)
            (or (vc-file-getprop dir 'project-git-root)
                (let ((root (vc-call-backend backend 'root dir)))
                  (vc-file-setprop dir 'project-git-root root))))))
    (and root (cons 'vc root))))

(defun mu--cider-repl-regex (type)
  "Return the regexp to get the CIDER REPL based on TYPE."
  (if (eq type 'clj)
      "\`*cider-repl .*clj[*]"
    "\`*cider-repl .*cljs"))

(defun mu--cider-repl-buffer-name (type)
  "Get buffer from `buffer-list' according to TYPE."
  (let ((regex (mu--cider-repl-regex type)))
    (car (seq-filter (lambda (s) (string-match-p regex s))
                     (mapcar #'buffer-name (buffer-list))))))

(defun mu-cider-switch-to-repl (&optional type)
  "Open a CIDER REPL for TYPE.
If TYPE is not passed, open a Clojure REPL."
  (interactive "P")
  (let ((type (or type 'clj)))
    (if-let (buffer (mu--cider-repl-buffer-name type))
        (pop-to-buffer buffer)
      (message "No CIDER REPL available"))))

(defun mu-cider-switch-to-cljs-repl ()
  "Open a CIDER REPL for ClojureScript."
  (interactive)
  (mu-cider-switch-to-repl 'cljs))

(defun mu--cider-session-by-type (type)
  "Return the current CIDER session by TYPE."
  (let* ((regex (mu--cider-repl-regex type))
         (system (sesman--system))
         (sessions (sesman-current-sessions system '(buffer))))
    (car
     (seq-filter (lambda (s)
                   (string-match-p regex (buffer-name (cadr s))))
                 sessions))))

(defun mu--cider-load-buffer (session)
  "Load the current buffer according to SESSION."
  (if session
      (let ((system (sesman--system))
            (buf (current-buffer)))
        (sesman--clear-links)
        (sesman-link-session system session 'buffer buf)
        (cider-load-buffer buf))
    (message "No CIDER REPL available")))

(defun mu-cider-load-clj-buffer ()
  "Load the current Clojure buffer."
  (interactive)
  (mu--cider-load-buffer (mu--cider-session-by-type 'clj)))

(defun mu-cider-load-cljc-buffer ()
  "Load the current ClojureC buffer."
  (interactive)
  (let ((clj-session (mu--cider-session-by-type 'clj))
        (cljs-session (mu--cider-session-by-type 'cljs)))
    (if (and (null clj-session)
             (null cljs-session))
        (message "No CIDER REPL available")
      (when clj-session
        (mu--cider-load-buffer clj-session))
      (when cljs-session
        (mu--cider-load-buffer cljs-session)))))

(defun mu-cider-load-cljs-buffer ()
  "Load the current ClojureScript buffer."
  (interactive)
  (mu--cider-load-buffer (mu--cider-session-by-type 'cljs)))

(defun mu--cider-repl-regex (type)
  "Return the regexp to get the CIDER REPL based on TYPE."
  (if (eq type 'clj)
      "\`*cider-repl .*clj[*]"
    "\`*cider-repl .*cljs"))

(defun mu--cider-repl-buffer-name (type)
  "Get buffer from `buffer-list' according to TYPE."
  (let ((regex (mu--cider-repl-regex type)))
    (car (seq-filter (lambda (s) (string-match-p regex s))
                     (mapcar #'buffer-name (buffer-list))))))

(defun mu-cider-switch-to-repl (&optional type)
  "Open a CIDER REPL for TYPE.
If TYPE is not passed, open a Clojure REPL."
  (interactive "P")
  (let ((type (or type 'clj)))
    (if-let (buffer (mu--cider-repl-buffer-name type))
        (pop-to-buffer buffer)
      (message "No CIDER REPL available"))))

(defun mu-cider-switch-to-cljs-repl ()
  "Open a CIDER REPL for ClojureScript."
  (interactive)
  (mu-cider-switch-to-repl 'cljs))

(defun mu--cider-session-by-type (type)
  "Return the current CIDER session by TYPE."
  (let* ((regex (mu--cider-repl-regex type))
         (system (sesman--system))
         (sessions (sesman-current-sessions system '(buffer))))
    (car
     (seq-filter (lambda (s)
                   (string-match-p regex (buffer-name (cadr s))))
                 sessions))))

(defun mu--cider-load-buffer (session)
  "Load the current buffer according to SESSION."
  (if session
      (let ((system (sesman--system))
            (buf (current-buffer)))
        (sesman--clear-links)
        (sesman-link-session system session 'buffer buf)
        (cider-load-buffer buf))
    (message "No CIDER REPL available")))

(defun mu-cider-load-clj-buffer ()
  "Load the current Clojure buffer."
  (interactive)
  (mu--cider-load-buffer (mu--cider-session-by-type 'clj)))

(defun mu-cider-load-cljc-buffer ()
  "Load the current ClojureC buffer."
  (interactive)
  (let ((clj-session (mu--cider-session-by-type 'clj))
        (cljs-session (mu--cider-session-by-type 'cljs)))
    (if (and (null clj-session)
             (null cljs-session))
        (message "No CIDER REPL available")
      (when clj-session
        (mu--cider-load-buffer clj-session))
      (when cljs-session
        (mu--cider-load-buffer cljs-session)))))

(defun mu-cider-load-cljs-buffer ()
  "Load the current ClojureScript buffer."
  (interactive)
  (mu--cider-load-buffer (mu--cider-session-by-type 'cljs)))

-#!/usr/bin/perl -w
+#!/usr/local/bin/perl -w

<?xml version="1.0"?>
<!DOCTYPE tsung SYSTEM "/usr/local/Cellar/tsung/1.7.0/share/tsung/tsung-1.0.dtd">
<tsung loglevel="notice" version="1.0">
  <clients>
    <client host="localhost" use_controller_vm="true"/>
  </clients>

  <servers>
    <server host="localhost" port="4000" type="tcp"></server>
  </servers>

  <load>
    <arrivalphase phase="1" duration="10" unit="minute">
      <users arrivalrate="10" unit="second"></users>
    </arrivalphase>
    <arrivalphase phase="2" duration="5" unit="minute">
      <users arrivalrate="20" unit="second"></users>
    </arrivalphase>
  </load>

  <sessions>
    <session name="http-example" probability="100" type="ts_http">
      <request> <http url="/" method="GET" version="1.1"></http> </request>
      <request> <http url="/ping" method="GET" version="1.1"></http> </request>
      <request> <http url="/users" method="GET" version="1.1"></http> </request>
      <request> <http url="/users" method="POST" contents_from_file="payload.json" content_type="application/json" version="1.1"></http> </request>
    </session>
  </sessions>
</tsung>
<!DOCTYPE tsung SYSTEM "/usr/local/Cellar/tsung/1.7.0/share/tsung/tsung-1.0.dtd">
<clients>
  <client host="localhost" use_controller_vm="true"/>
</clients>
<servers>
  <server host="localhost" port="4000" type="tcp"></server>
</servers>
<load>
  <arrivalphase phase="1" duration="10" unit="minute">
    <users arrivalrate="10" unit="second"></users>
  </arrivalphase>

  <arrivalphase phase="2" duration="10" unit="minute">
    <users arrivalrate="20" unit="second"></users>
  </arrivalphase>
</load>
<sessions>
  <session name="http-example" probability="100" type="ts_http">
    <request> <http url="/" method="GET" version="1.1"></http> </request>
    <request> <http url="/ping" method="GET" version="1.1"></http> </request>
    <request> <http url="/users" method="GET" version="1.1"></http> </request>
    <request> <http url="/users" method="POST" contents_from_file="payload.json" content_type="application/json" version="1.1"></http> </request>
  </session>
</sessions>
{
  "name": "tsung",
  "email": "demo@demo.com"
}
tsung -f demo.xml start
Starting Tsung
Log directory is: /Users/erick/.tsung/log/20201004-1229
/usr/local/lib/tsung/bin/tsung_stats.pl
1 - The Lisp Condition System - phoe
2 - Implementing a blockchain in Lisp - F. Drummer

products = firstquery()
for word in words:
    products = products.objects.filter(Q(title__icontains=word) |
                                       Q(authors__name__icontains=word))\
                               .distinct()

       SELECT DISTINCT ... FROM "product" LEFT OUTER JOIN ...
       WHERE
       (("product"."title" LIKE %hommes% ESCAPE '\'
         OR "author"."name" LIKE %hommes% ESCAPE '\')
        AND
         ("product"."title" LIKE %femmes% ESCAPE '\'
         OR T5."name" LIKE %femmes% ESCAPE '\'))
       ORDER BY "product"."created" DESC
       LIMIT 3

   title like keyword 1 OR author like keyword 1
AND
   title like keyword 2 OR author like keyword 2

(defun find-product (&key query (order :asc))
  (mito:select-dao 'product
    (when query
      (sxql:where (:or (:like :title (str:concat "%" query "%"))
                       (:like :authors (str:concat "%" query "%")))))
    (sxql:order-by `(,order :created-at))))

(:AND
 (:OR (:LIKE :TITLE "%word1%")
      (:LIKE :AUTHORS "%word1%"))
 (:OR (:LIKE :TITLE "%word2%")
      (:LIKE :AUTHORS "%word2%")))

(sxql:where
 `(:and   ;; <-- backquote
   ,@(loop for word in (str:words query)  ;; <-- comma-splice
        :collect `(:or (:like :title ,(str:concat "%" word "%"))  ;; <-- backquote, comma
                       (:like :authors ,(str:concat "%" word "%"))))))

git config --global user.name "name and last name"
git config --global user.email "work-or-personal-email"
# If applied, this commit will...

# Explain why this change is being made

# Provide links to any relevant tickets, articles or other resources
[commit]
	template = ~/.git_commit_message.txt
((:|id| integer)
 :|title|
 :|cover|
 :|isbn|
 :|price|
 :|author|
 :|publisher|
 :|date_publication|
 :|date-publication|
 :|shelf|
 :|shelf_id|
 :|details-url|
 :|summary|
 :|quantity|
 :|repr|
 :|repr2|)

[…]

title: Programming Algorithms
author: Vsevolod Domkin
cover: https://d2sofvawe08yqg.cloudfront.net/progalgs/hero?1586867024
details-url: https://leanpub.com/progalgs
shelf: programming
shelf_id: 99
publisher: Leanpub
price: 15
likes: 5

title: Cats
author: mother cat
cover: https://gitlab.com/abstock/abstock.gitlab.io/-/raw/master/logo.png
details-url: https://gitlab.com/abstock/abstock.gitlab.io/-/blob/master/logo.png
shelf: nature
shelf_id: 98
publisher: nature
price: 5
likes: 100

title: Screwdriver
author:
cover: https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Ftse1.mm.bing.net%2Fth%3Fid%3DOIP.jGOb7dVL1oA9VDzNVPDPpwAAAA%26pid%3DApi&f=1
details-url:
shelf: craftmanship
shelf_id: 97
publisher:
price: 10
likes: 1

function pod_shell {
    local namespace=`kubectl get ns | sed 1d | awk '{print $1}' | fzf`
    local pod=`kubectl get pods -n $namespace | sed 1d | awk '{print $1}' | fzf`
    echo "Connecting to $pod"

    if [ -z $1 ]
    then
        kubectl -n $namespace exec -ti $pod bash
    else
        kubectl -n $namespace exec -ti $pod $1
    fi
}
function pod_proxy {
    local namespace=`kubectl get ns | sed 1d | awk '{print $1}' | fzf`
    local pod=`kubectl get pods -n $namespace | sed 1d | awk '{print $1}' | fzf`
    local port_mapping
    echo "Enter port mapping using the form local_port:pod_port"
    read port_mapping
    echo "Setting up proxy to $pod on $port_mapping..."

    kubectl port-forward -n $namespace $pod $port_mapping
}
function pod_logs {
    local namespace=`kubectl get ns | sed 1d | awk '{print $1}' | fzf`
    local pod=`kubectl get pods -n $namespace | sed 1d | awk '{print $1}' | fzf`
    echo "Showing logs for $pod"

    kubectl -n $namespace logs -f $pod
}
function k8s_change_context {
    local context=`kubectl config get-contexts --output='name' | fzf`
    echo "Changing to $context"
    kubectl config use-context $context
}
(defvar my/org-src-block-tmp-window-configuration nil)

(defun my/org-edit-special (&optional arg)
  "Save current window configuration before a org-edit buffer is open."
  (setq my/org-src-block-tmp-window-configuration (current-window-configuration)))

(defun my/org-edit-src-exit ()
  "Restore the window configuration that was saved before org-edit-special was called."
  (set-window-configuration my/org-src-block-tmp-window-configuration))
(eval-after-load "org"
  `(progn
     (advice-add 'org-edit-special :before 'my/org-edit-special)
     (advice-add 'org-edit-src-exit :after 'my/org-edit-src-exit)))
(defvar my/org-src-block-tmp-window-configuration nil)

(defun my/org-edit-special (&optional arg)
  "Save current window configuration before a org-edit buffer is open."
  (setq my/org-src-block-tmp-window-configuration (current-window-configuration)))

(defun my/org-edit-src-exit ()
  "Restore the window configuration that was saved before org-edit-special was called."
  (set-window-configuration my/org-src-block-tmp-window-configuration))

(eval-after-load "org"
  `(progn
     (advice-add 'org-edit-special :before 'my/org-edit-special)
     (advice-add 'org-edit-src-exit :after 'my/org-edit-src-exit)))
* rlwrap sbcl --load run.lisp

This is SBCL 1.4.5.debian, an implementation of ANSI Common Lisp.
re information about SBCL is available at <http://www.sbcl.org/>.
[…]
; Loading "web-live-reload"
..................................................
Starting the web server on port 7890
Ready. You can access the application!
*

* (in-package :web-live-reload)
* (setf *config*
    '((:key "Name"
       :val "James")
      (:key "phone"
       :val "0098 007")
      (:key "secret language?"
       :val "Lisp")))

class MiComponente extends React.Component{

    constructor(props){
        super(props);
        this.state = {nombre: ''};
    }

    handleChange = e =>{
        this.setState({nombre: e.target.value});
    }

    render(){
        return(
            <input onChange={this.handleChange()} value={this.state.nombre} />
        );
    }
}

import {React, useState} from 'react';

function MiComponente(props){
    const [nombre, setNombre] = useState('');

    function handleChange(e){
        setNombre(e.target.value);
    }

    return(
        <input onChange={handleChange()} value={nombre} />
    );
}

    {% extends "base.html" %}
    {% block title %}Memberlist{% endblock %}
    {% block content %}
      <ul>
      {% for user in users %}
        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
      {% endfor %}
      </ul>
    {% endblock %}

(def-filter :myfilter-name (value arg)
  (body))

(def-filter :capfirst (val)
  (string-capitalize (princ-to-string val)))

(def-filter :add (it n)
  (+ it (parse-integer n)))

(def-filter :datetime (it &optional format)
  (let ((timestamp …))))

    (def-filter :replace (it regex)
       (lambda (replace)
         (ppcre:regex-replace-all regex it replace)))

    (def-filter :with (it replace)
       (funcall it replace))

{{ value | replace:foo | with:bar }}

(def-filter :handle-error-filter (it)
   (handler-case
         (do-something)
     (condition (e)
       (template-error "There was an error executing this filter: ~A" e))))

buttons, progressbar, image selector, (collapsable) tree, list, grid, range, slider, color picker,
date-picker

(ql-dist:install-dist "http://bodge.borodust.org/dist/org.borodust.bodge.txt" :replace t :prompt nil)

;; (cl:pushnew :bodge-gl2 cl:*features*)

(ql:quickload :bodge-ui-window)

(ql:quickload :bodge-ui-window/examples)
(bodge-ui-window.example.basic:run)

(cl:defpackage :bodge-ui-window-test
  (:use :cl :bodge-ui :bodge-host))
(in-package :bodge-ui-window-test)

(defpanel (main-panel
            (:title "Hello Bodge UI")
            (:origin 200 50)
            (:width 400) (:height 400)
            (:options :movable :resizable
                      :minimizable :scrollable
                      :closable))
  (label :text "Nested widgets:")
  (horizontal-layout
   (radio-group
    (radio :label "Option 1")
    (radio :label "Option 2" :activated t))
   (vertical-layout
    (check-box :label "Check 1" :width 100)
    (check-box :label "Check 2"))
   (vertical-layout
    (label :text "Awesomely" :align :left)
    (label :text "Stacked" :align :centered)
    (label :text "Labels" :align :right)))
  (label :text "Expand by width:")
  (horizontal-layout
   (button :label "Dynamic")
   (button :label "Min-Width" :width 80)
   (button :label "Fixed-Width" :expandable nil :width 100))
  )

(defun run ()
  (bodge-host:open-window (make-instance 'main-window)))

(run)

:on-click
:on-hover
:on-leave
:on-change
:on-mouse-press
:on-mouse-release

Radio, Tabs, FlatTabs, ScrollBox, DetachBox,
Button, FlatButton, DropButton, Calendar, Canvas, Colorbar, ColorBrowser, DatePick, Dial, Gauge, Label, FlatLabel,
FlatSeparator, Link, List, FlatList, ProgressBar, Spin, Text, Toggle, Tree, Val,
listDialog, Alarm, Color, Message, Font, Scintilla, file-dialog…
Cells, Matrix, MatrixEx, MatrixList,
GLCanvas, Plot, MglPlot, OleControl, WebBrowser (WebKit/Gtk+)…
drag-and-drop

(ql:quickload :iup)

(defpackage :test-iup
  (:use :cl))
(in-package :test-iup)

(defun hello ()
  (iup:with-iup ()
    (let* ((label (iup:label :title (format nil "Hello, World!~%IUP ~A~%~A ~A"
                                            (iup:version)
                                            (lisp-implementation-type)
                                            (lisp-implementation-version))))
           (dialog (iup:dialog label :title "Hello, World!")))
      (iup:show dialog)
      (iup:main-loop))))
(hello)

(defun run-gui-function ()
  #-sbcl (gui-function)
  #+sbcl
  (sb-int:with-float-traps-masked
      (:divide-by-zero :invalid)
    (gui-function)))

(iup:button :title "Test &1"
            :expand :yes
            :tip "Callback inline at control creation"
            :action (lambda (handle)
                      (iup:message "title" "button1's action callback")
                      iup:+default+))

(defun click-button ()
  (iup:with-iup ()
    (let* ((label (iup:label :title (format nil "Hello, World!~%IUP ~A~%~A ~A"
                                            (iup:version)
                                            (lisp-implementation-type)
                                            (lisp-implementation-version))))
           (button (iup:button :title "Click me"
                               :expand :yes
                               :tip "yes, click me"
                               :action (lambda (handle)
                                         (declare (ignorable handle))
                                         (iup:message "title" "button clicked")
                                         iup:+default+)))
           (vbox
            (iup:vbox (list label button)
                      :gap "10"
                      :margin "10x10"
                      :alignment :acenter))
           (dialog (iup:dialog vbox :title "Hello, World!")))
      (iup:show dialog)
      (iup:main-loop))))

#+sbcl
(sb-int:with-float-traps-masked
      (:divide-by-zero :invalid)
    (click-button))

(defun counter ()
  (iup:with-iup ()
    (let* ((counter (iup:label :title 0))
           (label (iup:label :title (format nil "The button was clicked ~a time(s)."
                                            (iup:attribute counter :title))))
           (button (iup:button :title "Click me"
                               :expand :yes
                               :tip "yes, click me"
                               :action (lambda (handle)
                                         (declare (ignorable handle))
                                         (setf (iup:attribute counter :title)
                                               (1+ (iup:attribute counter :title 'number)))
                                         (setf (iup:attribute label :title)
                                               (format nil "The button was clicked ~a times."
                                                       (iup:attribute counter :title)))
                                         iup:+default+)))
           (vbox
            (iup:vbox (list label button)
                      :gap "10"
                      :margin "10x10"
                      :alignment :acenter))
           (dialog (iup:dialog vbox :title "Counter")))
      (iup:show dialog)
      (iup:main-loop))))

(defun run-counter ()
  #-sbcl
  (counter)
  #+sbcl
  (sb-int:with-float-traps-masked
      (:divide-by-zero :invalid)
    (counter)))

(defun list-test ()
  (iup:with-iup ()
    (let*  ((list-1 (iup:list :tip "List 1"  ;; tooltip
                              ;; multiple selection
                              :multiple :yes
                              :expand :yes))
            (list-2 (iup:list :value 2   ;; default index of the selected row
                              :tip "List 2" :expand :yes))
            (list-3 (iup:list :value 9 :tip "List 3" :expand :yes))
            (frame (iup:frame
                    (iup:hbox
                     (progn
                       ;; populate the lists: display integers.
                       (loop for i from 1 upto 10
                          do (setf (iup:attribute list-1 i)
                                   (format nil "~A" i))
                          do (setf (iup:attribute list-2 i)
                                   (format nil "~A" (+ i 10)))
                          do (setf (iup:attribute list-3 i)
                                   (format nil "~A" (+ i 50))))
                       ;; hbox wants a list of widgets.
                       (list list-1 list-2 list-3)))
                    :title "IUP List"))
            (dialog (iup:dialog frame :menu "menu" :title "List example")))

      (iup:map dialog)
      (iup:show dialog)
      (iup:main-loop))))

(defun run-list-test ()
  #-sbcl (hello)
  #+sbcl
  (sb-int:with-float-traps-masked
      (:divide-by-zero :invalid)
    (list-test)))

(ql:quickload :cl-cffi-gtk)

(defpackage :gtk-tutorial
  (:use :gtk :gdk :gdk-pixbuf :gobject
   :glib :gio :pango :cairo :common-lisp))

(in-package :gtk-tutorial)

(gtk-label-new)
(gtk-button-new-with-label "Label")

(let ((box (make-instance 'gtk-box :orientation :horizontal :spacing 6))) ...)

(gtk-box-pack-start box mybutton-1)

(gtk-container-add window box)

(gtk-widget-show-all window)

(g-signal-connect window "destroy"
  (lambda (widget)
    (declare (ignore widget))
    (leave-gtk-main)))

(g-signal-connect button "clicked"
  (lambda (widget)
    (declare (ignore widget))
    (format t "Button was pressed.~%")))

(defun hello-world ()
  ;; in the docs, this is example-upgraded-hello-world-2.
  (within-main-loop
    (let ((window (make-instance 'gtk-window
                                 :type :toplevel
                                 :title "Hello Buttons"
                                 :default-width 250
                                 :default-height 75
                                 :border-width 12))
          (box (make-instance 'gtk-box
                              :orientation :horizontal
                              :spacing 6)))
      (g-signal-connect window "destroy"
                        (lambda (widget)
                          (declare (ignore widget))
                          (leave-gtk-main)))
      (let ((button (gtk-button-new-with-label "Button 1")))
        (g-signal-connect button "clicked"
                          (lambda (widget)
                            (declare (ignore widget))
                            (format t "Button 1 was pressed.~%")))
        (gtk-box-pack-start box button))
      (let ((button (gtk-button-new-with-label "Button 2")))
        (g-signal-connect button "clicked"
                          (lambda (widget)
                            (declare (ignore widget))
                            (format t "Button 2 was pressed.~%")))
        (gtk-box-pack-start box button))
      (gtk-container-add window box)
      (gtk-widget-show-all window))))

(ql:quickload '(:qtools :qtcore :qtgui))

(defpackage #:qtools-test
  (:use #:cl+qt)
  (:export #:main))
(in-package :qtools-test)
(in-readtable :qtools)

(define-widget main-window (QWidget)
  ())

(define-subwidget (main-window name) (q+:make-qlineedit main-window)
  (setf (q+:placeholder-text name) "Your name please."))

(define-subwidget (main-window go-button) (q+:make-qpushbutton "Go!" main-window))

(define-subwidget (main-window layout) (q+:make-qhboxlayout main-window)
  (q+:add-widget layout name)
  (q+:add-widget layout go-button))

(with-main-window
  (window 'main-window))

(define-slot (main-window go-button) ()
  (declare (connected go-button (pressed)))
  (declare (connected name (return-pressed)))
  (q+:qmessagebox-information main-window
                              "Greetings"  ;; title
                              (format NIL "Good day to you, ~a!" (q+:text name))))

(with-main-window (window 'main-window))

(define-signal (main-window name-set) (string))

(define-slot (main-window go-button) ()
  (declare (connected go-button (pressed)))
  (declare (connected name (return-pressed)))
  (signal! main-window (name-set string) (q+:text name)))

(define-slot (main-window name-set) ((new-name string))
  (declare (connected main-window (name-set string)))
  (q+:qmessagebox-information main-window "Greetings" (format NIL "Good day to you, ~a!" new-name)))

(with-main-window (window 'main-window))

Button Canvas Check-button Entry Frame Label Labelframe Listbox
Menu Menubutton Message
Paned-window
Radio-button Scale
Scrollbar Spinbox Text
Toplevel Widget Canvas

Ltk-megawidgets:
    progress
    history-entry
    menu-entry

treelist tooltip searchable-listbox date-picker calendar autocomplete-listbox
password-entry progress-bar-star notify-window
dot-plot bar-chart equalizer-bar
swap-list

(ql:quickload :ltk)
(in-package :ltk-user)

(make-instance 'button)
(make-instance 'treeview)

(with-ltk ()
  (let ((frame (make-instance 'frame)))
    …))

(with-ltk ()
  (let ((button (make-instance 'button :text "hello")))
    (grid button 0 0)))

(make-instance 'button
  :text "Hello"
  :command (lambda ()
             (format t "clicked")))

(ql:quickload :nodgui)
(nodgui.demo:demo)

(defun fibonacci (n &aux (f0 0) (f1 1))
  "docstring"
  (case n
    (0 f0)
    (1 f1)

    (t (loop for n from 2 to n
          for a = f0 then b and b = f1 then result
          for result = (+ a b)
          finally (return result)))))

(swank:create-server :dont-close t)

(setf erudite::*swank-port* 4005)

(erudite:erudite #p"literal.md" "literal-erudite.lisp" :output-type :markdown)

(ql:quickload :cl-inotify)

(bt:make-thread
 (lambda ()
   (cl-inotify:with-inotify (inotify t ("literal-erudite.lisp" :close-write))
     (cl-inotify:do-events (event inotify :blocking-p t)
       (format t "~a~&" event)
       (erudite:erudite #p"literal.md" "literal-erudite.lisp" :output-type :markdown))))
 :name "inotify-erudite")

(setq2 x y (+ z 3))

(setq2 v1 v2 e)

(progn
  (setq v1 e)
  (setq v2 e))

(defmacro setq2 (v1 v2 e)
  (list 'progn (list 'setq v1 e) (list 'setq v2 e)))

(defparameter v1 1)
(defparameter v2 2)
(setq2 v1 v2 3)
;; 3

(macroexpand '(setq2 v1 v2 3))
;; (PROGN (SETQ V1 3) (SETQ V2 3))
;; T

(macroexpand '(setq2 v1 v2 (+ z 3)))
;; (PROGN (SETQ V1 (+ z 3)) (SETQ V2 (+ z 3)))
;; T

[|](setq2 v1 v2 3)
;^ cursor
; C-c M-m
; =>
; (PROGN (SETQ V1 3) (SETQ V2 3))

(defun setq2-function (v1 v2 e)
  (list 'progn (list 'setq v1 e) (list 'setq v2 e)))

(progn (setq x (+ z 3)) (setq y (+ z 3)))

(defmacro setq2 (v1 v2 e)
  (let ((e1 (some-computation e)))
    (list 'progn (list 'setq v1 e1) (list 'setq v2 e1))))

(defmacro some-computation (exp) ...) ;; _Wrong!_

(defmacro setq2 (v1 v2 e)
  (let ((e1 (some-computation e)))
    (list 'progn (list 'setq v1 e1) (list 'setq v2 e1))))

(defun some-computation (exp) ...) ;; _Right!_

(defmacro foo (x &optional y &key (cxt 'null)) ...)

(defmacro setq-reversible (e1 e2 direction)
  (case direction
    (:normal (list 'setq e1 e2))
    (:backward (list 'setq e2 e1))
    (t (error "Unknown direction: ~a" direction))))

(macroexpand '(setq-reversible x y :normal))
(SETQ X Y)
T
(macroexpand '(setq-reversible x y :backward))
(SETQ Y X)
T

(macroexpand '(setq-reversible x y :other-way-around))

(defmacro setq-reversible (v1 v2 direction)
  (case direction
    (:normal (list 'setq v1 v2))
    (:backward (list 'setq v2 v1))
    (t `(error "Unknown direction: ~a" ,direction))))
    ;; ^^ backquote                    ^^ comma: get the value inside the backquote.

(macroexpand '(SETQ-REVERSIBLE v1 v2 :other-way-around))
;; (ERROR "Unknown direction: ~a" :OTHER-WAY-AROUND)
;; T

  `(progn (setq ,v1 ,e) (setq ,v2 ,e))
;;^ backquote   ^   ^         ^   ^ commas

`(v1 = ,v1) ;; => (V1 = 3)

(zap ,@v ,v)

(zap oh boy (oh boy))
;;   ^^^^^ elements of v (two elements), spliced.
;;          ^^ v itself (a list)

(defmacro explain-exp (exp)
  `(format t "~S = ~S" ',exp ,exp))
  ;;                   ^^

(explain-exp (+ 2 3))
;; (+ 2 3) = 5

;; Defmacro with no quote at all:
(defmacro explain-exp (exp)
  (format t "~a = ~a" exp exp))
(explain-exp v1)
;; V1 = V1

;; OK, with a backquote and a comma to get the value of exp:
(defmacro explain-exp (exp)
  ;; WRONG example
  `(format t "~a = ~a" exp ,exp))
(explain-exp v1)
;; => error: The variable EXP is unbound.

;; We then must use quote-comma:
(defmacro explain-exp (exp)
  `(format t "~a = ~a" ',exp ,exp))
(explain-exp (+ 1 2))
;; (+ 1 2) = 3

(progn
  (setq x (+ x 2))
  (setq y (+ x 2)))

(macroexpand '(setq2 x y (+ x 2)))
;;(PROGN (SETQ X (+ X 2)) (SETQ Y (+ X 2)))

(defmacro setq2 (v1 v2 e)
  (let ((tempvar (gensym)))
    `(let ((,tempvar ,e))
       (progn (setq ,v1 ,tempvar)
              (setq ,v2 ,tempvar)))))

(let ((#:g2003 (+ x 2)))
  (progn (setq x #:g2003) (setq y #:g2003)))

brew install clojure/tools/clojure
brew upgrade clojure/tools/clojure
[code]sudo apt install htop[/code]
[code]free[/code]
[code]vmstat -s | awk '{print int(($1 / 1024 / 1024)+0.51)}' | head -1[/code]
[code]sudo swapoff -a[/code]
[code]sudo fallocate -l 16g /swapfile[/code]
[code]sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile[/code]
[code]echo '/swapfile swap swap defaults 0 0' | sudo tee -a /etc/fstab[/code]
[code]sudo findmnt -no SOURCE,UUID -T /swapfile[/code]
[code]sudo apt install uswsusp
sudo dpkg-reconfigure -pmedium uswsusp[/code]
[code]sudo update-initramfs -u[/code]
[code]sudo s2disk[/code]
[code]sudo nano /etc/default/grub[/code]
[code]GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=0c233fbb-f72e-470f-8460-4f2521bf3569"[/code]
[code]sudo update-grub[/code]
[code]reboot[/code]
[code]sudo systemctl edit systemd-hibernate.service[/code]
[code][Service]
ExecStart=
ExecStart=/usr/sbin/s2disk 
ExecStartPost=/bin/run-parts -a post /lib/systemd/system-sleep[/code]
[code]systemctl hibernate[/code]
[code]systemctl status systemd-hibernate.service[/code]
[code]sudo nano /etc/polkit-1/localauthority/50-local.d/com.ubuntu.enable-hibernate.pkla[/code]
[code][Re-enable hibernate by default in upower]
Identity=unix-user:*
Action=org.freedesktop.upower.hibernate
ResultActive=yes

[Re-enable hibernate by default in logind]
Identity=unix-user:*
Action=org.freedesktop.login1.hibernate;org.freedesktop.login1.hibernate-multiple-sessions
ResultActive=yes[/code]
$ npm install cors

var express = require('express')
var cors = require('cors')
var app = express()

app.use(cors())

app.get('/products/:id', function (req, res, next) {
  res.json({msg: 'This is CORS-enabled for all origins!'})
})

app.listen(80, function () {
  console.log('CORS-enabled web server listening on port 80')
})

var whitelist = ['http://example1.com', 'http://example2.com']
var corsOptions = {
  origin: function (origin, callback) {
    if (whitelist.indexOf(origin) !== -1) {
      callback(null, true)
    } else {
      callback(new Error('Not allowed by CORS'))
    }
  }
}

...

app.get('/products/:id', cors(corsOptions), function (req, res, next) {
  res.json({msg: 'This is CORS-enabled for a whitelisted domain.'})
})

1 Alice 40 40
2 Bob 39 50

(for-file-lines ("test.txt")
    (with-fields ((a b c d))
        ($print a b c d)))

1 Alice 40 40
2 Bob 39 50
NIL

(for-file-lines ("test.txt")
    (with-fields ((id name payrate hrsworked))
        (declare (ignore id))
        ($print name ($* payrate hrsworked))))
Alice 1600
Bob 1950
NIL

(for-file-lines ("test.txt")
    (let ((clawk:*fs* "-"))
        (with-fields ((a b c))
        ($print a))))

(defun say (verb name)
  (format t "~a, ~a !~&" verb name))

(replic.completion:add-completion "say"
                                  (list "greetings" "\"nice to see you\"")
                                  (lambda () *names*))

(defun list-of-3tuples-strings-p (list)
  "Return t if LIST is a list composed of 3-tuples, made only of strings."
  (and (consp list)
       (every (lambda (it)
                (and
                 (= 3 (length it))
                 (every #'stringp it)))
              list)))

(deftype alist-of-3tuples-strings ()
  `(satisfies list-of-3tuples-strings-p))

(defconstant +foo+ 3)
(defun bar ()
  (concatenate 'string "+" +foo+))
; caught WARNING:
;   Constant 3 conflicts with its asserted type SEQUENCE.
;   See also:
;     The SBCL Manual, Node "Handling of Types"

(declaim (type (string) *name*))
(defparameter *name* "book")

(setf *name* :me)
Value of :ME in (THE STRING :ME) is :ME, not a STRING.
   [Condition of type SIMPLE-TYPE-ERROR]

(defun list-of-strings-p (list)
  "Return t if LIST is non nil and contains only strings."
  (and (consp list)
       (every #'stringp list)))

(deftype list-of-strings ()
  `(satisfies list-of-strings-p))

(declaim (type (list-of-strings) *all-names*))
(defparameter *all-names* "")

(declaim (type (or null list-of-strings) *all-names*))

(declaim (ftype (function (fixnum) fixnum) add))
;;                         ^^input ^^output [optional]
(defun add (n)
	(+ n  1))

(defun add (n)
	(format nil "~a" (+ n  1)))
; caught WARNING:
;   Derived type of ((GET-OUTPUT-STREAM-STRING STREAM)) is
;     (VALUES SIMPLE-STRING &OPTIONAL),
;   conflicting with the declared function return type
;     (VALUES FIXNUM &REST T).

(defun bad-concat (n)
    (concatenate 'string (add n)))
; caught WARNING:
;   Derived type of (ADD N) is
;     (VALUES FIXNUM &REST T),
;   conflicting with its asserted type
;     SEQUENCE.

(declaim (ftype (function (string)) bad-arg))
(defun bad-arg (n)
    (add n))
; caught WARNING:
;   Derived type of N is
;     (VALUES STRING &OPTIONAL),
;   conflicting with its asserted type
;     FIXNUM.

(use-package restclient
  :ensure t
  :mode (("\\.http\\'" . restclient-mode)))
from uuid import uuid4

from flask import Flask, escape, jsonify, make_response, request

app = Flask(__name__)

items = [{"uid": uuid4().hex, "name": f"item {i + 1}"} for i in range(3)]

SECRET = "password"

@app.route("/")
def index():
    name = request.args.get("name", "World")
    return f"Hello, {escape(name)}!"

@app.route("/api")
def api():
    return jsonify({"version": 1.0})

@app.route("/api/items")
def list_items():
    return jsonify({"data": items})

@app.route("/api/items", methods=["post"])
def create_item():
    if authenticated(request):
        new_item = {"uid": uuid4().hex, "name": request.json.get("name")}
        items.append(new_item)
        return make_response(jsonify({"data": new_item}), 201)
    else:
        return make_response(jsonify({"error": "please provide credentiales"}), 401)

def authenticated(req):
    token = req.headers.get("authorization")
    return token is not None and token == SECRET
docker run -p 5000:5000 erickgnavar/restclient-api-example:0.1
GET http://localhost:5000/?name=guest
Content-Type: application/json
Hello, guest!
<!-- GET http://localhost:5000/?name=guest -->
<!-- HTTP/1.0 200 OK -->
<!-- Content-Type: text/html; charset=utf-8 -->
<!-- Content-Length: 13 -->
<!-- Server: Werkzeug/0.16.0 Python/3.6.9 -->
<!-- Date: Tue, 29 Oct 2019 05:34:44 GMT -->
<!-- Request duration: 0.023261s -->

GET http://localhost:5000/?name=foo
# a split
GET http://localhost:5000/?name=bar
# a split
GET http://localhost:5000/?name=baz
GET http://localhost:5000/api
Content-Type: application/json
{
  "version": 1.0
}
// GET http://localhost:5000/api
// HTTP/1.0 200 OK
// Content-Type: application/json
// Content-Length: 16
// Server: Werkzeug/0.16.0 Python/3.6.9
// Date: Tue, 29 Oct 2019 05:42:01 GMT
// Request duration: 0.025286s

GET http://localhost:5000/api/items
Content-Type: application/json
{
  "data": [
    {
      "name": "item 1",
      "uid": "931d90b493e944d9816061f46b57ce92"
    },
    {
      "name": "item 2",
      "uid": "edf9c8dda1ed4e8da205c53d9978ede2"
    },
    {
      "name": "item 3",
      "uid": "57a5146e3c98479785374f38e9e4c056"
    }
  ]
}
// GET http://localhost:5000/api/items
// HTTP/1.0 200 OK
// Content-Type: application/json
// Content-Length: 188
// Server: Werkzeug/0.16.0 Python/3.6.9
// Date: Tue, 29 Oct 2019 05:42:33 GMT
// Request duration: 0.026217s

:password = wrong-password

POST http://localhost:5000/api/items
Content-Type: application/json
Authorization: :password
{
    "name": "new item"
}
{
  "error": "please provide credentiales"
}
// POST http://localhost:5000/api/items
// HTTP/1.0 401 UNAUTHORIZED
// Content-Type: application/json
// Content-Length: 40
// Server: Werkzeug/0.16.0 Python/3.6.9
// Date: Tue, 29 Oct 2019 05:47:24 GMT
// Request duration: 0.036553s

:password = password

POST http://localhost:5000/api/items
Content-Type: application/json
Authorization: :password
{
    "name": "new item"
}
{
  "data": {
    "name": "new item",
    "uid": "f1ede16e39754b3eb735627e78d26146"
  }
}
// POST http://localhost:5000/api/items
// HTTP/1.0 201 CREATED
// Content-Type: application/json
// Content-Length: 70
// Server: Werkzeug/0.16.0 Python/3.6.9
// Date: Tue, 29 Oct 2019 05:48:15 GMT
// Request duration: 0.034962s

  curl -i -H Authorization\:\ password -H Content-Type\:\ application/json -XPOST http\://localhost\:5000/api/items -d \{'
  '\ \ \ \ \"name\"\:\ \"new\ item\"'
  '\}
(use-package json-mode
  :ensure t)

(use-package restclient
  :ensure t
  :defer t
  :mode (("\\.http\\'" . restclient-mode))
  :bind (:map restclient-mode-map
	      ("C-c C-f" . json-mode-beautify)))
(use-package elixir-mode
  :ensure t
  :bind (:map elixir-mode-map
	      ("C-c C-f" . elixir-format)))
(use-package dumb-jump
  :ensure t
  :init
  (setq dumb-jump-selector 'helm))
(use-package yasnippet
  :ensure t
  :hook ((prog-mode . yas-minor-mode)
	 (conf-mode . yas-minor-mode)
	 (text-mode . yas-minor-mode)
	 (snippet-mode . yas-minor-mode)))

(use-package yasnippet-snippets
  :ensure t
  :after (yasnippet))
(defun my/mix-run-test (&optional at-point)
  "If AT-POINT is true it will pass the line number to mix test."
  (interactive)
  (let* ((current-file (buffer-file-name))
	 (current-line (line-number-at-pos))
	 (mix-file (concat (projectile-project-root) "mix.exs"))
	 (default-directory (file-name-directory mix-file))
	 (mix-env (concat "MIX_ENV=test ")))

    (if at-point
	(compile (format "%s mix test %s:%s" mix-env current-file current-line))
      (compile (format "%s mix test %s" mix-env current-file)))))

(defun my/mix-run-test-file ()
  "Run mix test over the current file."
  (interactive)
  (my/mix-run-test nil))

(defun my/mix-run-test-at-point ()
  "Run mix test at point."
  (interactive)
  (my/mix-run-test t))
(use-package elixir-mode
  :ensure t
  :bind (:map elixir-mode-map
	      ("C-c C-f" . elixir-format)
	      ("C-c C-t" . my/mix-run-test-at-point)))
>>> from pathlib import Path
>>> p = Path('/etc')
>>> q = p / 'init.d' / 'reboot'
>>> q
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

from pathlib import Path

path = Path('.config')
with path.open(mode='w') as config:
    config.write('# config goes here')

Path('.config').write_text('# config goes here')

from pathlib import Path

proyectos = Path.home() / 'proyectos'  # carpeta en el directorio HOME
palabra = "pathlib"

ficheros = [p for p in proyectos.rglob("*.py")
            if palabra in p.read_text()]

size = sum(p.stat().st_size for p ficheros)

import os.path

size = sum(os.path.getsize(p) for p ficheros)

version: '3.1'
services:
  mongo:
    image: mongo
    container_name: mongodb
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: example
      MONGO_INITDB_DATABASE: ejemplodb
    ports:
      - 27017:27017

  mongo-express: 
    image: mongo-express
    restart: always
    container_name: mongodb-ui
    ports:
      - 8081:8081
    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: root
      ME_CONFIG_MONGODB_ADMINPASSWORD: example

docker-compose up

npm install express

npm install mongoose

const express       = require('express');
const bodyParser    = require('body-parser');
const cors          = require('cors'); 
const mongoose      = require('mongoose');

const PORT = 3000;
const app = express();
app.use(cors());
app.use(bodyParser.json());

app.get('/', (req, res) =>{
    res.send('Index');
});

app.listen(PORT, () =>{
    console.log('Servidor backend listo...');
});

mongoose.connect('mongodb://localhost/basededatos', {useNewUrlParser: true, useUnifiedTopology: true});

const connection = mongoose.connection;

connection.once('open', () =>{
    console.log('Conectado a la BD');
});

mongoose.connect('mongodb://user:pass@localhost/db', {useNewUrlParser: true, useUnifiedTopology: true});

UnhandledPromiseRejectionWarning: MongoError: Authentication failed

docker exec -it mongodb mongo -u root

use tu-base-de-datos
db.createUser({
    user: 'user',
    pwd: 'pass',
    roles: [
        { role: 'readWrite', db: 'tu-base-de-datos' }
    ]
})

mongoose.connect('mongodb://user:pass@localhost/db', {useNewUrlParser: true, useUnifiedTopology: true});

(defun foo ()
 nil[])

(/ 0) =>
…
1: (CCL::INTEGER-/-INTEGER 1 0)
…

(setq slime-export-symbol-representation-function
      (lambda (n) (format ":%s" n)))

(setq slime-export-symbol-representation-function
 (lambda (n) (format "\"%s\"" (upcase n))))

(defclass person ()
  ((favorite-dog :type symbol
                 :field-type :member
                 :members (:wedge :walter)
                 :initarg :favorite-dog
                 :required t)
   (age :type (integer 0)
        :initarg :age
        :required t)
   (potato :type string
           :initarg :potato
           :required t))
  (:metaclass sanity-clause.metaclass:validated-metaclass))

(make-instance 'person :favorite-dog :nope)
; Evaluation aborted on Error converting value for field #<MEMBER-FIELD {1004BFA973}>:
Value "NOPE" couldn't be found in set (WEDGE WALTER)

(make-instance 'person :age -1 :favorite-dog :walter)
; Evaluation aborted on Error validating value -1 in field #<INTEGER-FIELD {1004BFF103}>:
* Value -1 didn't satisfy condition "must be larger than 0"

(make-instance 'person :age 7 :favorite-dog :walter)
; Evaluation aborted on A value for field POTATO is required but none was provided..

(make-instance 'person :age 1 :favorite-dog :walter :potato "patate")
#<PERSON {10060371E3}>

(ql:quickload '("hunchentoot" "caveman" "spinneret" "djula"))

(defvar *acceptor* (make-instance 'hunchentoot:easy-acceptor :port 4242))
(hunchentoot:start *acceptor*)

(setf (hunchentoot:acceptor-document-root *acceptor*) #p"path/to/www")

<html>
  <head>
    <title>Hello!</title>
  </head>
  <body>
    <h1>Hello local server!</h1>
    <p>
    We just served our own files.
    </p>
  </body>
</html>

(defvar *my-acceptor* (make-instance 'hunchentoot:easy-acceptor :port 4444
                                   :document-root #p"www/"))
(hunchentoot:start *my-acceptor*)

(hunchentoot:start (make-instance 'hunchentoot:easy-acceptor :port 4242))

(defun hello ()
   (format nil "Hello, it works!"))

(push
  (hunchentoot:create-prefix-dispatcher "/hello.html" #'hello)
  hunchentoot:*dispatch-table*)

(defvar *server* (make-instance 'hunchentoot:easy-acceptor :port 4242))
(hunchentoot:start *server*)

127.0.0.1 - [2018-10-27 23:50:09] "get / http/1.1" 200 393 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0"
127.0.0.1 - [2018-10-27 23:50:10] "get /img/made-with-lisp-logo.jpg http/1.1" 200 12583 "http://localhost:4242/" "Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0"
127.0.0.1 - [2018-10-27 23:50:10] "get /favicon.ico http/1.1" 200 1406 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0"
127.0.0.1 - [2018-10-27 23:50:19] "get /hello.html http/1.1" 200 20 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0"

define-easy-handler (function-name :uri <uri> …) (lambda list parameters)

(hunchentoot:define-easy-handler (say-yo :uri "/yo") (name)
  (setf (hunchentoot:content-type*) "text/plain")
  (format nil "Hey~@[ ~A~]!" name))

define-easy-handler (function-name &key uri acceptor-names default-request-type) (lambda list parameters)

(defroute "/welcome" (&key (|name| "Guest"))
  (format nil "Welcome, ~A" |name|))

@route GET "/welcome"
(lambda (&key (|name| "Guest"))
  (format nil "Welcome, ~A" |name|))

(defroute "/hello/:name" (&key name)
  (format nil "Hello, ~A" name))

(defroute "/say/*/to/*" (&key splat)
  ; matches /say/hello/to/world
  (format nil "~A" splat))
;=> (hello world)

(defroute ("/hello/([\\w]+)" :regexp t) (&key captures)
  (format nil "Hello, ~A!" (first captures)))

(hunchentoot:parameter "my-param")

(hunchentoot:define-easy-handler (say-yo :uri "/yo") (name)
  (setf (hunchentoot:content-type*) "text/plain")
  (format nil "Hey~@[ ~A~]!" name))

(hunchentoot:define-easy-handler (say-yo :uri "/yo") (name)
  (setf (hunchentoot:content-type*) "text/plain")
  (format nil "Hey~@[ ~A~] you are of type ~a" name (type-of name)))

Hey Alice you are of type (SIMPLE-ARRAY CHARACTER (5))

(defwidget task ()
        ((title
          :initarg :title
          :accessor title)
         (done
          :initarg :done
          :initform nil
          :accessor done)))

(defmethod render ((task task))
        "Render a task."
        (with-html
              (:span (if (done task)
                         (with-html
                               (:s (title task)))
                       (title task)))))

...
(with-html
          (:p (:input :type "checkbox"
            :checked (done task)
            :onclick (make-js-action
                      (lambda (&key &allow-other-keys)
                        (toggle task))))
...

(djula:add-template-directory (asdf:system-relative-pathname "webapp" "templates/"))

{\% extends "base.html" \%}
{\% block title %}Memberlist{\% endblock \%}
{\% block content \%}
  <ul>
  {\% for user in users \%}
    <li><a href="{{ user.url }}">{{ user.username }}</a></li>
  {\% endfor \%}
  </ul>
{\% endblock \%}

(with-page (:title "Home page")
     (:header
      (:h1 "Home page"))
     (:section
      ("~A, here is *your* shopping list: " *user-name*)
      (:ol (dolist (item *shopping-list*)
             (:li (1+ (random 10)) item))))
     (:footer ("Last login: ~A" *last-login*)))

(defun login (user)
  "Log the user into the session"
  (setf (gethash :user *session*) user))

(defun logout ()
  "Log the user out of the session."
  (setf (gethash :user *session*) nil))

(defun logged-in-p ()
  (gethash :user cm:*session*))

(defmacro with-logged-in (&body body)
  `(if (logged-in-p)
       (progn ,@body)
       (render #p"login.html"
               '(:message "Please log-in to access this page."))))

(defroute "/account/logout" ()
  "Show the log-out page, only if the user is logged in."
  (with-logged-in
    (logout)
    (render #p"logout.html")))

(defroute ("/account/review" :method :get) ()
  (with-logged-in
    (render #p"review.html"
            (list :review (get-review (gethash :user *session*))))))

(defun password-hash (password)
  (ironclad:pbkdf2-hash-password-to-combined-string
   (babel:string-to-octets password)))

(defun check-user-password (user password)
  (handler-case
      (let* ((data (my-get-user-data user))
             (hash (my-get-user-hash data))
             (active (my-get-user-active data)))
        (when (and active (ironclad:pbkdf2-check-password (babel:string-to-octets password)
                                                          hash))
          (my-get-user-id data)))
    (condition () nil)))

(defun set-password (user password)
  (with-connection (db)
    (execute
     (make-statement :update :web_user
                     (set= :hash (password-hash password))
                     (make-clause :where
                                  (make-op := (if (integerp user)
                                                  :id_user
                                                  :email)
                                           user))))))

$ ./my-web-app
Hunchentoot server is started.
Listening on localhost:9003.

;; Load Ceramic and our app
(ql:quickload '(:ceramic :our-app))

;; Ensure Ceramic is set up
(ceramic:setup)
(ceramic:interactive)

;; Start our app (here based on the Lucerne framework)
(lucerne:start our-app.views:app :port 8000)

;; Open a browser window to it
(defvar window (ceramic:make-window :url "http://localhost:8000/"))

;; start Ceramic
(ceramic:show-window window)

$ emacs -nw /etc/systemd/system/my-app.service
[Unit]
Description=stupid simple example

[Service]
WorkingDirectory=/path/to/your/app
ExecStart=/usr/local/bin/sthg sthg
Type=simple
Restart=always
RestartSec=10

sudo systemctl start my-app.service

systemctl status my-app.service

journalctl -f -u my-app.service

Restart=always

[Install]
WantedBy=basic.target

sudo systemctl enable my-app.service

hot_deploy:
	$(call $(LISP), \
		(ql:quickload :quickutil-server) (ql:quickload :swank-client), \
		(swank-client:with-slime-connection (conn "localhost" $(SWANK_PORT)) \
			(swank-client:slime-eval (quote (handler-bind ((error (function continue))) \
				(ql:quickload :quickutil-utilities) (ql:quickload :quickutil-server) \
				(funcall (symbol-function (intern "STOP" :quickutil-server))) \
				(funcall (symbol-function (intern "START" :quickutil-server)) $(start_args)))) conn)) \
		$($(LISP)-quit))

(ql:quickload "trivia")

(use-package :trivia)

(match '(1 2 3)
  ((cons x y)
  ; ^^ pattern
   (print x)
   (print y)))
;; |-> 1
;; |-> (2 3)

(match '(something #(0 1 2))
  ((list a (vector 0 _ b))
   (values a b)))
SOMETHING
2

(match '(1 2 . 3)
  ((list* _ _ x)
   x))
3

(match #(1 2 3)
  ((vector _ x _)
   x))
;; -> 2

(match #(1 2 3 4)
  ((vector _ x _)
   x))
;; -> NIL : does not match

(match #(1 2 3 4)
  ((vector* _ x _)
   x))
;; -> 2 : soft match.

<vector-pattern> : vector      | simple-vector
                   bit-vector  | simple-bit-vector
                   string      | simple-string
                   base-string | simple-base-string | sequence
(<vector-pattern> &rest subpatterns)

(defstruct foo bar baz)
(defvar *x* (make-foo :bar 0 :baz 1)

(match *x*
  ;; make-instance style
  ((foo :bar a :baz b)
   (values a b))
  ;; with-slots style
  ((foo (bar a) (baz b))
   (values a b))
  ;; slot name style
  ((foo bar baz)
   (values bar baz)))

(match x
  ((or (list 1 a)
       (cons a 3))
   a))

(match (list 2 5)
  ((guard (list x y)     ; subpattern
          (= 10 (* x y)) ; test-form
          (- x y) (satisfies evenp)) ; generator1, subpattern1
   t))

(match '(:a (3 4) 5)
  ((list :a (list _ c) _)
   c))

(defun <name> (list of arguments)
  "docstring"
  (function body))

(defun hello-world ()
  ;;               ^^ no arguments
  (print "hello world!"))

(hello-world)
;; "hello world!"  <-- output
;; "hello world!"  <-- a string is returned.

(defun hello (name)
  "Say hello to `name'."
  (format t "hello ~a !~&" name))
;; HELLO

(hello "me")
;; hello me !  <-- this is printed by `format`
;; NIL         <-- return value: `format t` prints a string to standard output and returns nil.

(defun hello (name &optional age gender) …)

(hello "me") ;; a value for the required argument, zero optional arguments
(hello "me" "7")  ;; a value for age
(hello "me" 7 :h) ;; a value for age and gender

(defun hello (name &key happy)
  "If `happy' is `t', print a smiley"
  (format t "hello ~a " name)
  (when happy
    (format t ":)~&"))

(hello "me")
(hello "me" :happy t)
(hello "me" :happy nil) ;; useless, equivalent to (hello "me")

(defun hello (name &key happy lisper cookbook-contributor-p) …)

(hello "me" :lisper t)
(hello "me" :lisper t :happy t)
(hello "me" :cookbook-contributor-p t :happy t)

(defun hello (&optional name &key happy)
  (format t "hello ~a " name)
  (when happy
    (format t ":)~&")))

; in: DEFUN HELLO
;     (SB-INT:NAMED-LAMBDA HELLO
;         (&OPTIONAL NAME &KEY HAPPY)
;       (BLOCK HELLO (FORMAT T "hello ~a " NAME) (WHEN HAPPY (FORMAT T ":)~&"))))
;
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (&OPTIONAL (NAME "John") &KEY
;                                                      HAPPY)
;
; compilation unit finished
;   caught 1 STYLE-WARNING condition

(hello "me" :happy t)
;; hello me :)
;; NIL

(defun hello (name &key (happy t))

(defun mean (x &rest numbers)
    (/ (apply #'+ x numbers)
       (1+ (length numbers))))

(mean 1)
(mean 1 2)
(mean 1 2 3 4 5)

(defun hello (name &key happy)
  (format t "hello ~a~&" name))

(hello "me" :lisper t)
;; => Error: unknown keyword argument

(defun hello (name &key happy &allow-other-keys)
  (format t "hello ~a~&" name))

(hello "me" :lisper t)
;; hello me

(defun foo (a b c)
  a)

(defvar *res* (foo :a :b :c))
;; :A

(defun foo (a b c)
  (values a b c))

(setf *res* (foo :a :b :c))
;; :A

(multiple-value-bind (res1 res2 res3)
    (foo :a :b :c)
  (format t "res1 is ~a, res2 is ~a, res2 is ~a~&" res1 res2 res3))
;; res1 is A, res2 is B, res2 is C
;; NIL

(multiple-value-bind (var-1 .. var-n) expr
  body)

(lambda (x) (print x))

((lambda (x) (print x)) "hello")
;; hello

(funcall #'+ 1 2)
(apply #'+ '(1 2))

(defun adder (n)
  (lambda (x) (+ x n)))
;; ADDER

(adder 5)
;; #<CLOSURE (LAMBDA (X) :IN ADDER) {100994ACDB}>
(funcall (adder 5) 3)
;; 8

((adder 3) 5)
In: (ADDER 3) 5
    ((ADDER 3) 5)
Error: Illegal function call.

;; The symbol foo is bound to nothing:
CL-USER> (boundp 'foo)
NIL
CL-USER> (fboundp 'foo)
NIL
;; We create a variable:
CL-USER> (defparameter foo 42)
FOO
* foo
42
;; Now foo is "bound":
CL-USER> (boundp 'foo)
T
;; but still not as a function:
CL-USER> (fboundp 'foo)
NIL
;; So let's define a function:
CL-USER> (defun foo (x) (* x x))
FOO
;; Now the symbol foo is bound as a function too:
CL-USER> (fboundp 'foo)
T
;; Get the function:
CL-USER> (function foo)
#<FUNCTION FOO>
;; and the shorthand notation:
* #'foo
#<FUNCTION FOO>
;; We call it:
(funcall (function adder) 5)
#<CLOSURE (LAMBDA (X) :IN ADDER) {100991761B}>
;; and call the lambda:
(funcall (funcall (function adder) 5) 3)
8

;;; continued from above
CL-USER> (fboundp '*my-fun*)
NIL
CL-USER> (setf (symbol-function '*my-fun*) (adder 3))
#<CLOSURE (LAMBDA (X) :IN ADDER) {10099A5EFB}>
CL-USER> (fboundp '*my-fun*)
T
CL-USER> (*my-fun* 5)
8

(let ((limit 3)
      (counter -1))
    (defun my-counter ()
      (if (< counter limit)
          (incf counter)
          (setf counter 0))))

(my-counter)
0
(my-counter)
1
(my-counter)
2
(my-counter)
3
(my-counter)
0

(defun repeater (n)
  (let ((counter -1))
     (lambda ()
       (if (< counter n)
         (incf counter)
         (setf counter 0)))))

(defparameter *my-repeater* (repeater 3))
;; *MY-REPEATER*
(funcall *my-repeater*)
0
(funcall *my-repeater*)
1
(funcall *my-repeater*)
2
(funcall *my-repeater*)
3
(funcall *my-repeater*)
0

(defun (setf <name>) (new-value <other arguments>)
  body)

(defparameter *current-name* ""
  "A global name.")

(defun hello (name)
  (format t "hello ~a~&" name))

(defun (setf hello) (new-value)
  (hello new-value)
  (setf *current-name* new-value)
  (format t "current name is now ~a~&" new-value))

(setf (hello) "Alice")
;; hello Alice
;; current name is now Alice
;; NIL

CL-USER> (declaim (ftype (function (function &rest t) function) curry) (inline curry))
NIL
CL-USER> (defun curry (function &rest args)
           (lambda (&rest more-args)
	           (apply function (append args more-args))))
CURRY
CL-USER> (funcall (curry #'+ 3) 5)
8
CL-USER> (funcall (curry #'+ 3) 6)
9
CL-USER> (setf (symbol-function 'power-of-ten) (curry #'expt 10))
#<Interpreted Function "LAMBDA (FUNCTION &REST ARGS)" {482DB969}>
CL-USER> (power-of-ten 3)
1000

(ql:quickload :alexandria)

(defun adder (foo bar)
  "Add the two arguments."
  (+ foo bar))

(defvar add-one (alexandria:curry #'adder 1) "Add 1 to the argument.")

(funcall add-one 10)  ;; => 11

(setf (symbol-function 'add-one) add-one)
(add-one 10)  ;; => 11

(reformatter-define haskell-format
  :program "hindent")
(define-key haskell-mode-map (kbd "C-c C-f") 'haskell-format-buffer)
(haskell-mode (mode . haskell-format-on-save))
(reformatter-define elixir-format
  :program "mix"
  :args '("format" "-"))
def quitar_dup(lista):

    for item in lista:

        item.reverse()

        if item in lista:
            lista.remove(item)

    return lista

L=[[1, 2], [1, 3], [2, 1], [3, 1]]

print quitar_dup(L)  #res: [[1, 3], [3, 1]]

>>> def add(a, l):
...   if a not in l:
...     l += [a]
...   return l
...
>>> L = [1, 2, 3]
>>> add(1, L)
[1, 2, 3]
>>> add(4, L)
[1, 2, 3, 4]
>>> L
[1, 2, 3, 4]

>>> def add(a, l=[]):
...   if a not in l:
...     l += [a]
...   return l
...
>>> add(1)
[1]
>>> add(2)
[1, 2]
>>> add(3, [])
[3]
>>> add(4)
[1, 2, 4]

fns = []

for i in range(5):
    fns.append( lambda x: x + i)

print fns[1](10)
print fns[2](10)

>>> l = [[0]*2]*2
[[0, 0], [0, 0]]
>>> l[0][0]
0
>>> l[0][0] = 1
>>> l
[[1, 0], [1, 0]]
>>> l[0] is l[1]
True

def add(a, lista):
  l = lista[:]
  if a not in l:
    l += [a]
  return l

def add(a, lista=None):
  l = [] if lista is None else lista[:]
  if a not in l:
    l += [a]
  return l

>>> l = [3, 5, 1, 2, 4]
>>> l_2 = [x*x for x in l.sort()]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not iterable

>>> l = [3, 5, 1, 2, 4]
>>> l_2 = [x*x for x in sorted(l)]
>>> l_2
[1, 4, 9, 16, 25]

sudo apt install python3-requests
#!/usr/bin/env python3
import requests

requests.post('https://api.telegram.org/bot<TOKEN>/sendMessage',
              data={'chat_id': '<CHAT_ID>', 'text': '<TEXTO>'})
#!/usr/bin/env python3
import requests

r = requests.post('https://api.telegram.org/bot<TOKEN>/sendMessage',
              data={'chat_id': '<CHAT_ID>', 'text': '<TEXTO>'})
print(r.text)
#!/usr/bin/env python3
import requests
import json

r = requests.post('https://api.telegram.org/bot<TOKEN>/sendMessage',
                  data={'chat_id': '<CHAT_ID>', 'text': '<TEXTO>'})
data = json.loads(r.text)
print(data['ok'])
#!/usr/bin/env python3
import requests
import sys

if __name__ == '__main__':
    if len(sys.argv) > 2:
        requests.post('https://api.telegram.org/bot<TOKEN>/sendMessage',
                      data={'chat_id': sys.argv[1], 'text': sys.argv[2]})
requests.post('https://api.telegram.org/bot<TOKEN>/sendPhoto',
              data={'chat_id': <CHAT_ID>, 'photo': <PHOTO_URL>, 'caption': <TEXT>})
requests.post('https://api.telegram.org/bot<TOKEN>/sendPhoto',
              files={'photo': (<ARCHIVO>, open(<ARCHIVO>, 'rb'))},
              data={'chat_id': <CHAT_ID>, 'caption': <TEXT>})
requests.post('https://api.telegram.org/bot<TOKEN>/sendVoice',
              files={'voice': (<ARCHIVO>, open(<ARCHIVO>, 'rb')),
                     'thumb': (<ARCHIVO2>, open(<ARCHIVO2>, 'rb'))},
              data={'chat_id': <CHAT_ID>, 'caption': <TEXT>})
requests.post('https://api.telegram.org/bot<TOKEN>/sendAudio',
              files={'audio': (<ARCHIVO>, open(<ARCHIVO>, 'rb')),
                     'thumb': (<ARCHIVO2>, open(<ARCHIVO2>, 'rb'))},
              data={'chat_id': <CHAT_ID>, 'caption': <TEXT>})
requests.post('https://api.telegram.org/bot<TOKEN>/sendAudio',
              files={'voice': (<ARCHIVO>, open(<ARCHIVO>, 'rb'))},
              data={'chat_id': <CHAT_ID>, 'caption': <TEXT>, 'thumb': <THUMB>})
requests.post('https://api.telegram.org/bot<TOKEN>/sendVideoNote',
              files={'video_note': (<ARCHIVO>, open(<ARCHIVO>, 'rb')),
                     'thumb': (<ARCHIVO2>, open(<ARCHIVO2>, 'rb'))},
              data={'chat_id': <CHAT_ID>, 'caption': <TEXT>,
                    'duration': <DURATION>, 'length': <LENGTH>})
requests.post('https://api.telegram.org/bot<TOKEN>/sendDocument',
              files={'document': (<ARCHIVO>, open(<ARCHIVO>, 'rb')),
                     'thumb': (<ARCHIVO2>, open(<ARCHIVO2>, 'rb'))},
              data={'chat_id': <CHAT_ID>, 'caption': <TEXT>})
(setf 5am:*on-error* :debug)

$user = $this->getUser();
$form = $this->createForm(UserBillingInfoType::class, $user)
             ->handleRequest($request);

if ($form->isSubmitted() && $form->isValid()) {
    // $user is already populated with the form values at this point
    // it's valid, so we can update the database and redirect the user now
}

$user = new User();
$user->addLicense(new License());
$manager->persist($user); // both user and its license will be saved

This class is a subclass of `stream` and of `standard-object`.  `streamp`
will return true for an instance of any class that includes this.  (It
may return true for some other things also.)

A subclass of `fundamental-stream`.  Its inclusion causes `input-stream-p`
to return true.

A subclass of `fundamental-stream`.  Its inclusion causes `output-stream-p`
to return true.  Bi-direction streams may be formed by including both
`fundamental-output-stream` and `fundamental-input-stream`.

A subclass of `fundamental-stream`.  It provides a method for
`stream-element-type` which returns `character`.

A subclass of `fundamental-stream`.  Any instantiable class that
includes this needs to define a method for `stream-element-type`.

Includes `fundamental-input-stream` and `fundamental-character-stream`.
It provides default methods for several generic functions used for
character input.

Includes `fundamental-output-stream` and `fundamental-character-stream`.
It provides default methods for several generic functions used for
character output.

Includes `fundamental-input-stream` and `fundamental-binary-stream`.

Includes `fundamental-output-stream` and `fundamental-binary-stream`.

This reads one character from the stream.  It returns either a
character object, or the symbol :EOF if the stream is at end-of-file.
Every subclass of `fundamental-character-input-stream` must define a
method for this function.

Note that for all of these generic functions, the stream argument
must be a stream object, not T or NIL.

Un-does the last call to `stream-read-char`, as in `unread-char`.  Returns
NIL.  Every subclass of `fundamental-character-input-stream` must define
a method for this function.

This is used to implement `read-char-no-hang`.  It returns either a
character, or NIL if no input is currently available, or :EOF if
end-of-file is reached.  The default method provided by
`fundamental-character-input-stream` simply calls `stream-read-char`; this
is sufficient for file streams, but interactive streams should define
their own method.

Used to implement `peek-char`; this corresponds to peek-type of NIL.
It returns either a character or :EOF.  The default method
calls `stream-read-char` and `stream-unread-char`.

Used by `listen`.  Returns true or false.  The default method uses
`stream-read-char-no-hang` and `stream-unread-char`.  Most streams should
define their own method since it will usually be trivial and will
always be more efficient than the default method.

Used by `read-line`.  A string is returned as the first value.  The
second value is true if the string was terminated by end-of-file
instead of the end of a line.  The default method uses repeated
calls to `stream-read-char`.

Implements `clear-input` for the stream, returning NIL.  The default
method does nothing.

Writes character to the stream and returns the character.  Every
subclass of `fundamental-character-output-stream` must have a method
defined for this function.

This function returns the column number where the next character
will be written, or NIL if that is not meaningful for this stream.
The first column on a line is numbered 0.  This function is used in
the implementation of `pprint` and the FORMAT ~T directive.  For every
character output stream class that is defined, a method must be
defined for this function, although it is permissible for it to
always return NIL.

This is a predicate which returns T if the stream is positioned at the
beginning of a line, else NIL.  It is permissible to always return
NIL.  This is used in the implementation of `fresh-line`.  Note that
while a value of 0 from `stream-line-column` also indicates the
beginning of a line, there are cases where `stream-start-line-p` can be
meaningfully implemented although `stream-line-column` can't be.  For
example, for a window using variable-width characters, the column
number isn't very meaningful, but the beginning of the line does have
a clear meaning.  The default method for `stream-start-line-p` on class
`fundamental-character-output-stream` uses `stream-line-column`, so if
that is defined to return `nil`, then a method should be provided for
either `stream-start-line-p` or `stream-fresh-line`.

This is used by `write-string`.  It writes the string to the stream,
optionally delimited by start and end, which default to 0 and NIL.
The string argument is returned.  The default method provided by
`fundamental-character-output-stream` uses repeated calls to
`stream-write-char`.

Writes an end of line, as for `terpri`.  Returns NIL.  The default
method does (`stream-write-char` stream #\NEWLINE).

Used by `fresh-line`.  The default method uses `stream-start-line-p` and
`stream-terpri`.

Implements `finish-output`.  The default method does nothing.

Implements `force-output`.  The default method does nothing.

Implements `clear-output`.  The default method does nothing.

Writes enough blank space so that the next character will be written
at the specified column.  Returns true if the operation is
successful, or NIL if it is not supported for this stream.
This is intended for use by by `pprint` and FORMAT ~T.  The default
method uses `stream-line-column` and repeated calls to
`stream-write-char` with a #\SPACE character; it returns NIL if
`stream-line-column` returns NIL.

The existing function `close` is redefined to be a generic function, but
otherwise behaves the same.  The default method provided by class
`fundamental-stream` sets a flag for `open-stream-p`.  The value returned
by `close` will be as specified by the issue `closed-stream-operations`.

This function [from proposal `stream-access]` is made generic.  A
default method is provided by class `fundamental-stream` which returns
true if `close` has not been called on the stream.

These three existing predicates may optionally be implemented as
generic functions for implementations that want to permit users to
define streams that are not `standard-object`s.  Normally, the default
methods provided by classes `fundamental-input-stream` and
`fundamental-output-stream` are sufficient.  Note that, for example,
(INPUT-STREAM-P x) is not equivalent to (TYPEP x
'FUNDAMENTAL-INPUT-STREAM) because implementations may have
additional ways of defining their own streams even if they don't
make that visible by making these predicates generic.

This existing function is made generic, but otherwise behaves the
same.  Class `fundamental-character-stream` provides a default method
which returns `character`.

Binary streams can be created by defining a class that includes either
`fundamental-binary-input-stream` or `fundamental-binary-output-stream`
(or both) and defining a method for `stream-element-type` and for one or
both of the following generic functions.

Used by `read-byte`; returns either an integer, or the symbol :EOF if the
stream is at end-of-file.

Implements `write-byte`; writes the integer to the stream and returns
the integer as the result.

  ;;;; Here is an example of how the default methods could be
  ;;;; implemented (omitting the most trivial ones):

  (defmethod STREAM-PEEK-CHAR ((stream fundamental-character-input-stream))
    (let ((character (stream-read-char stream)))
      (unless (eq character :eof)
	(stream-unread-char stream character))
      character))

  (defmethod STREAM-LISTEN ((stream fundamental-character-input-stream))
    (let ((char (stream-read-char-no-hang stream)))
      (and (not (null char))
	   (not (eq char :eof))
	   (progn (stream-unread-char stream char) t))))

  (defmethod STREAM-READ-LINE ((stream fundamental-character-input-stream))
    (let ((line (make-array 64 :element-type 'string-char
			    :fill-pointer 0 :adjustable t)))
      (loop (let ((character (stream-read-char stream)))
	      (if (eq character :eof)
		  (return (values line t))
		(if (eql character #\newline)
		    (return (values line nil))
		  (vector-push-extend character line)))))))

  (defmethod STREAM-START-LINE-P ((stream fundamental-character-output-stream))
    (equal (stream-line-column stream) 0))

  (defmethod STREAM-WRITE-STRING ((stream fundamental-character-output-stream)
				  string &optional (start 0)
				  (end (length string)))
    (do ((i start (1+ i)))
	((>= i end) string)
      (stream-write-char stream (char string i))))

  (defmethod STREAM-TERPRI ((stream fundamental-character-output-stream))
    (stream-write-char stream #\newline)
    nil)

  (defmethod STREAM-FRESH-LINE ((stream fundamental-character-output-stream))
    (if (stream-start-line-p stream)
	nil
      (progn (stream-terpri stream) t)))

  (defmethod STREAM-ADVANCE-TO-COLUMN ((stream fundamental-character-output-stream)
				       column)
    (let ((current (stream-line-column stream)))
      (unless (null current)
	(dotimes (i (- current column) t)
	  (stream-write-char stream #\space)))))

  (defmethod INPUT-STREAM-P ((stream fundamental-input-stream)) t)
  (defmethod INPUT-STREAM-P ((stream fundamental-output-stream))
    ;; allow the two classes to be mixed in either order
    (typep stream 'fundamental-input-stream))
  (defmethod OUTPUT-STREAM-P ((stream fundamental-output-stream)) t)
  (defmethod OUTPUT-STREAM-P ((stream fundamental-input-stream))
    (typep stream 'fundamental-output-stream))

  ;;;; Following is an example of how the existing I/O functions could
  ;;;; be implemented using standard Common Lisp and the generic
  ;;;; functions specified above.  The standard functions being defined
  ;;;; are in upper case.

  ;;  Internal helper functions

  (proclaim '(inline decode-read-arg decode-print-arg check-for-eof))
  (defun decode-read-arg (arg)
    (cond ((null arg) *standard-input*)
	  ((eq arg t) *terminal-io*)
	  (t arg)))

  (defun decode-print-arg (arg)
    (cond ((null arg) *standard-output*)
	  ((eq arg t) *terminal-io*)
	  (t arg)))

  (defun check-for-eof (value stream eof-errorp eof-value)
    (if (eq value :eof)
	(report-eof stream eof-errorp eof-value)
      value))

  (defun report-eof (stream eof-errorp eof-value)
    (if eof-errorp
	(error 'end-of-file :stream stream)
      eof-value))

  ;;;  Common Lisp input functions

  (defun READ-CHAR (&optional input-stream (eof-errorp t) eof-value recursive-p)
    (declare (ignore recursive-p)) ; a mistake in CLtL?
    (let ((stream (decode-read-arg input-stream)))
      (check-for-eof (stream-read-char stream) stream eof-errorp eof-value)))

  (defun PEEK-CHAR (&optional peek-type input-stream (eof-errorp t)
			eof-value recursive-p)
    (declare (ignore recursive-p))
    (let ((stream (decode-read-arg input-stream)))
      (if (null peek-type)
	  (check-for-eof (stream-peek-char stream) stream eof-errorp eof-value)
        (loop
	  (let ((value (stream-peek-char stream)))
	    (if (eq value :eof)
		(return (report-eof stream eof-errorp eof-value))
	      (if (if (eq peek-type t)
		      (not (member value '(#\space #\tab #\newline
					   #\page #\return #\linefeed)))
		    (char= peek-type value))
		  (return value)
		(stream-read-char stream))))))))

  (defun UNREAD-CHAR (character &optional input-stream)
    (stream-unread-char (decode-read-arg input-stream) character))

  (defun LISTEN (&optional input-stream)
    (stream-listen (decode-read-arg input-stream)))

  (defun READ-LINE (&optional input-stream (eof-error-p t)
			eof-value recursive-p)
    (declare (ignore recursive-p))
    (let ((stream (decode-read-arg input-stream)))
      (multiple-value-bind (string eofp)
	  (stream-read-line stream)
	(if eofp
	    (if (= (length string) 0)
		(report-eof stream eof-error-p eof-value)
	      (values string t))
	  (values string nil)))))

  (defun CLEAR-INPUT (&optional input-stream)
    (stream-clear-input (decode-read-arg input-stream)))

  (defun READ-CHAR-NO-HANG (&optional input-stream (eof-errorp t)
				eof-value recursive-p)
    (declare (ignore recursive-p))
    (let ((stream (decode-read-arg input-stream)))
      (check-for-eof (stream-read-char-no-hang stream)
		     stream eof-errorp eof-value)))

  ;;;  Common Lisp output functions

  (defun WRITE-CHAR (character &optional output-stream)
     (stream-write-char (decode-print-arg output-stream) character))

  (defun FRESH-LINE (&optional output-stream)
    (stream-fresh-line (decode-print-arg output-stream)))

  (defun TERPRI (&optional output-stream)
    (stream-terpri (decode-print-arg output-stream)))

  (defun WRITE-STRING (string &optional output-stream &key (start 0) end)
    (stream-write-string (decode-print-arg output-stream) string start end))

  (defun WRITE-LINE (string &optional output-stream &key (start 0) end)
    (let ((stream (decode-print-arg output-stream)))
      (stream-write-string stream string start end)
      (stream-terpri stream)
      string))

  (defun FORCE-OUTPUT (&optional stream)
    (stream-force-output (decode-print-arg stream)))

  (defun FINISH-OUTPUT (&optional stream)
    (stream-finish-output (decode-print-arg stream)))

  (defun CLEAR-OUTPUT (&optional stream)
    (stream-clear-output (decode-print-arg stream)))

  ;;;  Binary streams

  (defun READ-BYTE (binary-input-stream &optional (eof-errorp t) eof-value)
    (check-for-eof (stream-read-byte binary-input-stream)
		   binary-input-stream eof-errorp eof-value))

  (defun WRITE-BYTE (integer binary-output-stream)
    (stream-write-byte binary-output-stream integer))

  ;;;  String streams

  (defclass string-input-stream (fundamental-character-input-stream)
    ((string :initarg :string :type string)
     (index :initarg :start :type fixnum)
     (end :initarg :end :type fixnum)
     ))

  (defun MAKE-STRING-INPUT-STREAM (string &optional (start 0) end)
    (make-instance 'string-input-stream :string string
		   :start start :end (or end (length string))))

  (defmethod stream-read-char ((stream string-input-stream))
    (with-slots (index end string) stream
      (if (>= index end)
	  :eof
	(prog1 (char string index)
	       (incf index)))))

  (defmethod stream-unread-char ((stream string-input-stream) character)
    (with-slots (index end string) stream
      (decf index)
      (assert (eql (char string index) character))
      nil))

  (defmethod stream-read-line ((stream string-input-stream))
    (with-slots (index end string) stream
      (let* ((endline (position #\newline string :start index :end end))
	     (line (subseq string index endline)))
	(if endline
	    (progn (setq index (1+ endline))
		   (values line nil))
	  (progn (setq index end)
		 (values line t))))))

  (defclass string-output-stream (fundamental-character-output-stream)
    ((string :initform nil :initarg :string)))

  (defun MAKE-STRING-OUTPUT-STREAM ()
    (make-instance 'string-output-stream))

  (defun GET-OUTPUT-STREAM-STRING (stream)
    (with-slots (string) stream
      (if (null string)
	  ""
	(prog1 string (setq string nil)))))

  (defmethod stream-write-char ((stream string-output-stream) character)
    (with-slots (string) stream
      (when (null string)
	(setq string (make-array 64. :element-type 'string-char
				 :fill-pointer 0 :adjustable t)))
      (vector-push-extend character string)
      character))

  (defmethod stream-line-column ((stream string-output-stream))
    (with-slots (string) stream
      (if (null string)
	  0
	(let ((nx (position #\newline string :from-end t)))
	  (if (null nx)
	      (length string)
	    (- (length string) nx 1))
	  ))))

    (defclass stream-generic-function (standard-generic-function) ())

  (defmethod no-applicable-method ((gfun stream-generic-function) &rest args)
    (if (streamp (first args))
	(apply #'stream-operation-not-handled (first args) gfun (rest args))
      (call-next-method)))

(defn start-app [args]
  (doseq [component (-> args
                        (parse-opts cli-options)
                        mount/start-with-args
                        :started)]
    (log/info component "started"))

  ;;run migrations  
  (migrations/migrate ["migrate"] (select-keys env [:database-url]))

  (.addShutdownHook (Runtime/getRuntime) (Thread. stop-app)))

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- encoders are assigned the type
             ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
        <encoder>
            <charset>UTF-8</charset>
            <pattern>%date{ISO8601} [%thread] %-5level %logger{36} - %msg %n</pattern>
        </encoder>
    </appender>
    <logger name="org.apache.http" level="warn" />
    <logger name="org.xnio.nio" level="warn" />
    <logger name="com.zaxxer.hikari" level="warn" />
    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

...
-----> Building with Leiningen
       Running: lein uberjar
       Compiling sample.app
       2019-01-18 01:10:30.857:INFO::main: Logging initialized @6674ms to org.eclipse.jetty.util.log.StdErrLog
       Created /tmp/build/target/myapp-1.0.1.jar
       Created /tmp/build/target/myapp.jar
...
=====> web=1
...
-----> Waiting for 10 seconds ...
-----> Default container check successful!
-----> Running post-deploy
-----> Configuring myapp.<server name>...(using built-in template)
-----> Creating http nginx.conf
-----> Running nginx-pre-reload
       Reloading nginx
-----> Setting config vars
       DOKKU_APP_RESTORE:  1
=====> 8dc31ac11011111117f71e4311111ca5962cf316411d5f0125e87bbac26
=====> Application deployed:
       http://myapp.<server name>

To http://<server name>:myapp
   6dcab39..1c0c8b7  master -> master

Picked up JAVA_TOOL_OPTIONS: -Xmx300m -Xss512k -XX:CICompilerCount=2 -Dfile.encoding=UTF-8
2019-01-19 19:09:48,258 [main] INFO  myapp.env -
-=[myapp started successfully]=-
2019-01-19 19:09:50,490 [main] INFO  luminus.http-server - starting HTTP server on port 5000
2019-01-19 19:09:50,628 [main] INFO  org.xnio - XNIO version 3.3.6.Final
2019-01-19 19:09:51,236 [main] INFO  org.projectodd.wunderboss.web.Web - Registered web context /
2019-01-19 19:09:51,242 [main] INFO  myapp.core - #'myapp.config/env started
2019-01-19 19:09:51,243 [main] INFO  myapp.core - #'myapp.db.core/*db* started
2019-01-19 19:09:51,243 [main] INFO  myapp.core - #'myapp.handler/init-app started
2019-01-19 19:09:51,244 [main] INFO  myapp.core - #'myapp.handler/app started
2019-01-19 19:09:51,249 [main] INFO  myapp.core - #'myapp.core/http-server started
2019-01-19 19:09:51,249 [main] INFO  myapp.core - #'myapp.core/repl-server started
2019-01-19 19:09:51,250 [main] INFO  myapp.core - running migrations
2019-01-19 19:09:51,257 [main] INFO  migratus.core - Starting migrations
2019-01-19 19:09:51,418 [main] INFO  migratus.database - creating migration table 'schema_migrations'
2019-01-19 19:09:51,992 [main] INFO  migratus.core - Running up for [20190118214013]
2019-01-19 19:09:51,997 [main] INFO  migratus.core - Up 20190118214013-add-users-table
2019-01-19 19:09:52,099 [main] INFO  migratus.core - Ending migrations

dokku postgres:connect mydb
mydb=# \d
               List of relations
 Schema |       Name        | Type  |  Owner
--------+-------------------+-------+----------
 public | schema_migrations | table | postgres
 public | users             | table | postgres
(2 rows)

sudo dokku postgres:expose mydb 5000

dokku enter myapp web
echo $DATABASE_URL

postgres://postgres:<password>@dokku-postgres-mydb:5432/mydb

ssh -L 5432:localhost:5000 <server name>

  (handler-case
      (do ((i 0 (1+ i))
           (text "")
           (verb "")
           (function nil)
           (variable nil)
           (args ""))
          ((string= "quit" (str:trim text)))

        (handler-case
            (setf text
                  (rl:readline :prompt (prompt)
                               :add-history t))
          (#+sbcl sb-sys:interactive-interrupt ()
                  (progn
                    (when (confirm)
                      (uiop:quit)))))

        (if (string= text "NIL")
            ;; that's a C-d, a blank input is just "".
            (when (confirm)
              (uiop:quit)))

        (unless (str:blank? text)
          (setf verb (first (str:words text)))
          (setf function (if (replic.completion:is-function verb)
                             ;; might do better than this or.
                             (replic.completion:get-function verb)))
          (setf variable (if (replic.completion:is-variable verb)
                             (replic.completion:get-variable verb)))
          (setf args (rest (str:words text)))

          (if (and verb function)
              (handler-case
                  ;; Call the function.
                  (apply function args)
                (#+sbcl sb-sys:interactive-interrupt (c)
                        (declare (ignore c))
                        (terpri))
                (error (c) (format t "Error: ~a~&" c)))

              (if variable
                  (format t "~a~&" (symbol-value variable))
                  (format t "No command or variable bound to ~a~&" verb)))

          (finish-output)

          (when (and *history*
                     *write-history*)
            (rl:write-history "/tmp/readline_history"))
          ))

    (error (c)
      (format t "~&Unknown error: ~&~a~&" c)))

(replic:repl)

(replic:functions-to-commands :my-package)

(in-package :replic.user)

(defparameter *names* '()
  "List of names (string) given to `hello`. Will be autocompleted by `goodbye`.")

(defun hello (name)
  "Takes only one argument. Adds the given name to the global
  `*names*` variable, used to complete arguments of `goodbye`.
  "
  (format t "hello ~a~&" name)
  (push name *names*))

(defun goodbye (name)
  "Says goodbye to name, where `name` should be completed from what was given to `hello`."
  (format t "goodbye ~a~&" name))

(replic.completion:add-completion "goodbye" (lambda () *names*))

(export '(hello goodbye))

(defvar window-snapshots '())

(defun save-window-snapshot ()
  "Save the current window configuration into `window-snapshots` alist."
  (interactive)
  (let ((key (read-string "Enter a name for the snapshot: ")))
    (setf (alist-get key window-snapshots) (current-window-configuration))
    (message "%s window snapshot saved!" key)))

(defun get-window-snapshot (key)
  "Given a KEY return the saved value in `window-snapshots` alist."
  (let ((value (assoc key window-snapshots)))
    (cdr value)))

(defun restore-window-snapshot ()
  "Restore a window snapshot from the window-snapshots alist."
  (interactive)
  (let* ((snapshot-name (completing-read "Choose snapshot: " (mapcar #'car window-snapshots)))
	 (snapshot (get-window-snapshot snapshot-name)))
    (if snapshot
	(set-window-configuration snapshot)
      (message "Snapshot %s not found" snapshot-name))))
(defvar window-snapshots '())

(defun save-window-snapshot ()
  "Save the current window configuration into `window-snapshots` alist."
  (interactive)
  (let ((key (read-string "Enter a name for the snapshot: ")))
    (setf (alist-get key window-snapshots) (current-window-configuration))
    (message "%s window snapshot saved!" key)))
(defun get-window-snapshot (key)
  "Given a KEY return the saved value in `window-snapshots` alist."
  (let ((value (assoc key window-snapshots)))
    (cdr value)))

(defun restore-window-snapshot ()
  "Restore a window snapshot from the window-snapshots alist."
  (interactive)
  (let* ((snapshot-name (completing-read "Choose snapshot: " (mapcar #'car window-snapshots)))
	 (snapshot (get-window-snapshot snapshot-name)))
    (if snapshot
	(set-window-configuration snapshot)
      (message "Snapshot %s not found" snapshot-name))))
[code]sudo apt install pulseaudio-utils[/code]
[code]pactl set-sink-volume 0 175%[/code]
[code]pacmd list-sinks | grep -e 'name:' -e 'index'[/code]
(ql:quickload :log4cl)

(defvar *foo* '(:a :b :c))

(log:info *foo*)
;; <INFO> [13:36:49] cl-user () - *FOO*: (:A :B :C)

(log:info "foo is " *foo*)
;; <INFO> [13:37:22] cl-user () - foo is *FOO*: (:A :B :C)
(log:info "foo is ~{~a~}" *foo*)
;; <INFO> [13:39:05] cl-user () - foo is ABC

    #+nil
    (progn
       (defvar *test-data* nil)
       (setf *test-data* (make-instance 'foo …)))

(inspect *foo*)

The object is a proper list of length 3.
0. 0: :A
1. 1: :B

2. 2: :C
> q

(defclass foo ()
    ((a :accessor foo-a :initform '(:a :b :c))
     (b :accessor foo-b :initform :b)))
;; #<STANDARD-CLASS FOO>
(make-instance 'foo)
;; #<FOO {100F2B6183}>

#<FOO {100F2B6183}>
--------------------
Class: #<STANDARD-CLASS FOO>
--------------------
 Group slots by inheritance [ ]
 Sort slots alphabetically  [X]

All Slots:
[ ]  A = (:A :B :C)
[ ]  B = :B

[set value]  [make unbound]

#<CONS {100F5E2A07}>
--------------------
A proper list:
0: :A
1: :B
2: :C

(declaim (optimize (speed 0) (space 0) (debug 3)))

(defun my-fun (xyz)
  (declare (optimize (debug 3)))
  …)

(defun factorial (n)
  (if (plusp n)
    (* n (factorial (1- n)))
    1))

(trace factorial)

(factorial 2)
  0: (FACTORIAL 3)
    1: (FACTORIAL 2)
      2: (FACTORIAL 1)
        3: (FACTORIAL 0)
        3: FACTORIAL returned 1
      2: FACTORIAL returned 1
    1: FACTORIAL returned 2
  0: FACTORIAL returned 6
6

(untrace factorial)

(declaim (optimize (debug 3)))

(trace foo :methods t)

(foo 2.0d0)
  0: (FOO 2.0d0)
    1: ((SB-PCL::COMBINED-METHOD FOO) 2.0d0)
      2: ((METHOD FOO (FLOAT)) 2.0d0)
        3: ((METHOD FOO (T)) 2.0d0)
        3: (METHOD FOO (T)) returned 3
      2: (METHOD FOO (FLOAT)) returned 9
      2: ((METHOD FOO :AFTER (DOUBLE-FLOAT)) 2.0d0)
      2: (METHOD FOO :AFTER (DOUBLE-FLOAT)) returned DOUBLE
    1: (SB-PCL::COMBINED-METHOD FOO) returned 9
  0: FOO returned 9
9

(step (factorial 2))

Evaluating call:
  (FACTORIAL 2)
With arguments:
  2
   [Condition of type SB-EXT:STEP-FORM-CONDITION]

Restarts:
 0: [STEP-CONTINUE] Resume normal execution
 1: [STEP-OUT] Resume stepping after returning from this function
 2: [STEP-NEXT] Step over call
 3: [STEP-INTO] Step into call
 4: [RETRY] Retry SLIME REPL evaluation request.
 5: [*ABORT] Return to SLIME's top level.
 --more--

Backtrace:
  0: ((LAMBDA ()))
  1: (SB-INT:SIMPLE-EVAL-IN-LEXENV (LET ((SB-IMPL::*STEP-OUT* :MAYBE)) (UNWIND-PROTECT (SB-IMPL::WITH-STEPPING-ENABLED #))) #S(SB-KERNEL:LEXENV :FUNS NIL :VARS NIL :BLOCKS NIL :TAGS NIL :TYPE-RESTRICTIONS ..
  2: (SB-INT:SIMPLE-EVAL-IN-LEXENV (STEP (FACTORIAL 2)) #<NULL-LEXENV>)
  3: (EVAL (STEP (FACTORIAL 2)))

(dolist (file (uiop:directory-files "./"))
   (legit:git-add :paths (pathname file))
   (legit:git-commit :files (pathname file) :message (format nil "add ~a" (file-namestring file))))

import pandas as pd
import numpy as np
import plotly.plotly as py
import plotly.graph_objs as go
import plotly

import matplotlib.pyplot as plt
from plotly import tools
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import plotly.figure_factory as ff
from IPython.display import HTML, Image

df=pd.read_csv("./datos/Pokemon.csv")

df.head()

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 800 entries, 0 to 799
Data columns (total 13 columns):
#             800 non-null int64
Name          800 non-null object
Type 1        800 non-null object
Type 2        414 non-null object
Total         800 non-null int64
HP            800 non-null int64
Attack        800 non-null int64
Defense       800 non-null int64
Sp. Atk       800 non-null int64
Sp. Def       800 non-null int64
Speed         800 non-null int64
Generation    800 non-null int64
Legendary     800 non-null bool
dtypes: bool(1), int64(9), object(3)
memory usage: 75.9+ KB

#Se busca los datos del pokemon Charizard
x = df[df["Name"] == "Charizard"]
#Se crea la grafica scatterpolar donde se le pasa  las variables que se quiere graficar. HP, Ataque, defensa, SP atk, 
#Sp def, velocidad y se define los nombres de los ejes.
data = [go.Scatterpolar(
  r = [x['HP'].values[0],x['Attack'].values[0],x['Defense'].values[0],x['Sp. Atk'].values[0],x['Sp. Def'].values[0],x['Speed'].values[0],x["HP"].values[0]],
  theta = ['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed','HP'],
  fill = 'toself'
)]

# se crea el layout, donde se le pasa un diccionario  donde se define los ejes de los radios, que son visibles y
#su rango en este caso desde 0 a 250, no se muestra legenda, y el título de la gráfica.

layout = go.Layout(
  polar = dict(
    radialaxis = dict(
      visible = True,
      range = [0, 250]
    )
  ),
  showlegend = False,
  title = "Stats of {}".format(x.Name.values[0])
)
#Se crea la instancia fig donde se pasa los datos y el layout.
fig = go.Figure(data=data, layout=layout)
#Se gràfica la gráfica
iplot(fig, filename = "Single Pokemon stats")

# Se crea una función donde se hace la comparación vía gráfica de la estadística de dos pokemons.
def compare2pokemon(x,y):
    #Se  captura los datos de los dos pokemons
    x = df[df["Name"] == x]
    y = df[df["Name"] == y]

    #Se define lo que se quiere gráficar del primer y segundo pokemon.
    trace0 = go.Scatterpolar(
      r = [x['HP'].values[0],x['Attack'].values[0],x['Defense'].values[0],x['Sp. Atk'].values[0],x['Sp. Def'].values[0],x['Speed'].values[0],x["HP"].values[0]],
      theta = ['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed','HP'],
      fill = 'toself',
      name = x.Name.values[0]
    )

    trace1 = go.Scatterpolar(
      r = [y['HP'].values[0],y['Attack'].values[0],y['Defense'].values[0],y['Sp. Atk'].values[0],y['Sp. Def'].values[0],y['Speed'].values[0],y["HP"].values[0]],
      theta = ['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed','HP'],
      fill = 'toself',
      name = y.Name.values[0]
    )

    #se define data como una lista que contiene los datos de los dos pokemon
    data = [trace0, trace1]

    #Se define el layout como en la gráfica anterior.
    layout = go.Layout(
      polar = dict(
        radialaxis = dict(
          visible = True,
          range = [0, 200]
        )
      ),
      showlegend = True,
      title = "{} vs {}".format(x.Name.values[0],y.Name.values[0])
    )
    #Se crea la instancia donde se pasa los datos y el layout
    fig = go.Figure(data=data, layout=layout)
    #Se crea la grafica.
    iplot(fig, filename = "Two Pokemon stats")

# Se compara primeape y muk
compare2pokemon("Primeape", "Muk")

(coo:document-system :my-system)

Object matchers
===============

This kind of matchers checks some sort of properties on an object, etc.

.. cl:package:: hamcrest/matchers

.. cl:macro:: has-plist-entries

(def-has-macro
    has-plist-entries
    "Matches plist entries:

.. code-block:: common-lisp-repl

   TEST> (let ((obj '(:foo :bar)))
           (assert-that obj
                        (has-plist-entries :foo \"bar\"
                                           :blah \"minor\")))
     × Key :FOO has :BAR value, but \"bar\" was expected

This way you can test any number of plist's entries."

    :check-obj-type (check-if-list object)
    :get-key-value (let ((key-value (getf object key 'absent)))
                      (when (eql key-value 'absent)
                          …

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Se crea el dataframe data_pais, data_vzla, data_global y co2_ppm

data_pais = pd.read_csv("./datos/GlobalLandTemperaturesByCountry.csv")
#Se crea una copia del dataframe obteniendo solo la información de Venezuela.
data_vzla = data_pais[data_pais["Country"] == "Venezuela"].copy()
data_vzla["dt"] = pd.to_datetime(data_vzla["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Argentina.
data_arg = data_pais[data_pais["Country"] == "Argentina"].copy()
data_arg["dt"] = pd.to_datetime(data_arg["dt"])

#Se crea una copia del dataframe obteniendo solo la información de USA.
data_canada = data_pais[data_pais["Country"] == "Canada"].copy()
data_canada["dt"] = pd.to_datetime(data_canada["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Mexico.
data_mexico = data_pais[data_pais["Country"] == "Mexico"].copy()
data_mexico["dt"] = pd.to_datetime(data_mexico["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Brasil.
data_brasil = data_pais[data_pais["Country"] == "Brazil"].copy()
data_brasil["dt"] = pd.to_datetime(data_brasil["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Venezuela.
data_chile = data_pais[data_pais["Country"] == "Chile"].copy()
data_chile["dt"] = pd.to_datetime(data_chile["dt"])

#Se crea el dataframe de la temperatura global. 
data_global = pd.read_csv("./datos/GlobalTemperatures.csv")
#Se modifica la fecha y hora como datetime.
data_global["dt"] = pd.to_datetime(data_global["dt"])
#Se crea el dataframe del co2.
co2_ppm = pd.read_csv("./datos/archive.csv")

data_pais.head()

data_pais.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 577462 entries, 0 to 577461
Data columns (total 4 columns):
dt                               577462 non-null object
AverageTemperature               544811 non-null float64
AverageTemperatureUncertainty    545550 non-null float64
Country                          577462 non-null object
dtypes: float64(2), object(2)
memory usage: 17.6+ MB

data_vzla.head()

data_vzla.describe().T

data_vzla.corr()

data_arg.head()

data_arg.describe().T

data_brasil.head()

data_brasil.describe().T

data_chile.head()

data_chile.describe().T

data_mexico.head()

data_mexico.describe().T

data_canada.head()

data_canada.describe().T

annual_mean_global = data_global.groupby(data_global["dt"].dt.year).mean()
reference_temperature_global = annual_mean_global.loc[1951:1980].mean()["LandAndOceanAverageTemperature"]
annual_mean_global["Anomaly"] = annual_mean_global["LandAndOceanAverageTemperature"] - reference_temperature_global

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_global.loc[1960:2015]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Anomalia anual de la temperatura promedio global")
plt.xlabel('')
plt.ylabel('Anomalia de la temperatura')
plt.show()

annual_mean_vzla = data_vzla.groupby(data_vzla["dt"].dt.year).mean()
reference_temperature_vzla = annual_mean_vzla.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_vzla["Anomaly"] = annual_mean_vzla["AverageTemperature"] - reference_temperature_vzla

annual_mean_vzla.head()

annual_mean_vzla.tail()

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_vzla.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Venezuela")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

annual_mean_arg = data_arg.groupby(data_arg["dt"].dt.year).mean()
reference_temperature_arg = annual_mean_arg.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_arg["Anomaly"] = annual_mean_arg["AverageTemperature"] - reference_temperature_arg

annual_mean_arg.head()

annual_mean_arg.tail()

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_arg.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Argentina")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

annual_mean_brasil = data_brasil.groupby(data_brasil["dt"].dt.year).mean()
reference_temperature_brasil = annual_mean_brasil.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_brasil["Anomaly"] = annual_mean_brasil["AverageTemperature"] - reference_temperature_brasil

annual_mean_brasil.head()

annual_mean_brasil.tail()

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_brasil.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Brasil")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

annual_mean_chile = data_chile.groupby(data_chile["dt"].dt.year).mean()
reference_temperature_chile = annual_mean_chile.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_chile["Anomaly"] = annual_mean_chile["AverageTemperature"] - reference_temperature_chile

annual_mean_chile.head()

annual_mean_chile.tail()

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_chile.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Chile")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

annual_mean_mexico = data_mexico.groupby(data_mexico["dt"].dt.year).mean()
reference_temperature_mexico = annual_mean_mexico.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_mexico["Anomaly"] = annual_mean_mexico["AverageTemperature"] - reference_temperature_mexico

annual_mean_mexico.head()

annual_mean_mexico.tail()

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_mexico.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Mexico")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

annual_mean_canada = data_canada.groupby(data_canada["dt"].dt.year).mean()
reference_temperature_canada = annual_mean_canada.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_canada["Anomaly"] = annual_mean_canada["AverageTemperature"] - reference_temperature_canada

annual_mean_canada.head()

annual_mean_canada.tail()

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_canada.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Canadá")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

plt.figure()
plt.style.use("fivethirtyeight")
annual_co2_ppm = co2_ppm.groupby(co2_ppm["Year"]).mean()
annual_co2_ppm.loc[1960:2015]["Carbon Dioxide (ppm)"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Nivel anual global de CO2 en la Atmosfera")
plt.ylabel("CO2 partes por millón")
plt.show()

annual_co2_temp = pd.merge(annual_mean_global.loc[1960:2015], annual_co2_ppm.loc[1960:2015], left_index=True, right_index=True)
annual_co2_temp = annual_co2_temp[["LandAndOceanAverageTemperature", "Anomaly", "Carbon Dioxide (ppm)"]].copy()
annual_co2_temp.corr()

sns.heatmap(annual_co2_temp.corr())

<matplotlib.axes._subplots.AxesSubplot at 0x7fcacea9cdd8>

plt.figure(figsize=(10,8))
sns.scatterplot(x="Anomaly",y="Carbon Dioxide (ppm)", data=annual_co2_temp)

<matplotlib.axes._subplots.AxesSubplot at 0x7fcace8d6c50>

#Se importa las librerias matplitlib, numpy, pandas, seaborn
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
sns.set_style("white")
import pandas as pd
my_dpi=96

# Se obtiene los datos en formato csv  y se convierte en un dataframe
url = 'https://python-graph-gallery.com/wp-content/uploads/gapminderData.csv'
data = pd.read_csv(url)

#Se muestra el data frame
data.head()

#Se revisa los tipos de datos de las columnas
data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1704 entries, 0 to 1703
Data columns (total 6 columns):
country      1704 non-null object
year         1704 non-null int64
pop          1704 non-null float64
continent    1704 non-null object
lifeExp      1704 non-null float64
gdpPercap    1704 non-null float64
dtypes: float64(3), int64(1), object(2)
memory usage: 80.0+ KB

# Transformar los datos de la columna continente a categoria.
data['continent']=pd.Categorical(data['continent'])
data.head()

#Se vuelve a revisar los tipos de las columnas y ahora se tiene que contienen es categoria
data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1704 entries, 0 to 1703
Data columns (total 6 columns):
country      1704 non-null object
year         1704 non-null int64
pop          1704 non-null float64
continent    1704 non-null category
lifeExp      1704 non-null float64
gdpPercap    1704 non-null float64
dtypes: category(1), float64(3), int64(1), object(1)
memory usage: 68.5+ KB

# Por cada año
for i in data.year.unique():
    # inicializa la figura
    fig = plt.figure(figsize=(680/my_dpi, 480/my_dpi), dpi=my_dpi)
    # se cambia de color con c y alpha, se mapea el color del eje X.
    tmp=data[ data.year == i ]
    plt.scatter(tmp['lifeExp'], tmp['gdpPercap'] , s=tmp['pop']/200000 , c=tmp['continent'].cat.codes, cmap="Accent", alpha=0.6, edgecolors="white", linewidth=2)
    # Se agrega el título, y los ejes.
    plt.yscale('log')
    plt.xlabel("Experanza de vida")
    plt.ylabel("PIB per capita")
    plt.title("Año: "+str(i) )
    plt.ylim(0,100000)
    plt.xlim(30, 90)

    # Se salva el archivo como png, cada archivo por año.
    filename='Gapminder_step'+str(i)+'.png'
    plt.savefig(filename, dpi=96)
    plt.gca()

(defclass person ()
  ((name
    :initarg :name
    :accessor name)
   (lisper
    :initform nil
    :accessor lisper)))

;; => #<STANDARD-CLASS PERSON>

(defvar p1 (make-instance 'person :name "me" ))
;;                                 ^^^^ initarg
;; => #<PERSON {1006234593}>

(name p1)
;;^^^ accessor
;; => "me"

(lisper p1)
;; => nil
;;    ^^ initform (slot unbound by default)

(setf (lisper p1) t)

(defclass child (person)
  ())

(defclass child (person)
  ((can-walk-p
     :accessor can-walk-p
     :initform t)))
;; #<STANDARD-CLASS CHILD>

(can-walk-p (make-instance 'child))
;; T

(defclass person ()
  ((name
    :initarg :name
    :accessor name)
   (lisper
    :initform nil
    :accessor lisper)))

(class-of p1)
#<STANDARD-CLASS PERSON>

(type-of p1)
PERSON

(defclass <class-name> (list of super classes)
  ((slot-1
     :slot-option slot-argument)
   (slot-2, etc))
  (:optional-class-option
   :another-optional-class-option))

(defclass point ()
  (x y z))

(defvar p1 (make-instance 'person :name "me" ))

(defun make-person (name &key lisper)
  (make-instance 'person :name name :lisper lisper))

(defvar pt (make-instance 'point))

(inspect pt)
The object is a STANDARD-OBJECT of type POINT.
0. X: "unbound"
1. Y: "unbound"
2. Z: "unbound"

(slot-value pt 'x) ;; => condition: the slot is unbound

(setf (slot-value pt 'x) 1)
(slot-value pt 'x) ;; => 1

(make-instance 'person :name "me")

(defclass foo ()
    ((a
      :initarg :a
      :initform (error "you didn't supply an initial value for slot a"))))
;; #<STANDARD-CLASS FOO>

(make-instance 'foo) ;; => enters the debugger.

(name p1) ;; => "me"

(type-of #'name)
STANDARD-GENERIC-FUNCTION

(with-slots (name lisper)
    c1
  (format t "got ~a, ~a~&" name lisper))

(with-slots ((n name)
             (l lisper))
    c1
  (format t "got ~a, ~a~&" n l))

(with-accessors ((name        name)
                  ^^variable  ^^accessor
                 (lisper lisper))
            p1
          (format t "name: ~a, lisper: ~a" name lisper))

(defclass person ()
  ((name :initarg :name :accessor name)
   (species
      :initform 'homo-sapiens
      :accessor species
      :allocation :class)))

;; Note that the slot "lisper" was removed in existing instances.
(inspect p1)
;; The object is a STANDARD-OBJECT of type PERSON.
;; 0. NAME: "me"
;; 1. SPECIES: HOMO-SAPIENS
;; > q

(defvar p2 (make-instance 'person))

(species p1)
(species p2)
;; HOMO-SAPIENS

(setf (species p2) 'homo-numericus)
;; HOMO-NUMERICUS

(species p1)
;; HOMO-NUMERICUS

(species (make-instance 'person))
;; HOMO-NUMERICUS

(let ((temp (make-instance 'person)))
    (setf (species temp) 'homo-lisper))
;; HOMO-LISPER
(species (make-instance 'person))
;; HOMO-LISPER

(find-class 'point)
;; #<STANDARD-CLASS POINT 275B78DC>

(class-name (find-class 'point))
;; POINT

(class-of my-point)
;; #<STANDARD-CLASS POINT 275B78DC>

(typep my-point (class-of my-point))
;; T

(class-of (class-of my-point))
;; #<STANDARD-CLASS STANDARD-CLASS 20306534>

(type-of c1)
;; CHILD

(subtypep (type-of c1) 'person)
;; T

(ql:quickload "closer-mop")
;; ...

(closer-mop:subclassp (class-of c1) 'person)
;; T

child <- person <-- standard-object <- t

(closer-mop:class-precedence-list (class-of c1))
;; (#<standard-class child>
;;  #<standard-class person>
;;  #<standard-class standard-object>
;;  #<sb-pcl::slot-class sb-pcl::slot-object>
;;  #<sb-pcl:system-class t>)

(closer-mop:class-direct-superclasses (class-of c1))
;; (#<standard-class person>)

(defun baby (child person)
  ())

(defclass person ()
  ((name
    :initarg :name
    :accessor name)
   (lisper
    :initform nil
    :accessor lisper)))

(setf p1 (make-instance 'person :name "me" ))

(lisper p1)
;; NIL

(defclass person ()
  ((name
    :initarg :name
    :accessor name)
   (lisper
    :initform t        ;; <-- from nil to t
    :accessor lisper)))

(lisper p1)
;; NIL (of course!)

(lisper (make-instance 'person :name "You"))
;; T

(defclass person ()
  ((name
    :initarg :name
    :accessor name)
   (lisper
    :initform nil
    :accessor lisper)
   (age
    :initarg :arg
    :initform 18
    :accessor age)))

(age p1)
;; => slot unbound error. This is different from "slot missing":

(slot-value p1 'bwarf)
;; => "the slot bwarf is missing from the object #<person…>"

(setf (age p1) 30)
(age p1) ;; => 30

(defclass person ()
  ((name
    :initarg :name
    :accessor name)))

(slot-value p1 'lisper) ;; => slot lisper is missing.
(lisper p1) ;; => there is no applicable method for the generic function lisper when called with arguments #(lisper).

(change-class p1 'child)
;; we can also set slots of the new class:
(change-class p1 'child :can-walk-p nil)

(class-of p1)
;; #<STANDARD-CLASS CHILD>

(can-walk-p p1)
;; T

#<PERSON {1006234593}>

#<PERSON me lisper: t>

(defmethod print-object ((obj person) stream)
      (print-unreadable-object (obj stream :type t)
        (with-accessors ((name name)
                         (lisper lisper))
            obj
          (format stream "~a, lisper: ~a" name lisper))))

p1
;; #<PERSON me, lisper: T>

(defmethod print-object ((obj person) stream)
  (print-unreadable-object (obj stream :type t)
    (format stream "~a, lisper: ~a" (name obj) (lisper obj))))

(defmethod print-object ((obj person) stream)
  (print-unreadable-object (obj stream :type t :identity t)))

(find-class 'symbol)
;; #<BUILT-IN-CLASS SYMBOL>
(class-name *)
;; SYMBOL
(eq ** (class-of 'symbol))
;; T
(class-of ***)
;; #<STANDARD-CLASS BUILT-IN-CLASS>

(find-class t)
;; #<BUILT-IN-CLASS T 20305AEC>

(defstruct foo)
FOO

(class-of (make-foo))
;; #<STRUCTURE-CLASS FOO 21DE8714>

closer-mop:class-default-initargs
closer-mop:class-direct-default-initargs
closer-mop:class-direct-slots
closer-mop:class-direct-subclasses
closer-mop:class-direct-superclasses
closer-mop:class-precedence-list
closer-mop:class-slots
closer-mop:classp
closer-mop:extract-lambda-list
closer-mop:extract-specializer-names
closer-mop:generic-function-argument-precedence-order
closer-mop:generic-function-declarations
closer-mop:generic-function-lambda-list
closer-mop:generic-function-method-class
closer-mop:generic-function-method-combination
closer-mop:generic-function-methods
closer-mop:generic-function-name
closer-mop:method-combination
closer-mop:method-function
closer-mop:method-generic-function
closer-mop:method-lambda-list
closer-mop:method-specializers
closer-mop:slot-definition
closer-mop:slot-definition-allocation
closer-mop:slot-definition-initargs
closer-mop:slot-definition-initform
closer-mop:slot-definition-initfunction
closer-mop:slot-definition-location
closer-mop:slot-definition-name
closer-mop:slot-definition-readers
closer-mop:slot-definition-type
closer-mop:slot-definition-writers
closer-mop:specializer-direct-generic-functions
closer-mop:specializer-direct-methods
closer-mop:standard-accessor-method

(defclass/std example ()
  ((slot1 slot2 slot3)))

(defclass example ()
  ((slot1
    :accessor slot1
    :initarg :slot1
    :initform nil)
   (slot2
     :accessor slot2
     :initarg :slot2
     :initform nil)
   (slot3
     :accessor slot3
     :initarg :slot3
     :initform nil)))

(defclass person ()
  ((name
    :initarg :name
    :accessor name)))
;; => #<STANDARD-CLASS PERSON>

(defclass child (person)
  ())
;; #<STANDARD-CLASS CHILD>

(setf p1 (make-instance 'person :name "me"))
(setf c1 (make-instance 'child :name "Alice"))

(defmethod greet (obj)
  (format t "Are you a person ? You are a ~a.~&" (type-of obj)))
;; style-warning: Implicitly creating new generic function common-lisp-user::greet.
;; #<STANDARD-METHOD GREET (t) {1008EE4603}>

(greet :anything)
;; Are you a person ? You are a KEYWORD.
;; NIL
(greet p1)
;; Are you a person ? You are a PERSON.

(defgeneric greet (obj)
  (:documentation "say hello"))
;; STYLE-WARNING: redefining COMMON-LISP-USER::GREET in DEFGENERIC
;; #<STANDARD-GENERIC-FUNCTION GREET (2)>

(defmethod greet ((obj person))
  (format t "Hello ~a !~&" (name obj)))
;; #<STANDARD-METHOD GREET (PERSON) {1007C26743}>

(greet p1) ;; => "Hello me !"
(greet c1) ;; => "Hello Alice !"

(defmethod greet ((obj child))
  (format t "ur so cute~&"))
;; #<STANDARD-METHOD GREET (CHILD) {1008F3C1C3}>

(greet p1) ;; => "Hello me !"
(greet c1) ;; => "ur so cute"

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Method combination: before, after, around.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defmethod greet :before ((obj person))
  (format t "-- before person~&"))
#<STANDARD-METHOD GREET :BEFORE (PERSON) {100C94A013}>

(greet p1)
;; -- before person
;; Hello me

(defmethod greet :before ((obj child))
  (format t "-- before child~&"))
;; #<STANDARD-METHOD GREET :BEFORE (CHILD) {100AD32A43}>
(greet c1)
;; -- before child
;; -- before person
;; ur so cute

(defmethod greet :after ((obj person))
  (format t "-- after person~&"))
;; #<STANDARD-METHOD GREET :AFTER (PERSON) {100CA2E1A3}>
(greet p1)
;; -- before person
;; Hello me
;; -- after person

(defmethod greet :after ((obj child))
  (format t "-- after child~&"))
;; #<STANDARD-METHOD GREET :AFTER (CHILD) {10075B71F3}>
(greet c1)
;; -- before child
;; -- before person
;; ur so cute
;; -- after person
;; -- after child

(defmethod greet :around ((obj child))
  (format t "Hello my dear~&"))
;; #<STANDARD-METHOD GREET :AROUND (CHILD) {10076658E3}>
(greet c1) ;; Hello my dear

;; call-next-method

(defmethod greet :around ((obj child))
  (format t "Hello my dear~&")
  (when (next-method-p)
    (call-next-method)))
;; #<standard-method greet :around (child) {100AF76863}>

(greet c1)
;; Hello my dear
;; -- before child
;; -- before person
;; ur so cute
;; -- after person
;; -- after child

;;;;;;;;;;;;;;;;;
;; Adding in &key
;;;;;;;;;;;;;;;;;

;; In order to add "&key" to our generic method, we need to remove its definition first.
(fmakunbound 'greet)  ;; with Slime: C-c C-u (slime-undefine-function)
(defmethod greet ((obj person) &key talkative)
  (format t "Hello ~a~&" (name obj))
  (when talkative
    (format t "blah")))

(defgeneric greet (obj &key &allow-other-keys)
  (:documentation "say hi"))

(defmethod greet (obj &key &allow-other-keys)
  (format t "Are you a person ? You are a ~a.~&" (type-of obj)))

(defmethod greet ((obj person) &key talkative &allow-other-keys)
  (format t "Hello ~a !~&" (name obj))
  (when talkative
    (format t "blah")))

(greet p1 :talkative t) ;; ok
(greet p1 :foo t) ;; still ok

;;;;;;;;;;;;;;;;;;;;;;;

(defgeneric greet (obj)
  (:documentation "say hello")
  (:method (obj)
    (format t "Are you a person ? You are a ~a~&." (type-of obj)))
  (:method ((obj person))
    (format t "Hello ~a !~&" (name obj)))
  (:method ((obj child))
    (format t "ur so cute~&")))

;;;;;;;;;;;;;;;;
;;; Specializers
;;;;;;;;;;;;;;;;

(defgeneric feed (obj meal-type)
  (:method (obj meal-type)
    (declare (ignorable meal-type))
    (format t "eating~&")))

(defmethod feed (obj (meal-type (eql :dessert)))
    (declare (ignorable meal-type))
    (format t "mmh, dessert !~&"))

(feed c1 :dessert)
;; mmh, dessert !

(defmethod feed ((obj child) (meal-type (eql :soup)))
    (declare (ignorable meal-type))
    (format t "bwark~&"))

(feed p1 :soup)
;; eating
(feed c1 :soup)
;; bwark

(defgeneric greet (obj)
  (:documentation "says hi")
  (:method (obj)
    (format t "Hi")))

(defmethod greet (foo)
  ...)

(defmethod greet ((foo person))
  ...)

(defmethod feed ((obj child) (meal-type (eql :soup)))
    (declare (ignorable meal-type))
    (format t "bwark~&"))

(feed c1 :soup)
;; "bwark"

attempt to add the method
  #<STANDARD-METHOD NIL (#<STANDARD-CLASS CHILD>) {1009504233}>
to the generic function
  #<STANDARD-GENERIC-FUNCTION GREET (2)>;
but the method and generic function differ in whether they accept
&REST or &KEY arguments.

(defgeneric hug (a b)
   (:documentation "Hug between two persons."))
;; #<STANDARD-GENERIC-FUNCTION HUG (0)>

(defmethod hug ((a person) (b person))
  :person-person-hug)

(defmethod hug ((a person) (b child))
  :person-child-hug)

(defmethod (setf name) (new-val (obj person))
  (if (equalp new-val "james bond")
    (format t "Dude that's not possible.~&")
    (setf (slot-value obj 'name) new-val)))

(setf (name p1) "james bond") ;; -> no rename

(closer-mop:generic-function-methods #'greet)
(#<STANDARD-METHOD GREET (CHILD) {10098406A3}>
 #<STANDARD-METHOD GREET (PERSON) {1009008EC3}>
 #<STANDARD-METHOD GREET (T) {1008E6EBB3}>)

(defmethod greet ((obj child))
  (format t "ur so cute~&")
  (when (next-method-p)
    (call-next-method)))
;; STYLE-WARNING: REDEFINING GREET (#<STANDARD-CLASS CHILD>) in DEFMETHOD
;; #<STANDARD-METHOD GREET (child) {1003D3DB43}>

(greet c1)
;; ur so cute
;; Hello Alice !

progn + list nconc and max or append min

(progn
  (method-1 args)
  (method-2 args)
  (method-3 args))

(defgeneric foo (obj)
  (:method-combination progn))

(defmethod foo progn ((obj obj))
   (...))

(defgeneric dishes (obj)
   (:method-combination progn)
   (:method progn (obj)
     (format t "- clean and dry.~&"))
   (:method progn ((obj person))
     (format t "- bring a person's dishes~&"))
   (:method progn ((obj child))
     (format t "- bring the baby dishes~&")))
;; #<STANDARD-GENERIC-FUNCTION DISHES (3)>

(dishes c1)
;; - bring the baby dishes
;; - bring a person's dishes
;; - clean and dry.

(greet c1)
;; ur so cute  --> only the most applicable method was called.

(list
  (method-1 args)
  (method-2 args)
  (method-3 args))

(defgeneric tidy (obj)
  (:method-combination list)
  (:method list (obj)
    :foo)
  (:method list ((obj person))
    :books)
  (:method list ((obj child))
    :toys))
;; #<STANDARD-GENERIC-FUNCTION TIDY (3)>

(tidy c1)
;; (:toys :books :foo)

(defmethod tidy :around (obj)
   (let ((res (call-next-method)))
     (format t "I'm going to clean up ~a~&" res)
     (when (> (length res)
              1)
       (format t "that's too much !~&"))))

(tidy c1)
;; I'm going to clean up (toys book foo)
;; that's too much !

(defgeneric foo (x)
  (:method (x) 3))
(defmethod foo :around ((x fixnum))
  (1+ (call-next-method)))
(defmethod foo ((x integer))
  (* 2 (call-next-method)))
(defmethod foo ((x float))
  (* 3 (call-next-method)))
(defmethod foo :before ((x single-float))
  'single)
(defmethod foo :after ((x double-float))
 'double)

(trace foo :methods t)

(foo 2.0d0)
  0: (FOO 2.0d0)
    1: ((SB-PCL::COMBINED-METHOD FOO) 2.0d0)
      2: ((METHOD FOO (FLOAT)) 2.0d0)
        3: ((METHOD FOO (T)) 2.0d0)
        3: (METHOD FOO (T)) returned 3
      2: (METHOD FOO (FLOAT)) returned 9
      2: ((METHOD FOO :AFTER (DOUBLE-FLOAT)) 2.0d0)
      2: (METHOD FOO :AFTER (DOUBLE-FLOAT)) returned DOUBLE
    1: (SB-PCL::COMBINED-METHOD FOO) returned 9
  0: FOO returned 9
9

(class-of p1) ;; #<STANDARD-CLASS PERSON>

(defclass counted-class (standard-class)
  ((counter :initform 0)))
#<STANDARD-CLASS COUNTED-CLASS>

(unintern 'person)
;; this is necessary to change the metaclass of person.
;; or (setf (find-class 'person) nil)
;; https://stackoverflow.com/questions/38811931/how-to-change-classs-metaclass#38812140

(defclass person ()
  ((name
    :initarg :name
    :accessor name)
  (:metaclass counted-class))) ;; <- metaclass
;; #<COUNTED-CLASS PERSON>
;;   ^^^ not standard-class anymore.

(defmethod closer-mop:validate-superclass ((class counted-class)
                                           (superclass standard-class))
  t)

(defmethod make-instance :after ((class counted-class) &key)
  (incf (slot-value class 'counter)))
;; #<STANDARD-METHOD MAKE-INSTANCE :AFTER (COUNTED-CLASS) {1007718473}>

(defvar p3 (make-instance 'person :name "adam"))
#<PERSON {1007A8F5B3}>

(slot-value p3 'counter)
;; => error. No, our new slot isn't on the person class.
(slot-value (find-class 'person) 'counter)
;; 1

(make-instance 'person :name "eve")
;; #<PERSON {1007AD5773}>
(slot-value (find-class 'person) 'counter)
;; 2

(defmethod initialize-instance :after ((obj person) &key)
  (do something with obj))

initialize-instance instance &rest initargs &key &allow-other-keys

├── archetypes
│   └── default.md
├── config.toml
├── content
├── data
├── layouts
├── static
└── themes
baseURL = "http://example.org/"
languageCode = "en-us"
title = "My New Hugo Site"
baseURL = "/"
languageCode = "en-us"
title = "My New Hugo Site"
cd themes
git submodule add https://github.com/halogenica/beautifulhugo.git
cd ..
[submodule "themes/beautifulhugo"]
	path = themes/beautifulhugo
	url = https://github.com/halogenica/beautifulhugo.git
theme = "beautifulhugo"
                   | EN
+------------------+----+
  Pages            |  7
  Paginator pages  |  0
  Non-page files   |  0
  Static files     | 33
  Processed images |  0
  Aliases          |  1
  Sitemaps         |  1
  Cleaned          |  0

Total in 46 ms
Watching for changes in /Users/erick/Code/hugo/myblog/{content,data,layouts,static,themes}
Watching for config changes in /Users/erick/Code/hugo/myblog/config.toml
Serving pages from memory
Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
Web Server is available at http://localhost:9000/ (bind address 127.0.0.1)
Press Ctrl+C to stop
---
title: "Hello World"
date: 2018-09-22T15:05:47-05:00
draft: true
---
# This is a heading with level 1

## This is a heading with level 2

This is a paragraph

This is some python code

This is a list:

- item 1
- item 2
  alarm at 7:45 am      # \"at\" is optional and doesn't change the meaning
  alarm 7:45 am
  alarm 9 pm
  alarm 7               # If AM/PM not specified, assumes AM
  alarm in 5 minutes    # Relative alarm times, in minutes or hours
  alarm in 10m          # minutes, minute, mins, min, , m are synonyms
  alarm in 7 hours      # hours, hour, hr, h are synonyms
  alarm in 8h
  alarm in 7:29         # h:mm format - seven hours, twenty-nine minutes
  alarm reset           # off/never/delete/disable/cancel/clear/reset

make shuffletron-bin  # sbcl
sudo make install
./shuffletron

apt install libflac-dev
apt install libvorbis-dev

Command list:

  /[query]       Search library for [query].
  show           Print search matches, highlighting songs in queue.
  back           Undo last search.
  [songs]        Play list of songs.
  all            Play all songs in selection (equivalent to \"0-\")
  +[songs]       Append list of songs to queue.
  pre[songs]     Prepend list of songs to queue.
  random         Play a random song from the current selection.
  random QUERY   Play a random song matching QUERY
  shuffle SONGS  Play songs in random order.

  queue          Print queue contents and current song playing.
  shuffle        Randomize order of songs in queue.
  clear          Clear the queue (current song continues playing)
  loop           Toggle loop mode (loop through songs in queue)
  qdrop          Remove last song from queue
  qdrop RANGES   Remove songs from queue
  qtag TAGS      Apply tags to all songs in queue
  fromqueue      Transfer queue to selection
  toqueue        Replace queue with selection

  now            Print name of song currently playing.
  play           Resume playing
  stop           Stop playing (current song pushed to head of queue)
  pause          Toggle paused/unpaused.
  skip           Skip currently playing song. If looping is enabled, this
                 song won't played again.
  next           Advance to next song. If looping is enabled, the current
                 song will be enqueued.
  repeat N       Add N repetitions of currently playing song to head of queue.
  seek TIME      Seek to time (in [h:]m:ss format, or a number in seconds)
  seek +TIME     Seek forward
  seek -TIME     Seek backward
  startat TIME   Always start playback at a given time (to skip long intros)

  tag            List tags of currently playing song.
  tag TAGS       Add one or more textual tags to the current song.
  untag TAGS     Remove the given tags from the currently playing song.
  tagged TAGS    Search for files having any of specified tags.
  tags           List all tags (and # occurrences) within current query.
  killtag TAGS   Remove all occurances of the given tags
  tagall TAGS    Apply tags to all selected songs
  untagall TAGS  Remove given tags from all selected songs

  time           Print current time
  alarm          Set alarm (see \"help alarms\")

  scanid3        Scan new files for ID3 tags
  prescan        Toggle file prescanning (useful if file IO is slow)
  exit           Exit the program.

  help [topic]   Help

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import threading
import time
import random

def sleeper(name, s_time):
    print('{} iniciado a las {}.'.format(
        name, time.strftime('%H:%M:%S', time.gmtime())))

    time.sleep(s_time)

    print('{} finalizado a las {}.'.format(
        name, time.strftime('%H:%M:%S', time.gmtime())))

for i in range(5):
    thread = threading.Thread(target=sleeper, args=(
        'Proceso ' + str(i + 1), random.randint(1, 9)))

    thread.start()

print('Yo he terminado, pero los otros subprocesos no.')

Proceso 1 iniciado a las 21:19:23.
Proceso 2 iniciado a las 21:19:23.
Proceso 3 iniciado a las 21:19:23.
Proceso 4 iniciado a las 21:19:23.
Proceso 5 iniciado a las 21:19:23.
Yo he terminado, pero los otros subprocesos no.
Proceso 1 finalizado a las 21:19:25.
Proceso 5 finalizado a las 21:19:26.
Proceso 4 finalizado a las 21:19:27.
Proceso 2 finalizado a las 21:19:32.
Proceso 3 finalizado a las 21:19:32.

class Miclase(object):

    def __del__(self):
        print "instance deleted"

a = Miclase()
b = a
del a

print b
print "Come on"
b = 1
print "END"

class Desc(object):

    def __init__(self, mul):
        self.mul = mul

    def __get__(self, obj, cls=None):
        return obj.value * self.mul

    def __set__(self, obj, value):
        raise AttributeError

    def __delete__(self, obj):
        del self

class Miclase(object):

    a12 = Desc(12)
    a200 = Desc(200)

    def __init__(self, value):
        self.value = value

c = Miclase(2)

print c.a12 #--> 24

c.a12 = 100  # ERROR: AttributeError

del Miclase.a12
c.a12=100

print c.a12  #--> 100 (no descriptor)

    def __delete__(self, obj):
        del self

from weakref import WeakKeyDictionary

class Desc(object):

    def __init__(self):
        self.data = WeakKeyDictionary()

    def __get__(self, obj, cls=None):
        if obj not in self.data:
            raise AttributeError
        total = sum(x for x in self.data.values())
        return (self.data.get(obj), total)

    def __set__(self, obj, value):
        if obj in self.data:
            raise AttributeError
        self.data[obj] = value

    def __delete__(self, obj):
        del self.data[obj]

class Miclase(object):

    value = Desc()

a = Miclase()
b = Miclase()

a.value = 2
b.value = 5

print a.value  #--> (2, 7)
print b.value  #--> (5, 7)

a.value = 100  # ERROR: AttributeError

del a.value
a.value = 11

print a.value  #--> (11, 16)
print b.value  #--> (5, 16)

del b

print a.value  #--> (11, 11)

>>> a = (1, 2, 3, 4)
>>> a += (5, 6, 7)
>>> print(a)
(1, 2, 3, 4, 5, 6, 7)

>>> a = [1, 2, 3, 4]
>>> a += [5, 6, 7]
>>> print( a )

>>> a = (1, 2, 3, 4)
>>> print(id(a))
192021604
>>> a += (5, 6, 7)
>>> print(id(a))
189519828

>>> a = [1, 2, 3, 4]
>>> print(id(a))
189780876
>>> a += [5, 6, 7]
>>> print(id(a))
189780876

>>> a = (1, 2, 3, 4)
>>> a = a + (5, 6, 7)

>>> a = [1, 2, 3, 4]
>>> a.extend([5, 6, 7])

class PointMutable(object):
    def __init__(self, x, y):
        self.x=x
        self.y=y

    def __repr__(self):
        return "<Point(%d,%d)>" % (self.x, self.y)

    def __sub__(self, other):
        self.x -= other.x
        self.y -= other.y
        return self

    def __add__(self, other):
        self.x += other.x
        self.y += other.y
        return self

    def move(self, dx, dy):
        self.x += dx
        self.y += dy
        return self

>>> p1=PointMutable(1, 1)
>>> p2=PointMutable(-1, 1)
>>> print p1.move(1, 1) - (p1 + p2).move(2, 2)
<Point(0,0)>

class PointInmutable(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return "<Point(%d,%d)>" % (self.x, self.y)

    def __sub__(self, other):
        return PointInmutable(self.x - other.x, self.y - other.y)

    def __add__(self, other):
        return PointInmutable(self.x + other.x, self.y + other.y)

    def move(self, dx, dy):
        return PointInmutable(self.x + dx, self.y + dy)

>>> p1=PointInmutable(1, 1)
>>> p2=PointInmutable(-1, 1)
>>> print p1.move(1, 1) - (p1 + p2).move(2, 2)
<Point(0,-2)>

#Se importa SparkContext y SparkConf
from pyspark import SparkContext, SparkConf

#Se crea la instancia de la configuración con el nombre de la aplicación contador
conf1 = SparkConf().setAppName("contador").setMaster("local[3]")

#Se crea el contexto pasando la instancia de la configuración
sc = SparkContext(conf = conf1)

#Se extrae las líneas del texto 
lineas = sc.textFile("data/declaracion_onut.text")

#Se extrae las palabras del texto y se cuentan
contarPalabras = lineas.flatMap(lambda linea: linea.split(" ")).countByValue()

#Se muestra las palabras con la cantidad de veces que tiene su aparición
for palabra, contador in contarPalabras.items():
    print("{} : {}".format(palabra, contador))

1942: : 1
La : 3
Declaración : 8
de : 29
las : 9
Naciones : 7
Unidas : 5
Representantes : 1
26 : 2
Estados : 3
que : 5
lucharon : 1
contra : 1
potencias : 1
del : 9
Eje : 1
Roma-Berlín-Tokio : 1
manifestaron : 1
su : 4
apoyo : 1
a : 10
la : 21
Carta : 3
Atlántico : 1
mediante : 1
firma : 1
« : 2
». : 2
En : 2
este : 2
trascendental : 2
documento, : 2
los : 9
signatarios : 4
se : 8
comprometían : 2
poner : 2
máximo : 2
empeño : 2
en : 7
guerra : 3
y : 10
no : 2
firmar : 2
una : 2
paz : 2
por : 3
separado. : 2
 : 9
prometiendo : 1
"emplear : 1
todos : 1
sus : 1
recursos, : 1
militares : 1
o : 1
económicos" : 1
"la : 1
lucha : 1
victoria : 1
sobre : 1
el : 5
hitlerismo". : 1
El : 2
día : 2
año : 1
nuevo : 1
1942, : 1
señor : 1
presidente : 2
Roosevelt : 1
señores : 1
Winston : 1
Churchill, : 1
Maxim : 1
Litvinov, : 1
Unión : 3
Soviética, : 1
T. : 1
V. : 1
Soong, : 1
China, : 2
firmaron : 1
un : 2
breve : 1
documento : 1
luego : 1
conocería : 1
como : 2
Unidas. : 2
Al : 1
siguiente : 1
sumaron : 1
representantes : 1
otras : 1
22 : 1
naciones : 1
más. : 1
alianza : 1
completa : 1
llegó : 1
esta : 1
forma : 1
concordaba : 1
con : 1
principios : 2
enunciados : 2
Atlántico, : 1
primera : 1
cláusula : 1
declaración : 2
reza : 1
países : 2
. : 4
han : 1
suscrito : 1
programa : 1
común : 1
propósitos : 1
conjunta : 1
Unidos : 2
América : 1
primer : 1
ministro : 1
Reino : 2
Unido : 2
Gran : 2
Bretaña : 2
e : 2
Irlanda : 2
Norte, : 2
fechada : 1
14 : 1
agosto : 1
1941, : 1
conocida : 1
Atlántico. : 1
Cuando : 1
tres : 1
años : 1
después : 1
iniciaban : 1
preparativos : 1
para : 1
conferencia : 1
San : 1
Francisco, : 1
únicamente : 1
invitó : 1
participar : 1
aquellos : 1
estados : 1
que, : 1
marzo : 1
1945, : 1
habían : 2
declarado : 1
Alemania : 1
al : 1
Japón : 1
firmado : 1
Signatarios : 1
Originales : 1
ONU : 1
Los : 3
originales : 1
fueron: : 1
América, : 1
Repúblicas : 1
Socialistas : 1
Soviéticas, : 1
Australia, : 1
Bélgica, : 1
Canadá, : 1
Costa : 1
Rica, : 1
Checoeslovaquia, : 1
Salvador, : 1
Grecia, : 1
Guatemala, : 1
Haití, : 1
Honduras, : 1
India, : 1
Luxemburgo, : 1
Nicaragua, : 1
Noruega, : 1
Nueva : 1
Zelandia, : 1
Países : 1
Bajos, : 1
Panamá, : 1
Polonia, : 1
República : 1
Dominicana, : 1
Sudafricana, : 1
Yugoeslavia : 1
firmantes : 1
posteriores : 1
Más : 1
tarde : 1
adhirieron : 1
siguientes : 1
(en : 1
orden : 1
firmas): : 1
México, : 1
Colombia, : 1
Iraq, : 1
Irán, : 1
Liberia, : 1
Paraguay, : 1
Chile, : 1
Uruguay, : 1
Egipto, : 1
Siria, : 1
Francia, : 1
Filipinas, : 1
Brasil, : 1
Bolivia, : 1
Etiopía, : 1
Ecuador, : 1
Perú, : 1
Venezuela, : 1
Turquía, : 1
Arabia : 1
Saudita, : 1
Líbano. : 1

CL-USER> (ql:quickload '(:weblocks :weblocks-ui :find-port))
CL-USER> (defpackage todo
           (:use #:cl
                 #:weblocks-ui/form
                 #:weblocks/html)
           (:import-from #:weblocks/widget
                    #:render
                    #:update
                    #:defwidget)
           (:import-from #:weblocks/actions
                    #:make-js-action)
           (:import-from #:weblocks/app
                    #:defapp))
#<PACKAGE "TODO">
CL-USER> (in-package todo)
#<PACKAGE "TODO">

TODO> (defapp tasks)
TODO> (weblocks/debug:on)
TODO> (defvar *port* (find-port:find-port))
TODO> (weblocks/server:start :port *port*)
 <INFO> [19:41:00] weblocks/server server.lisp (start) -
  Starting weblocks WEBLOCKS/SERVER::PORT: 40000
  WEBLOCKS/SERVER::SERVER-TYPE: :HUNCHENTOOT DEBUG: T
 <INFO> [19:41:00] weblocks/server server.lisp (start-server) -
  Starting webserver on WEBLOCKS/SERVER::INTERFACE: "localhost"
  WEBLOCKS/SERVER::PORT: 40000 DEBUG: T
 #<SERVER port=40000 running>
 (NIL)

No weblocks/session:init method defined.
Please define a method weblocks.session:init to initialize a session.

It could be something simple, like this one:

(defmethod weblocks/session:init ((app tasks))
            "Hello world!")

Read more in the documentaion.

TODO> (defwidget task ()
        ((title
          :initarg :title
          :accessor title)
         (done
          :initarg :done
          :initform nil
          :accessor done)))

TODO> (defvar *task-1* (make-instance 'task :title "Make my first Weblocks app"))
TODO> *task-1*
#<TASK {1005406F33}>

TODO> (title *task-1*)
"Make my first Weblocks app"
TODO> (done *TASK-1*)
NIL
TODO> (setf (done *TASK-1*) t)
T

TODO> (defun make-task (&key title done)
        (make-instance 'task :title title :done done))

TODO> (defwidget task-list ()
        ((tasks
          :initarg :tasks
          :accessor tasks)))

TODO> (defmethod render ((task task))
        "Render a task."
        (with-html
              (:span (if (done task)
                         (with-html
                               (:s (title task)))
                       (title task)))))

TODO> (defmethod render ((widget task-list))
        "Render a list of tasks."
        (with-html
              (:h1 "Tasks")
              (:ul
                (loop for task in (tasks widget) do
                      (:li (render task))))))

TODO> (render *task-1*)
<div class="widget task"><span>Make my first Weblocks app</span>
</div>
NIL

TODO> (defun make-task-list (&rest rest)
             "Create some tasks from titles."
             (loop for title in rest collect
                   (make-task :title title)))

TODO> (defmethod weblocks/session:init ((app tasks))
         (declare (ignorable app))
         (let ((tasks (make-task-list "Make my first Weblocks app"
                                      "Deploy it somewhere"
                                      "Have a profit")))
           (make-instance 'task-list :tasks tasks)))

TODO> (weblocks/debug:reset-latest-session)

TODO> (ql:quickload "weblocks-ui")
TODO> (use-package :weblocks-ui/form)

TODO> (defmethod render ((widget task-list))
          (flet ((add-task (&key title &allow-other-keys)
                   (push (make-task :title title)
                         (tasks (weblocks/widgets/root:get)))
                   (update (weblocks/widgets/root:get))))
            (with-html
              (:h1 "Tasks")
              (loop for task in (tasks widget) do
                   (render task))
              (with-html-form (:POST #'add-task)
                (:input :type "text"
                        :name "title"
                        :placeholder "Task's title")
                (:input :type "submit"
                        :value "Add")))))

TODO> (weblocks/debug:reset-latest-session)

(with-html-form (:POST #'add-task)
   (:input :type "text"
    :name "task"
    :placeholder "Task's title")
   (:input :type "submit"
    :value "Add"))

TODO> (defmethod toggle ((task task))
        (setf (done task)
              (if (done task)
                  nil
                  t))
        (update task))

TODO> (defmethod render ((task task))
        (with-html
          (:p (:input :type "checkbox"
            :checked (done task)
            :onclick (make-js-action
                      (lambda (&rest rest)
                        (declare (ignore rest))
                      (toggle task))))
              (:span (if (done task)
                   (with-html
                         ;; strike
                         (:s (title task)))
                 (title task))))))

consumer_key = 'consumer key'
consumer_secret = 'consumer secrets'
access_token = 'access token'
access_token_secret = 'access token secret'
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

#!/usr/bin/env python3

#Se importa la librería tweepy

import tweepy

#Se importa sleep, datetime, TextBlob y matplotlib

from time import sleep

from datetime import datetime

from textblob import TextBlob 

import matplotlib.pyplot as plt 

#Se define las variables para el acceso al API de twitter

consumer_key = ''

consumer_secret = ''

access_token = ''

access_token_secret = ''

#Se autentica en twitter

auth = tweepy.OAuthHandler(consumer_key, consumer_secret)

auth.set_access_token(access_token, access_token_secret)

api = tweepy.API(auth)

#se verifica que el usuario conectado en twitter es de uno

print(api.me().name)

#Se pregunta por la palabra a preguntar

palabra = input("Buscar: ")

#Se define la cantida de tweets a capturar

numero_de_Tweets = int(input(u"Número de tweets a capturar: "))

#Se define el idioma de los tweets a analizar

lenguaje = input("Idioma [es/en]:")

def ObtenerTweets(palabra="Trump",times=100,leguanje="en"):

    #Se define las listas que capturan la popularidad

    popularidad_list = []

    numeros_list = []

    numero = 1

    for tweet in tweepy.Cursor(api.search, palabra, lang=lenguaje).items(numero_de_Tweets):

        try:

            #Se toma el texto, se hace el analisis de sentimiento

            #y se agrega el resultado a las listas

            analisis = TextBlob(tweet.text)

            analisis = analisis.sentiment

            popularidad = analisis.polarity

            popularidad_list.append(popularidad)

            numeros_list.append(numero)

            numero = numero + 1

        except tweepy.TweepError as e:

            print(e.reason)

        except StopIteration:

            break

    return (numeros_list,popularidad_list,numero)

def GraficarDatos(numeros_list,popularidad_list,numero):

    axes = plt.gca()

    axes.set_ylim([-1, 2])

    plt.scatter(numeros_list, popularidad_list)

    popularidadPromedio = (sum(popularidad_list))/(len(popularidad_list))

    popularidadPromedio = "{0:.0f}%".format(popularidadPromedio * 100)

    time  = datetime.now().strftime("A : %H:%M\n El: %m-%d-%y")

    plt.text(0, 1.25, 

             "Sentimiento promedio:  " + str(popularidadPromedio) + "\n" + time, 

             fontsize=12, 

             bbox = dict(facecolor='none', 

                         edgecolor='black', 

                         boxstyle='square, pad = 1'))

    plt.title("Sentimientos sobre " + palabra + " en twitter")

    plt.xlabel("Numero de tweets")

    plt.ylabel("Sentimiento")

    plt.show()

numeros_list,popularidad_list,numero = ObtenerTweets(palabra,numero_de_Tweets,lenguaje)

GraficarDatos(numeros_list,popularidad_list,numero)

(ql:quickload :mito)

(mito:connect-toplevel :mysql :database-name "myapp" :username "fukamachi" :password "c0mon-1isp")

(connect-toplevel :sqlite3 :database-name "myapp")

(defun connect ()
  "Connect to the DB."
  (connect-toplevel :sqlite3 :database-name "myapp"))

(defclass user ()
  ((name :col-type (:varchar 64)
         :initarg :name
         :accessor user-name)
   (email :col-type (or (:varchar 128) :null)
          :initarg :email
          :accessor user-email))
  (:metaclass mito:dao-table-class))

(mito.class:table-column-slots (find-class 'user))
;=> (#<MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS MITO.DAO.MIXIN::ID>
;    #<MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS COMMON-LISP-USER::NAME>
;    #<MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS COMMON-LISP-USER::EMAIL>
;    #<MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS MITO.DAO.MIXIN::CREATED-AT>
;    #<MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS MITO.DAO.MIXIN::UPDATED-AT>)

(find-class 'user)
;=> #<MITO.DAO.TABLE:DAO-TABLE-CLASS COMMON-LISP-USER::USER>

(c2mop:class-direct-superclasses *)
;=> (#<STANDARD-CLASS MITO.DAO.TABLE:DAO-CLASS>)

(mito:ensure-table-exists 'user)

(defun ensure-tables ()
  (mapcar #'mito:ensure-table-exists '(user foo bar)))

   (email :col-type (or (:varchar 128) :null)
          :initarg :email
          :accessor user-email))

(defclass user ()
  ((name :col-type (:varchar 64)
         :initarg :name
         :accessor user-name)
   (email :col-type (:varchar 128)
          :initarg :email
          :accessor user-email))
  (:metaclass mito:dao-table-class)
  (:unique-keys email))

(defclass tweet ()
  ((status :col-type :text
           :initarg :status
           :accessor tweet-status)
   ;; This slot refers to USER class
   (user :col-type user
         :initarg :user
         :accessor tweet-user))
  (:metaclass mito:dao-table-class))

(table-definition (find-class 'tweet))
;=> (#<SXQL-STATEMENT: CREATE TABLE tweet (
;        id BIGSERIAL NOT NULL PRIMARY KEY,
;        status TEXT NOT NULL,
;        user_id BIGINT NOT NULL,
;        created_at TIMESTAMP,
;        updated_at TIMESTAMP
;    )>)

(defvar *user* (mito:create-dao 'user :name "Eitaro Fukamachi"))
(mito:create-dao 'tweet :user *user*)

(mito:find-dao 'tweet :user *user*)

(defclass book ()
    ((title
       :col-type (:varchar 128)
       :initarg :title
       :accessor title)
     (ean
       :col-type (or (:varchar 128) :null)
       :initarg :ean
       :accessor ean))
    (:metaclass mito:dao-table-class))

(defclass user-books ()
    ((user
      :col-type user
      :initarg :user)
    (book
      :col-type book
      :initarg :book))
    (:metaclass mito:dao-table-class))

(defclass user-books ()
    ((user
      :col-type user
      :initarg :user)
    (book
      :col-type book
      :initarg :book)
    ;; Set the quantity, 1 by default:
    (quantity
      :col-type :integer
      :initarg :quantity
      :initform 1
      :accessor quantity))
    (:metaclass mito:dao-table-class))

(defclass user ()
  ((name :col-type (:varchar 64)
         :initarg :name
         :accessor user-name)
   (email :col-type (:varchar 128)
          :initarg :email
          :accessor user-email))
  (:metaclass mito:dao-table-class)
  (:unique-keys email))

(defclass temporary-user (user)
  ((registered-at :col-type :timestamp
                  :initarg :registered-at
                  :accessor temporary-user-registered-at))
  (:metaclass mito:dao-table-class))

(mito:table-definition 'temporary-user)
;=> (#<SXQL-STATEMENT: CREATE TABLE temporary_user (
;        id BIGSERIAL NOT NULL PRIMARY KEY,
;        name VARCHAR(64) NOT NULL,
;        email VARCHAR(128) NOT NULL,
;        registered_at TIMESTAMP NOT NULL,
;        created_at TIMESTAMP,
;        updated_at TIMESTAMP,
;        UNIQUE (email)
;    )>)

(defclass has-email ()
  ((email :col-type (:varchar 128)
          :initarg :email
          :accessor object-email))
  (:metaclass mito:dao-table-mixin)
  (:unique-keys email))
;=> #<MITO.DAO.MIXIN:DAO-TABLE-MIXIN COMMON-LISP-USER::HAS-EMAIL>

(defclass user (has-email)
  ((name :col-type (:varchar 64)
         :initarg :name
         :accessor user-name))
  (:metaclass mito:dao-table-class))
;=> #<MITO.DAO.TABLE:DAO-TABLE-CLASS COMMON-LISP-USER::USER>

(mito:table-definition 'user)
;=> (#<SXQL-STATEMENT: CREATE TABLE user (
;       id BIGSERIAL NOT NULL PRIMARY KEY,
;       name VARCHAR(64) NOT NULL,
;       email VARCHAR(128) NOT NULL,
;       created_at TIMESTAMP,
;       updated_at TIMESTAMP,
;       UNIQUE (email)
;   )>)

Cannot CHANGE-CLASS objects into CLASS metaobjects.
   [Condition of type SB-PCL::METAOBJECT-INITIALIZATION-VIOLATION]
See also:
  The Art of the Metaobject Protocol, CLASS [:initialization]

(setf (find-class 'foo) nil)

(ensure-table-exists 'user)

(mito:migrate-table 'user)

(ensure-table-exists 'user)
;-> ;; CREATE TABLE IF NOT EXISTS "user" (
;       "id" BIGSERIAL NOT NULL PRIMARY KEY,
;       "name" VARCHAR(64) NOT NULL,
;       "email" VARCHAR(128),
;       "created_at" TIMESTAMP,
;       "updated_at" TIMESTAMP
;   ) () [0 rows] | MITO.DAO:ENSURE-TABLE-EXISTS

(mito:migration-expressions 'user)
;=> NIL

(defclass user ()
  ((name :col-type (:varchar 64)
         :initarg :name
         :accessor user-name)
   (email :col-type (:varchar 128)
          :initarg :email
          :accessor user-email))
  (:metaclass mito:dao-table-class)
  (:unique-keys email))

(mito:migration-expressions 'user)
;=> (#<SXQL-STATEMENT: ALTER TABLE user ALTER COLUMN email TYPE character varying(128), ALTER COLUMN email SET NOT NULL>
;    #<SXQL-STATEMENT: CREATE UNIQUE INDEX unique_user_email ON user (email)>)

(mito:migrate-table 'user)
;-> ;; ALTER TABLE "user" ALTER COLUMN "email" TYPE character varying(128), ALTER COLUMN "email" SET NOT NULL () [0 rows] | MITO.MIGRATION.TABLE:MIGRATE-TABLE
;   ;; CREATE UNIQUE INDEX "unique_user_email" ON "user" ("email") () [0 rows] | MITO.MIGRATION.TABLE:MIGRATE-TABLE
;-> (#<SXQL-STATEMENT: ALTER TABLE user ALTER COLUMN email TYPE character varying(128), ALTER COLUMN email SET NOT NULL>
;    #<SXQL-STATEMENT: CREATE UNIQUE INDEX unique_user_email ON user (email)>)

(defvar me
  (make-instance 'user :name "Eitaro Fukamachi" :email "e.arrows@gmail.com"))
;=> USER

(mito:insert-dao me)
;-> ;; INSERT INTO `user` (`name`, `email`, `created_at`, `updated_at`) VALUES (?, ?, ?, ?) ("Eitaro Fukamachi", "e.arrows@gmail.com", "2016-02-04T19:55:16.365543Z", "2016-02-04T19:55:16.365543Z") [0 rows] | MITO.DAO:INSERT-DAO
;=> #<USER {10053C4453}>

(mito:create-dao 'user :name "Eitaro Fukamachi" :email "e.arrows@gmail.com")

(defun make-user (&key name)
  (make-instance 'user :name name))

(setf (slot-value me 'name) "nitro_idiot")
;=> "nitro_idiot"

(mito:save-dao me)

(mito:delete-dao me)
;-> ;; DELETE FROM `user` WHERE (`id` = ?) (1) [0 rows] | MITO.DAO:DELETE-DAO

;; or:
(mito:delete-by-values 'user :id 1)
;-> ;; DELETE FROM `user` WHERE (`id` = ?) (1) [0 rows] | MITO.DAO:DELETE-DAO

(mito:object-id me)
;=> 1

(mito:count-dao 'user)
;=> 1

(mito:find-dao 'user :id 1)
;-> ;; SELECT * FROM `user` WHERE (`id` = ?) LIMIT 1 (1) [1 row] | MITO.DB:RETRIEVE-BY-SQL
;=> #<USER {10077C6073}>

(defgeneric find-user (key-name key-value)
  (:documentation "Retrieves an user from the data base by one of the unique
keys."))

(defmethod find-user ((key-name (eql :id)) (key-value integer))
  (mito:find-dao 'user key-value))

(defmethod find-user ((key-name (eql :name)) (key-value string))
  (first (mito:select-dao 'user
                          (sxql:where (:= :name key-value)))))

(mito:select-dao 'user)
;=> (#<USER {10077C6073}>)

(mito:find-dao 'tweet :user *user*)

(select-dao 'tweet
    (where (:like :status "%Japan%")))

(select-dao 'foo
  (where (:and (:> :age 20) (:<= :age 65))))

(order-by :age (:desc :id))

(group-by :sex)

(having (:>= (:sum :hoge) 88))

(limit 0 10)

:not
:is-null, :not-null
:asc, :desc
:distinct
:=, :!=
:<, :>, :<= :>=
:a<, :a>
:as
:in, :not-in
:like
:and, :or
:+, :-, :* :/ :%
:raw

(defmethod mito:insert-dao :before ((object user))
  (format t "~&Adding ~S...~%" (user-name object)))

(mito:create-dao 'user :name "Eitaro Fukamachi" :email "e.arrows@gmail.com")
;-> Adding "Eitaro Fukamachi"...
;   ;; INSERT INTO "user" ("name", "email", "created_at", "updated_at") VALUES (?, ?, ?, ?) ("Eitaro Fukamachi", "e.arrows@gmail.com", "2016-02-16 21:13:47", "2016-02-16 21:13:47") [0 rows] | MITO.DAO:INSERT-DAO
;=> #<USER {100835FB33}>

(defclass user-report ()
  ((title :col-type (:varchar 100)
          :initarg :title
          :accessor report-title)
   (body :col-type :text
         :initarg :body
         :initform ""
         :accessor report-body)
   (reported-at :col-type :timestamp
                :initarg :reported-at
                :initform (local-time:now)
                :accessor report-reported-at
                :inflate #'local-time:universal-to-timestamp
                :deflate #'local-time:timestamp-to-universal))
  (:metaclass mito:dao-table-class))

;; BAD EXAMPLE

(use-package '(:mito :sxql))

(defvar *tweets-contain-japan*
  (select-dao 'tweet
    (where (:like :status "%Japan%"))))

;; Getting names of tweeted users.
(mapcar (lambda (tweet)
          (user-name (tweet-user tweet)))
        *tweets-contain-japan*)

;; GOOD EXAMPLE with eager loading

(use-package '(:mito :sxql))

(defvar *tweets-contain-japan*
  (select-dao 'tweet
    (includes 'user)
    (where (:like :status "%Japan%"))))
;-> ;; SELECT * FROM `tweet` WHERE (`status` LIKE ?) ("%Japan%") [3 row] | MITO.DB:RETRIEVE-BY-SQL
;-> ;; SELECT * FROM `user` WHERE (`id` IN (?, ?, ?)) (1, 3, 12) [3 row] | MITO.DB:RETRIEVE-BY-SQL
;=> (#<TWEET {1003513EC3}> #<TWEET {1007BABEF3}> #<TWEET {1007BB9D63}>)

;; No additional SQLs will be executed.
(tweet-user (first *))
;=> #<USER {100361E813}>

$ ros install mito
$ mito
Usage: mito command [option...]

Commands:
    generate-migrations
    migrate

Options:
    -t, --type DRIVER-TYPE          DBI driver type (one of "mysql", "postgres" or "sqlite3")
    -d, --database DATABASE-NAME    Database name to use
    -u, --username USERNAME         Username for RDBMS
    -p, --password PASSWORD         Password for RDBMS
    -s, --system SYSTEM             ASDF system to load (several -s's allowed)
    -D, --directory DIRECTORY       Directory path to keep migration SQL files (default: "/Users/nitro_idiot/Programs/lib/mito/db/")
    --dry-run                       List SQL expressions to migrate

(ql:quickload "closer-mop")

(closer-mop:class-direct-slots (find-class 'user))
;; (#<MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS NAME>
;;  #<MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS EMAIL>)

(defparameter user-slots *)

(mito.class.column:table-column-type (first user-slots))
;; (:VARCHAR 64)

(mito.class.column:table-column-not-null-p
  (first user-slots))
;; T
(mito.class.column:table-column-not-null-p
  (second user-slots))
;; NIL

(defun random-string (length)
  ;; thanks 40ants/hacrm.
  (let ((chars "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"))
    (coerce (loop repeat length
                  collect (aref chars (random (length chars))))
            'string)))

(defmacro with-empty-db (&body body)
  "Run `body` with a new temporary DB.
  "
  `(let* ((*random-state* (make-random-state t))
          (prefix (concatenate 'string
                               (random-string 8)
                               "/"))
          (connection mito:*connection*))
     (uiop:with-temporary-file (:pathname name :prefix prefix)
       (let* ((*db-name* name)
              (*db* (connect)))
         (ensure-tables-exist)
         (migrate-all)
         ,@body
         (setf mito:*connection* connection)
         (connect)))))

(prove:subtest "Creation in a temporary DB."
  (with-empty-db
    (let ((user (make-user :name "Cookbook")))
      (save-user user)

      (prove:is (name user)
                "Cookbook"
                "Test username in a temp DB."))))
;; Creation in a temporary DB
;;  CREATE TABLE "user" (
;;       id BIGSERIAL NOT NULL PRIMARY KEY,
;;       name VARCHAR(64) NOT NULL,
;;       email VARCHAR(128) NOT NULL,
;;       created_at TIMESTAMP,
;;       updated_at TIMESTAMP,
;;       UNIQUE (email)
;; ) () [0 rows] | MITO.DB:EXECUTE-SQL
;; ✓ Test username in a temp DB.

##Se importa Numpy, MLPCCLassifier y KNeighborsClassifier
import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier

#un Arreglo con la tabla de la verdad
# 0 0
# 0 1
# 1 0
# 1 1
xs = np.array([
    0, 0,
    0, 1,
    1, 0,
    1, 1
]).reshape(4, 2)
xs

array([[0, 0],
       [0, 1],
       [1, 0],
       [1, 1]])
#Se muestra un arreglo con el resultado de hacer un XOR
ys = np.array([0, 1, 1, 0]).reshape(4,)
ys

array([0, 1, 1, 0])
#Se crea el clasificador con la función de activación relu,con 10k iteraciones y tiene capaz ocultas 4,2
model = MLPClassifier(activation='tanh', max_iter=10000, hidden_layer_sizes=(4,2))
model

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)
#Se entrena la red neuronal pasando los arreglos de entrada y de salida
model.fit(xs, ys)

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)
print('prediccion:', model.predict(xs)) # salida 0110

prediccion: [0 1 1 0]

print('Se espera:', np.array([0, 1, 1, 0]))

Se espera: [0 1 1 0]

#Se importa de numpy array
from numpy import array

#Datos de entrada y de salida
datos_entrada = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]).reshape(4, 3)
datos_salida = array([[0, 1, 1, 0]]).reshape(4, )
print(datos_entrada)
print ("-"*4)
print(datos_salida)

[[0 0 1]
 [1 1 1]
 [1 0 1]
 [0 1 1]]
----
[0 1 1 0]

#En este caso se usa KNeighborsClassifier con 2 capaz
KNC = KNeighborsClassifier(n_neighbors= 2)

KNC.fit(datos_entrada,datos_salida)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=2, p=2,
           weights='uniform')
#Se predice el valor de 1,0,0 que da como resultado el mismo del artículo anterior.
print(KNC.predict([[1, 0,0]]))

[1]

#Se crea la red de nuevo pero ahora con PLPCCLassifier.
#Se crea el clasificador con la función de activación relu,con 10k iteraciones y tiene capaz ocultas 4,2
KNC = MLPClassifier(activation='tanh', max_iter=10000, hidden_layer_sizes=(4,2))

#Se entrena la red neuronal pasando los arreglos de entrada y de salida
KNC.fit(datos_entrada, datos_salida)

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)
#Se predice el valor de 1,0,0 que da como resultado el mismo del artículo anterior.
print(KNC.predict([[1, 0,0]]))

[1]

#Se importa pandas como pd
import pandas as pd
#Se lee los datos de wikipedia de los estados de venezuela, este devuelve una lista
estados=   pd.read_html('https://es.wikipedia.org/wiki/Estados_de_Venezuela') 
estados

[    0                                                  1
 0 NaN  Este artículo o sección necesita referencias q...,
                                                    0
 0                     Estados Federales de Venezuela
 1  Bolívar Amazonas Apure Zulia Táchira Barinas M...,
           0                       1                       2           3  \
 0   Bandera         Entidad federal                 Capital  Código ISO   
 1       NaN                Amazonas         Puerto Ayacucho        VE-Z   
 2       NaN              Anzoátegui               Barcelona        VE-B   
 3       NaN                   Apure   San Fernando de Apure        VE-C   
 4       NaN                  Aragua                 Maracay        VE-D   
 5       NaN                 Barinas                 Barinas        VE-E   
 6       NaN                 Bolívar          Ciudad Bolívar        VE-F   
 7       NaN                Carabobo                Valencia        VE-G   
 8       NaN                 Cojedes              San Carlos        VE-H   
 9       NaN           Delta Amacuro                Tucupita        VE-Y   
 10      NaN        Distrito Capital                 Caracas        VE-A   
 11      NaN                  Falcón                    Coro        VE-I   
 12      NaN                 Guárico  San Juan de Los Morros        VE-J   
 13      NaN                    Lara            Barquisimeto        VE-K   
 14      NaN                  Mérida                  Mérida        VE-L   
 15      NaN                 Miranda              Los Teques        VE-M   
 16      NaN                 Monagas                 Maturín        VE-N   
 17      NaN           Nueva Esparta             La Asunción        VE-O   
 18      NaN              Portuguesa                 Guanare        VE-P   
 19      NaN                   Sucre                  Cumaná        VE-R   
 20      NaN                 Táchira           San Cristóbal        VE-S   
 21      NaN                Trujillo                Trujillo        VE-T   
 22      NaN                  Vargas               La Guaira        VE-X   
 23      NaN                 Yaracuy              San Felipe        VE-U   
 24      NaN                   Zulia               Maracaibo        VE-V   
 25      NaN  Dependencias Federales              Gran Roque        VE-W   

                   4                                 5  \
 0   Año de admisión              Población (2011)[2]   
 1              1992    &&&&&&&&&0161844.&&&&&0161 844   
 2              1909  &&&&&&&&02179838.&&&&&02 179 838   
 3              1864    &&&&&&&&&0501404.&&&&&0501 404   
 4              1909  &&&&&&&&01819630.&&&&&01 819 630   
 5              1937    &&&&&&&&&0853949.&&&&&0853 949   
 6              1901  &&&&&&&&02069064.&&&&&02 069 064   
 7              1865  &&&&&&&&02342665.&&&&&02 342 665   
 8              1864    &&&&&&&&&0367020.&&&&&0367 020   
 9              1992    &&&&&&&&&0180363.&&&&&0180 363   
 10             1999  &&&&&&&&04033186.&&&&&04 033 186   
 11             1872  &&&&&&&&01064615.&&&&&01 064 615   
 12             1864    &&&&&&&&&0746174.&&&&&0746 174   
 13             1909  &&&&&&&&01892439.&&&&&01 892 439   
 14             1909    &&&&&&&&&0903955.&&&&&0903 955   
 15             1909  &&&&&&&&03112851.&&&&&03 112 851   
 16             1909    &&&&&&&&&0938185.&&&&&0938 185   
 17             1909    &&&&&&&&&0525139.&&&&&0525 139   
 18             1909    &&&&&&&&&0897104.&&&&&0897 104   
 19             1909    &&&&&&&&&0892990.&&&&&0892 990   
 20             1899  &&&&&&&&01277241.&&&&&01 277 241   
 21             1864    &&&&&&&&&0901239.&&&&&0901 239   
 22             1998    &&&&&&&&&0419928.&&&&&0419 928   
 23             1899    &&&&&&&&&0645688.&&&&&0645 688   
 24             1864  &&&&&&&&04694856.&&&&&04 694 856   
 25             1938       &&&&&&&&&&&02155.&&&&&02155   

                                  6                              7  \
 0                 Superficie (km²)             Densidad (hab/km²)   
 1   &&&&&&&&&0177617.&&&&&0177 617    &&&&&&&&&&&&&&00.9900000,99   
 2    &&&&&&&&&&043300.&&&&&043 300    &&&&&&&&&&&&&033.90000033,9   
 3    &&&&&&&&&&076500.&&&&&076 500     &&&&&&&&&&&&&&06.&&&&&06,0   
 4      &&&&&&&&&&&07014.&&&&&07014   &&&&&&&&&&&&0235.600000235,6   
 5    &&&&&&&&&&035200.&&&&&035 200    &&&&&&&&&&&&&023.20000023,2   
 6   &&&&&&&&&0240528.&&&&&0240 528    &&&&&&&&&&&&&&07.8700007,87   
 7      &&&&&&&&&&&04650.&&&&&04650  &&&&&&&&&&&&0713.&10000713,01   
 8    &&&&&&&&&&014800.&&&&&014 800    &&&&&&&&&&&&&021.80000021,8   
 9    &&&&&&&&&&040200.&&&&&040 200    &&&&&&&&&&&&&&04.6500004,65   
 10      &&&&&&&&&&&&0433.&&&&&0433  &&&&&&&&&&&07246.4000007246,4   
 11   &&&&&&&&&&024800.&&&&&024 800    &&&&&&&&&&&&&036.40000036,4   
 12   &&&&&&&&&&064986.&&&&&064 986    &&&&&&&&&&&&&011.50000011,5   
 13   &&&&&&&&&&019800.&&&&&019 800    &&&&&&&&&&&&&089.60000089,6   
 14   &&&&&&&&&&011300.&&&&&011 300    &&&&&&&&&&&&&092.80000092,8   
 15     &&&&&&&&&&&07950.&&&&&07950   &&&&&&&&&&&&0336.500000336,5   
 16   &&&&&&&&&&028900.&&&&&028 900    &&&&&&&&&&&&&031.30000031,3   
 17     &&&&&&&&&&&01150.&&&&&01150  &&&&&&&&&&&&0480.&10000480,01   
 18   &&&&&&&&&&015200.&&&&&015 200    &&&&&&&&&&&&&057.70000057,7   
 19   &&&&&&&&&&011800.&&&&&011 800    &&&&&&&&&&&&&076.&&&&&076,0   
 20   &&&&&&&&&&011100.&&&&&011 100   &&&&&&&&&&&&0105.300000105,3   
 21     &&&&&&&&&&&07400.&&&&&07400    &&&&&&&&&&&&&092.80000092,8   
 22     &&&&&&&&&&&01497.&&&&&01497   &&&&&&&&&&&&0235.800000235,8   
 23     &&&&&&&&&&&07100.&&&&&07100    &&&&&&&&&&&&&084.60000084,6   
 24   &&&&&&&&&&063100.&&&&&063 100    &&&&&&&&&&&&&073.70000073,7   
 25      &&&&&&&&&&&&0120.&&&&&0120    &&&&&&&&&&&&&018.&&&&&018,0   

                     8     9  
 0              Región  Mapa  
 1             Guayana   NaN  
 2      Nor - Oriental   NaN  
 3              Llanos   NaN  
 4             Central   NaN  
 5              Andina   NaN  
 6             Guayana   NaN  
 7             Central   NaN  
 8             Central   NaN  
 9             Guayana   NaN  
 10            Capital   NaN  
 11  Centro-Occidental   NaN  
 12             Llanos   NaN  
 13  Centro-Occidental   NaN  
 14             Andina   NaN  
 15            Capital   NaN  
 16     Nor - Oriental   NaN  
 17            Insular   NaN  
 18  Centro-Occidental   NaN  
 19     Nor - Oriental   NaN  
 20             Andina   NaN  
 21             Andina   NaN  
 22            Capital   NaN  
 23  Centro-Occidental   NaN  
 24            Zuliana   NaN  
 25            Insular   NaN  ]
#Tipo de los estados
type(estados)

list
#Tipo del primer elemento es un dataframe
type(estados[0])

pandas.core.frame.DataFrame
#Se listan del dataframe estados y capitales (elementos 1 y 2 del dataframe, y se recorre)
for i in range(1,26):
    print(estados[2][1][i],estados[2][2][i])

Amazonas Puerto Ayacucho
Anzoátegui Barcelona
Apure San Fernando de Apure
Aragua Maracay
Barinas Barinas
Bolívar Ciudad Bolívar
Carabobo Valencia
Cojedes San Carlos
Delta Amacuro Tucupita
Distrito Capital Caracas
Falcón Coro
Guárico San Juan de Los Morros
Lara Barquisimeto
Mérida Mérida
Miranda Los Teques
Monagas Maturín
Nueva Esparta La Asunción
Portuguesa Guanare
Sucre Cumaná
Táchira San Cristóbal
Trujillo Trujillo
Vargas La Guaira
Yaracuy San Felipe
Zulia Maracaibo
Dependencias Federales Gran Roque

#Ahora se crea una lista de diccionarios donde estará la información de cada estado
lista = []
for i in range(1,26):
    lista.append({'Estado':estados[2][1][i],
                  'Capital': estados[2][2][i],
                  'codigo_iso': estados[2][3][i],
                  u'año_admision': estados[2][4][i],
                  'Poblacion': int(estados[2][5][i].split(".")[0].split("&")[-1]),
                  'Superficie': int(estados[2][6][i].split(".")[0].split("&")[-1]),
                  'Densidad': float(estados[2][7][i].split(",")[0].split("&")[-1]),
                  'Region': estados[2][8][i]
                 })

print(lista)

[{'Region': 'Guayana', 'Densidad': 0.99, 'Superficie': 177617, 'Estado': 'Amazonas', 'codigo_iso': 'VE-Z', 'Poblacion': 161844, 'Capital': 'Puerto Ayacucho', 'año_admision': '1992'}, {'Region': 'Nor - Oriental', 'Densidad': 33.90000033, 'Superficie': 43300, 'Estado': 'Anzoátegui', 'codigo_iso': 'VE-B', 'Poblacion': 2179838, 'Capital': 'Barcelona', 'año_admision': '1909'}, {'Region': 'Llanos', 'Densidad': 6.0, 'Superficie': 76500, 'Estado': 'Apure', 'codigo_iso': 'VE-C', 'Poblacion': 501404, 'Capital': 'San Fernando de Apure', 'año_admision': '1864'}, {'Region': 'Central', 'Densidad': 235.600000235, 'Superficie': 7014, 'Estado': 'Aragua', 'codigo_iso': 'VE-D', 'Poblacion': 1819630, 'Capital': 'Maracay', 'año_admision': '1909'}, {'Region': 'Andina', 'Densidad': 23.20000023, 'Superficie': 35200, 'Estado': 'Barinas', 'codigo_iso': 'VE-E', 'Poblacion': 853949, 'Capital': 'Barinas', 'año_admision': '1937'}, {'Region': 'Guayana', 'Densidad': 7.8700007, 'Superficie': 240528, 'Estado': 'Bolívar', 'codigo_iso': 'VE-F', 'Poblacion': 2069064, 'Capital': 'Ciudad Bolívar', 'año_admision': '1901'}, {'Region': 'Central', 'Densidad': 10000713.0, 'Superficie': 4650, 'Estado': 'Carabobo', 'codigo_iso': 'VE-G', 'Poblacion': 2342665, 'Capital': 'Valencia', 'año_admision': '1865'}, {'Region': 'Central', 'Densidad': 21.80000021, 'Superficie': 14800, 'Estado': 'Cojedes', 'codigo_iso': 'VE-H', 'Poblacion': 367020, 'Capital': 'San Carlos', 'año_admision': '1864'}, {'Region': 'Guayana', 'Densidad': 4.6500004, 'Superficie': 40200, 'Estado': 'Delta Amacuro', 'codigo_iso': 'VE-Y', 'Poblacion': 180363, 'Capital': 'Tucupita', 'año_admision': '1992'}, {'Region': 'Capital', 'Densidad': 7246.4000007246, 'Superficie': 433, 'Estado': 'Distrito Capital', 'codigo_iso': 'VE-A', 'Poblacion': 4033186, 'Capital': 'Caracas', 'año_admision': '1999'}, {'Region': 'Centro-Occidental', 'Densidad': 36.40000036, 'Superficie': 24800, 'Estado': 'Falcón', 'codigo_iso': 'VE-I', 'Poblacion': 1064615, 'Capital': 'Coro', 'año_admision': '1872'}, {'Region': 'Llanos', 'Densidad': 11.50000011, 'Superficie': 64986, 'Estado': 'Guárico', 'codigo_iso': 'VE-J', 'Poblacion': 746174, 'Capital': 'San Juan de Los Morros', 'año_admision': '1864'}, {'Region': 'Centro-Occidental', 'Densidad': 89.60000089, 'Superficie': 19800, 'Estado': 'Lara', 'codigo_iso': 'VE-K', 'Poblacion': 1892439, 'Capital': 'Barquisimeto', 'año_admision': '1909'}, {'Region': 'Andina', 'Densidad': 92.80000092, 'Superficie': 11300, 'Estado': 'Mérida', 'codigo_iso': 'VE-L', 'Poblacion': 903955, 'Capital': 'Mérida', 'año_admision': '1909'}, {'Region': 'Capital', 'Densidad': 336.500000336, 'Superficie': 7950, 'Estado': 'Miranda', 'codigo_iso': 'VE-M', 'Poblacion': 3112851, 'Capital': 'Los Teques', 'año_admision': '1909'}, {'Region': 'Nor - Oriental', 'Densidad': 31.30000031, 'Superficie': 28900, 'Estado': 'Monagas', 'codigo_iso': 'VE-N', 'Poblacion': 938185, 'Capital': 'Maturín', 'año_admision': '1909'}, {'Region': 'Insular', 'Densidad': 10000480.0, 'Superficie': 1150, 'Estado': 'Nueva Esparta', 'codigo_iso': 'VE-O', 'Poblacion': 525139, 'Capital': 'La Asunción', 'año_admision': '1909'}, {'Region': 'Centro-Occidental', 'Densidad': 57.70000057, 'Superficie': 15200, 'Estado': 'Portuguesa', 'codigo_iso': 'VE-P', 'Poblacion': 897104, 'Capital': 'Guanare', 'año_admision': '1909'}, {'Region': 'Nor - Oriental', 'Densidad': 76.0, 'Superficie': 11800, 'Estado': 'Sucre', 'codigo_iso': 'VE-R', 'Poblacion': 892990, 'Capital': 'Cumaná', 'año_admision': '1909'}, {'Region': 'Andina', 'Densidad': 105.300000105, 'Superficie': 11100, 'Estado': 'Táchira', 'codigo_iso': 'VE-S', 'Poblacion': 1277241, 'Capital': 'San Cristóbal', 'año_admision': '1899'}, {'Region': 'Andina', 'Densidad': 92.80000092, 'Superficie': 7400, 'Estado': 'Trujillo', 'codigo_iso': 'VE-T', 'Poblacion': 901239, 'Capital': 'Trujillo', 'año_admision': '1864'}, {'Region': 'Capital', 'Densidad': 235.800000235, 'Superficie': 1497, 'Estado': 'Vargas', 'codigo_iso': 'VE-X', 'Poblacion': 419928, 'Capital': 'La Guaira', 'año_admision': '1998'}, {'Region': 'Centro-Occidental', 'Densidad': 84.60000084, 'Superficie': 7100, 'Estado': 'Yaracuy', 'codigo_iso': 'VE-U', 'Poblacion': 645688, 'Capital': 'San Felipe', 'año_admision': '1899'}, {'Region': 'Zuliana', 'Densidad': 73.70000073, 'Superficie': 63100, 'Estado': 'Zulia', 'codigo_iso': 'VE-V', 'Poblacion': 4694856, 'Capital': 'Maracaibo', 'año_admision': '1864'}, {'Region': 'Insular', 'Densidad': 18.0, 'Superficie': 120, 'Estado': 'Dependencias Federales', 'codigo_iso': 'VE-W', 'Poblacion': 2155, 'Capital': 'Gran Roque', 'año_admision': '1938'}]

#Luego se crea un dataframe de la lista de diccionarios
df = pd.DataFrame(lista)
df

#Si se quiere la información de Carabobo
mascara = df["Estado"] == "Carabobo"
df[mascara]

#Otra forma de traer la información de Carabobo
df.iloc[6]

Capital            Valencia
Densidad        1.00007e+07
Estado             Carabobo
Poblacion           2342665
Region              Central
Superficie             4650
año_admision           1865
codigo_iso             VE-G
Name: 6, dtype: object
#Para obtener la capital del estado
df.iloc[6]["Capital"]

'Valencia'

#!/usr/bin/env python3

nombre = input('¿Cómo te llamas? ')
print('Hola, {}.'.format(nombre))

#!/usr/bin/env python3

import gettext

gettext.install('saluda', 'locale')

nombre = input(_('¿Cómo te llamas? '))
print(_('Hola, {}.').format(nombre))

mkdir locale

pygettext -d saluda -p locale saluda.py

#!/usr/bin/env python3
# Copyright (C) 2016 Julie Marchant <onpon4@riseup.net>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os
import subprocess

if __name__ == "__main__":
    for fname in os.listdir():
        root, ext = os.path.splitext(fname)
        if ext == ".po":
            print("Generando {}...".format(fname))
            d, root = os.path.split(root)
            os.makedirs(os.path.join(d, root, "LC_MESSAGES"), exist_ok=True)
            oname = os.path.join(d, root, "LC_MESSAGES", "saluda.mo")
            subprocess.call(["msgfmt", "-o", oname, fname])

    print("Terminado.")

sudo apt-get install python3-venv
git clone git@github.com:tanrax/workshop-flask-with-vuejs.git
cd workshop-flask-with-vuejs
python3 -m venv venv
source venv/bin/activate
pip3 install -r requirements.txt
git checkout tema1-1
(let ((*standard-output* (make-string-output-stream))
      (*error-output* (make-string-output-stream)))
  (apply function args) ;; anything
  (setf standard-output (get-output-stream-string *standard-output*)))
(print-results standard-output))

(setf standard-output (with-output-to-string (*standard-output*)
                        (apply function args)))

(with-output-to-string (s)
  (let ((*standard-output* s)) (write-string "abc")))
-> "abc"

(with-output-to-string (s)
  (let ((*standard-output* s)
        (*standard-error* s))
    (write-string "abc")
    (write-string "def" *standard-error*)))
-> "abcdef"

(with-output-to-string (*standard-output*)
  (let ((*standard-error* *standard-output*))
    (write-string "abc")
    (write-string "def" *standard-error*)))
--> "abcdef"

%matplotlib inline
import pandas as pd

sp500 = pd.read_csv('data/SP500.csv', sep=',', parse_dates=True, index_col='Date', usecols=['Adj Close', 'Date'])
sp500.head()

sp500['Pct Change'] = sp500['Adj Close'].pct_change()
sp500['SMA 365'] = sp500['Adj Close'].rolling(window=365).mean()
sp500.dropna().head()

sp500['Criteria'] = sp500['Adj Close'] >= sp500['SMA 365'] 
sp500['Criteria'].value_counts() 

True     10577
False     4032
Name: Criteria, dtype: int64

sp500['Buy & Hold'] = 100 * (1 + sp500['Pct Change']).cumprod()

sp500['Trend'] = 100 * (1 + ( sp500['Criteria'].shift(1) * sp500['Pct Change'] )).cumprod()

ax = sp500[['Trend', 'Buy & Hold']].plot(grid=True, kind='line', title="Trend (12 month SMA) vs. Buy & Hold", logy=True)

(defun juxt (&rest functions)
  "Return a function that will juxtapose the results of `functions`.
  This is like Clojure's `juxt`.  Given functions `(f0 f1 ... fn)`, this will
  return a new function which, when called with some arguments, will return
  `(list (f0 ...args...) (f1 ...args...) ... (fn ...args...))`.
  Example:
    (funcall (juxt #'list #'+ #'- #'*) 1 2)
    => ((1 2) 3 -1 2)
  "
  (lambda (&rest args)
    (mapcar (alexandria:rcurry #'apply args) functions)))

(defun nullary (function &optional result)
  "Return a new function that acts as a nullary-patched version of `function`.
  The new function will return `result` when called with zero arguments, and
  delegate to `function` otherwise.
  Examples:
    (max 1 10 2) ; => 10
    (max)        ; => invalid number of arguments
    (funcall (nullary #'max))          ; => nil
    (funcall (nullary #'max 0))        ; => 0
    (funcall (nullary #'max 0) 1 10 2) ; => 10
    (reduce #'max nil)                  ; => invalid number of arguments
    (reduce (nullary #'max) nil)        ; => nil
    (reduce (nullary #'max :empty) nil) ; => :empty
    (reduce (nullary #'max) '(1 10 2))  ; => 10
  "
  (lambda (&rest args)
    (if (null args) result (apply function args))))

(defmacro gathering (&body body)
  ;; https://github.com/sjl/cl-losh/blob/master/losh.lisp#L515
  "Run `body` to gather some things and return a fresh list of them.
  `body` will be executed with the symbol `gather` bound to a function of one
  argument.  Once `body` has finished, a list of everything `gather` was called
  on will be returned.
  It's handy for pulling results out of code that executes procedurally and
  doesn't return anything, like `maphash` or Alexandria's `map-permutations`.
  The `gather` function can be passed to other functions, but should not be
  retained once the `gathering` form has returned (it would be useless to do so
  anyway).
  Examples:
    (gathering
      (dotimes (i 5)
        (gather i))
    =>
    (0 1 2 3 4)
    (gathering
      (mapc #'gather '(1 2 3))
      (mapc #'gather '(a b)))
    =>
    (1 2 3 a b)
  "
  (with-gensyms (result)
    `(let ((,result (make-queue)))
      (flet ((gather (item)
               (enqueue item ,result)))
        (declare (dynamic-extent #'gather))
        ,@body)
      (queue-contents ,result))))

(defstruct (queue (:constructor make-queue))
  (contents nil :type list)
  (last nil :type list)
  (size 0 :type fixnum))

;; real code is richer, with inline and inlinable function declarations.

(defun make-queue ()
  "Allocate and return a fresh queue."
  (make-queue%))

(defun queue-empty-p (queue)
  "Return whether `queue` is empty."
  (zerop (queue-size queue)))

(defun enqueue (item queue)
  "Enqueue `item` in `queue`, returning the new size of the queue."
  (let ((cell (cons item nil)))
    (if (queue-empty-p queue)
      (setf (queue-contents queue) cell)
      (setf (cdr (queue-last queue)) cell))
    (setf (queue-last queue) cell))
  (incf (queue-size queue)))

(defun dequeue (queue)
  "Dequeue an item from `queue` and return it."
  (when (zerop (decf (queue-size queue)))
    (setf (queue-last queue) nil))
  (pop (queue-contents queue)))

(defun queue-append (queue list)
  "Enqueue each element of `list` in `queue` and return the queue's final size."
  (loop :for item :in list
        :for size = (enqueue item queue)
        :finally (return size)))

(defun frequencies (sequence &key (test 'eql))
  ;; https://github.com/sjl/cl-losh/blob/master/losh.lisp#L1910
  "Return a hash table containing the frequencies of the items in `sequence`.
  Uses `test` for the `:test` of the hash table.
  Example:
    (frequencies '(foo foo bar))
    => {foo 2
        bar 1}
  "
  (iterate
    (with result = (make-hash-table :test test))
    (for i :in-whatever sequence)
    (incf (gethash i result 0))
    (finally (return result))))

(defun proportions (sequence &key (test 'eql) (float t))
  "Return a hash table containing the proportions of the items in `sequence`.
  Uses `test` for the `:test` of the hash table.
  If `float` is `t` the hash table values will be coerced to floats, otherwise
  they will be left as rationals.
  Example:
    (proportions '(foo foo bar))
    => {foo 0.66666
        bar 0.33333}
    (proportions '(foo foo bar) :float nil)
    => {foo 2/3
        bar 1/3}
  "
  (let* ((freqs (frequencies sequence :test test))
         (total (reduce #'+ (hash-table-values freqs)
                        :initial-value (if float 1.0 1))))
    (mutate-hash-values (lambda (v) (/ v total))
                        freqs)))

(defun group-by (function sequence &key (test #'eql) (key #'identity))
  "Return a hash table of the elements of `sequence` grouped by `function`.
  This function groups the elements of `sequence` into buckets.  The bucket for
  an element is determined by calling `function` on it.
  The result is a hash table (with test `test`) whose keys are the bucket
  identifiers and whose values are lists of the elements in each bucket.  The
  order of these lists is unspecified.
  If `key` is given it will be called on each element before passing it to
  `function` to produce the bucket identifier.  This does not effect what is
  stored in the lists.
  Examples:
    (defparameter *items* '((1 foo) (1 bar) (2 cats) (3 cats)))
    (group-by #'first *items*)
    ; => { 1 ((1 foo) (1 bar))
    ;      2 ((2 cats))
    ;      3 ((3 cats)) }
    (group-by #'second *items*)
    ; => { foo  ((1 foo))
    ;      bar  ((1 bar))
    ;      cats ((2 cats) (3 cats)) }
    (group-by #'evenp *items* :key #'first)
    ; => { t   ((2 cats))
    ;      nil ((1 foo) (1 bar) (3 cats)) }
  "
  (iterate
    (with result = (make-hash-table :test test))
    (for i :in-whatever sequence)
    (push i (gethash (funcall function (funcall key i)) result))
    (finally (return result))))

(defun take-list (n list)
  (iterate (declare (iterate:declare-variables))
           (repeat n)
           (for item :in list)
           (collect item)))

(defun take-seq (n seq)
  (subseq seq 0 (min n (length seq))))

(defmacro do-repeat (n &body body)
  "Perform `body` `n` times."
  `(dotimes (,(gensym) ,n)
     ,@body))

(defmacro do-range (ranges &body body)
  "Perform `body` on the given `ranges`.

  Each range in `ranges` should be of the form `(variable from below)`.  During
  iteration `body` will be executed with `variable` bound to successive values
  in the range [`from`, `below`).

  If multiple ranges are given they will be iterated in a nested fashion.

  Example:

    (do-range ((x  0  3)
               (y 10 12))
      (pr x y))
    ; =>
    ; 0 10
    ; 0 11
    ; 1 10
    ; 1 11
    ; 2 10
    ; 2 11

  "
  (if (null ranges)
    `(progn ,@body)
    (destructuring-bind (var from below) (first ranges)
      `(loop :for ,var :from ,from :below ,below
             :do (do-range ,(rest ranges) ,@body)))))

(defun enumerate (sequence &key (start 0) (step 1) key)
  "Return an alist of `(n . element)` for each element of `sequence`.
  `start` and `step` control the values generated for `n`, NOT which elements of
  the sequence are enumerated.
  Examples:
    (enumerate '(a b c))
    ; => ((0 . A) (1 . B) (2 . C))
    (enumerate '(a b c) :start 1)
    ; => ((1 . A) (2 . B) (3 . C))
    (enumerate '(a b c) :key #'ensure-keyword)
    ; => ((0 . :A) (1 . :B) (2 . :C))
  "
  (iterate (for el :in-whatever sequence)
           (for n :from start :by step)
           (collect (cons n (if key
                              (funcall key el)
                              el)))))

(defun take (n seq)
  "Return a fresh sequence of the first `n` elements of `seq`.
  The result will be of the same type as `seq`.
  If `seq` is shorter than `n` a shorter result will be returned.
  Example:
    (take 2 '(a b c))
    => (a b)
    (take 4 #(1))
    => #(1)
  From Serapeum.
  "
  (check-type n array-index)
  (ctypecase seq
    (list (take-list n seq))
    (sequence (take-seq n seq))))

(defun take-list (n list)
  (iterate (declare (iterate:declare-variables))
           (repeat n)
           (for item :in list)
           (collect item)))

(defun take-seq (n seq)
  (subseq seq 0 (min n (length seq))))

(defun take-while-list (predicate list)
  (iterate (for item :in list)
           (while (funcall predicate item))
           (collect item)))

(defun take-while-seq (predicate seq)
  (subseq seq 0 (position-if-not predicate seq)))

(defun take-while (predicate seq)
  "Take elements from `seq` as long as `predicate` remains true.
  The result will be a fresh sequence of the same type as `seq`.
  Example:
    (take-while #'evenp '(2 4 5 6 7 8))
    ; => (2 4)
    (take-while #'evenp #(1))
    ; => #()
  "
  (ctypecase seq
    (list (take-while-list predicate seq))
    (sequence (take-while-seq predicate seq))))

(defun drop-list (n list)
  (copy-list (nthcdr n list)))

(defun drop-seq (n seq)
  (subseq seq (min n (length seq))))

(defun drop (n seq)
  "Return a fresh copy of the `seq` without the first `n` elements.
  The result will be of the same type as `seq`.
  If `seq` is shorter than `n` an empty sequence will be returned.
  Example:
    (drop 2 '(a b c))
    => (c)
    (drop 4 #(1))
    => #()
  From Serapeum.
  "
  (check-type n array-index)
  (ctypecase seq
    (list (drop-list n seq))
    (sequence (drop-seq n seq))))

(defun drop-while-list (predicate list)
  (iterate (for tail :on list)
           (while (funcall predicate (first tail)))
           (finally (return (copy-list tail)))))

(defun drop-while-seq (predicate seq)
  (let ((start (position-if-not predicate seq)))
    (if start
      (subseq seq start)
      (subseq seq 0 0))))

(defun drop-while (predicate seq)
  "Drop elements from `seq` as long as `predicate` remains true.
  The result will be a fresh sequence of the same type as `seq`.
  Example:
    (drop-while #'evenp '(2 4 5 6 7 8))
    ; => (5 6 7 8)
    (drop-while #'evenp #(2))
    ; => #(2)
  "
  (ctypecase seq
    (list (drop-while-list predicate seq))
    (sequence (drop-while-seq predicate seq))))

(defun extrema (predicate sequence)
  "Return the smallest and largest elements of `sequence` according to `predicate`.
  `predicate` should be a strict ordering predicate (e.g. `<`).
  Returns the smallest and largest elements in the sequence as two values,
  respectively.
  "
  (iterate (with min = (elt sequence 0))
           (with max = (elt sequence 0))
           (for el :in-whatever sequence)
           (when (funcall predicate el min) (setf min el))
           (when (funcall predicate max el) (setf max el))
           (finally (return (values min max)))))

(defun summation (sequence &key key)
  "Return the sum of all elements of `sequence`.
  If `key` is given, it will be called on each element to compute the addend.
  This function's ugly name was chosen so it wouldn't clash with iterate's `sum`
  symbol.  Sorry.
  Examples:
    (sum #(1 2 3))
    ; => 6
    (sum '(\"1\" \"2\" \"3\") :key #'parse-integer)
    ; => 6
    (sum '(\"1\" \"2\" \"3\") :key #'length)
    ; => 3
  "
  (if key
    (iterate (for n :in-whatever sequence)
             (sum (funcall key n)))
    (iterate (for n :in-whatever sequence)
             (sum n))))

(defun product (sequence &key key)
  ;; https://github.com/sjl/cl-losh/blob/master/losh.lisp#L2181
  "Return the product of all elements of `sequence`.
  If `key` is given, it will be called on each element to compute the
  multiplicand.
  Examples:
    (product #(1 2 3))
    ; => 6
    (product '(\"1\" \"2\" \"3\") :key #'parse-integer)
    ; => 6
    (product '(\"1\" \"2\" \"3\") :key #'length)
    ; => 1
  "
  (if key
    (iterate (for n :in-whatever sequence)
             (multiplying (funcall key n)))
    (iterate (for n :in-whatever sequence)
             (multiplying n))))

(defun pr (&rest args)
  "Print `args` readably, separated by spaces and followed by a newline.
  Returns the first argument, so you can just wrap it around a form without
  interfering with the rest of the program.
  This is what `print` should have been.
  "
  (format t "~{~S~^ ~}~%" args)
  (finish-output)
  (first args))

(defmacro prl (&rest args)
  "Print `args` labeled and readably.
  Each argument form will be printed, then evaluated and the result printed.
  One final newline will be printed after everything.
  Returns the last result.
  Examples:
    (let ((i 1)
          (l (list 1 2 3)))
      (prl i (second l)))
    ; =>
    i 1
    (second l) 2
  "
  `(prog1
    (progn ,@(mapcar (lambda (arg) `(pr ',arg ,arg)) args))
    (terpri)
    (finish-output)))

(defmacro shut-up (&body body)
  "Run `body` with stdout and stderr redirected to the void."
  `(let ((*standard-output* (make-broadcast-stream))
         (*error-output* (make-broadcast-stream)))
    ,@body))

(defmacro comment (&body body)
  "Do nothing with a bunch of forms.
  Handy for block-commenting multiple expressions.
  "
  (declare (ignore body))
  nil)

(defun print-table (rows)
  ;; https://github.com/sjl/cl-losh/blob/master/losh.lisp#L2334
  "Print `rows` as a nicely-formatted table.
  Each row should have the same number of colums.
  Columns will be justified properly to fit the longest item in each one.
  Example:
    (print-table '((1 :red something)
                   (2 :green more)))
    =>
    1 | RED   | SOMETHING
    2 | GREEN | MORE
  "
  (when rows
    (iterate
      (with column-sizes =
            (reduce (alexandria:curry #'mapcar #'max)
                    (mapcar (alexandria:curry #'mapcar (compose #'length #'aesthetic-string))
                            rows))) ; lol
      (for row :in rows)
      (format t "~{~vA~^ | ~}~%" (weave column-sizes row))))
  (values))

;; from Quickutil.
(defun ensure-function (function-designator)
    "Returns the function designated by `function-designator`:
if `function-designator` is a function, it is returned, otherwise
it must be a function name and its `fdefinition` is returned."
    (if (functionp function-designator)
        function-designator
        (fdefinition function-designator)))

;; from Quickutil.
(defun compose (function &rest more-functions)
    "Returns a function composed of `function` and `more-functions` that applies its ;
arguments to to each in turn, starting from the rightmost of `more-functions`,
and then calling the next one with the primary value of the last."
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (reduce (lambda (f g)
              (let ((f (ensure-function f))
                    (g (ensure-function g)))
                (lambda (&rest arguments)
                  (declare (dynamic-extent arguments))
                  (funcall f (apply g arguments)))))
            more-functions
            :initial-value function))

(defun make-gensym-list (length &optional (x "G"))
    "Returns a list of `length` gensyms, each generated as if with a call to `make-gensym`,
using the second (optional, defaulting to `\"G\"`) argument."
    (let ((g (if (typep x '(integer 0)) x (string x))))
      (loop repeat length
            collect (gensym g))))

  (define-compiler-macro compose (function &rest more-functions)
    (labels ((compose-1 (funs)
               (if (cdr funs)
                   `(funcall ,(car funs) ,(compose-1 (cdr funs)))
                   `(apply ,(car funs) arguments))))
      (let* ((args (cons function more-functions))
             (funs (make-gensym-list (length args) "COMPOSE")))
        `(let ,(loop for f in funs for arg in args
                     collect `(,f (ensure-function ,arg)))
           (declare (optimize (speed 3) (safety 1) (debug 1)))
           (lambda (&rest arguments)
             (declare (dynamic-extent arguments))
             ,(compose-1 funs))))))

;; from Quickutil.
(defun weave (&rest lists)
    "Return a list whose elements alternate between each of the lists
`lists`. Weaving stops when any of the lists has been exhausted."
    (apply #'mapcan #'list lists))

(defun aesthetic-string (thing)
  "Return the string used to represent `thing` when printing aesthetically."
  (format nil "~A" thing))

(defun print-hash-table (hash-table &optional (stream t))
  "Print a pretty representation of `hash-table` to `stream.`
  Respects `*print-length*` when printing the elements.
  "
  (let* ((keys (alexandria:hash-table-keys hash-table))
         (vals (alexandria:hash-table-values hash-table))
         (count (hash-table-count hash-table))
         (key-width (-<> keys
                      (mapcar (alexandria:compose #'length #'prin1-to-string) <>)
                      (reduce #'max <> :initial-value 0)
                      (clamp 0 20 <>))))
    (print-unreadable-object (hash-table stream :type t)
      (princ
        ;; Something shits the bed and output gets jumbled (in SBCL at least) if
        ;; we try to print to `stream` directly in the format statement inside
        ;; `print-unreadable-object`, so instead we can just render to a string
        ;; and `princ` that.
        (format nil ":test ~A :count ~D {~%~{~{  ~vs ~s~}~%~}}"
                (hash-table-test hash-table)
                count
                (loop
                  :with limit = (or *print-length* 40)
                  :for key :in keys
                  :for val :in vals
                  :for i :from 0 :to limit
                  :collect
                  (if (= i limit)
                    (list key-width :too-many-items (list (- count i) :more))
                    (list key-width key val))))
        stream)))
  (terpri stream)
  (values))

(defun pht (hash-table &optional (stream t))
  "Synonym for `print-hash-table` for less typing at the REPL."
  (print-hash-table hash-table stream))

(defun print-hash-table-concisely (hash-table &optional (stream t))
  "Print a concise representation of `hash-table` to `stream.`
  Should respect `*print-length*` when printing the elements.
  "
  (print-unreadable-object (hash-table stream :type t)
    (prin1 (hash-table-test hash-table))
    (write-char #\space stream)
    (prin1 (hash-table-contents hash-table) stream)))

;; needed:
(defun clamp (from to value)
  "Clamp `value` between `from` and `to`."
  (let ((max (max from to))
        (min (min from to)))
    (cond
      ((> value max) max)
      ((< value min) min)
      (t value))))

;; see
(defmacro -<> (expr &rest forms)
  "Thread the given forms, with `<>` as a placeholder."
  ;; I am going to lose my fucking mind if I have to program lisp without
  ;; a threading macro, but I don't want to add another dep to this library, so
  ;; here we are.
  `(let* ((<> ,expr)
          ,@(mapcar (lambda (form)
                      (if (symbolp form)
                        `(<> (,form <>))
                        `(<> ,form)))
                    forms))
     <>))

#+sbcl
(defun dump-profile (filename)
  (with-open-file (*standard-output* filename
                                     :direction :output
                                     :if-exists :supersede)
    (sb-sprof:report :type :graph
                     :sort-by :cumulative-samples
                     :sort-order :ascending)
    (sb-sprof:report :type :flat
                     :min-percent 0.5)))

#+sbcl
(defun start-profiling (&key call-count-packages (mode :cpu))
  "Start profiling performance.  SBCL only.
  `call-count-packages` should be a list of package designators.  Functions in
  these packages will have their call counts recorded via
  `sb-sprof::profile-call-counts`.
  "
  (sb-sprof::reset)
  (-<> call-count-packages
    (mapcar #'mkstr <>)
    (mapcar #'string-upcase <>)
    (mapc #'sb-sprof::profile-call-counts <>))
  (sb-sprof::start-profiling :max-samples 50000
                             :mode mode
                             ; :mode :time
                             :sample-interval 0.01
                             :threads :all))

#+sbcl
(defun stop-profiling (&optional (filename "lisp.prof"))
  "Stop profiling performance and dump a report to `filename`.  SBCL only."
  (sb-sprof::stop-profiling)
  (dump-profile filename))

#+sbcl
(defmacro profile (&body body)
  "Profile `body` and dump the report to `lisp.prof`."
  `(progn
     (start-profiling)
     (unwind-protect
         (time (progn ,@body))
       (stop-profiling))))

(ql:quickload :fset)

(defun get-dependencies (system)
  "Returns a set with all dependencies of a given system.
   System should be loaded first."
  (labels ((normalize (name)
             (etypecase name
               (string (string-downcase name))
               (symbol (normalize (symbol-name name)))
               (list
                (let ((dep-type (first name))
                      (supported-dep-types (list :version :feature :require)))
                  (unless (member dep-type
                                  supported-dep-types)
                    (error "This component \"~A\" should have first element from this list: ~A."
                           name
                           supported-dep-types))

                  (normalize
                   (case dep-type
                     (:version (second name))
                     (:feature (third name))
                     (:require (second name)))))))))

    (let ((processed (fset:set))
          (queue (fset:set (normalize system))))

      (do ((current-name (fset:arb queue)
                         (fset:arb queue)))
          ((null current-name)
           ;; return result
           processed)

        ;; Remove current name from the queue
        (setf queue
              (fset:less queue current-name))
        ;; And put it into the "processed" pool
        (setf processed
              (fset:with processed current-name))

        ;; And add it's dependencies which aren't processed or in the queue already
        ;; Sometimes system can't be found because itself depends on some feature,
        ;; for example, you can specify dependency as a list:
        ;; (:FEATURE :SBCL (:REQUIRE :SB-INTROSPECT))
        ;; and it will be loaded only on SBCL.
        ;; When we are collecting dependencies on another implementation,
        ;; we don't want to fail with an error because ASDF is unable to find
        ;; such dependencies
        (let* ((system (ignore-errors
                        (asdf:find-system current-name)))
               (deps (when system
                       (asdf:component-sideway-dependencies system))))
          (dolist (dep deps)
            (let ((normalized-dep (normalize dep)))
              (unless (or (fset:lookup processed normalized-dep)
                          (fset:lookup queue normalized-dep))
                (setf queue
                      (fset:with queue normalized-dep)))))))

      (values processed))))

#|
DEPENDENCIES> (ql:quickload :clinch)
DEPENDENCIES> (get-dependencies :clinch)
#{
  "cffi"
  "sdl2"
  "uiop"
  "babel"
  "swank"
  "clinch"
  "cl-glut"
  "cl-json"
  "cl-ppcre"
  "rtg-math"
  "cl-opengl"
  "cl-plus-c"
  "alexandria"
  "cl-autowrap"
  "glsl-symbols"
  "defpackage-plus"
  "trivial-garbage"
  "trivial-timeout"
  "bordeaux-threads"
  "trivial-channels"
  "trivial-features" }
|#

  (print-licenses 'fast-io)
  =>
  alexandria           | Public Domain / 0-clause MIT
  babel                | MIT
  cffi                 | MIT
  cffi-grovel          | MIT
  cffi-toolchain       | MIT
  fast-io              | NewBSD
  static-vectors       | MIT
  trivial-features     | MIT
  trivial-gray-streams | MIT
  uiop                 | Unspecified

(defun print-licenses (quicklisp-project-designator)
  (print-table (sort (license-list quicklisp-project-designator)
                     #'string<
                     :key #'car)))

(defun license-list (quicklisp-project-designator)
  (remove-duplicates
    (mapcar (alexandria:rcurry #'coerce 'list)
            (alexandria:flatten (license-tree quicklisp-project-designator)))
    :key #'car :test #'string=))

(defun license-tree (quicklisp-project-designator)
  (let ((sys (ql-dist:dependency-tree quicklisp-project-designator)))
    (assert (not (null sys)) ()
      "Cannot find Quicklisp project for designator ~S"
      quicklisp-project-designator)
    (shut-up
      (ql:quickload quicklisp-project-designator))
    (map-tree
      (lambda (s)
        (vector (slot-value s 'ql-dist:name)
                (or (asdf:system-license
                      (asdf:find-system
                        (ql-dist:system-file-name s)))
                    "Unspecified")))
      sys)))

(defmacro shut-up (&body body)
  "Run `body` with stdout and stderr redirected to the void."
  `(let ((*standard-output* (make-broadcast-stream))
         (*error-output* (make-broadcast-stream)))
     ,@body))

;; from Quickutil.
(defun map-tree (function tree)
    "Map `function` to each of the leave of `tree`."
    (check-type tree cons)
    (labels ((rec (tree)
               (cond
                 ((null tree) nil)
                 ((atom tree) (funcall function tree))
                 ((consp tree)
                  (cons (rec (car tree))
                        (rec (cdr tree)))))))
      (rec tree)))

;; from Quickutil
(defun aesthetic-string (thing)
  "Return the string used to represent `thing` when printing aesthetically."
  (format nil "~A" thing))

;; from Quickutil
(defun weave (&rest lists)
  "Return a list whose elements alternate between each of the lists
`lists`. Weaving stops when any of the lists has been exhausted."
  (apply #'mapcan #'list lists))

(defun print-table (rows)
  "Print `rows` as a nicely-formatted table.
  Each row should have the same number of colums.
  Columns will be justified properly to fit the longest item in each one.
  Example:
    (print-table '((1 :red something)
                   (2 :green more)))
    =>
    1 | RED   | SOMETHING
    2 | GREEN | MORE
  "
  (when rows
    (iterate
      (with column-sizes =
            (reduce (curry #'mapcar #'max)
                    (mapcar (curry #'mapcar (compose #'length #'aesthetic-string))
                            rows))) ; lol
      (for row :in rows)
      (format t "~{~vA~^ | ~}~%" (weave column-sizes row))))
  (values))

(access my-var elt)

{{ var.foo }}

(ql:quickload "access")

(use-package :access)

(defparameter my-alist '((:foo . "foo") (:bar . "bar")))
MY-ALIST

(defparameter my-plist (list :foo "foo" :bar "bar"))
MY-PLIST

(defparameter my-hashtable (make-hash-table))
MY-HASHTABLE
(setf (gethash :foo my-hashtable) "foo")
"foo"

(defclass obj-test ()
  ((foo :accessor foo :initarg :foo :initform :foo)
   (bar :accessor bar :initarg :bar :initform :bar)))
;; #<STANDARD-CLASS OBJ-TEST>
(defparameter my-obj (make-instance 'obj-test))
;; MY-OBJ

(access my-alist :foo)
"foo"
T

(access my-plist :foo)
"foo"
T

(access my-hashtable :foo)
"foo"
T

(access my-obj :foo) ;; <= accessor, not slot name
;; :FOO
;; T

(setf (access my-alist :foo) "oof")

(with-access (foo bar (other-name plist))
             my-obj
           (format t "Got: ~a~a~a~&" foo bar other-name)
           ;; we can change variables
           (setf other-name "hello plist")
           (format t "other-name: ~a~&" other-name)
           ;; it changed the object too
           (format t "object slot: ~a~&" (plist my-obj)))
Got: FOOBAR(FOO foo BAR bar)
other-name: hello plist
object slot: hello plist
NIL

(defclass obj-test ()
  ((foo :accessor foo :initarg :foo :initform :foo)
   (bar :accessor bar :initarg :bar :initform :bar)
   (plist :accessor plist :initarg plist :initform (copy-list MY-PLIST))))
#<STANDARD-CLASS OBJ-TEST>

(accesses MY-OBJ 'plist :foo)
;; "foo"

(with-dot ()
    my-alist.foo)
"foo"

(with-dot ()
    my-obj.foo)
"hello plist"

(enable-dot-syntax)

#Dmy-alist.foo
"foo"

;; back to initial case
(setf my-obj (make-instance 'obj-test))
;; #<OBJ-TEST {1005AA3B13}>
#Dmy-obj.plist.foo
;; "foo"

(defn report-error! [event]
  (let [error (.-error event)
        message (.-message error)
        stacktrace (.-stack error)]    
    (ajax/POST "/error"
               {:headers
                {"x-csrf-token"
                 (.-value (js/document.getElementById "__anti-forgery-token"))}
                :params
                {:message     message
                 :stacktrace stacktrace}})))

(defn init! []
  (.addEventListener js/window "error" report-error!)
  (reagent/render [home-page] (.getElementById js/document "app")))

(defn home-page []
  [:div>h2 "Error Test"
   [:div>button
    {:on-click #(throw (js/Error. "I'm an error"))}
    "throw an error"]])

Uncaught Error: I'm an error
    at app.core.home_page (core.cljs:25)
    at Object.ReactErrorUtils.invokeGuardedCallback (react-dom.inc.js:9073)
    at executeDispatch (react-dom.inc.js:3031)
    at Object.executeDispatchesInOrder (react-dom.inc.js:3054)
    at executeDispatchesAndRelease (react-dom.inc.js:2456)
    at executeDispatchesAndReleaseTopLevel (react-dom.inc.js:2467)
    at Array.forEach (<anonymous>)
    at forEachAccumulated (react-dom.inc.js:15515)
    at Object.processEventQueue (react-dom.inc.js:2670)
    at runEventQueueInBatch (react-dom.inc.js:9097)

 Error: I'm an error
    at app.core.home_page (http://localhost:3000/js/out/app/core.js:51:8)
    at Object.ReactErrorUtils.invokeGuardedCallback (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:9073:16)
    at executeDispatch (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:3031:21)
    at Object.executeDispatchesInOrder (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:3054:5)
    at executeDispatchesAndRelease (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:2456:22)
    at executeDispatchesAndReleaseTopLevel (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:2467:10)
    at Array.forEach (<anonymous>)
    at forEachAccumulated (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:15515:9)
    at Object.processEventQueue (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:2670:7)
    at runEventQueueInBatch (http://localhost:3000/js/out/cljsjs/react-dom/development/react-dom.inc.js:9097:18)

:dependencies
[...
 [ring-webjars "0.2.0"]
 [org.webjars.bower/stacktrace-js "2.0.0"]]

(ns app.handler
 (:require
  ...
  [ring.middleware.webjars :refer [wrap-webjars]]))

 (defn -main []
  (run-jetty
   (-> handler
       (wrap-webjars)
       (wrap-defaults site-defaults))
   {:port 3000 :join? false}))

(defroutes handler
  (GET "/" []
    (html5
      [:head
       [:meta {:charset "utf-8"}]
       (anti-forgery-field)]
      [:body
       [:div#app]
        (include-js "/assets/stacktrace-js/dist/stacktrace.min.js"
                    "/js/app.js")]))

  (POST "/error" {:keys [body]}
    (let [{:keys [message stacktrace]}
          (-> body
              (transit/reader :json)
              (transit/read))]
      (println "Client error:" message "\n" stacktrace))
    "ok")

  (resources "/")
  (not-found "Not Found"))

{:output-dir "target/cljsbuild/public/js"
 :output-to  "target/cljsbuild/public/js/app.js"
 :source-map "target/cljsbuild/public/js/app.js.map"
 :optimizations :advanced
 :infer-externs true
 :closure-warnings {:externs-validation :off
                    :non-standard-jsdoc :off}}

(defn report-error! [event]
  (let [error (.-error event)]
    (-> (js/StackTrace.fromError error)
        (.then
         (fn [stacktrace]
           (ajax/POST "/error"
                      {:headers
                       {"x-csrf-token"
                        (.-value (js/document.getElementById "__anti-forgery-token"))}
                       :params
                       {:message    (.-message error)
                        :stacktrace (->> stacktrace
                                          (mapv #(.toString %))
                                          (string/join "\n "))}}))))))

I'm an error
 Error()@http://localhost:3000/js/app/core.cljs:27:23
 mountComponent()@http://localhost:3000/js/app.js:40:5631
 focusDOMComponent()@http://localhost:3000/js/app.js:38:22373
 focusDOMComponent()@http://localhost:3000/js/app.js:38:22588
 focusDOMComponent()@http://localhost:3000/js/app.js:38:18970
 focusDOMComponent()@http://localhost:3000/js/app.js:38:19096
 didPutListener()@http://localhost:3000/js/app.js:41:12120
 focusDOMComponent()@http://localhost:3000/js/app.js:38:20154
 mountComponent()@http://localhost:3000/js/app.js:40:5880

{:deps
 {org.clojure/data.csv {:git/url "https://github.com/clojure/data.csv.git"
                        :sha "e5beccad0bafdb8e78f19cba481d4ecef5fabf36"}}}
(defstruct person
   id name age)

(defstruct person
   id
   (name "john doe")
   age)

(defstruct person
  id
  (name "john doe" :type string)
  age)

(defparameter *me* (make-person))
*me*
#S(PERSON :ID NIL :NAME "john doe" :AGE NIL)

(defparameter *bad-name* (make-person :name 123))

Invalid initialization argument:
  :NAME
in call for class #<STRUCTURE-CLASS PERSON>.
   [Condition of type SB-PCL::INITARG-ERROR]

(defstruct (person (:constructor create-person (id name age)))
     id
     name
     age)

(create-person 1 "me" 7)
#S(PERSON :ID 1 :NAME "me" :AGE 7)

(make-person :name "me")
;; debugger:
obsolete structure error for a structure of type PERSON
[Condition of type SB-PCL::OBSOLETE-STRUCTURE]

(person-name *me*)
;; "john doe"

(setf (person-name *me*) "Cookbook author")
(person-name *me*)
;; "Cookbook author"

(person-p *me*)
T

(defstruct (female (:include person))
     (gender "female" :type string))
(make-female :name "Lilie")
;; #S(FEMALE :ID NIL :NAME "Lilie" :AGE NIL :GENDER "female")

(defstruct person
       id
       (name "john doe" :type string)
       age
       email)

attempt to redefine the STRUCTURE-OBJECT class PERSON
incompatibly with the current definition
   [Condition of type SIMPLE-ERROR]

Restarts:
 0: [CONTINUE] Use the new definition of PERSON, invalidating already-loaded code and instances.
 1: [RECKLESSLY-CONTINUE] Use the new definition of PERSON as if it were compatible, allowing old accessors to use new instances and allowing new accessors to use old instances.
 2: [CLOBBER-IT] (deprecated synonym for RECKLESSLY-CONTINUE)
 3: [RETRY] Retry SLIME REPL evaluation request.
 4: [*ABORT] Return to SLIME's top level.
 5: [ABORT] abort thread (#<THREAD "repl-thread" RUNNING {1002A0FFA3}>)

*me*
obsolete structure error for a structure of type PERSON
   [Condition of type SB-PCL::OBSOLETE-STRUCTURE]

(ignore-errors
  (/ 3 0))
; in: IGNORE-ERRORS (/ 3 0)
;     (/ 3 0)
;
; caught STYLE-WARNING:
;   Lisp error during constant folding:
;   arithmetic error DIVISION-BY-ZERO signalled
;   Operation was (/ 3 0).
;
; compilation unit finished
;   caught 1 STYLE-WARNING condition
NIL
#<DIVISION-BY-ZERO {1008FF5F13}>

(handler-case (/ 3 0)
  (error (c)
    (format t "We caught a condition.~&")
    (values 0 c)))
; in: HANDLER-CASE (/ 3 0)
;     (/ 3 0)
;
; caught STYLE-WARNING:
;   Lisp error during constant folding:
;   Condition DIVISION-BY-ZERO was signalled.
;
; compilation unit finished
;   caught 1 STYLE-WARNING condition
We caught a condition.
0
#<DIVISION-BY-ZERO {1004846AE3}>

(handler-case (code that errors out)
   (condition-type (the-condition) ;; <-- optional argument
      (code))
   (another-condition (the-condition)
       ...))

(handler-case
    (progn
      (format t "This won't work…~%")
      (/ 3 0))
  (t (c)
    (format t "Got an exception: ~a~%" c)
    (values 0 c)))
;; …
;; This won't work…
;; Got an exception: arithmetic error DIVISION-BY-ZERO signalled
;; Operation was (/ 3 0).
;; 0
;; #<DIVISION-BY-ZERO {100608F0F3}>

(handler-case (/ 3 0)
  (division-by-zero (c)
    (format t "Caught division by zero: ~a~%" c)))
;; …
;; Caught division by zero: arithmetic error DIVISION-BY-ZERO signalled
;; Operation was (/ 3 0).
;; NIL

; caught STYLE-WARNING:
;   The variable C is defined but never used.

(handler-case (/ 3 0)
  (division-by-zero (c)
   (declare (ignore c))
   (format t "Caught division by zero~%"))) ;; we don't print "c" here and don't get the warning.

(handler-bind ((a-condition #'function-to-handle-it)
               (another-one #'another-function))
    (code that can...)
    (...error out))

(handler-bind
             ((division-by-zero #'(lambda (c) (format t "hello condition~&"))))
           (/ 3 0))

(handler-bind ((opts:unknown-option #'unknown-option)
               (opts:missing-arg #'missing-arg)
               (opts:arg-parser-failed #'arg-parser-failed))
  (opts:get-opts))

(defun unknown-option (condition)
  (format t "~s option is unknown.~%" (opts:option condition))
  (opts:describe)
  (exit)) ;; <-- we return to the command line, no debugger.

(define-condition my-division-by-zero (error) ())

(define-condition my-division-by-zero (error)
  ((dividend :initarg :dividend
            :reader dividend)) ;; <= so we'll get the dividend with (dividend condition), as soon as on the next line.
  ;; the :report is the message into the debugger:
  (:report (lambda (condition stream) (format stream "You were going to divide ~a by zero.~&" (dividend condition)))))

(define-condition my-condition (condition-it-inherits-from)
  ;; list of arguments, can be "()".
  ((message :initarg :message
            :reader my-condition-message)
   (second ...))
  ;; class arguments
  (:report (lambda (condition stream) (...))) ;; what is printed in the REPL.
  (:documentation "a string")) ;; good practice ;)

(defun my-division (x y)
    (if (= y 0)
        (error 'MY-DIVISION-BY-ZERO :dividend x))
    (/ x y))

(my-division 3 0)
;;
;; into the debugger:
;;
You were going to divide 3 by zero.
   [Condition of type MY-DIVISION-BY-ZERO]

Restarts:
 0: [RETRY] Retry SLIME REPL evaluation request.
 1: [*ABORT] Return to SLIME's top level.
 2: [ABORT] abort thread (#<THREAD "repl-thread" RUNNING {1002957FA3}>)

Backtrace:
  0: (MY-DIVISION 3 0)

(define-condition troublesome-option (simple-error)
  ((option
    :initarg :option
    :reader option))
  (:report (lambda (c s) (format s "troublesome option: ~s" (option c))))
  (:documentation "Generalization over conditions that have to do with some
particular option."))

(define-condition unknown-option (troublesome-option)
  ()
  (:report (lambda (c s) (format s "unknown option: ~s" (option c))))
  (:documentation "This condition is thrown when parser encounters
unknown (not previously defined with `define-opts') option."))

(error 'unknown-option
        :option opt)

(defun division-restarter ()
  (restart-case (/ 3 0)
    (return-zero () 0)
    (divide-by-one () (/ 3 1))))

(defun division-and-bind ()
           (handler-bind
               ((error (lambda (c)
                         (format t "Got error: ~a~%" c) ;; error-message
                         (format t "and will divide by 1~&")
                         (invoke-restart 'divide-by-one))))
             (division-restarter)))
;; (DIVISION-AND-BIND)
;; Got error: arithmetic error DIVISION-BY-ZERO signalled
;; and will divide by 1
;; Operation was (/ 3 0).
;; 3

(defun division-restarter ()
  (restart-case (/ 3 0)
    (return-nil () nil)
    (divide-by-one () (/ 3 1))
    (choose-another-dividend (new-dividend)
      :report "Please choose another dividend"
      :interactive (lambda ()
                     (format t "Enter a new dividend: ")
                     (list (read))) ;; <-- must return a list.
      (format t "New division: 3/~a = ~a~&" new-dividend (/ 3 new-dividend)))))

arithmetic error DIVISION-BY-ZERO signalled
Operation was (/ 3 0).
  [Condition of type DIVISION-BY-ZERO]

Restarts:
 0: [RETURN-NIL] RETURN-NIL
 1: [DIVIDE-BY-ONE] DIVIDE-BY-ONE
 2: [CHOOSE-ANOTHER-DIVIDEND] Please choose another dividend <-- new
 3: [RETRY] Retry SLIME REPL evaluation request.
 4: [*ABORT] Return to SLIME's top level.
 5: [ABORT] abort thread (#<THREAD "repl-thread" RUNNING {1002A47FA3}>)

(division-restarter)
;;
;; Entered debugger, chose the 2nd restart.
;;
Enter a new dividend: 10  <-- got prompted to enter a new value.
New division: 3/10 = 3/10
NIL

(restart-case
   (return-zero ()
     :test (lambda ()
             (some-test))
    ...

(sb-ext:save-lisp-and-die #P"path/name-of-executable" :toplevel #'my-app:main-function :executable t)

(load "my-app.asd")
(ql:quickload :my-app)
(sb-ext:save-lisp-and-die #p"my-app-binary" :toplevel #'my-app:main :executable t)

build:
	sbcl --load my-app.asd \
	     --eval '(ql:quickload :my-app)' \
         --eval "(sb-ext:save-lisp-and-die #p\"my-app\" :toplevel #my-app:main :executable t)"

:build-operation "program-op" ;; leave as is
:build-pathname "<binary-name>"
:entry-point "<my-package:main-function>"

LISP ?= sbcl

build:
    $(LISP) --load torrents.asd \
    	--eval '(ql:quickload :my-app)' \
		--eval '(asdf:make :my-app)' \
		--eval '(quit)'

buildapp --output myapp \
         --asdf-path . \
         --asdf-tree ~/quicklisp/dists \
         --load-system my-app \
         --entry my-app:main

$ ./my-web-app
Hunchentoot server is started.
Listening on localhost:9003.

(defun main ()
  (start-app :port 9003) ;; our start-app, for example clack:clack-up
  ;; let the webserver run.
  ;; warning: hardcoded "hunchentoot".
  (handler-case (bt:join-thread (find-if (lambda (th)
                                            (search "hunchentoot" (bt:thread-name th)))
                                         (bt:all-threads)))
    ;; Catch a user's C-c
    (#+sbcl sb-sys:interactive-interrupt
      #+ccl  ccl:interrupt-signal-condition
      #+clisp system::simple-interrupt-condition
      #+ecl ext:interactive-interrupt
      #+allegro excl:interrupt-signal
      () (progn
           (format *error-output* "Aborting.~&")
           (clack:stop *server*)
           (uiop:quit)))
    (error (c) (format t "Woops, an unknown error occured:~&~a~&" c))))

| program size | implementation |  CPU | startup time |
|--------------+----------------+------+--------------|
|           28 | /bin/true      |  15% |        .0004 |
|         1005 | ecl            | 115% |        .5093 |
|        48151 | sbcl           |  91% |        .0064 |
|        27054 | ccl            |  93% |        .0060 |
|        10162 | clisp          |  96% |        .0170 |
|         4901 | ecl.big        | 113% |        .8223 |
|        70413 | sbcl.big       |  93% |        .0073 |
|        41713 | ccl.big        |  95% |        .0094 |
|        19948 | clisp.big      |  97% |        .0259 |

(ql:quickload "unix-opts")

(opts:define-opts
    (:name :help
           :description "print this help text"
           :short #\h
           :long "help")
    (:name :nb
           :description "here we want a number argument"
           :short #\n
           :long "nb"
           :arg-parser #'parse-integer) ;; <- takes an argument
    (:name :info
           :description "info"
           :short #\i
           :long "info"))

$ my-app -h
my-app. Usage:

Available options:
  -h, --help               print this help text
  -n, --nb ARG             here we want a number argument
  -i, --info               info

  (multiple-value-bind (options free-args)
      ;; There is no error handling yet.
      (opts:get-opts)
      ...

(multiple-value-bind (options free-args)
                   (opts:get-opts '("hello" "-h" "-n" "1"))
                 (format t "Options: ~a~&" options)
                 (format t "free args: ~a~&" free-args))
Options: (HELP T NB-RESULTS 1)
free args: (hello)
NIL

  (multiple-value-bind (options free-args)
      (opts:get-opts)

    (if (getf options :help)
        (progn
          (opts:describe
           :prefix "You're in my-app. Usage:"
           :args "[keywords]") ;; to replace "ARG" in "--nb ARG"
          (opts:exit))) ;; <= optional return status.
    (if (getf options :nb)
       ...)

  (multiple-value-bind (options free-args)
      (handler-bind ((opts:unknown-option #'unknown-option) ;; the condition / our function
                     (opts:missing-arg #'missing-arg)
                     (opts:arg-parser-failed #'arg-parser-failed)
                     (opts:missing-required-option))
         (opts:get-opts))
    …
    ;; use "options" and "free-args"

(defun handle-arg-parser-condition (condition)
  (format t "Problem while parsing option ~s: ~a .~%" (opts:option condition) ;; reader to get the option from the condition.
                                                       condition)
  (opts:describe) ;; print help
  (opts:exit)) ;; portable exit

$ ./my-app
sleep…
^C
debugger invoked on a SB-SYS:INTERACTIVE-INTERRUPT in thread   <== condition name
#<THREAD "main thread" RUNNING {1003156A03}>:
  Interactive interrupt at #x7FFFF6C6C170.

Type HELP for debugger help, or (SB-EXT:EXIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [CONTINUE     ] Return from SB-UNIX:SIGINT.               <== it was a SIGINT indeed
  1: [RETRY-REQUEST] Retry the same request.

(handler-case
    (run-my-app free-args)
  (sb-sys:interactive-interrupt () (progn
                                     (format *error-output* "Abort.~&")
                                     (opts:exit))))

(handler-case
    (run-my-app free-args)
  (#+sbcl sb-sys:interactive-interrupt
   #+ccl  ccl:interrupt-signal-condition
   #+clisp system::simple-interrupt-condition
   #+ecl ext:interactive-interrupt
   #+allegro excl:interrupt-signal
   ()
   (opts:exit)))

image: daewok/lisp-devel

before_script:
  - apt-get update -qy
  - apt-get install -y git-core
  - git clone https://github.com/foo/bar ~/quicklisp/local-projects/

test:
  script:
    - make test

docker run --rm -it -v /path/to/local/code:/usr/local/share/common-lisp/source daewok/lisp-devel:latest bash

image: daewok/lisp-devel

stages:
  - test
  - build

before_script:
  - apt-get update -qy
  - apt-get install -y git-core
  - git clone https://github.com/foo/bar ~/quicklisp/local-projects/

test:
  stage: test
  script:
    - make test

build:
  stage: build
  only:
    - tags
  script:
    - make build
  artifacts:
    paths:
      - some-file-name

https://gitlab.com/username/project-name/-/jobs/artifacts/master/raw/some-file-name?job=build

curl -O https://beta.quicklisp.org/quicklisp.lisp

sbcl --load quicklisp.lisp

apt-get install cl-quicklisp

(load "/usr/share/cl-quicklisp/quicklisp.lisp")

(quicklisp-quickstart:install)

#-quicklisp
  (let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
                                         (user-homedir-pathname))))
    (when (probe-file quicklisp-init)
      (load quicklisp-init)))

(ql:quickload "package-name")

(require "asdf")
(require "cl-ppcre")
(cl-ppcre:regex-replace "fo+" "foo bar" "frob")

(ql:quickload "package")

(defmacro --map (form list)
  `(mapcar (lambda (it) ,form) ,list))

(--map (* it 2) '(2 3))

(map ^(foo-bar %) items)

(cons 1 2)
;; => (1 . 2) ;; representation with a point, a dotted pair.

[o|o]--- 2
 |
 1

(cons 1 (cons 2 nil))
;; => (1 2)

[o|o]---[o|/]
 |       |
 1       2

(list 1 2)
;; => (1 2)

'(1 2)
;; => (1 2)

(car (cons 1 2)) ;; => 1
(cdr (cons 1 2)) ;; => 2
(first (cons 1 2)) ;; => 1
(first '(1 2 3)) ;; => 1
(rest '(1 2 3)) ;; => (2 3)

(last '(1 2 3))
;; => (3)
(car (last '(1 2 3)) )
;; => 3
(butlast '(1 2 3))
;; => (1 2)

(defparameter mylist '(1 2 3))
;; => (1 2 3)
(reverse mylist)
;; => (3 2 1)
mylist
;; => (1 2 3)
(nreverse mylist)
;; => (3 2 1)
mylist
;; => (1) in SBCL but implementation dependant.

(append (list 1 2) (list 3 4))
;; => (1 2 3 4)

(defparameter mylist '(1 2 3))
(push 0 mylist)
;; => (0 1 2 3)

(defparameter x ’(a (b c) d))
;; => (A (B C) D)
(push 5 (cadr x))
;; => (5 B C)
x
;; => (A (5 B C) D)

(caar (list 1 2 3))                  ==> error
(caar (list (list 1 2) 3))           ==> 1
(cadr (list (list 1 2) (list 3 4)))  ==> (3 4)
(caadr (list (list 1 2) (list 3 4))) ==> 3

(destructuring-bind (x y z) (list 1 2 3)
  (list :x x :y y :z z))
;; => (:X 1 :Y 2 :Z 3)

(destructuring-bind (x (y1 y2) z) (list 1 (list 2 20) 3)
  (list :x x :y1 y1 :y2 y2 :z z))
;; => (:X 1 :Y1 2 :Y2 20 :Z 3)

(destructuring-bind (x (y1 &optional y2) z) (list 1 (list 2) 3)
  (list :x x :y1 y1 :y2 y2 :z z))
;; => (:X 1 :Y1 2 :Y2 NIL :Z 3)

(destructuring-bind (&key x y z) (list :z 1 :y 2 :x 3)
  (list :x x :y y :z z))
;; => (:X 3 :Y 2 :Z 1)

(destructuring-bind (&whole whole-list &key x y z) (list :z 1 :y 2 :x 3)
  (list :x x :y y :z z :whole whole-list))
;; => (:X 3 :Y 2 :Z 1 :WHOLE-LIST (:Z 1 :Y 2 :X 3))

(destructuring-bind (&key a (b :not-found) c
                     &allow-other-keys)
    ’(:c 23 :d "D" :a #\A :foo :whatever)
  (list a b c))
;; => (#\A :NOT-FOUND 23)

(make-list 3 :initial-element "ta")
;; => ("ta" "ta" "ta")

(make-list 3)
;; => (NIL NIL NIL)
(fill * "hello")
;; => ("hello" "hello" "hello")

(find x y :key 'car)

(defparameter my-alist (list (cons 'foo "foo")
                             (cons 'bar "bar")))
;; => ((FOO . "foo") (BAR . "bar"))
(find 'bar my-alist)
;; => NIL
(find 'bar my-alist :key 'car)
;; => (BAR . "bar")

(find 'bar my-alist :key (lambda (it) (car it)))

(find 'bar my-alist :key ^(car %))
(find 'bar my-alist :key (lm (it) (car it)))

(defparameter foo '(1 2 3))
(every #'evenp foo)
;; => NIL
(some #'evenp foo)
;; => T

(defparameter str '("foo" "bar" "team"))
(every #'stringp str)
;; => T
(some #'(lambda (it) (= 3 (length it))) str)
;; => T
(some ^(= 3 (length %)) str) ;; in CL21
;; => T

(remove "foo" '("foo" "bar" "foo") :test 'equal)
;; => ("bar")

(defparameter foo '(1 2 3))
(map 'list (lambda (it) (* 10 it)) foo)

(reduce '- '(1 2 3 4))
;; => -8
(reduce '- '(1 2 3 4) :initial-value 100)
;; => 90

(defparameter *var* "bar")
;; First try:
'("foo" *var* "baz") ;; no backquote
;; => ("foo" *VAR* "baz") ;; nope

`("foo" ,*var* "baz")     ;; backquote, comma
;; => ("foo" "bar" "baz") ;; good

(defparameter *var* '("bar" "baz"))
;; First try:
`("foo" ,*var*)
;; => ("foo" ("bar" "baz")) ;; nested list
`("foo" ,@*var*)            ;; backquote, comma-@ to
;; => ("foo" "bar" "baz")

(defparameter list-a '(0 1 2 3))
(defparameter list-b '(0 2 4))
(intersection list-a list-b)
;; => (2 0)

(set-difference list-a list-b)
;; => (3 1)
(set-difference list-b list-a)
;; => (4)

(union list-a list-b)
;; => (3 1 0 2 4) ;; order can be different in your lisp

(set-exclusive-or list-a list-b)
;; => (4 3 1)

(defparameter myarray (make-array '(2 2 2) :initial-element 1))
myarray
;; => #3A(((1 1) (1 1)) ((1 1) (1 1)))
(aref myarray 0 0 0)
;; => 1
(setf (aref myarray 0 0 0) 9)
;; => 9
(row-major-aref myarray 0)
;; => 9

(defparameter myarray (make-array '(2 2 2)))
;; => MYARRAY
myarray
;; => #3A(((0 0) (0 0)) ((0 0) (0 0)))
(array-rank myarray)
;; => 3
(array-dimensions myarray)
;; => (2 2 2)
(array-dimension myarray 0)
;; => 2
(array-total-size myarray)
;; => 8

(vector 1 2 3)
;; => #(1 2 3)
#(1 2 3)
;; => #(1 2 3)

(defparameter *my-hash* #H(:name "Eitaro Fukamachi"))

(getf *my-hash* :name)

(gethash 'bar *my-hash* "default-bar")
;; => "default-bar"
;;     NIL

(ql:quickload :alexandria)
;; […]
(alexandria:hash-table-keys *my-hash*)
;; => (BAR)

CL-USER> (defparameter *my-hash* (make-hash-table))
*MY-HASH*
CL-USER> (setf (gethash 'one-entry *my-hash*) "one")
"one"
CL-USER> (setf (gethash 'another-entry *my-hash*) 2/4)
1/2
CL-USER> (gethash 'one-entry *my-hash*)
"one"
T
CL-USER> (gethash 'another-entry *my-hash*)
1/2
T

CL-USER> (defparameter *my-hash* (make-hash-table))
*MY-HASH*
CL-USER> (setf (gethash 'one-entry *my-hash*) "one")
"one"
CL-USER> (if (gethash 'one-entry *my-hash*)
           "Key exists"
           "Key does not exist")
"Key exists"
CL-USER> (if (gethash 'another-entry *my-hash*)
           "Key exists"
           "Key does not exist")
"Key does not exist"

CL-USER> (setf (gethash 'another-entry *my-hash*) nil)
NIL
CL-USER> (if (gethash 'another-entry *my-hash*)
           "Key exists"
           "Key does not exist")
"Key does not exist"

CL-USER> (if (nth-value 1 (gethash 'another-entry *my-hash*))
           "Key exists"
           "Key does not exist")
"Key exists"
CL-USER> (if (nth-value 1 (gethash 'no-entry *my-hash*))
           "Key exists"
           "Key does not exist")
"Key does not exist"

CL-USER> (defparameter *my-hash* (make-hash-table))
*MY-HASH*
CL-USER> (setf (gethash 'first-key *my-hash*) 'one)
ONE
CL-USER> (gethash 'first-key *my-hash*)
ONE
T
CL-USER> (remhash 'first-key *my-hash*)
T
CL-USER> (gethash 'first-key *my-hash*)
NIL
NIL
CL-USER> (gethash 'no-entry *my-hash*)
NIL
NIL
CL-USER> (remhash 'no-entry *my-hash*)
NIL
CL-USER> (gethash 'no-entry *my-hash*)
NIL
NIL

CL-USER> (defparameter *my-hash* (make-hash-table))
*MY-HASH*
CL-USER> (setf (gethash 'first-key *my-hash*) 'one)
ONE
CL-USER> (setf (gethash 'second-key *my-hash*) 'two)
TWO
CL-USER> (setf (gethash 'third-key *my-hash*) nil)
NIL
CL-USER> (setf (gethash nil *my-hash*) 'nil-value)
NIL-VALUE
CL-USER> (defun print-hash-entry (key value)
    (format t "The value associated with the key ~S is ~S~%" key value))
PRINT-HASH-ENTRY
CL-USER> (maphash #'print-hash-entry *my-hash*)
The value associated with the key FIRST-KEY is ONE
The value associated with the key SECOND-KEY is TWO
The value associated with the key THIRD-KEY is NIL
The value associated with the key NIL is NIL-VALUE

;;; same hash-table as above
CL-USER> (with-hash-table-iterator (my-iterator *my-hash*)
           (loop
              (multiple-value-bind (entry-p key value)
                  (my-iterator)
                (if entry-p
                    (print-hash-entry key value)
                    (return)))))
The value associated with the key FIRST-KEY is ONE
The value associated with the key SECOND-KEY is TWO
The value associated with the key THIRD-KEY is NIL
The value associated with the key NIL is NIL-VALUE
NIL

;;; same hash-table as above
CL-USER> (loop for key being the hash-keys of *my-hash*
           do (print key))
FIRST-KEY
SECOND-KEY
THIRD-KEY
NIL
NIL
CL-USER> (loop for key being the hash-keys of *my-hash*
           using (hash-value value)
           do (format t "The value associated with the key ~S is ~S~%" key value))
The value associated with the key FIRST-KEY is ONE
The value associated with the key SECOND-KEY is TWO
The value associated with the key THIRD-KEY is NIL
The value associated with the key NIL is NIL-VALUE
NIL
CL-USER> (loop for value being the hash-values of *my-hash*
           do (print value))
ONE
TWO
NIL
NIL-VALUE
NIL
CL-USER> (loop for value being the hash-values of *my-hash*
           using (hash-key key)
           do (format t "~&~A -> ~A" key value))
FIRST-KEY -> ONE
SECOND-KEY -> TWO
THIRD-KEY -> NIL
NIL -> NIL-VALUE
NIL

CL-USER> (defparameter *my-hash* (make-hash-table))
*MY-HASH*
CL-USER> (hash-table-count *my-hash*)
0
CL-USER> (setf (gethash 'first *my-hash*) 1)
1
CL-USER> (setf (gethash 'second *my-hash*) 2)
2
CL-USER> (setf (gethash 'third *my-hash*) 3)
3
CL-USER> (hash-table-count *my-hash*)
3
CL-USER> (setf (gethash 'second *my-hash*) 'two)
TWO
CL-USER> (hash-table-count *my-hash*)
3
CL-USER> (clrhash *my-hash*)
#<EQL hash table, 0 entries {48205F35}>
CL-USER> (hash-table-count *my-hash*)
0

CL-USER> (defparameter *my-hash* (make-hash-table))
*MY-HASH*
CL-USER> (hash-table-size *my-hash*)
65
CL-USER> (hash-table-rehash-size *my-hash*)
1.5
CL-USER> (time (dotimes (n 100000) (setf (gethash n *my-hash*) n)))
Compiling LAMBDA NIL:
Compiling Top-Level Form:

Evaluation took:
  0.27 seconds of real time
  0.25 seconds of user run time
  0.02 seconds of system run time
  0 page faults and
  8754768 bytes consed.
NIL
CL-USER> (time (dotimes (n 100000) (setf (gethash n *my-hash*) n)))
Compiling LAMBDA NIL:
Compiling Top-Level Form:

Evaluation took:
  0.05 seconds of real time
  0.05 seconds of user run time
  0.0 seconds of system run time
  0 page faults and
  0 bytes consed.
NIL

CL-USER> (log (/ 100000 65) 1.5)
18.099062
CL-USER> (let ((size 65)) (dotimes (n 20) (print (list n size)) (setq size (* 1.5 size))))
(0 65)
(1 97.5)
(2 146.25)
(3 219.375)
(4 329.0625)
(5 493.59375)
(6 740.3906)
(7 1110.5859)
(8 1665.8789)
(9 2498.8184)
(10 3748.2275)
(11 5622.3413)
(12 8433.512)
(13 12650.268)
(14 18975.402)
(15 28463.104)
(16 42694.656)
(17 64041.984)
(18 96062.98)
(19 144094.47)
NIL

CL-USER> (defparameter *my-hash* (make-hash-table :size 100000))
*MY-HASH*
CL-USER> (hash-table-size *my-hash*)
100000
CL-USER> (time (dotimes (n 100000) (setf (gethash n *my-hash*) n)))
Compiling LAMBDA NIL:
Compiling Top-Level Form:

Evaluation took:
  0.04 seconds of real time
  0.04 seconds of user run time
  0.0 seconds of system run time
  0 page faults and
  0 bytes consed.
NIL

CL-USER> (defparameter *my-hash* (make-hash-table :rehash-size 100000))
*MY-HASH*
CL-USER> (hash-table-size *my-hash*)
65
CL-USER> (hash-table-rehash-size *my-hash*)
100000
CL-USER> (time (dotimes (n 100000) (setf (gethash n *my-hash*) n)))
Compiling LAMBDA NIL:
Compiling Top-Level Form:

Evaluation took:
  0.07 seconds of real time
  0.05 seconds of user run time
  0.01 seconds of system run time
  0 page faults and
  2001360 bytes consed.
NIL

(defparameter my-alist (list (cons 'foo "foo")
                             (cons 'bar "bar")))
;; => ((FOO . "foo") (BAR . "bar"))

[o|o]---[o|/]
 |       |
 |      [o|o]---"bar"
 |       |
 |      BAR
 |
[o|o]---"foo"
 |
FOO

(pairlis '(:foo :bar)
         '("foo" "bar"))
;; => ((:BAR . "bar") (:FOO . "foo"))

(push (cons 'team "team") my-alist)
;; => ((TEAM . "team") (FOO . "foo") (BAR . "bar"))

(remove :team my-alist)
;; => ((:TEAM . "team") (FOO . "foo") (BAR . "bar")) ;; didn't remove anything
(remove :team my-alist :key 'car)
;; => ((FOO . "foo") (BAR . "bar")) ;; returns a copy

(push (cons 'bar "bar2") my-alist)
;; => ((BAR . "bar2") (TEAM . "team") (FOO . "foo") (BAR . "bar")) ;; twice the 'bar key
(remove 'bar my-alist :key 'car :count 1)
;; => ((TEAM . "team") (FOO . "foo") (BAR . "bar"))
;; because otherwise:
(remove 'bar my-alist :key 'car)
;; => ((TEAM . "team") (FOO . "foo")) ;; no more 'bar

(defparameter my-plist (list 'foo "foo" 'bar "bar"))

[o|o]---[o|o]---[o|o]---[o|/]
 |       |       |       |
FOO     "foo"   BAR     "bar"

(defparameter my-plist (list 'foo "foo" 'bar "bar"))
;; => (FOO "foo" BAR "bar")
(setf (getf my-plist 'foo) "foo!!!")
;; => "foo!!!"

(ql:quickload '(:dexador :plump :lquery :lparallel))

(defvar *url* "https://lispcookbook.github.io/cl-cookbook/")
(defvar *request* (dex:get *url*))

"<!DOCTYPE html>
 <html lang=\"en\">
  <head>
    <title>Home &ndash; the Common Lisp Cookbook</title>
    […]
    "
200
#<HASH-TABLE :TEST EQUAL :COUNT 19 {1008BF3043}>
#<QURI.URI.HTTP:URI-HTTPS https://lispcookbook.github.io/cl-cookbook/>
#<CL+SSL::SSL-STREAM for #<FD-STREAM for "socket 192.168.0.23:34897, peer: 151.101.120.133:443" {100781C133}>>

(defvar *parsed-content* (plump:parse *request*))
;; => *PARSED-CONTENT**
*parsed-content**
;; => #<PLUMP-DOM:ROOT {1009EE5FE3}>

(lquery:$  *parsed-content* "#content li")
;; => #(#<PLUMP-DOM:ELEMENT li {100B3263A3}> #<PLUMP-DOM:ELEMENT li {100B3263E3}>
;;  #<PLUMP-DOM:ELEMENT li {100B326423}> #<PLUMP-DOM:ELEMENT li {100B326463}>
;;  #<PLUMP-DOM:ELEMENT li {100B3264A3}> #<PLUMP-DOM:ELEMENT li {100B3264E3}>
;;  #<PLUMP-DOM:ELEMENT li {100B326523}> #<PLUMP-DOM:ELEMENT li {100B326563}>
;;  #<PLUMP-DOM:ELEMENT li {100B3265A3}> #<PLUMP-DOM:ELEMENT li {100B3265E3}>
;;  #<PLUMP-DOM:ELEMENT li {100B326623}> #<PLUMP-DOM:ELEMENT li {100B326663}>
;;  […]

(lquery:$  *parsed-content* "#content" (text))
#("License" "Editor support" "Strings" "Dates and Times" "Hash Tables"
  "Pattern Matching / Regular Expressions" "Functions" "Loop" "Input/Output"
  "Files and Directories" "Packages" "Macros and Backquote"
  "CLOS (the Common Lisp Object System)" "Sockets" "Interfacing with your OS"
  "Foreign Function Interfaces" "Threads" "Defining Systems"
  "Using the Win32 API" "Testing" "Miscellaneous" "License" "Marco Antoniotti"
  "Zach Beane" "Pierpaolo Bernardi" "Christopher Brown" "Frederic Brunel"
  "Jeff Caldwell" "Bill Clementson" "Martin Cracauer" "Gerald Doussot"
  "Paul Foley" "Jörg-Cyril
  […]
  "Edi Weitz" "Fernando Borretti" "lisp-lang.org" "The Awesome-cl list"
  "The Common Lisp HyperSpec by Kent M. Pitman" "The Common Lisp UltraSpec"
  "Practical Common Lisp by Peter Seibel"
  "Common Lisp Recipes by Edmund Weitz, published in 2016,"
  […]
  "A Tutorial on Good Lisp Style by Peter Norvig and Kent Pitman"
  "Lisp and Elements of Style by Nick Levine"
  "Pascal Costanza’s Highly Opinionated Guide to Lisp"
  "Loving Lisp - the Savy Programmer’s Secret Weapon by Mark Watson"
  "FranzInc, a company selling Common Lisp and Graph Database solutions.")

(lquery:$  *parsed-content* "#content li a" (attr :href))
;; => #("license.html" "editor-support.html" "strings.html" "dates_and_times.html"
;;  "hashes.html" "pattern_matching.html" "functions.html" "loop.html" "io.html"
;;  "files.html" "packages.html" "macros.html"
;;  "/cl-cookbook/clos-tutorial/index.html" "sockets.html" "os.html" "ffi.html"
;;  "process.html" "systems.html" "win32.html" "testing.html" "misc.html"
;;  "license.html" "mailto:xach@xach.com" "mailto:skeptomai@mac.com"
;;  "mailto:brunel@mail.dotcom.fr" "mailto:jdcal@yahoo.com"
;;  "mailto:bill_clementson@yahoo.com" "mailto:gdoussot@yahoo.com"
;;  […]
;;  "mailto:matthieu@matthieu-villeneuve.net" "mailto:edi@agharta.de"
;;  "http://lisp-lang.org/" "https://github.com/CodyReichert/awesome-cl"
;;  "http://www.lispworks.com/documentation/HyperSpec/Front/index.htm"
;;  "http://phoe.tymoon.eu/clus/doku.php" "http://www.gigamonkeys.com/book/"
;;  […]
;;  "http://www.nicklevine.org/declarative/lectures/"
;;  "http://www.p-cos.net/lisp/guide.html" "https://leanpub.com/lovinglisp/"
;;  "https://franz.com/")

(defvar *urls* (lquery:$  *parsed-content* "#content li a" (attr :href)))

(remove-if (lambda (it) (string= it "mailto:" :start1 0 :end1 (length "mailto:"))) *urls*)
;; => #("license.html" "editor-support.html" "strings.html" "dates_and_times.html"
;;  […]
;;  "process.html" "systems.html" "win32.html" "testing.html" "misc.html"
;;  "license.html" "http://lisp-lang.org/"
;;  "https://github.com/CodyReichert/awesome-cl"
;;  "http://www.lispworks.com/documentation/HyperSpec/Front/index.htm"
;;  […]
;;  "https://franz.com/")

(map 'vector (lambda (it) (str:starts-with-p "mailto:" it)) *urls*)

(remove-if-not (lambda (it) (string= it "http" :start1 0 :end1 (length "http"))) *) ;; note the remove-if-NOT

(defvar *filtered-urls* *)

(setf (aref *filtered-urls* 0) "http://lisp.org")  ;; too bad indeed

(map 'vector (lambda (it)
  (ignore-errors
    (nth-value 1 (dex:get it))))
  *filtered-urls*)

#(NIL 200 200 200 200 200 200 200 200 200 200 NIL 200 200 200 200 200 200 200
  200 200 200 200)

 (handler-case ( <code> )
   (error (c)
     ( <return sthg> )))

Evaluation took:
  21.554 seconds of real time
  0.188000 seconds of total run time (0.172000 user, 0.016000 system)
  0.87% CPU
  55,912,081,589 processor cycles
  9,279,664 bytes consed

(time (lparallel:pmap 'vector
  (lambda (it)
    (ignore-errors (let ((status (nth-value 1 (dex:get it)))) status)))
  *filtered-urls*)
;;  Evaluation took:
;;  11.584 seconds of real time
;;  0.156000 seconds of total run time (0.136000 user, 0.020000 system)
;;  1.35% CPU
;;  30,050,475,879 processor cycles
;;  7,241,616 bytes consed
;;
;;#(NIL 200 200 200 200 200 200 200 200 200 200 NIL 200 200 200 200 200 200 200
;;  200 200 200 200)

... (if (and status (= 200 status)) it) ...
(defvar *valid-urls* *)

(set-difference (coerce *filtered-urls* 'list)
                (coerce *valid-urls* 'list))
;; => ("http://lisp-lang.org/" "http://www.psg.com/~dlamkins/sl/cover.html")

(ql:quickload :osicat)

(describe (osicat-posix:stat #P"/tmp/file"))

#<OSICAT-POSIX:STAT {1004F20C93}>
  [standard-object]

Slots with :INSTANCE allocation:
  DEV      = 2065
  INO      = 7349974
  MODE     = 33204
  NLINK    = 1
  UID      = 1000
  GID      = 1000
  RDEV     = 0
  SIZE     = 4304
  BLKSIZE  = 4096
  BLOCKS   = 16
  ATIME    = 1497626097
  MTIME    = 1497347216
  CTIME    = 1497347216
; No value

osicat-posix:stat-dev
osicat-posix:stat-gid
osicat-posix:stat-ino
osicat-posix:stat-uid
osicat-posix:stat-mode
osicat-posix:stat-rdev
osicat-posix:stat-size
osicat-posix:stat-atime
osicat-posix:stat-ctime
osicat-posix:stat-mtime
osicat-posix:stat-nlink
osicat-posix:stat-blocks
osicat-posix:stat-blksize

(let ((stat (osicat-posix:stat #P"./files.md")))
  (osicat-posix:stat-size stat))  ;; => 10629

@route app "/hello"
(defview index (name)
  (with-params (search)
    (render-template (+index+)
                     :search search)))

@route app (:post "/tweet")
(defview tweet ()
  (if (lucerne-auth:logged-in-p)
      (let ((user (current-user)))
        (with-params (tweet)
          (utweet.models:tweet user tweet))
        (redirect "/"))
      (render-template (+index+)
                       :error "You are not logged in.")))

;; https://github.com/eudoxia0/lucerne/blob/master/src/http.lisp
(defmacro with-params (params &body body)
  "Extract the parameters in @cl:param(param) from the @c(*request*), and bind
them for use in @cl:param(body)."
  `(let ,(loop for param in params collecting
               `(,param (let ((str (parameter *request*
                                              ,(intern (string-downcase
                                                        (symbol-name param))
                                                       :keyword))))
                          (if (equal str "")
                              nil
                              str))))
     ,@body))

(assoc "a-param" (clack.request:query-parameter lucerne:*request*) :test 'string=)

(defun query-param (param)
  (cdr (assoc param (clack.request:query-parameter lucerne:*request*) :test #'string=)))

((@ document write)
  (ps-html ((:a :href "foobar") "blorg")))

document.write("<A HREF=\"foobar\">blorg</A>")

apt-get install sbcl

(print "hello lisp!")
(quit) ;; or C-d

apt-get install rlwrap

rwrap sbcl

M-x package-install RET slime RET

 wget https://beta.quicklisp.org/quicklisp.lisp

sbcl --load quicklisp.lisp

(quicklisp-quickstart:install)

==================================================
2,846 bytes in 0.001 seconds (2779.30KB/sec)
Upgrading ASDF package from version 2.004 to version 2.009
; Fetching #<URL "http://beta.quicklisp.org/dist/quicklisp.txt">
; 0.40KB
==================================================
408 bytes in 0.003 seconds (132.81KB/sec)

  ==== quicklisp installed ====

    To load a system, use: (ql:quickload "system-name")

    To find systems, use: (ql:system-apropos "term")

    To load Quicklisp every time you start Lisp, use: (ql:add-to-init-file)

    For more information, see http://www.quicklisp.org/beta/

NIL

(ql:quickload "dexador")

;;; The following lines added by ql:add-to-init-file:
  #-quicklisp
  (let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
                                         (user-homedir-pathname))))
    (when (probe-file quicklisp-init)
      (load quicklisp-init)))

ros install sbcl/1.2.14
ros install sbcl  # the latest
ros install ccl-bin

ros list versions

ros use sbcl/1.2.14

ros install qlot

ros install dexador  # http client

(concatenate 'string "fo" "o")

(ql:quickload "str")

(in-package #:asdf-user)

(defsystem :str
  :source-control (:git "git@github.com:vindarel/cl-s.git")
  :description "Modern, consistent and terse Common Lisp string manipulation library."
  :depends-on (:prove :cl-ppcre)  ;; <= depends only on cl-ppcre.
  :components ((:file "str"))
  )

(defvar *whitespaces* '(#\Space #\Newline #\Backspace #\Tab
                        #\Linefeed #\Page #\Return #\Rubout))

(defun trim-left (s)
  "Remove whitespaces at the beginning of s. "
  (string-left-trim *whitespaces* s))

(defun trim-right (s)
  "Remove whitespaces at the end of s."
  (string-right-trim *whitespaces* s))

(defun trim (s)
  (string-trim *whitespaces* s))

(defun concat (&rest strings)
  "Join all the string arguments into one string."
  (apply #'concatenate 'string strings))

(defun join (separator strings)
  (let ((separator (replace-all "~" "~~" separator)))
    (format nil
            (concatenate 'string "~{~a~^" separator "~}")
            strings)))

(is "foo~bar"
    (join "~" '("foo" "bar")))

(defun split (separator s &key omit-nulls)
  "Split s into substring by separator (cl-ppcre takes a regex, we do not)."
  ;; cl-ppcre:split doesn't return a null string if the separator appears at the end of s.
  (let* ((val (concat s
                      (string separator)
                      ;; so we need an extra character, but not the user's.
                      (if (string-equal separator #\x) "y" "x")))
         (res (butlast (cl-ppcre:split (cl-ppcre:quote-meta-chars (string separator)) val))))
    (if omit-nulls
        (remove-if (lambda (it) (empty? it)) res)
        res)))

(defun repeat (count s)
  "Make a string of S repeated COUNT times."
  (let ((result nil))
    (dotimes (i count)
      (setf result (cons s result)))
    (apply #'concat result)))

(defun replace-all (old new s)
  "Replace `old` by `new` in `s`. Arguments are not regexs."
  (let* ((cl-ppcre:*allow-quoting* t)
         (old (concatenate 'string  "\\Q" old))) ;; treat metacharacters as normal.
    (cl-ppcre:regex-replace-all old s new)))

(defun starts-with? (start s &key (ignore-case nil))
  "Return t if s starts with the substring 'start', nil otherwise."
  (when (>= (length s) (length start))
    (let ((fn (if ignore-case #'string-equal #'string=)))
      (funcall fn s start :start1 0 :end1 (length start)))))

;; An alias:
;; Serapeum defines a "defalias".
(setf (fdefinition 'starts-with-p) #'starts-with?)

(defun ends-with? (end s &key (ignore-case nil))
  "Return t if s ends with the substring 'end', nil otherwise."
  (when (>= (length s) (length end))
    (let ((fn (if ignore-case #'string-equal #'string=)))
      (funcall fn s end :start1 (- (length s) (length end))))))

(setf (fdefinition 'ends-with-p) #'ends-with?)

(subtest "starts-with?"
  (ok (starts-with? "foo" "foobar") "default case")
  (ok (starts-with? "" "foo") "with blank start")
  (ok (not (starts-with? "rs" "")) "with blank s")
  (ok (not (starts-with? "foobar" "foo")) "with shorter s")
  (ok (starts-with? "" "") "with everything blank")
  (ok (not (starts-with? "FOO" "foobar")) "don't ignore case")
  (ok (starts-with-p "f" "foo") "starts-with-p alias")
  (ok (starts-with? "FOO" "foobar" :ignore-case t) "ignore case"))

(defun empty? (s)
  "Is s nil or the empty string ?"
  (or (null s) (string-equal "" s)))

(defun emptyp (s)
  "Is s nil or the empty string ?"
  (empty? s))

(defun blank? (s)
  "Is s nil or only contains whitespaces ?"
  (or (null s) (string-equal "" (trim s))))

(defun blankp (s)
  "Is s nil or only contains whitespaces ?"
  (blank? s))

(defun words (s &key (limit 0))
  "Return list of words, which were delimited by white space. If the optional limit is 0 (the default), trailing empty strings are removed from the result list (see cl-ppcre)."
  (if (not s)
      nil
      (cl-ppcre:split "\\s+" (trim-left s) :limit limit)))

(defun unwords (strings)
  "Join the list of strings with a whitespace."
  (join " " strings))

(defun lines (s &key omit-nulls)
  "Split the string by newline characters and return a list of lines."
  (split #\NewLine s :omit-nulls omit-nulls))

(defun unlines (strings)
  "Join the list of strings with a newline character."
  (join (make-string 1 :initial-element #\Newline) strings))

"foo"[:-1] # negative index and starting from the end
"foo"[0:100] # end is too large, thus it returns the entire array.

(defun substring (start end s)
  "Return the substring of `s' from `start' to `end'.

It uses `subseq' with differences:
- argument order, s at the end
- `start' and `end' can be lower than 0 or bigger than the length of s.

- for convenience `end' can be nil or t to denote the end of the string.
"
  (let* ((s-length (length s))
         (end (cond
                ((null end) s-length)
                ((eq end t) s-length)
                (t end))))
    (setf start (max 0 start))
    (if (> start s-length)
        ""
        (progn
          (setf end (min end s-length))
          (when (< end (- s-length))
            (setf end 0))
          (when (< end 0)
            (setf end (+ s-length end)))
          (if (< end start)
              ""
              (subseq s start end))))))

(subtest "substring"
  (is "abcd" (substring 0 4 "abcd") "normal case")
  (is "ab" (substring 0 2 "abcd") "normal case substing")
  (is "bc" (substring 1 3 "abcd") "normal case substing middle")
  (is "" (substring 4 4 "abcd") "normal case")
  (is "" (substring 0 0 "abcd") "normal case")
  (is "d" (substring 3 4 "abcd") "normal case")
  (is "abcd" (substring 0 t "abcd") "end is t")
  (is "abcd" (substring 0 nil "abcd") "end is nil")
  (is "abcd" (substring 0 100 "abcd") "end is too large")
  (is "abc" (substring 0 -1 "abcd") "end is negative")
  (is "b" (substring 1 -2 "abcd") "end is negative")
  (is "" (substring 2 1 "abcd") "start is bigger than end")
  (is "" (substring 0 -100 "abcd") "end is too low")
  (is "" (substring 100 1 "abcd") "start is too big")
  (is "abcd" (substring -100 4 "abcd") "start is too low")
  (is "abcd" (substring -100 100 "abcd") "start and end are too low and big")
  (is "" (substring 100 -100 "abcd") "start and end are too big and low")
  )

CL-USER 29 > (let ((f (lambda (a b)
                         (+ (prog1 2 (break))  ; we have a break here
                            (* a b)))))
              (funcall f 2 3))

Break.
  1 (continue) Return from break.
  2 (abort) Return to level 0.
  3 Return to top loop level 0.

Type :b for backtrace or :c <option number> to proceed.
Type :bug-form "<subject>" for a bug report template or :? for other options.

CL-USER 30 : 1 > :lambda
(LAMBDA (A B) (+ (PROG1 2 (BREAK)) (* A B)))

CL-USER 31 : 1 > (setf (first (third *)) 'expt)
EXPT

CL-USER 32 : 1 > :res

Break.
  1 (continue) Return from break.
  2 (abort) Return to level 0.
  3 Return to top loop level 0.

Type :b for backtrace or :c <option number> to proceed.
Type :bug-form "<subject>" for a bug report template or :? for other options.

CL-USER 33 : 1 > :c 1
64                                   ; we computed 2^(2*3)  instead of 2+(2*3)

CL-USER 1 > (defvar *hooklevel* 0)
*HOOKLEVEL*

CL-USER 2 > (defun hook (x)
              (let ((*evalhook* 'eval-hook-function))
                (eval x)))
HOOK

CL-USER 3 > (compile 'hook)
HOOK
NIL
NIL

CL-USER 4 > (defun eval-hook-function (form &rest env)
              (let ((*hooklevel* (+ *hooklevel* 1)))
                (format *trace-output* "~%~V@TForm:  ~S"
                        (* *hooklevel* 2) form)
                (let ((values (multiple-value-list
                               (evalhook form
                                         #'eval-hook-function
                                         nil
                                         env))))
                  (format *trace-output* "~%~V@TValue:~{ ~S~}"
                          (* *hooklevel* 2) values)
                  (values-list values))))
EVAL-HOOK-FUNCTION

CL-USER 5 > (compile 'eval-hook-function)
EVAL-HOOK-FUNCTION
NIL
NIL

CL-USER 6 > (hook '(cons (floor *print-base* 2) 'b))

  Form:  (CONS (FLOOR *PRINT-BASE* 2) (QUOTE B))
    Form:  (FLOOR *PRINT-BASE* 2)
      Form:  *PRINT-BASE*
      Value: 10
      Form:  2
      Value: 2
    Value: 5 0
    Form:  (QUOTE B)
    Value: B
  Value: (5 . B)
(5 . B)

(ns football.data
  (:require [reagent.core :as reagent]))

(defonce games (reagent/atom nil))

(defn generate-fake-player []
  {:name               (-> js/faker .-name (.findName))
   :effort-level       (rand-int 10)
   :invited-next-week? (> (rand) 0.5)})

(defn generate-fake-game []
  {:id                 (-> js/faker .-random (.uuid))
   :clock              0
   :score              {:home 0 :away 0}
   :teams              {:home (-> js/faker .-address (.city))
                        :away (-> js/faker .-address (.city))}
   :outrageous-tackles 0
   :cards              {:yellow 0 :read 0}
   :players            (mapv generate-fake-player (range 4))})

(defn generate-games [game-count]
  (reset! games (mapv generate-fake-game (range game-count))))

(defn maybe-update [game prob path f]
  (if (< (rand-int 100) prob)
    (update-in game path f)
    game))

(defn update-rand-player [game idx]
  (-> game
      (assoc-in [:players idx :effort-level] (rand-int 10))
      (assoc-in [:players idx :invited-next-week?] (> (rand) 0.5))))

(defn update-game [game]
  (-> game
      (update :clock inc)
      (maybe-update 5 [:score :home] inc)
      (maybe-update 5 [:score :away] inc)
      (maybe-update 8 [:cards :yellow] inc)
      (maybe-update 2 [:cards :red] inc)
      (maybe-update 10 [:outrageous-tackles] inc)
      (update-rand-player (rand-int 4))))

(defn update-game-at-interval [interval idx]
  (swap! games update idx update-game)
  (js/setTimeout update-game-at-interval interval interval idx))

(def event-interval 1000)

(defn update-games [game-count]
  (dotimes [i game-count]
    (swap! games update i update-game)
    (js/setTimeout #(update-game-at-interval event-interval i)
                   (* i event-interval))))

(ns football.core
  (:require
    [football.data :as data]
    [reagent.core :as reagent]))

(defn player-component [{:keys [name invited-next-week? effort-level]}]
  [:td
   [:div.player
    [:p.player__name
     [:span name]
     [:span.u-small (if invited-next-week? "Doing well" "Not coming again")]]
    [:div {:class-name (str "player__effort "
                            (if (< effort-level 5)
                              "player__effort--low"
                              "player__effort--high"))}]]])

(defn game-component [game]
  [:tr
   [:td.u-center (:clock game)]
   [:td.u-center (-> game :score :home) "-" (-> game :score :away)]
   [:td.cell--teams (-> game :teams :home) "-" (-> game :teams :away)]
   [:td.u-center (:outrageous-tackles game)]
   [:td
    [:div.cards
     [:div.cards__card.cards__card--yellow (-> game :cards :yellow)]
     [:div.cards__card.cards__card--red (-> game :cards :red)]]]
   (for [player (:players game)]
     ^{:key player}
     [player-component player])])

(defn games-component []
  [:tbody
   (for [game @data/games]
     ^{:key game}
     [game-component game])])

(defn games-table-component []
  [:table
   [:thead
    [:tr
     [:th {:width "50px"} "Clock"]
     [:th {:width "50px"} "Score"]
     [:th {:width "200px"} "Teams"]
     [:th "Outrageous Tackles"]
     [:th {:width "100px"} "Cards"]
     [:th {:width "100px"} "Players"]
     [:th {:width "100px"} ""]
     [:th {:width "100px"} ""]
     [:th {:width "100px"} ""]
     [:th {:width "100px"} ""]]]
   [games-component]])

(defn home-page []
  [games-table-component])

(defn mount-root []
  (reagent/render [home-page] (.getElementById js/document "app")))

(def game-count 50)

(defn init! []
  (data/generate-games game-count)
  (data/update-games game-count)
  (mount-root))

(defn player-component [player]
  [:td
   [:div.player
    [:p.player__name
     [:span (:name @player)]
     [:span.u-small
      (if (:invited-next-week? @player)
        "Doing well" "Not coming again")]]
    [:div {:class-name (str "player__effort "
                            (if (< (:effort-level @player) 5)
                              "player__effort--low"
                              "player__effort--high"))}]]])

(defn game-component [game]
  [:tr
   [:td.u-center (:clock @game)]
   [:td.u-center (-> @game :score :home) "-" (-> @game :score :away)]
   [:td.cell--teams (-> @game :teams :home) "-" (-> @game :teams :away)]
   [:td.u-center (:outrageous-tackles @game)]
   [:td
    [:div.cards
     [:div.cards__card.cards__card--yellow (-> @game :cards :yellow)]
     [:div.cards__card.cards__card--red (-> @game :cards :red)]]]
   (for [idx (range (count (:players @game)))]
     ^{:key idx}
     [player-component (reagent/cursor game [:players idx])])])

(def game-count 50)

(defn games-component []
  [:tbody
   (for [idx (range game-count)]
     ^{:key idx}
     [game-component (reagent/cursor data/games [idx])])])

(defn games-table-component []
  [:table
   [:thead
    [:tr
     [:th {:width "50px"} "Clock"]
     [:th {:width "50px"} "Score"]
     [:th {:width "200px"} "Teams"]
     [:th "Outrageous Tackles"]
     [:th {:width "100px"} "Cards"]
     [:th {:width "100px"} "Players"]
     [:th {:width "100px"} ""]
     [:th {:width "100px"} ""]
     [:th {:width "100px"} ""]
     [:th {:width "100px"} ""]]]
   [games-component]])

(defn home-page []
  [games-table-component])

function updateGame(game) {
    game = game.update("clock", (sec) => sec + 1);

    game = maybeUpdate(5, game, () => game.updateIn(["score", "home"], (s) => s + 1));
    game = maybeUpdate(5, game, () => game.updateIn(["score", "away"], (s) => s + 1));

    game = maybeUpdate(8, game, () => game.updateIn(["cards", "yellow"], (s) => s + 1));
    game = maybeUpdate(2, game, () => game.updateIn(["cards", "red"], (s) => s + 1));

    game = maybeUpdate(10, game, () => game.update("outrageousTackles", (t) => t + 1));

    const randomPlayerIndex = randomNum(0, 4);
    const effortLevel = randomNum();
    const invitedNextWeek = faker.random.boolean();

    game = game.updateIn(["players", randomPlayerIndex], (player) => {
        return player.set("effortLevel", effortLevel).set("invitedNextWeek", invitedNextWeek);
    });

    return game;
}

(defn update-rand-player [game idx]
  (-> game
      (assoc-in [:players idx :effort-level] (rand-int 10))
      (assoc-in [:players idx :invited-next-week?] (> (rand) 0.5))))

(defn update-game [game]
  (-> game
      (update :clock inc)
      (maybe-update 5 [:score :home] inc)
      (maybe-update 5 [:score :away] inc)
      (maybe-update 8 [:cards :yellow] inc)
      (maybe-update 2 [:cards :red] inc)
      (maybe-update 10 [:outrageous-tackles] inc)
      (update-rand-player (rand-int 4))))

@route app (:post "/tweet")
(defview tweet ()
  (if (lucerne-auth:logged-in-p)
      (let ((user (current-user)))
        (with-params (tweet)
          (utweet.models:tweet user tweet))
        (redirect "/"))
      (render-template (+index+)
                       :error "You are not logged in.")))

(defroute lispdoc (:get :text/* name &key (package :cl) (doctype 'function))
   ...

(setf (ningle:route *app* "/hello/:name")
      #'(lambda (params)
          (format nil "Hello, ~A" (cdr (assoc "name" params :test #'string=)))))

(assoc "the-query-param" (clack.request:query-parameter lucerne:*request*) :test 'string=)

(defroute "/edit" (&key _parsed)
  (format nil "~S" (cdr (assoc "person" _parsed :test #'string=))))
;=> "((\"name\" . \"Eitaro\") (\"email\" . \"e.arrows@gmail.com\") (\"birth\" . ((\"year\" . 2000) (\"month\" . 1) (\"day\" . 1))))"

(defclass user ()
  ((name :col-type (:varchar 64)
         :initarg :name
         :accessor user-name)
   (email :col-type (:varchar 128)
          :initarg :email
          :accessor user-email))
  (:metaclass mito:dao-table-class)
  (:unique-keys email))

(ensure-table-exists 'user)
;-> ;; CREATE TABLE IF NOT EXISTS "user" (
;       "id" BIGSERIAL NOT NULL PRIMARY KEY,
;       "name" VARCHAR(64) NOT NULL,
;       "email" VARCHAR(128),
;       "created_at" TIMESTAMP,
;       "updated_at" TIMESTAMP
;   ) () [0 rows] | MITO.DAO:ENSURE-TABLE-EXISTS

(mito:migration-expressions 'user)
;=> (#<SXQL-STATEMENT: ALTER TABLE user ALTER COLUMN email TYPE character varying(128), ALTER COLUMN email SET NOT NULL>
;    #<SXQL-STATEMENT: CREATE UNIQUE INDEX unique_user_email ON user (email)>)

(mito:migrate-table 'user)
;-> ;; ALTER TABLE "user" ALTER COLUMN "email" TYPE character varying(128), ALTER COLUMN "email" SET NOT NULL () [0 rows] | MITO.MIGRATION.TABLE:MIGRATE-TABLE
;   ;; CREATE UNIQUE INDEX "unique_user_email" ON "user" ("email") () [0 rows] | MITO.MIGRATION.TABLE:MIGRATE-TABLE
;-> (#<SXQL-STATEMENT: ALTER TABLE user ALTER COLUMN email TYPE character varying(128), ALTER COLUMN email SET NOT NULL>
;    #<SXQL-STATEMENT: CREATE UNIQUE INDEX unique_user_email ON user (email)>)

<body>
      <% if posts %>
        <h1>Recent Posts</h1>
        <ul id="post-list">
          <% loop for (title . snippet) in posts %>
            <li><%= title %> - <%= snippet %></li>
          <% end %>
        </ul>
        ...

(defwidget task ()
        ((title
          :initarg :title
          :accessor title)
         (done
          :initarg :done
          :initform nil
          :accessor done)))

(defwidget task-list ()
        ((tasks
          :initarg :tasks
          :accessor tasks)))

(defmethod render ((task task))
        "Render a task."
        (with-html
              (:span (if (done task)
                         (with-html
                               (:s (title task)))
                       (title task)))))

(defmethod render ((widget task-list))
        "Render a list of tasks."
        (with-html
              (:h1 "Tasks")
              (:ul
                (loop for task in (tasks widget) do
                      (:li (render task))))))

(defmethod weblocks/session:init ((app tasks))
         (declare (ignorable app))
         (let ((tasks (make-task-list "Make my first Weblocks app"
                                      "Deploy it somewhere"
                                      "Have a profit")))
           (make-instance 'task-list :tasks tasks)))

(defmethod add-task ((task-list task-list) title)
        (push (make-task title)
              (tasks task-list))
        (update task-list))

(defmethod render ((task-list task-list))
        (with-html
          (:h1 "Tasks")
          (loop for task in (tasks task-list) do
            (render task))
          (with-html-form (:POST (lambda (&key title &allow-other-keys)
                                         (add-task task-list title)))
            (:input :type "text"
                    :name "title"
                    :placeholder "Task's title")
            (:input :type "submit"
                    :value "Add"))))

(sb-ext:save-lisp-and-die #p"name-of-executable" :toplevel #'main :executable t)

(defun main ()
    ;; with bordeaux-threads. Also sb-ext: join-thread, thread-name, list-all-threads.
    (bt:join-thread (find-if (lambda (th)
                                (search "hunchentoot" (bt:thread-name th)))
                              (bt:all-threads))))

$ ./my-webapp
Hunchentoot server is started.
Listening on localhost:9003.

(defun main ()
  (start-app :port 9003)
  ;; with bordeaux-threads
  (handler-case (bt:join-thread (find-if (lambda (th)
                                             (search "hunchentoot" (bt:thread-name th)))
                                         (bt:all-threads)))
    (#+sbcl sb-sys:interactive-interrupt
      #+ccl  ccl:interrupt-signal-condition
      #+clisp system::simple-interrupt-condition
      #+ecl ext:interactive-interrupt
      #+allegro excl:interrupt-signal
      () (progn
           (format *error-output* "Aborting.~&")
           (clack:stop *server*)
           (uiop:quit 1)) ;; portable exit, included in ASDF, already loaded.
    ;; for others, unhandled errors (we might want to do the same).
    (error (c) (format t "Woops, an unknown error occured:~&~a~&" c)))))

;; Load Ceramic and our app
(ql:quickload '(:ceramic :our-app))

;; Ensure Ceramic is set up
(ceramic:setup)
(ceramic:interactive)

;; Start our app (here based on the Lucerne framework)
(lucerne:start our-app.views:app :port 8000)

;; Open a browser window to it
(defvar window (ceramic:make-window :url "http://localhost:8000/"))

;; start Ceramic
(ceramic:show-window window)

(ceramic.bundler:bundle :ceramic-hello-world
                                 :bundle-pathname #p"/home/me/app.tar")
Copying resources...
Compiling app...
Compressing...
Done!
#P"/home/me/app.tar"

sbcl --load <my-app> --eval (start-my-app)

run:
	sbcl --load my-app.asd \
	     --eval '(ql:quickload :my-app)' \
	     --eval '(my-app:start-app)'  ;; given this function starts clack or hunchentoot.

$ clackup app.lisp
Hunchentoot server is started.
Listening on localhost:5000.

$ /etc/systemd/system/my-app.service
[Unit]
Description=stupid simple example

[Service]
WorkingDirectory=/path/to/your/app
ExecStart=sbcl --load run.lisp  # your command
Type=simple
Restart=always
RestartSec=10

sudo systemctl start my-app.service

systemctl status my-app.service

journalctl -f -u my-app.service

Restart=always

[Install]
WantedBy=basic.target

sudo systemctl enable my-app.service

mmap: wanted 1040384 bytes at 0x20000000, actually mapped at 0x715fa2145000
ensure_space: failed to allocate 1040384 bytes at 0x20000000
(hint: Try "ulimit -a"; maybe you should increase memory limits.)

sudo bash -c "echo 0 > /proc/sys/kernel/randomize_va_space"

;; a little common lisp swank demo
;; while this program is running, you can connect to it from another terminal or machine
;; and change the definition of doprint to print something else out!
;; (ql:quickload '(:swank :bordeaux-threads))

(require :swank)
(require :bordeaux-threads)

(defparameter *counter* 0)

(defun dostuff ()
  (format t "hello world ~a!~%" *counter*))

(defun runner ()
  (bt:make-thread (lambda ()
                    (swank:create-server :port 4006)))
  (format t "we are past go!~%")
  (loop while t do
       (sleep 5)
       (dostuff)
       (incf *counter*)))

(runner)

sbcl --load demo.lisp

ssh -L4006:127.0.0.1:4006 username@example.com

(defun dostuff ()
  (format t "goodbye world ~a!~%" *counter*))
(setf *counter* 0)

hot_deploy:
	$(call $(LISP), \
		(ql:quickload :quickutil-server) (ql:quickload :swank-client), \
		(swank-client:with-slime-connection (conn "localhost" $(SWANK_PORT)) \
			(swank-client:slime-eval (quote (handler-bind ((error (function continue))) \
				(ql:quickload :quickutil-utilities) (ql:quickload :quickutil-server) \
				(funcall (symbol-function (intern "STOP" :quickutil-server))) \
				(funcall (symbol-function (intern "START" :quickutil-server)) $(start_args)))) conn)) \
		$($(LISP)-quit))

lein build

$ node --inspect target/out/guestbook.js

Debugger listening on port 9229.
Warning: This is an experimental feature and could change at any time.
To start debugging, open the following URL in Chrome:
    chrome-devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=127.0.0.1:9229/0dbaef2a-996f-4229-8a52-6c4e50d0bf18
INFO [guestbook.core:19] - guestbook started on 127.0.0.1 : 3000
Figwheel: trying to open cljs reload socket
Figwheel: socket connection established

npm install supervisor -g
supervisor --inspect target/out/guestbook.js

(defn handler [req res raise]
  (res {:body (str (-> req :params :name))}))

(defn parse-params [req]
  ;;parses request parameters into a map
  )

(defn wrap-params [handler]
  (fn [req res raise]
    (handler (parse-params req) res raise)))

(defn keywordize-params [params]
  ;;keywordizes the params
  )

(defn wrap-keyword-params [handler]
  (fn [req res raise]
    (handler (update req :params keywordize-params) res raise)))

(def wrapped-handler (-> handler
                         wrap-keyword-params
                         wrap-params))

(defn
  ^{:macchiato/middleware
    {:id :wrap-params}}    
  wrap-params [handler]
  (fn [req res raise]
    (handler (parse-params req) res raise)))

(defn
 ^{:macchiato/middleware
   {:id :wrap-keyword-params
    :required [:wrap-params]}}
  wrap-keyword-params [handler]
  (fn [req res raise]
    (handler (update req :params keywordize-params) res raise)))

(defn update-middleware-meta [handler handler-middleware middleware-meta]
  (with-meta
    handler
    {:macchiato/middleware
     (conj handler-middleware middleware-meta)}))

(defn loaded? [middleware {:keys [id]}]
  (some #{id} (map :id middleware)))

(defn- middleware-from-handler [handler]
  (->> handler meta :macchiato/middleware (remove nil?) vec))

(defn wrap
  ([handler middleware-fn]
   (wrap handler middleware-fn nil))
  ([handler middleware-fn opts]
   (let [handler-middleware (middleware-from-handler handler)
         middleware-meta    (-> middleware-fn meta :macchiato/middleware)]
     (if (loaded? handler-middleware middleware-meta)
       handler
       (update-middleware-meta
         (if opts
           (middleware-fn handler opts)
           (middleware-fn handler))
         handler-middleware
         middleware-meta)))))

(def wrapped-handler (-> handler
                         (wrap #'wrap-keyword-params)
                         (wrap #'wrap-params)))

(meta wrapped-handler)

{:macchiato/middleware
 [{:id :wrap-params}
  {:id :wrap-keyword-params
   :required [:wrap-params]}]}

(defn validate [handler-middleware
   {:keys [id required] :as middleware-meta}]
  (when (not-empty (difference (set required)
                               (set (map :id handler-middleware))))
    (throw (js/Error. (str id " is missing required middleware: " required))))
  middleware-meta)

(defn validate-handler [handler]
  (let [middleware (middleware-from-handler handler)]
    (loop [[middleware-meta & handler-middleware] middleware]
      (when middleware-meta
        (validate handler-middleware middleware-meta)
        (recur handler-middleware)))
    handler))  

(m/wrap-middleware
  handler
  #'wrap-anti-forgery
  [#'wrap-session {:store (mem/memory-store)}]
  #'wrap-nested-params
  #'wrap-keyword-params
  #'wrap-params)

(defprotocol IHTTPResponseWriter
  (-write-response [data res] "Write data to a http.ServerResponse"))

(defn response [req res opts]
  (fn [{:keys [cookies headers body status]}]
    (cookies/set-cookies cookies req res (:cookies opts))
    (.writeHead res status (clj->js headers))
    (when (-write-response body res)
      (.end res))))

(defn handler [handler-fn & [opts]]
  (let [opts (or opts {})]
    (fn [req res]
      (handler-fn (req->map req res opts) (response req res opts)))))

(defstate env :start (config/env))

(defstate http :start (js/require "http"))

(defn app []
  (mount/start)
  (let [host (or (:host env) "127.0.0.1")
        port (or (some-> env :port js/parseInt) 3000)]
    (-> @http
        (.createServer
          (handler
            router
            {:cookies {:signed? true}
             :session {:store (mem/memory-store)}}))
        (.listen port host #(info "{{name}} started on" host ":" port)))))

(defn start-workers [os cluster]
  (dotimes [_ (-> os .cpus .-length)]
    (.fork cluster))
  (.on cluster "exit"
       (fn [worker code signal]
         (info "worker terminated" (-> worker .-process .-pid)))))

(defn main [& args]
  (let [os      (js/require "os")
        cluster (js/require "cluster")]
    (if (.-isMaster cluster)
      (start-workers os cluster)
      (app))))

lein new macchiato myapp

lein build

node target/out/myapp.js

lein package

lspci | grep Wireless
sudo apt-get install linux-headers-generic build-essential git
git clone https://github.com/lwfinger/rtlwifi_new.git
cd rtlwifi_new
make
sudo make install
sudo modprobe rtl8821ae
reboot
[code]sudo nano /lib/systemd/system-sleep/broken-desktop-fix[/code]
[code]#!/bin/bash

case "$1" in
	post)
		DISPLAY=:0.0 ; export DISPLAY
		STR="$(users)"
		echo ${STR}
		IFS=' ' read -ra NAMES <<< ${STR}

 		for i in "${NAMES[@]}"; do
		    su $i -c 'dbus-send --type=method_call --dest=org.gnome.Shell /org/gnome/Shell org.gnome.Shell.Eval "string:global.reexec_self()"'
		done;;
esac[/code]
[code]sudo chmod 755 /lib/systemd/system-sleep/broken-desktop-fix[/code]
lein new luminus pg-feed-demo +postgres +re-frame

{:profiles/dev
 {:env
  {:database-url
   "jdbc:pgsql://localhost:5432/feeds_dev?user=feeds&password=feeds"}}

lein migratus create events-table

CREATE TABLE events
(id SERIAL PRIMARY KEY,
 event TEXT);
--;;
CREATE FUNCTION notify_trigger() RETURNS trigger AS $$
DECLARE
BEGIN
 -- TG_TABLE_NAME - name of the table that was triggered
 -- TG_OP - name of the trigger operation
 -- NEW - the new value in the row
 IF TG_OP = 'INSERT' or TG_OP = 'UPDATE' THEN
   execute 'NOTIFY '
   || TG_TABLE_NAME
   || ', '''
   || TG_OP
   || ' '
   || NEW
   || '''';
 ELSE
   execute 'NOTIFY '
   || TG_TABLE_NAME
   || ', '''
   || TG_OP
   || '''';
 END IF;
 return new;
END;
$$ LANGUAGE plpgsql;
--;;
CREATE TRIGGER event_trigger
AFTER INSERT or UPDATE or DELETE ON events
FOR EACH ROW EXECUTE PROCEDURE notify_trigger();

DROP FUNCTION notify_trigger() CASCADE;
DROP TABLE events;

lein run migrate

-- :name event! :! :n
-- :doc insert a new event
INSERT INTO events (event) VALUES (:event)

;[org.postgresql/postgresql "9.4.1211"]
[com.impossibl.pgjdbc-ng/pgjdbc-ng "0.6"]

(ns pg-feed-demo.db.core
  (:require
    [cheshire.core :refer [generate-string parse-string]]
    [clojure.java.jdbc :as jdbc]
    [conman.core :as conman]
    [pg-feed-demo.config :refer [env]]
    [mount.core :refer [defstate]])
  (:import
    com.impossibl.postgres.api.jdbc.PGNotificationListener))

(defstate ^:dynamic *db*
  :start (conman/connect! {:jdbc-url (env :database-url)})
  :stop (conman/disconnect! *db*))

(conman/bind-connection *db* "sql/queries.sql")

(defstate notifications-connection
  :start (jdbc/get-connection {:connection-uri (env :database-url)})
  :stop (.close notifications-connection))

(defn add-listener [conn id listener-fn]
  (let [listener (proxy [PGNotificationListener] []
                   (notification [chan-id channel message]
                     (listener-fn chan-id channel message)))]
    (.addNotificationListener conn listener)
    (jdbc/db-do-commands
      {:connection notifications-connection}
      (str "LISTEN " (name id)))
    listener))

(defn remove-listener [conn listener]
  (.removeNotificationListener conn listener))

(require :reload 'pg-feed-demo.db.core)
(in-ns 'pg-feed-demo.db.core)

(mount.core/start
  #'*db*
  #'notifications-connection)

(add-listener
  notifications-connection
  "events"
  (fn [& args]
    (apply println "got message:" args)))

(event! {:event "hello world"})

got message: 32427 messages INSERT (0,"hello world")

(ns pg-feed-demo.routes.home
  (:require [pg-feed-demo.layout :as layout]
            [compojure.core :refer [defroutes GET]]
            [pg-feed-demo.db.core :as db]
            [mount.core :refer [defstate]]
            [immutant.web.async :as async]
            [clojure.tools.logging :as log]))

(defstate channels
  :start (atom #{}))

(defstate ^{:on-reload :noop} event-listener
  :start (db/add-listener
           db/notifications-connection
           :events
           (fn [_ _ message]
             (doseq [channel @channels]
               (async/send! channel message))))
  :stop (db/remove-listener
          db/notifications-connection
          event-listener))

(defn persist-event! [_ event]
  (db/event! {:event event}))

(defn connect! [channel]
  (log/info "channel open")
  (swap! channels conj channel))

(defn disconnect! [channel {:keys [code reason]}]
  (log/info "close code:" code "reason:" reason)
  (swap! channels #(remove #{channel} %)))

(defn home-page []
  (layout/render "home.html"))

(defroutes home-routes
  (GET "/" []
    (home-page))
  (GET "/events" request
    (async/as-channel
      request
      {:on-open    connect!
       :on-close   disconnect!
       :on-message persist-event})))

lein figwheel

(reg-event-db
  :event
  (fn [db [_ event]]
    (update db :events (fnil conj []) event)))

(reg-sub
  :events
  (fn [db _]
    (:events db)))

(ns pg-feed-demo.ws)

(defonce ws-chan (atom nil))

(defn send
  [message]
  (if @ws-chan
    (.send @ws-chan message)
    (throw (js/Error. "Websocket is not available!"))))

(defn connect-ws [url handler]
  (if-let [chan (js/WebSocket. url)]
    (do
      (set! (.-onmessage chan) #(-> % .-data handler))
      (reset! ws-chan chan))
    (throw (js/Error. "Websocket connection failed!"))))

(ns pg-feed-demo.core
  (:require [reagent.core :as r]
            [re-frame.core :as rf]
            [pg-feed-demo.handlers]
            [pg-feed-demo.subscriptions]
            [pg-feed-demo.ws :as ws]))

(defn home-page []
  [:div.container
   [:div.navbar]
   [:div.row>div.col-sm-12>div.card
    [:div.card-header>h4 "Events"]
    [:div.card-block>ul
     (for [event @(rf/subscribe [:events])]
       ^{:key event}
       [:li event])]]
   [:hr]
   [:div.row>div.col-sm-12>span.btn-primary.input-group-addon
    {:on-click #(ws/send (str "user event " (js/Date.)))}
    "generate event"]])

(defn mount-components []
  (r/render [#'home-page] (.getElementById js/document "app")))

(defn init! []
  (rf/dispatch-sync [:initialize-db])
  (ws/connect-ws
    (str "ws://" (.-host js/location) "/events")
    #(rf/dispatch [:event %]))
  (mount-components))

lein new luminus myapp +sqlite
cd myapp 
lein run migrate

lein run
(ns myapp.routes.home
  (:require [myapp.layout :as layout]
            [compojure.core :refer [defroutes GET]]
            [ring.util.http-response :as response]
            [clojure.java.io :as io]
            ;; add a reference to the db namespace
            [myapp.db.core :as db]))

(mount.core/start #'db/*db*)

(db/create-user!
 {:id "foo"
  :first_name "Bob"
  :last_name "Bobberton"
  :email "bob@foo.bar"
  :pass "secret"})

(db/get-user {:id "foo"})

{:id "foo"
 :admin nil
 :is_active nil
 :last_login nil
 :first_name "Bob"
 :last_name "Bobberton"
 :email "bob@foo.bar"
 :pass "secret"}

(defn clojurize [[k v]]
  [(-> k name (.replaceAll "_" "-") keyword) v])

(clojurize [:first_name "Bob"])
=>[:first-name "Bob"]

(defn clojurize-keys [m]
  (->> m (map clojurize) (into {})))

(clojurize-keys (db/get-user {:id "foo"}))

{:id "foo"
 :admin nil
 :is-active nil
 :last-login nil
 :first-name "Bob"
 :last-name "Bobberton"
 :email "bob@foo.bar"
 :pass "secret"}

(defroutes home-routes
  (GET "/" [] (home-page))
  (GET "/user/:id" [id]
       (-> (db/get-user {:id id})
           (clojurize-keys)
           (response/ok)))
  (GET "/about" [] (about-page)))

(defonce document (ref {}))

(defn bmi [weight height]
  (when (and weight height (pos? height))
    (/ weight (* height height))))

(defn bmi-rule [doc]
  (let [weight (get-in doc [:vitals :weight])
        height (get-in doc [:vitals :height])]
    [{:path  [:vitals :bmi]
      :value (bmi weight height)}]))

(def rules
  {[:vitals :weight] bmi-rule
   [:vitals :height] bmi-rule})

(defn run-rules [doc {:keys [path]}]
  (when-let [rule (rules path)]
    (rule doc)))

(defn update-document! [{:keys [path value] :as path-value}]
  (dosync
    (let [current-document (alter document assoc-in path value)
          updated-paths    (run-rules current-document path-value)]
      (doseq [{:keys [path value]} updated-paths]
        (alter document assoc-in path value))
      (into [path-value] updated-paths))))

(defmethod handle-message :document/update [{:keys [?data]}]
  (let [updated-paths (update-document! ?data)]
    (doseq [uid (-> @socket :connected-uids deref :any)]
      ((:send-fn @socket) uid [:document/update updated-paths]))))

(defn update-value [path-value]
  ((:send-fn @socket) [:document/update path-value]))

(defmethod handle-message :document/update [[_ updated-paths]]
  (doseq [{:keys [path value]} updated-paths]
    (dispatch [:set-doc-value path value])))

(reg-event-db
  :set-doc-value
  (fn [db [_ path value]]
    (assoc-in db (into [:document] path) value)))

(reg-event-db
  :save
  (fn [db [_ path value]]
    (ws/update-value {:path path :value value})
    db))

(reg-sub
  :document
  (fn [db [_ path]]
    (let [doc (:document db)]
      (if path (get-in doc path) doc))))

(def Name
  {:first s/Str
   :last  s/Str})

(def demographics
  {[:demographics :mrn]
   s/Str

   [:demographics :name]
   Name

   [:demographics :name :dob]
   #?(:clj java.util.Date
      :cljs js/Date)

   [:demographics :address :province]
   (s/enum "AB" "BC" "MB" "NB" "NL" "NS" "NT" "NU" "ON" "PE" "QC" "SK" "YT")})

(defmulti widget :type)

(defmethod widget :text-input [{:keys [label path]}]
  (r/with-let [value    (r/atom nil)
               focused? (r/atom false)]
    [:div.form-group
     [:label label]
     [:input.form-control
      {:type      :text
       :on-focus  #(do
                    (reset! value @(rf/subscribe [:document path]))
                    (reset! focused? true))
       :on-blur   #(do
                    (rf/dispatch
                      [:save path @value])
                    (reset! focused? false))
       :value     (if @focused? @value @(subscribe-doc path))
       :on-change #(reset! value (-> % .-target .-value))}]]))

[widget {:type :text-input
         :lable "first name"
         :path [:patient :name :first]}]

(defmethod widget :name [{:keys [first-name last-name path]}]
  [:div
   [widget {:label first-name
            :type :text-input
            :path (conj path :first)}]
   [widget {:label last-name
            :type :text-input
            :path (conj path :last)}]])

(def demographics-form
  {[:demographics :mrn]
   {:label "medical record number"
    :type  :text-input}

   [:demographics :name]
   {:first-name "first name"
    :last-name  "last name"
    :type       :name}})

(defn create-widget [view path]
  (let [opts (view path)]
    [widget (assoc opts :path path)]))

(defn form-row [view path]
  [:div.row>div.col-md-12
   (create-widget view path)])

(defn demographics [view]
  [:div
   (form-row demographics-form [:demographics :mrn])
   (form-row demographics-form [:demographics :name])])

(-> "https://gist.githubusercontent.com/yogthos/f432e5ba0bb9d70dc479/raw/768050c7fae45767b277a2ce834f4d4f00158887/names.clj"
    (java.net.URL.)
    (slurp)
    (load-string))

(gen-name 11 6)    

(defn read-image [url]
  (let [conn (.openConnection (java.net.URL. url))]    
    (.getInputStream conn)))

(clojure.java.io/copy
  (read-image "https://http.cat/200")
  (java.io.FileOutputStream. "200.jpg"))

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException:
PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException:
unable to find valid certification path to requested target
...

(defn set-socket-factory [conn]
  (let [cert-manager (make-array X509TrustManager 1)
        sc           (SSLContext/getInstance "SSL")]
    (aset cert-manager 0
          (proxy [X509TrustManager][]
            (getAcceptedIssuers [])
            (checkClientTrusted [_ _])
            (checkServerTrusted [_ _])))
    (.init sc nil cert-manager (java.security.SecureRandom.))
    (.setSSLSocketFactory conn (.getSocketFactory sc))))

(defn read-image [url]
  (let [conn (.openConnection (java.net.URL. url))]
    (set-socket-factory conn)
    (.getInputStream conn)))

(clojure.java.io/copy
  (read-image "https://http.cat/200")
  (java.io.FileOutputStream. "200.jpg"))    

lein new reagent hoplon-app

  :dependencies [[org.clojure/clojure "1.8.0"]
                 [ring-server "0.4.0"]
                 [hoplon "6.0.0-alpha15"]
                 [ring "1.4.0"]
                 [ring/ring-defaults "0.2.0"]
                 [compojure "1.5.0"]
                 [hiccup "1.0.5"]
                 [yogthos/config "0.8"]
                 [org.clojure/clojurescript "1.9.36"
                  :scope "provided"]
                 [secretary "1.2.3"]]

(ns hoplon-app.core
  (:require
    [hoplon.core
     :as h
     :include-macros true]
    [javelin.core
     :refer [cell]
     :refer-macros [cell= dosync]]))

(h/defelem home []
  (h/div
    :id "app"
    (h/h3 "Welcome to Hoplon")))

(defn mount-root []
  (js/jQuery #(.replaceWith (js/jQuery "#app") (home))))

(defn init! []
  (mount-root))    

lein figwheel

(def todo-items (cell ["foo"]))

(h/defelem home []
  (h/div
    :id "app"
    (h/h3 "Welcome to Hoplon")
    (h/p (cell= todo-items))))

(h/defelem add-todo []
  (let [new-item (cell "")]
    (h/div
      (h/input :type "text"
               :value new-item
               :change #(reset! new-item @%))
      (h/button :click #(dosync
                          (swap! todo-items conj @new-item)
                          (reset! new-item ""))
                (h/text "Add #~{(inc (count todo-items))}")))))

(h/defelem home []
  (h/div
    :id "app"
    (h/h3 "Welcome to Hoplon")
    (h/p (cell= todo-items))
    (add-todo)))

(h/defelem todo-list [{:keys [title]}]
  (h/div
      (h/h4 (or title "TODO"))
      (h/ul
        (h/for-tpl [todo todo-items]
          (h/li todo)))))

(h/defelem home []
  (h/div
    :id "app"
    (h/h3 "Welcome to Hoplon")
    (todo-list {:title "TODO List"})
    (add-todo)))

(defn expandable-component []
  [:div
   [:input
    {:type :text}]
   [:table>tbody      
    (for [row (range 5)]
      [:tr
       (for [n (range 5)]
         [:td>button.btn
          {:on-click
           #(do
              (reset! value n)
              (reset! expanded? false))} n])])]])

(defn expandable-component1 []
  (r/with-let
    [expanded? (r/atom false)
     value     (r/atom nil)]
    [:div
     [:input
      {:type :text
       :value @value
       :on-click #(swap! expanded? not)}]
     [:table>tbody
      {:style (if @expanded?
                {:position :absolute}
                {:display "none"})}
      (for [row (range 5)]
        [:tr
         (for [n (range 5)]
           [:td>button.btn.btn-secondary
            {:on-click
             #(do
                (reset! value n)
                (reset! expanded? false))} n])])]]))

(defn expandable-component []
  (r/with-let
    [expanded? (r/atom false)
     value     (r/atom nil)
     mounse-on-table? (r/atom false)]
    [:div
     [:input
      {:type :text
       :value @value
       :on-click #(swap! expanded? not)
       :on-blur #(when-not @mounse-on-table? (reset! expanded? false))}]
     [:table>tbody
      {:style (if @expanded? {:position :absolute} {:display "none"})
       :on-mouse-enter #(reset! mounse-on-table? true)
       :on-mouse-leave #(reset! mounse-on-table? false)}
      (for [row (range 5)]
        [:tr
         (for [n (range 5)]
           [:td>button.btn.btn-secondary
            {:on-click
             #(do
                (reset! value n)
                (reset! expanded? false))} n])])]]))

(def queries (hugsql.core/map-of-db-fns "queries.sql")

(defn get-user [db opts]
  ((-> queries :get-user :fn) db opts))

-- name: create-user!
-- creates a new user record
INSERT INTO users
(id, pass)
VALUES (:id, :pass)

-- name: get-users
-- retrieve all users
SELECT * FROM users

-- name: get-user
-- retrieve a user given the id.
SELECT * FROM users
WHERE id = :id

-- :name create-user! :! :n
-- :doc creates a new user record
INSERT INTO users
(id, pass)
VALUES (:id, :pass)

-- :name get-users :? :*
-- :doc retrieve all users
SELECT * FROM users

-- :name get-user :? :1
-- :doc retrieve a user given the id
SELECT * FROM users
WHERE id = :id

-- :name add-users! :! :n
-- :doc add multiple users
INSERT INTO users
(id, pass)
VALUES :t*:users

(add-users! db {:users
                [["bob" "Bob"]
                 ["alice" "Alice"]]})

-- :name find-users :? :*
-- :doc find users with a matching ID
SELECT *
FROM users
WHERE id IN (:v*:ids)

(find-users db {:ids ["foo" "bar" "baz"]})

Caused by: java.io.FileNotFoundException: Could not locate clojure/tools/reader/impl/ExceptionInfo__init.class or clojure/tools/reader/impl/ExceptionInfo.clj on classpath.

### stdout appender
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%d][%p][%c] %m%n

### rolling file appender
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=./log/app-name.log

log4j.appender.R.MaxFileSize=100KB
log4j.appender.R.MaxBackupIndex=20

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=[%d][%p][%c] %m%n

### root logger sets the minimum logging level
### and aggregates the appenders
log4j.rootLogger=DEBUG, stdout, R

export LOG_CONFIG=prod-log.properties

            pure code
+----------+
| business |
|  logic   |
|          |
+-----+----+
      |
------|---------------------
      |     stateful code
+-----+----+   +-----------+
|  route   |   |           |
| handlers +---+  database |
|          |   |           |
+----------+   +-----------+

lein new reagent reagent-serverside

(ns reagent-serverside.home
  #?(:cljs
     (:require [reagent.core :as reagent :refer [atom]])))

(ns reagent-serverside.home
  #?(:cljs
     (:require [reagent.core :as reagent :refer [atom]])))

(def items (atom nil))

(defn item-list [items]
  [:ul
   (for [item items]
     ^{:key item}
     [:li item])])

(defn add-item-button [items]
  [:button
   {:on-click #(swap! items conj (count @items))}
   "add item"])

(defn home-page []
  [:div [:h2 "Welcome to reagent-serverside"]
   [add-item-button items]
   [item-list @items]])

(ns reagent-serverside.handler
  (:require ...
            [reagent-serverside.home :refer [items home-page]]))

(defn react-id-str [react-id]
  (assert (vector? react-id))
  (str "." (clojure.string/join "." react-id)))

(defn set-react-id [react-id element]
  (update element 1 merge {:data-reactid (react-id-str react-id)}))

(defn normalize [component]
  (if (map? (second component))
    component
    (into [(first component) {}] (rest component))))

(defn render
  ([component] (render [0] component))  
  ([id component]
   (cond
    (fn? component)
    (render (component))    

    (not (coll? component))
    component

    (coll? (first component))
    (map-indexed #(render (conj id %1) %2) component)

    (keyword? (first component))
    (let [[tag opts & body] (normalize component)]
      (->> body
           (map-indexed #(render (conj id %1) %2))
           (into [tag opts])
           (set-react-id id)))

    (fn? (first component))
    (render id (apply (first component) (rest component))))))

(reset! items (range 10))

(def mount-target
  [:div#app (render home-page)])

(ns reagent-serverside.core
    (:require [reagent.core :as reagent :refer [atom]]
              [reagent-serverside.home :refer [items home-page]]))

(defn mount-root []
  (reagent/render [home-page] (.getElementById js/document "app")))

(defn init! []
  (reset! items (range 20))
  (mount-root))

lein new reagent cljs-eval-example +figwheel

lein figwheel

(ns cljs-eval-example.core
  (:require
   ...
   [cljs.js :refer [empty-state eval-str js-eval]]))

(defn evaluate [s cb]
  (eval-str
     (empty-state)
     s
     nil
     {:eval       js-eval    
      :source-map true
      :context    :expr}
     cb))

(defn home-page []
  [:div
   [:button
    {:on-click #(evaluate "(println \"hello world!\")" (fn [_]))}
    "let's compile!"]])

(defn home-page []
  (let [input (atom nil)
        output (atom nil)]
    (fn []
      [:div
       [:textarea
        {:value @input
         :on-change #(reset! input (-> % .-target .-value))}]       
       [:div>button
        {:on-click #(evaluate @input (fn [result] (reset! output result)))}
        "let's compile!"]
       [:p @output]])))

(defn head []
  [:head
   [:meta {:charset "utf-8"}]
   [:meta {:name "viewport"
           :content "width=device-width, initial-scale=1"}]
   (include-css
    (if (env :dev) "/css/site.css" "/css/site.min.css")
    "//cdnjs.cloudflare.com/ajax/libs/codemirror/5.8.0/codemirror.min.css"
    (if (env :dev) "css/site.css" "css/site.min.css"))
   (include-js
    "//cdnjs.cloudflare.com/ajax/libs/codemirror/5.8.0/codemirror.min.js"
    "//cdnjs.cloudflare.com/ajax/libs/codemirror/5.8.0/mode/clojure/clojure.min.js")])

(defn editor [input]
  (reagent/create-class
   {:render (fn [] [:textarea 
                     {:default-value ""
                      :auto-complete "off"}])
    :component-did-mount (editor-did-mount input)}))

(defn editor-did-mount [input]
  (fn [this]
    (let [cm (.fromTextArea  js/CodeMirror
                             (reagent/dom-node this)
                             #js {:mode "clojure"
                                  :lineNumbers true})]
      (.on cm "change" #(reset! input (.getValue %))))))

(defn home-page []
  (let [input (atom nil)
        output (atom nil)]
    (fn []
      [:div
       [editor input]
       [:div
        [:button
         {:on-click #(evaluate @input (fn [{:keys [value]}] (reset! output value)))}
         "run"]]
       [:p @output]])))

(defn head []
  [:head
   [:meta {:charset "utf-8"}]
   [:meta {:name "viewport"
           :content "width=device-width, initial-scale=1"}]
   (include-css
    (if (env :dev) "/css/site.css" "/css/site.min.css")
    "//cdnjs.cloudflare.com/ajax/libs/codemirror/5.8.0/codemirror.min.css"
    "//cdnjs.cloudflare.com/ajax/libs/highlight.js/8.9.1/styles/default.min.css"
    (if (env :dev) "css/site.css" "css/site.min.css"))
   (include-js
    "//cdnjs.cloudflare.com/ajax/libs/highlight.js/8.9.1/highlight.min.js"
    "//cdnjs.cloudflare.com/ajax/libs/codemirror/5.8.0/codemirror.min.js"
    "//cdnjs.cloudflare.com/ajax/libs/codemirror/5.8.0/mode/clojure/clojure.min.js")])

(ns cljs-eval-example.core
  (:require ...
            [cljs.pprint :refer [pprint]]))

...

(defn result-view [output]
  (reagent/create-class
   {:render (fn []
              [:pre>code.clj
               (with-out-str (pprint @output))])
    :component-did-update render-code}))

(defn render-code [this]
  (->> this reagent/dom-node (.highlightBlock js/hljs)))

(defn home-page []
  (let [input (atom nil)
        output (atom nil)]
    (fn []
      [:div
       [editor input]
       [:div
        [:button
         {:on-click #(evaluate @input (fn [{:keys [value]}] (reset! output value)))}
         "run"]]
       [:div
        [result-view output]]])))

(ns cljs-eval-example.core
  (:require
   [reagent.dom :as dom]
   [reagent.core :as reagent :refer [atom]]
   [cljs.js :refer [empty-state eval-str js-eval]]
   [cljs.pprint :refer [pprint]]))

(defn evaluate [s cb]
  (eval-str
     (empty-state)
     s
     nil
     {:eval       js-eval    
      :source-map true
      :context    :expr}
     cb))

(defn editor-did-mount [input]
  (fn [this]
    (let [cm (.fromTextArea  js/CodeMirror
                             (dom/dom-node this)
                             #js {:mode "clojure"
                                  :lineNumbers true})]
      (.on cm "change" #(reset! input (.getValue %))))))

(defn editor [input]
  (reagent/create-class
   {:render (fn [] [:textarea
                    {:default-value ""
                     :auto-complete "off"}])
    :component-did-mount (editor-did-mount input)}))

(defn render-code [this]
  (->> this dom/dom-node (.highlightBlock js/hljs)))

(defn result-view [output]
  (reagent/create-class
   {:render (fn []
              [:pre>code.clj
               (with-out-str (pprint @output))])
    :component-did-update render-code}))

(defn home-page []
  (let [input (atom nil)
        output (atom nil)]
    (fn []
      [:div
       [editor input]
       [:div
        [:button
         {:on-click #(evaluate @input (fn [{:keys [value]}] (reset! output value)))}
         "run"]]
       [:div
        [result-view output]]])))

(defn mount-root []
  (dom/render [home-page] (.getElementById js/document "app")))

(defn init! []
  (mount-root))

lein new luminus guestbook
cd guestbook
lein uberjar
java -jar target/guestbook.jar

jconsole

ab -c 10 -n 1000 http://127.0.0.1:3000/
This is ApacheBench, Version 2.3 <$Revision: 1663405 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests

Server Software:        undertow
Server Hostname:        127.0.0.1
Server Port:            3000

Document Path:          /
Document Length:        3918 bytes

Concurrency Level:      10
Time taken for tests:   3.544 seconds
Complete requests:      1000
Failed requests:        0
Total transferred:      4251000 bytes
HTML transferred:       3918000 bytes
Requests per second:    282.14 [#/sec] (mean)
Time per request:       35.444 [ms] (mean)
Time per request:       3.544 [ms] (mean, across all concurrent requests)
Transfer rate:          1171.26 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       3
Processing:    15   35  27.4     26     252
Waiting:       15   35  26.3     26     226
Total:         15   35  27.5     26     252

Percentage of the requests served within a certain time (ms)
  50%     26
  66%     31
  75%     37
  80%     41
  90%     54
  95%     75
  98%    110
  99%    227
 100%    252 (longest request)

lein new duct swagger-service +example

cd swagger-service
lein setup

lein run

:dependencies
[...
 [crypto-password "0.1.3"]
 [metosin/compojure-api "0.23.1"]
 [org.xerial/sqlite-jdbc "3.8.11.1"]
 [yesql "0.5.0"]
 [migratus "0.8.4"]]

:plugins [[lein-environ "1.0.1"]
          [lein-gen "0.2.2"]
          [migratus-lein "0.1.7"]]

:migratus {:store :database             
           :db {:classname "org.sqlite.JDBC"
                :connection-uri "jdbc:sqlite:service-store.db"}}          

mkdir resources/migrations
lein migratus create users

20151001145313-users.down.sql
20151001145313-users.up.sql

CREATE TABLE users
(id VARCHAR(20) PRIMARY KEY,
 first_name VARCHAR(30),
 last_name VARCHAR(30),
 email VARCHAR(30),
 admin BOOLEAN,
 last_login TIME,
 is_active BOOLEAN,
 pass VARCHAR(100));

DROP TABLE users;

lein migratus migrate

-- name: create-user!
-- creates a new user record
INSERT INTO users
(id, first_name, last_name, email, pass)
VALUES (:id, :first_name, :last_name, :email, :pass)

-- name: get-user
-- retrieve a user given the id.
SELECT * FROM users
WHERE id = :id

-- name: get-users
-- retrieve a user given the id.
SELECT id, first_name, last_name, email FROM users

-- name: delete-user!
-- delete a user given the id
DELETE FROM users
WHERE id = :id

(ns swagger-service.component.db
  (:require [yesql.core :refer [defqueries]]
            [com.stuartsierra.component :as component]
            [crypto.password.bcrypt :as password]
            [environ.core :refer [env]]))

(defqueries "sql/queries.sql")

(defn create-user-account! [user db]
  (create-user! (update user :pass password/encrypt) db))

(defn authenticate [user db]
  (boolean
   (when-let [db-user (-> user (get-user db) first)]
     (password/check (:pass user) (:pass db-user)))))

(defrecord DbComponent [connection]
  component/Lifecycle
  (start [component]
         (assoc component :connection connection))
  (stop [component]
        (dissoc component :connection)))

(defn db-component [connection]
  (->DbComponent connection))

(def environ
  {:http {:port (some-> env :port Integer.)}
   :db   {:connection-uri (:connection-uri env)}})

;; Local profile overrides

{:profiles/dev  {:env {:connection-uri "jdbc:sqlite:service-store.db"}}
 :profiles/test {}}

(ns swagger-service.system
 (:require ...
           [swagger-service.component.db :refer [db-component]]))

...

(defn new-system [config]
 (let [config (meta-merge base-config config)]
   (-> (component/system-map
        :db      (db-component (:db config))
        :app     (handler-component (:app config))
        :http    (jetty-server (:http config))
        :example (endpoint-component example-endpoint))
       (component/system-using
        {:http [:app]
         :app  [:example]
         :example []          
         :db []}))))            

(ns swagger-service.endpoint.service
 (:require [clojure.java.io :as io]
           [ring.util.http-response :refer :all]
           [compojure.api.sweet :refer :all]
           [schema.core :as s]
           [swagger-service.component.db :as db]))

(s/defschema User
 {:id String
  (s/optional-key :first_name) String
  (s/optional-key :last_name) String
  (s/optional-key :email) String
  (s/optional-key :pass) String})

(defn service-endpoint [config]
 (api
   (ring.swagger.ui/swagger-ui
    "/swagger-ui")
   (swagger-docs
    {:info {:title "User API"}})
   (context* "/api" []
             :tags ["users"]

             (GET* "/users" []
                   :return  [User]
                   :summary "returns the list of users"
                   (ok (db/get-users {} (:db config))))

             (GET* "/user/:id"  []
                   :return      User
                   :path-params [id :- String]
                   :summary     "returns the user with a given id"
                   (ok (db/get-users {:id id} (:db config))))

             (POST* "/authenticate" []
                    :return         Boolean
                    :body-params    [user :- User]
                    :summary        "authenticates the user using the id and pass."
                    (ok (db/authenticate user (:db config))))

             (POST* "/user"      []
                    :return      Long
                    :body-params [user :- User]
                    :summary     "creates a new user record."
                    (ok (db/create-user-account! user (:db config))))

             (DELETE* "/user"    []
                    :return      Long
                    :body-params [id :- String]
                    :summary     "deletes the user record with the given id."
                    (ok (db/delete-user! {:id id} (:db config)))))))

(ns swagger-service.system
 (:require ...
           [swagger-service.component.db :refer [db-component]]
           [swagger-service.endpoint.service :refer [service-endpoint]]))

...

(defn new-system [config]
 (let [config (meta-merge base-config config)]
   (-> (component/system-map
        :db      (db-component (:db config))
        :app     (handler-component (:app config))
        :http    (jetty-server (:http config))
        :example (endpoint-component example-endpoint)
        :service (endpoint-component service-endpoint))
       (component/system-using
        {:http [:app]
         :app  [:example :service]
         :service [:db]
         :example []          
         :db []}))))            

lein new pulsar-example

[co.paralleluniverse/pulsar "0.7.2"]
[co.paralleluniverse/quasar-core "0.7.2"]

:java-agents [[co.paralleluniverse/quasar-core "0.7.2"]]

(ns pulsar-example.core
  (:require
   [co.paralleluniverse.pulsar
    [core :refer :all]
    [actors :refer :all]])
  (:refer-clojure :exclude [promise await])
  (:gen-class))

(defsfn ping [n pong]
  (if (== n 0)
    (do
      (! pong :finished)
      (println "ping finished"))
    (do
      (! pong [:ping @self])
      (receive
        :pong (println "Ping received pong"))
      (recur (dec n) pong))))

(defsfn pong []
  (receive
    :finished (println "Pong finished")
    [:ping ping] (do
                   (println "Pong received ping")
                   (! ping :pong)
                   (recur))))

(defn -main []
  (let [a1 (spawn pong)
        b1 (spawn ping 3 a1)]
    (join a1)
    (join b1)
    :ok))

:manifest
 {"Premain-Class" "co.paralleluniverse.fibers.instrument.JavaAgent"
  "Agent-Class" "co.paralleluniverse.fibers.instrument.JavaAgent"
  "Can-Retransform-Classes" "true"
  "Can-Redefine-Classes" "true"}

java -javaagent:target/pulsar-example.jar -jar target/pulsar-example.jar

:figwheel
{:http-server-root "public"
 :server-port 3449
 :nrepl-port 7002 ;;start nREPL on port 7002
 :css-dirs ["resources/public/css"]
 :ring-handler yourapp/handler}

user> (use 'figwheel-sidecar.repl-api)
user> (cljs-repl)

lein new luminus multi-client-ws +http-kit +cljs

lein run

lein figwheel

(ns multi-client-ws.routes.websockets
 (:require [compojure.core :refer [GET defroutes]]
           [org.httpkit.server
            :refer [send! with-channel on-close on-receive]]
           [cognitect.transit :as t]
           [taoensso.timbre :as timbre]))

(defroutes websocket-routes
 (GET "/ws" request (ws-handler request)))

(defn ws-handler [request]
 (with-channel request channel
               (connect! channel)
               (on-close channel (partial disconnect! channel))
               (on-receive channel #(notify-clients %))))

(defonce channels (atom #{}))

(defn connect! [channel]
 (timbre/info "channel open")
 (swap! channels conj channel))

(defn disconnect! [channel status]
 (timbre/info "channel closed:" status)
 (swap! channels #(remove #{channel} %)))

(defn notify-clients [msg]
 (doseq [channel @channels]
     (send! channel msg)))

(def app
 (-> (routes
       websocket-routes
       (wrap-routes home-routes middleware/wrap-csrf)
       base-routes)
     middleware/wrap-base))

(ns multi-client-ws.websockets
 (:require [cognitect.transit :as t]))

(defonce ws-chan (atom nil))
(def json-reader (t/reader :json))
(def json-writer (t/writer :json))

(defn receive-transit-msg!
 [update-fn]
 (fn [msg]
   (update-fn
     (->> msg .-data (t/read json-reader)))))

(defn send-transit-msg!
 [msg]
 (if @ws-chan
   (.send @ws-chan (t/write json-writer msg))
   (throw (js/Error. "Websocket is not available!"))))

(defn make-websocket! [url receive-handler]
 (println "attempting to connect websocket")
 (if-let [chan (js/WebSocket. url)]
   (do
     (set! (.-onmessage chan) (receive-transit-msg! receive-handler))
     (reset! ws-chan chan)
     (println "Websocket connection established with: " url))
   (throw (js/Error. "Websocket connection failed!"))))

(ns multi-client-ws.core
 (:require [reagent.core :as reagent :refer [atom]]
           [multi-client-ws.websockets :as ws]))

(defonce messages (atom []))

(defn message-list []
 [:ul
  (for [[i message] (map-indexed vector @messages)]
    ^{:key i}
    [:li message])])

(defn message-input []
 (let [value (atom nil)]
   (fn []
     [:input.form-control
      {:type :text
       :placeholder "type in a message and press enter"
       :value @value
       :on-change #(reset! value (-> % .-target .-value))
       :on-key-down
       #(when (= (.-keyCode %) 13)
          (ws/send-transit-msg!
           {:message @value})
          (reset! value nil))}])))

(defn home-page []
 [:div.container
  [:div.row
   [:div.col-md-12
    [:h2 "Welcome to chat"]]]
  [:div.row
   [:div.col-sm-6
    [message-list]]]
  [:div.row
   [:div.col-sm-6
    [message-input]]]])

(defn mount-components []
 (reagent/render-component [#'home-page] (.getElementById js/document "app")))

(defn init! []
 (ws/make-websocket! (str "ws://" (.-host js/location) "/ws") update-messages!)
 (mount-components))

(defn init []
  (swap! markup-registry conj (markdown)))

{:description "Markdown parser"
 :init cryogen-markdown.core/init}

(defn load-plugins []
  (let [plugins (.getResources (ClassLoader/getSystemClassLoader) "plugin.edn")]
    (loop []
      (load-plugin (.. plugins nextElement openStream))
      (when (.hasMoreElements plugins)
        (recur)))))

(defn load-plugin [url]
  (let [{:keys [description init]} (edn/read-string (slurp url))]
    (println (green (str "loading module: " description)))
    (-> init str (s/split #"/") first symbol require)
    ((resolve init))))

lein new reagent my-app
cd my-app
lein cljsbuild auto &
lein ring server

(defn write-file [{:keys [data name]}]
   (with-open [w (clojure.java.io/output-stream
                   (str "resources/templates/files/" name))]
     (.write w data)))

(defn extract-files []
  (doseq [file (sql/query db ["select * from file"])]
    (write-file file)))

(defn extract-tags [post]
  (update-in post [:tags] #(vec (.getArray %))))

(defn get-posts []
  (map extract-tags
       (sql/query db
         ["select array_agg(t.tag) as tags,
                  b.id, b.time, b.title, b.content from blog b, tag_map t
           where t.blogid = b.id
           group by b.id, b.time, b.title, b.content"])))

(defn format-post-date [date]
  (let [fmt (java.text.SimpleDateFormat. "dd-MM-yyyy")]
    (.format fmt date)))

(defn format-post-filename [time title]
  (str
    (->> (re-seq #"[a-zA-Z0-9]+" title)
         (clojure.string/join "-")
         (str "resources/templates/md/posts/" (format-post-date time) "-"))
   ".md"))

(defn write-post [{:keys [id time tags content title]}]
  (with-open [wrt (clojure.java.io/writer (format-post-filename time title))]
    (.write wrt
            (with-out-str
              (clojure.pprint/pprint
                {:title title
                 :layout :post
                 :tags (vec (.split tags " "))})))
    (.write wrt "\n")
    (.write wrt content)))

(defn extract-posts []
  (doseq [post (get-posts)]
    (write-post post)))

lein new cryogen my-blog

lein ring server

(defn render-file [filename args]
  (render (parse filename) args))

(parser/render "Hello {{name}}!" {:name "Yogthos"})

(defn parse [file]
  (with-open [rdr (clojure.java.io/reader file)]

(render
  (parse
    (java.io.StringBufferInputStream. "Hello {{name}}"))
    {:name "Yogthos"})
=>"Hello filter tag value: name"

(ns example
  (:require [reagent.core :as reagent :refer [atom]]))

(defn atom-input [value]
  [:input {:type "text"
           :value @value
           :on-change #(reset! value (-> % .-target .-value))}])

(defn shared-state []
  (let [val (atom "foo")]
    (fn []
      [:div
       [:p "The value is now: " @val]
       [:p "Change it here: " [atom-input val]]])))

(ns myform.core
  (:require [reagent-forms.core :refer [bind-fields]])

(defn row [label input]
  [:div.row
    [:div.col-md-2 [:label label]]
    [:div.col-md-5 input]])

(def form-template
  [:div
   (row "first name" [:input {:field :text :id :person.first-name}])
   (row "last name" [:input {:field :text :id :person.last-name}])
   (row "age" [:input {:field :numeric :id :person.age}])
   (row "email" [:input {:field :email :id :person.email}])
   (row "comments" [:textarea {:field :textarea :id :comments}])])

(defn form []
  (let [doc (atom {})]
    (fn []
      [:div
       [:div.page-header [:h1 "Reagent Form"]]
       [bind-fields form-template doc]
       [:label (str @doc)]])))

(defn row [label input]
  [:div.row
    [:div.col-md-2 [:label label]]
    [:div.col-md-5 input]])

(def form-template
 [:div
   [:h3 "BMI Calculator"]
   (row "Height" [:input {:field :numeric :id :height}])
   (row "Weight" [:input {:field :numeric :id :weight}])
   (row "BMI" [:input {:field :numeric :id :bmi :disabled true}])])

[w/bind-fields
  form-template
  doc
  (fn [[id] value {:keys [weight height] :as doc}]
    (when (and (some #{id} [:height :weight]) weight height)
      (assoc-in doc [:bmi] (/ weight (* height height)))))]

(defmethod init-field :radio
  [[type {:keys [field id value] :as attrs} & body]
   {:keys [get save!]}]
  (let [state (atom (= value (get id)))]
    (fn []
      (into
        [type
         (merge {:type :radio
                 :checked @state
                 :class "form-control"
                 :on-change
                 #(do
                    (save! id value)
                    (reset! state (= value (get id))))}
                attrs)]
         body))))

{:create event-handler
 :modify event-handler}

(defn event-handler [event]
  (println (.kind event) (.context event)))

(defn register-events! [dir watch-service opts]
  (.register dir watch-service
    (-> opts
       (select-keys [StandardWatchEventKinds/ENTRY_CREATE
                     StandardWatchEventKinds/ENTRY_MODIFY
                     StandardWatchEventKinds/ENTRY_DELETE
                     StandardWatchEventKinds/OVERFLOW])
       (keys)
       (into-array))))

(defn rename-event-keys [opts]
  (rename-keys opts
    {:create StandardWatchEventKinds/ENTRY_CREATE
     :modify StandardWatchEventKinds/ENTRY_MODIFY
     :delete StandardWatchEventKinds/ENTRY_DELETE
     :overflow StandardWatchEventKinds/OVERFLOW}))

(defn watch [path opts]
  (let [dir (-> path (file) (.toURI) (Paths/get))
        opts (rename-event-keys opts)]
    (with-open [watch-service
                (.newWatchService (FileSystems/getDefault))]
      (register-events! dir watch-service opts)
      (watch-loop watch-service opts))))

(defn watch-loop [watch-service opts]
  (loop []
    (let [k (.take watch-service)]      
      (doseq [event (.pollEvents k)]
        (if-let [handler (get opts (.kind event))]
          (handler event)))
      (when (.reset k) (recur)))))

(defn start-watcher! [path opts]
  (doto (Thread. #(watch path opts))
    (.setDaemon true)
    (.start)))

(start-watcher! “~/downlads”
  {:create #(println “file created” (-> % (.context) (.toString)))
   :modify #(println “file modified” (-> % (.context) (.toString)))})

(defn register-events! [dir watch-service]
  (.register dir
    watch-service
    (into-array
      [StandardWatchEventKinds/ENTRY_CREATE
       StandardWatchEventKinds/ENTRY_MODIFY
       StandardWatchEventKinds/ENTRY_DELETE
       StandardWatchEventKinds/OVERFLOW])
    (into-array
      [(com.sun.nio.file.SensitivityWatchEventModifier/HIGH)])))

src
  └ cljs
    └ guestbook
      └ core.cljs
      └ pages
        └ guest.cljs
        └ guest_list.cljs

<script type="text/javascript">goog.require("guestbook.core");</script>

(ns guestbook.pages.guest-list
  (:require [reagent.session :as session]
            [clojure.string :as s]
            [reagent.core :as reagent :refer [atom]]
            [secretary.core :refer [dispatch!]]))

(defn guest-list-page []
  [:div
   [:div.page-header [:h2 "Guests"]]
   (for [{:keys [first-name last-name]}
         (session/get :guests)]
     [:div.row
      [:p first-name " " last-name]])
   [:button {:type "submit"
             :class "btn btn-default"
             :on-click #(dispatch! "/sign-in")}
    "sign in"]])

(ns guestbook.core
  (:require [reagent.core :as r]
            [reagent.session :as session]
            [secretary.core :as secretary :include-macros true]
            [goog.events :as events]
            [goog.history.EventType :as HistoryEventType]
            [guestbook.ajax :refer [load-interceptors!]]
            [guestbook.pages.guest-list
            :refer [guest-list-page]]
           [guestbook.pages.guest :refer [guest-page]])
  (:import goog.History))

(defn page []
  [(session/get :current-page)])

;; -------------------------
;; Routes
(secretary/set-config! :prefix "#")

(secretary/defroute "/" []
  (session/put! :current-page guest-list-page))

(secretary/defroute "/sign-in" []
  (session/put! :current-page guest-page))

;; -------------------------
;; History
;; must be called after routes have been defined
(defn hook-browser-navigation! []
  (doto (History.)
        (events/listen
          HistoryEventType/NAVIGATE
          (fn [event]
              (secretary/dispatch! (.-token event))))
        (.setEnabled true)))

;; -------------------------
;; Initialize app
(defn mount-components []
  (r/render [#'page] (.getElementById js/document "app")))

(defn init! []
  (load-interceptors!)
  (hook-browser-navigation!)
  (mount-components))

Views--->(actions) --> Dispatcher-->(callback)--> Stores---+
Ʌ                                                          |
|                                                          V
+--(event handlers update)--(Stores emit "change" events)--+

(ns guestbook.pages.guest
  (:refer-clojure :exclude [get])
  (:require [reagent.session :as session]
            [reagent.core :as reagent :refer [atom]]
            [secretary.core :refer [dispatch!]]
            [ajax.core :refer [POST]]))

(defn put! [doc id value]
  (swap! doc assoc :saved? false id value))

(defn get [doc id]
  (id @doc))

(defn row [label & body]
  [:div.row
   [:div.col-md-2 [:span label]]
   [:div.col-md-3 body]])

(defn text-input [doc id label]
  [row label
   [:input {:type "text"
            :class "form-control"
            :value (get doc id)
            :onChange #(put! doc id (-> % .-target .-value))}]])

(defn save-doc [doc]
  (POST "/save"
        {:params (dissoc @doc :saved?)
         :handler
         (fn [_]
           (put! doc :saved? true)
           (session/update-in! [:guests] conj @doc)
           (dispatch! "/"))}))

(defn guest-page []
  (let [doc (atom {})]
    (fn []
      [:div
       [:div.page-header [:h1 "Sign In"]]

       [text-input doc :first-name "First name"]
       [text-input doc :last-name "Last name"]

       (if (get doc :saved?)
         [:p "Saved"]
         [:button {:type "submit"
                   :class "btn btn-default"
                   :on-click #(save-doc doc)}
          "Submit"])
       [:button {:type "submit"
                 :class "btn btn-default"
                 :on-click #(dispatch! "/")} "back"]])))

(ns guestbook.core
 (:require [reagent.session :as session]
           [guestbook.pages.guest-list
            :refer [guest-list-page]]
           [guestbook.pages.guest :refer [guest-page]]
           [reagent.core :as reagent :refer [atom]]
           [secretary.core :as secretary
             :include-macros true :refer [defroute]]
           [goog.events :as events]
           [goog.history.EventType :as EventType]))

(defn hook-browser-navigation! []
  (doto (History.)
    (events/listen
      EventType/NAVIGATE
      (fn [event]
        (secretary/dispatch! (.-token event))))
    (.setEnabled true)))

(defn init! []
  (load-interceptors!)
  (hook-browser-navigation!)
  (mount-components))

;;reducing function signature
whatever, input -> whatever
;;transducer signature
(whatever, input -> whatever) -> (whatever, input -> whatever)
;;look Ma, no collection!
(map f)
(def xform (comp (map inc) (filter even?)))
(->> aseq (map inc) (filter even?))
(sequence xform data)
(transduce xform + 0 data)
(into [] xform data)
(iteration xform data)
(chan 1 xform)
(ns main.core
 (:require [reagent.core :as reagent :refer [atom]]))

(defn home []
  [:div
    [:div.page-header [:h1 "Reagent Form"]]])

(reagent/render-component [home]
  (.getElementById js/document "app"))

(defn text-input [label]
  [:div.row
    [:div.col-md-2
      [:span label]]
    [:div.col-md-3
      [:input {:type "text" :class "form-control"}]]])

(defn home []
  [:div
    [:div.page-header [:h1 "Reagent Form"]]
    [text-input "First name"]])

(defn row [label & body]
  [:div.row
   [:div.col-md-2 [:span label]]
   [:div.col-md-3 body]])

(defn text-input [label]
  [row label [:input {:type "text" :class "form-control"}]])

(def state (atom {:doc {} :saved? false}))

(defn set-value! [id value]
  (swap! state assoc :saved? false)
  (swap! state assoc-in [:doc id] value))

(defn get-value [id]
  (get-in @state [:doc id]))

(defn text-input [id label]
  [row label
   [:input
     {:type "text"
       :class "form-control"
       :value (get-value id)
       :on-change #(set-value! id (-> % .-target .-value))}]])

(defn home []
  [:div
    [:div.page-header [:h1 "Reagent Form"]]
    [text-input :first-name "First name"]])

(defn home []
  [:div
    [:div.page-header [:h1 "Reagent Form"]]
    [text-input :first-name "First name"]    
    [:button {:type "submit"
              :class "btn btn-default"
              :on-click #(.log js/console (clj->js @state))}
     "Submit"]])

(defn home []
  [:div
    [:div.page-header [:h1 "Reagent Form"]]

    [text-input :first-name "First name"]
    [text-input :last-name "First name"]

    [:button {:type "submit"
              :class "btn btn-default"
              :onClick #(.log js/console (clj->js @state))}
     "Submit"]])

(defn selection-list [id label & items]
  (let [selections (->> items (map (fn [[k]] [k false])) (into {}) atom)]    
    (fn []
      [:div.row
       [:div.col-md-2 [:span label]]
       [:div.col-md-5
        [:div.row
         (for [[k v] items]
          [list-item id k v selections])]]])))

(defn list-item [id k v selections]
  (letfn [(handle-click! []
            (swap! selections update-in [k] not)
            (set-value! id (->> @selections
                                (filter second)
                                (map first))))]
    [:li {:class (str "list-group-item"
                      (if (k @selections) " active"))
          :on-click handle-click!}
      v]))

(defn home []
  [:div
    [:div.page-header [:h1 "Reagent Form"]]

    [text-input :first-name "First name"]
    [text-input :last-name "First name"]

    [selection-list :favorite-drinks "Favorite drinks"
     [:coffee "Coffee"]
     [:beer "Beer"]
     [:crab-juice "Crab juice"]]

    [:button {:type "submit"
              :class "btn btn-default"
              :onClick #(.log js/console (clj->js @state))}
     "Submit"]])

(ns main.core
 (:require [reagent.core :as reagent :refer [atom]]
           [ajax.core :refer [POST]]))

(defn save-doc []
  (POST (str js/context "/save")
        {:params (:doc @state)
         :handler (fn [_] (swap! state assoc :saved? true))}))

(defn home []
  [:div
    [:div.page-header [:h1 "Reagent Form"]]

    [text-input :first-name "First name"]
    [text-input :last-name "Last name"]
    [selection-list :favorite-drinks "Favorite drinks"
     [:coffee "Coffee"]
     [:beer "Beer"]
     [:crab-juice "Crab juice"]]

   (if (:saved? @state)
     [:p "Saved"]
     [:button {:type "submit"
              :class "btn btn-default"
              :onClick save-doc}
     "Submit"])])

(ns reagent-example.routes.services
  (:use compojure.core)
  (:require [reagent-example.layout :as layout]
            [noir.response :refer [edn]]
            [clojure.pprint :refer [pprint]]))

(defn save-document [doc]
  (pprint doc)
  {:status "ok"})

(defroutes service-routes
  (POST "/save" {:keys [body-params]}
        (edn (save-document body-params))))

{:first-name "Jasper", :last-name "Beardly", :favorite-drinks (:coffee :beer)}

<html>
  <body>
    {% blok %}
    {% endblock %}
    <h2>Hello {{name}}</h2>
  </body>
</html>

Exception in thread "main" java.lang.Exception: unrecognized tag: :blok - did you forget to close a tag?

Exception in thread "main" java.lang.Exception: Unrecognized tag: {% blok %} on line 3 for template file:/Users/Yogthos/selmer-test/resources/index.html

(defn template-error-page [handler]
  (fn [request]
    (try
      (handler request)
      (catch clojure.lang.ExceptionInfo ex
        (let [{:keys [type error-template] :as data} (ex-data ex)]
          (if (= :selmer-validation-error type)
            {:status 500
             :body   (selmer.parser/render error-template data)}
            (throw ex)))))))

:dev {:dependencies [[ring-mock "0.1.5"]
                     [ring/ring-devel "1.2.1"]]
      :env {:selmer-dev true}}}

(defn template-error-page [handler]
  (if (env :selmer-dev)
    (fn [request]
      (try
        (handler request)
        (catch clojure.lang.ExceptionInfo ex
          (let [{:keys [type error-template] :as data} (ex-data ex)]
            (if (= :selmer-validation-error type)
              {:status 500
               :body (parser/render error-template data)}
              (throw ex))))))
    handler))

(defn render [template params]  
  (let [buf (StringBuilder.)]
    (doseq [element template] 
      (.append buf (if (string? element) element (element params))))
    (.toString buf)))

(defprotocol INode
  (render-node [this context-map] "Renders the context"))

(deftype FunctionNode [handler]
  INode
  (render-node ^String [this context-map]
    (handler context-map)))

(deftype TextNode [text]
  INode
  (render-node ^String [this context-map]
    text))

(defn render-template [template context-map]
  """ vector of ^selmer.node.INodes and a context map."""
  (let [buf (StringBuilder.)]
    (doseq [^selmer.node.INode element template]
        (if-let [value (.render-node element context-map)]
          (.append buf value)))
    (.toString buf)))

(selmer.filters/add-filter! :empty? empty?)

(render 
  "{% if files|empty? %}
   no files available 
   {% else %} 
       {% for file in files %}{{file}}{% endfor %} 
   {% endif %}"
  {:files []})

(use 'selmer.filters)

(add-filter! :embiginate #(.toUpperCase %))

(render "{{shout|embiginate}}" {:shout "hello"})
=>"HELLO"

(use 'selmer.parser)

(add-tag! :foo
  (fn [args context-map]
    (str "foo " (first args))))

(render "{% foo quux %} {% foo baz %}" {})
=>"foo quux foo baz"

(add-tag! :foo
  (fn [args context-map content]
    (str content))
  :bar :endfoo)

(render "{% foo %} some text {% bar %} some more text {% endfoo %}" {})
=>"{:foo {:args nil, :content \" some text \"}, :bar {:args nil, :content \" some more text \"}}"

(render "[% for ele in foo %]<<[{ele}]>>[%endfor%]"
                 {:foo [1 2 3]}
                 {:tag-open \[
                  :tag-close \]})

(restricted GET "/private" [] handler)

(GET "/private" [] (restricted handler))

(def-restricted-routes

(defroutes app-routes
 ;;restricted routes
 (GET "/restricted" [] (restricted "this page is restricted"))
 (GET "/restricted1" [] (restricted "this is another restricted page"))
 (GET "/users/:id" [] (restricted "howdy"))
 (GET "/admin" [] (restricted "admin route"))
 (GET "/config" [] (restricted "config route"))
 (GET "/super-secret" [] (restricted "secret route"))
 ;;public routes
 (GET "/denied1" [] "denied")
 (GET "/denied2" [] "denied differently"))

(def app 
 (middleware/app-handler 
   [app-routes]
   :access-rules 
   [(fn [req] (session/get :user))

    {:uri "/restricted"
     :redirect "/denied1"
     :rule (fn [req] false)}

    {:redirect (fn [req] 
                 (log/info (str "redirecting " (:uri req)))
                 "/denied2")
     :uri "/users/*"
     :rule (fn [req] false)}

    {:uris ["/admin*" "/config*"]
     :rules {:any [(fn [req] (session/get :admin))
                   (fn [req] (session/get :root))]}}

    {:on-fail (fn [req] "you tried to access the super secret page!")
     :uri "/super-secret*"
     :rules [(fn [req] (session/get :admin))
             (fn [req] (session/get :root))]}

    {:uri "/super-secret*"
     :rules {:every [(fn [req] (session/get :admin))
                     (fn [req] (session/get :root))]
             :any   [(fn [req] (session/get :zeus))
                     (fn [req] (session/get :athena))]}}
]))

(defn log-user-in-session [handler]
  (fn [req]
    (timbre/info (session/get :user))
    (handler req)))

(def app (-> (middleware/app-handler all-routes)
             log-user-in-session))

java.lang.ClassCastException: clojure.lang.Var$Unbound cannot be cast to java.util.concurrent.Future

(def app (middleware/app-handler all-routes
          :middleware [log-user-in-session]))

(defn private-pages [method url params]    
    (session/get :user-id))

(def app (middleware/app-handler all-routes 
          :access-rules
          [[{:redirect "/unauthorized"} private-pages]]))

(wrap-rewrites handler #"/foo" "/bar")

(defroutes private-routes
  (restricted GET "/route1" [] handler1)
  (restricted GET "/route2" [] handler2)
  (restricted GET "/route3" [] handler3)
  (restricted GET "/route4" [] handler4))

(def-restricted-routes private-routes
  (GET "/route1" [] handler1)
  (GET "/route2" [] handler2)
  (GET "/route3" [] handler3)
  (GET "/route4" [] handler4))

(def app (middleware/app-handler all-routes 
          :access-rules
          [[{:redirect 
             (fn [] 
              (println "redirecting") "/unauthorized")} 
             private-pages]]))

:cljsbuild
{:crossovers [markdown.transformers]
  :crossover-path "crossover"
  :crossover-jar true        
  :builds {:main
           {:source-paths ["src-cljs"]
            :jar true
            :compiler {:output-to "js/markdown.js"
                       :optimizations :advanced
                       :pretty-print false}}
           :dev 
           {:compiler {:optimizations :whitespace
                       :pretty-print true}}}}

(defproject markdown-clj "0.9.25"
  :clojurescript? true
  :description "Markdown parser"
   :url "https://github.com/yogthos/markdown-clj"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.5.1"]
                  [criterium "0.3.1" :scope "test"]]
   :plugins [[lein-cljsbuild "0.3.2"]]
   :hooks [leiningen.cljsbuild]
   :test-selectors {:default (complement :benchmark)
                    :benchmark :benchmark
                    :all (constantly true)}

   :cljsbuild
   {:crossovers [markdown.transformers]
    :crossover-path "crossover"
    :crossover-jar true        
    :builds {:main
             {:source-paths ["src-cljs"]
              :jar true
              :compiler {:output-to "js/markdown.js"
                         :optimizations :advanced
                         :pretty-print false}}
             :dev 
             {:compiler {:optimizations :whitespace
                         :pretty-print true}}}})

(ns foo
 (:require [ajax.core :refer [GET POST]]))

(defn handler [response]
 (.log js/console (str response)))

(defn error-handler [{:keys [status status-text]}]
 (.log js/console 
  (str "something bad happened: " status " " status-text)))

(GET "/hello")

(GET "/hello" {:handler handler
               :error-handler error-handler})

(POST "/hello")

(POST "/send-message" 
      {:params {:message "Hello World"
                :user    "Bob"}
      :handler handler
      :error-handler error-handler})

(POST "/send-message" 
      {:params {:message "Hello World"
                :user    "Bob"}
      :handler handler
      :format :json
      :error-handler error-handler})

lein new luminus ajax-example +cljs

(ns cljs-test.main
 (:require [ajax.core :refer [GET POST]]
           [domina :refer [value by-id destroy-children! append!]]
           [domina.events :refer [listen!]]
           [dommy.template :as template]))

(defn render-message [{:keys [message user]}]
 [:li [:p {:id user} message " - " user]])

(defn render-messages [messages]
 (let [messages-div (by-id "messages")]
   (destroy-children! messages-div)
   (->> messages
        (map render-message)
        (into [:ul])
        template/node
        (append! messages-div))))

(defn add-message [_]
 (POST "/add-message"
       {:params {:message (value (by-id "message"))
                 :user    (value (by-id "user"))}
        :handler render-messages}))

(defn ^:export init []
 (GET "/messages" {:handler render-messages})
 (listen! (by-id "send")
          :click add-message))

(ns ajax-example.routes.cljsexample
 (:require [compojure.core :refer :all]
           [noir.response :as response]
           [ajax-example.views.layout :as layout]))

(def messages
 (atom
   [{:message "Hello world"
     :user    "Foo"}
    {:message "Ajax is fun"
     :user    "Bar"}]))

(defroutes cljs-routes
 (GET "/cljsexample" [] (layout/render "cljsexample.html"))
 (GET "/messages" [] (response/edn @messages))
 (POST "/add-message" [message user]
       (response/edn
         (swap! messages conj {:message message :user user}))))

{% extends "cljs_test/views/templates/base.html" %}

{% block content %}

<br/>
<div id="messages"></div>
<textarea id="message"></textarea>
<br/>
<input type="text" id="user"></input>
<br/>
<button id="send">add message</button>

<!--  scripts -->
<script type="text/javascript" src="js/site.js"></script>
<script type="text/javascript">
	cljs_test.main.init();
</script>

{% endblock %}

lein new luminus guestbook +h2

<h2>Hello {{user}}</h2>

(render "<h2>Hello {{user}}</h2>" {:user "John"})

<h2>Hello {{user.last}}", " {{user.first}}</h2>

(ns guestbook.util  
  (:require ...
            [clabango.parser :as parser]))

(defn render [template params]
  (parser/render (io/slurp-resource template) params))

(defn create-guestbook-table []
  (sql/with-connection
    db-spec
    (sql/create-table
      :guestbook
      [:id "INTEGER PRIMARY KEY AUTO_INCREMENT"]
      [:timestamp :timestamp]
      [:name "varchar(30)"]
      [:message "varchar(200)"])
    (sql/do-commands
      "CREATE INDEX timestamp_index ON guestbook (timestamp)")))

(defn create-tables
  "creates the database tables used by the application"
  []
  (create-guestbook-table))

(defn init []
  (if-not (schema/initialized?) (schema/create-tables))
  (println "guestbook started successfully..."))

(ns guestbook.models.db
  (:use korma.core
        [korma.db :only (defdb)])
  (:require [guestbook.models.schema :as schema]))

(defdb db schema/db-spec)

(defentity guestbook)

(defn save-message
  [name message]
  (insert guestbook 
          (values {:name name
                   :message message
                   :timestamp (new java.util.Date)})))

(defn get-messages []
  (select guestbook))

<ul>
{% for item in messages %}
  <li> 
      <blockquote>{{item.message}}</blockquote>
      <p> - {{item.name}}</p>
      <time>{{item.timestamp}}</time>
  </li>
{% endfor %}
</ul>

{% if error %}
<p>{{error}}</p>
{% endif %}

<form action="/" method="POST">
	<p>Name: <input type="text" name="name" value={{name}}></p>
	<p>Message: <input type="text" name="message" value={{message}}></p>
	<input type="submit" value="comment">
</form>

(defn home-page [& [name message error]]
  (layout/common   
    (util/render "/templates/welcome.html" 
                 {:error    error
                  :name     name
                  :message  message
                  :messages (db/get-messages)})))

(defn save-message [name message]
  (cond

    (empty? name)
    (home-page name message "Some dummy who forgot to leave a name")

    (empty? message)
    (home-page name message "Don't you have something to say?")

    :else
    (do
      (db/save-message name message)
      (home-page))))

(defroutes home-routes
  (GET "/" [] (home-page))
  (POST "/" [name message] (save-message name message))
  (GET "/about" [] (about-page)))

(defn private-page [method url params]
  (session/get :user))

(-> handler
  (wrap-access-rules rule1)
  (wrap-access-rules {:redirect "/unauthorized"} rule2 rule3))

(def private-pages
  (access-rule "/private/:id" (= (session/get :user) (first params))))

(def private-pages 
  (access-rule "/private/:id"  [_ _ params] 
    (= (session/get :user) (first params))))

(ns myapp.upload
  ...
  (:require [noir.io :as io]))

(defn upload-page []
  (common/layout
    [:h2 "Upload a file"]
    (form-to {:enctype "multipart/form-data"}
             [:post "/upload"]            
             (file-upload :file)            
             (submit-button "upload"))))

(defn handle-upload [file]
  (upload-file "/uploads" file)
  (redirect
    (str "/" (session/get :user) "/" (:filename file))))

(defroutes upload-routes
  (GET "/upload" [] (upload-page))
  (POST "/upload" [file] (handle-upload file)))

(defn user-page [method url params] 
  (and (= url "/private/:id")
       (= (first params) (session/get :user))))

(def app (-> all-routes
             (middleware/app-handler)
             (middleware/wrap-access-rules user-page)))  

(restricted GET "/private/:id" [id] "private!")

(defn wrap-request-map [handler]
  (fn [req]
    (binding [noir.request/*request* req]
      (handler req))))

lein new luminus myapp

lein new luminus myapp +bootstrap

lein new luminus myapp +bootstrap +sqlite

lein new template compojure-app

(defproject compojure-app/lein-template "0.2.7"
  :description "Compojure project template for Leiningen"
  :url "https://github.com/yogthos/compojure-template"
  :eval-in-leiningen true
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[leinjacker "0.2.0"]])

src/compojure-template/leiningen/new/compojure_app.clj

(ns leiningen.new.compojure-app
  (:use [leiningen.new.templates :only [renderer sanitize year ->files]]
        [leinjacker.utils :only [lein-generation]]))

(def project-file
  (if (= (lein-generation) 2)
    "project_lein2.clj"
    "project_lein1.clj"))

(defn compojure-app
  "Create a new Compojure project"
  [name]
  (let [data {:name name
              :sanitized (sanitize name)
              :year (year)}
        render #((renderer "compojure_app") % data)]
    (println "Generating a lovely new Compojure project named" (str name "..."))
    (->files data
             [".gitignore"  (render "gitignore")]
             ["project.clj" (render project-file)]
             ["README.md"   (render "README.md")]
             ["src/{{sanitized}}/handler.clj"      (render "handler.clj")]
             ["src/{{sanitized}}/server.clj"       (render "server.clj")]
             ["src/{{sanitized}}/common.clj" (render "common.clj")]
             ["resources/public/css/screen.css" (render "screen.css")]
             "resources/public/js"
             "resources/public/img"
             "src/{{sanitized}}/models"
             ["test/{{sanitized}}/test/handler.clj" (render "handler_test.clj")])))

src/compojure-template/leiningen/new/compojure_app

(ns {{name}}.common
  (:use [hiccup.page :only [html5 include-css]]))

(defn layout [& body]
  (html5 
    [:head
     [:title "Welcome to {{name}}"]
     (include-css "/css/screen.css")]
    (into [:body] body)))

{:user
  {:plugins [[compojure-app/lein-template "0.2.7"]]}}

(defpage "/" []
  (common/layout 
    (form-to [:post "/"]                           
              (text-area {:placeholder "say something..."} "message") 
              [:br]
              (text-field {:placeholder "name"} "id")
              (submit-button "post message"))))

(defpage [:post "/"] params
  (common/layout 
    [:p (:id params) " says " (:message params)]))

(defroutes app-routes  
  (GET "/" [] (message))
  (POST "/" params (display-message params))
  (route/resources "/")
  (route/not-found "Not Found"))

(defn message []
  (html5 
    [:body 
     (form-to [:post "/"]                           
              (text-area {:placeholder "say something..."} "message") 
              [:br]
              (text-field {:placeholder "name"} "id")
              (submit-button "post message"))]))

(defn display-message [params]
  (let [form-params (:form-params params)] 
    (html5 
      [:body 
       [:p (get form-params "id") " says " (get form-params "message")]])))

(ns myapp.common
  (:use [hiccup.def :only [defhtml]] 
        [hiccup.page :only [include-css]]))

(defhtml layout [& body]  
  [:head
   [:title "Welcome to myapp"]
   (include-css "/css/screen.css")]
  (into [:body] body))

(defmacro page [f form-params & body]
  `(defn ~f [~'request]
     (let [~form-params 
           (into {} (for [[k# v#] (:form-params ~'request)] 
                      [(keyword k#) v#]))]
       ~@body)))

(page message []
  (layout
    (form-to [:post "/"]                           
             (text-area {:placeholder "say something..."} "message") 
             [:br]
             (text-field {:placeholder "name"} "id")
             (submit-button "post message"))))

(page display-message {:keys [id message]}
  (layout
      [:p id " says " message]))

(defroutes app-routes  
  (GET "/" [] (message []))
  (POST "/" params (display-message params))
  (route/resources "/")
  (route/not-found "Not Found"))

(defn display-message [id message]
  (layout [:p id " says " message]))

(defroutes app-routes  
  (POST "/" [id message] (display-message id message))
  (route/not-found "Not Found"))

(-> handler
  (wrap-noir-cookies)
  (session/wrap-noir-session 
    {:store (memory-store session/mem)})
  (wrap-noir-validation))

lein new compojure-app myapp

(defproject tetris "0.1.0-SNAPSHOT"
  :description "a simple Tetris game"
  :url "https://github.com/yogthos/Clojure-Tetris"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}

  :dependencies [[org.clojure/clojure "1.4.0"]]
  :plugins [[lein-cljsbuild "0.2.9"]]

  :source-paths ["src"]
  :main tetris.core

  :cljsbuild {:crossovers [tetris.game]
              :builds
              [{:source-path "src-cljs"
                :compiler
                {:output-to "js/tetris.js"
                 :optimizations :advanced
                 :pretty-print false}}]})

(defn log [& items]
  (.log js/console (apply str items)))

(defn ^:export init []
  (log "Hello ClojureScript!"))

(defn ^:export init []
  (let [canvas (.getElementById js/document "canvas")
        ctx    (.getContext canvas "2d")
        width  (.-width canvas) 
        height (.-height canvas)]

    (log "width: " width ", height: " height)

    ;;set a property
    (set! (.-fillStyle ctx) "black")

    (.fillRect ctx 0 0 width height)))

(ns foo)

(defn bar [])

(ns hello
 (:use foo))

(defn ^:export init []
	(js/alert "Hello from ClojureScript!"))

java.lang.UnsupportedOperationException: nth not supported on this type: Symbol

(declare game-loop)
(defn game-loop [state]
  (if (not (:game-over state))
    (js/setTimeout
      (fn [] (game-loop (update-state state)))
      10)))     

(def db {:classname "org.postgresql.Driver"
           :subprotocol "postgresql"
           :subname "//localhost:5432/testdb"
           :user "user"
           :password "secret"})

(defn create-employee-table []
  (sql/create-table
    :employee
    [:name "varchar(50)"]
    [:occupation "varchar(50)"]
    [:place "varchar(50)"]
    [:country "varchar(50)"]))

(sql/with-connection 
  db
  (create-employee-table)
  (sql/insert-rows 
    :employee
    ["Babji, Chetty", "Engineer", "Nuremberg", "Germany"]
    ["Albert Einstein", "Engineer", "Ulm", "Germany"]
    ["Alfred Hitchcock", "Movie Director", "London", "UK"]
    ["Wernher Von Braun", "Rocket Scientist", "Wyrzysk", "Poland (Previously Germany)"]
    ["Sigmund Freud", "Neurologist", "Pribor", "Czech Republic (Previously Austria)"]
    ["Mahatma Gandhi", "Lawyer", "Gujarat", "India"]
    ["Sachin Tendulkar", "Cricket Player", "Mumbai", "India"]
    ["Michael Schumacher", "F1 Racer", "Cologne", "Germany"]))

(defn read-employees []
  (sql/with-connection db 
    (sql/with-query-results rs ["select * from employee"] (doall rs))))

(clojure.pprint/pprint (read-employees))

({:country "Germany",
  :place "Nuremberg",
  :occupation "Engineer",
  :name "Babji, Chetty"}
 {:country "Germany",
  :place "Ulm",
  :occupation "Engineer",
  :name "Albert Einstein"}
  ...)

(def employee-template 
  (template [$name $occupation $place $country]))

(employee-template (take 2 (read-employees)))

(["Babji, Chetty" "Engineer" "Nuremberg" "Germany"] 
 ["Albert Einstein" "Engineer" "Ulm" "Germany"])

(pdf
 [{}
  (into [:table 
         {:border false
          :cell-border false
          :header [{:color [0 150 150]} "Name" "Occupation" "Place" "Country"]}]
        (employee-template (read-employees)))]
 "report.pdf")

(def employee-template-paragraph 
  (template 
    [:paragraph 
     [:heading $name]
     [:chunk {:style :bold} "occupation: "] $occupation "\n"
     [:chunk {:style :bold} "place: "] $place "\n"
     [:chunk {:style :bold} "country: "] $country
     [:spacer]]))

(pdf 
  [{:font {:size 11}}      
   [:heading {:size 14} "Employees Test"]
   [:line]
   [:spacer]
   (employee-template-paragraph (read-employees))]
  "report.pdf")

src/liberator_service
         server.clj
         resources.clj
         static_resources.clj
         ui.clj
resources/public
         site.js
project.clj

(defproject liberator-example "0.1.0-SNAPSHOT"
  :description "Example for the Liberator library"
  :url "https://github.com/yogthos/liberator-example"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.4.0"]
                 [compojure "1.0.2"]
                 [liberator "0.5.0"]
                 [sandbar "0.4.0-SNAPSHOT"]
                 [org.clojure/data.json "0.1.2"]
                 [ring/ring-jetty-adapter "1.1.0"]]
  :dev-dependencies [[lein-ring "0.7.3"]]
  :ring {:handler liberator-service.server/handler}
  :main liberator-service.server)

(ns liberator-service.server
  (:use [liberator.representation :only [wrap-convert-suffix-to-accept-header]]
        [ring.middleware.multipart-params :only [wrap-multipart-params]]
        ring.middleware.session.memory
        sandbar.stateful-session
        compojure.core 
        [compojure.handler :only [api]]
        liberator-service.ui
        liberator-service.resources
        liberator-service.static-resources)
  (:require
   [ring.adapter.jetty :as jetty]))

(defonce my-session (atom {}))

(defn assemble-routes []
  (routes
    (GET   "/" [] home)
    (POST "/login" [] login)
    (POST "/logout" [] logout)
    (GET   "/resources/:resource" [resource] static)))

(defn create-handler []
  (fn [request]
    ((->
       (assemble-routes)
       api
       wrap-multipart-params
       (wrap-stateful-session {:store (memory-store my-session)})
       (wrap-convert-suffix-to-accept-header
         {".html" "text/html"
          ".txt" "text/plain"
          ".xhtml" "application/xhtml+xml"
          ".xml" "application/xml"
          ".json" "application/json"}))
      request)))

(defn start [options]
  (jetty/run-jetty
   (fn [request]
     ((create-handler) request))
   (assoc options :join? false)))

(defn -main
  ([port]
     (start {:port (Integer/parseInt port)}))
  ([]
     (-main "8000")))

(ns liberator-service.ui
  (:use hiccup.page
        hiccup.element
        hiccup.form
        sandbar.stateful-session
        [liberator.core :only [defresource]]))

(defresource home
  :available-media-types ["text/html"]
  :available-charsets ["utf-8"]
  :handle-ok (html5 [:head (include-js
                             "http://ajax.googleapis.com/ajax/libs/jquery/1.8.0/jquery.min.js"
                             "/resources/site.js")]
                    [:body
                       [:div#message]
                       [:div#login
                        (text-field "user")
                        (password-field "pass")
                        [:button {:type "button" :onclick "login()"} "login"]]]))

function login() {
	$("#message").text("sending login request");
	$.post("/login", 
	       {user: $("#user").val(), pass: $("#pass").val()}, 
    	       function({window.location.reload(true);},
    	       "json")
         .error( function(xhr, textStatus, errorThrown) {       			 
      			 $("#message").text(textStatus + ": " + xhr.responseText);
   	 });
}

function logout() {
    $.post("/logout", 
           function() {window.location.reload(true);});					  	
}

(ns liberator-service.static-resources  
  (:use [liberator.core :only [defresource]]
        [ring.util.mime-type :only [ext-mime-type]])
  (:require [clojure.java.io :as io]))

(let [static-dir  (io/file "resources/public/")]
  (defresource static
    :available-media-types
    #(let [file (get-in % [:request :route-params :resource])]       
       (if-let [mime-type (ext-mime-type file)]
         [mime-type]
         []))

    :exists?
    #(let [file (get-in % [:request :route-params :resource])]       
       (let [f (io/file static-dir file)]
         [(.exists f) {::file f}]))

    :handle-ok (fn [{{{file :resource} :route-params} :request}]                 
                 (io/file static-dir file)))

    :last-modified (fn [{{{file :resource} :route-params} :request}]                                                               
                     (.lastModified (io/file static-dir file))))

(ns liberator-service.resources
  (:use clojure.data.json                        
        sandbar.stateful-session
        [liberator.core :only [defresource request-method-in]]))

(def users [{:user "foo" 
             :pass "bar"
             :firstname "John"
             :lastname "Doe"}])

(defn valid-user [user]
  (some #(= user (select-keys % [:user :pass])) users))

(defresource login
  :available-media-types ["application/json" "text/javascript"]
  :method-allowed? (request-method-in :post)  
  :authorized?     (fn [{{user :params} :request}]                 
                     (or (session-get :user) (valid-user user)))

  :post! (fn [{{{:keys [user]} :params} :request :as ctx}]
           (session-put! :user user))

  :handle-unauthorized (fn [ctx] (:message ctx))  
  :handle-created      (json-str {:message "login successful"}))

(defresource logout
  :available-media-types ["application/json" "text/javascript"]
  :method-allowed? (request-method-in :post)  
  :post!           (session-delete-key! :user)
  :handle-created  (json-str {:message "logout successful"}))

(ns liberator-service.ui
  (:use hiccup.page
        hiccup.element
        hiccup.form
        sandbar.stateful-session
        liberator-service.resources
        [liberator.core :only [defresource]]))

(defn get-user []
  (first (filter #(= (session-get :user) (get-in % [:user])) users)))

(def login-page 
  [:body
   [:div#message]
   [:div#login
    (text-field "user")
    (password-field "pass")
    [:button {:type "button" :onclick "login()"} "login"]]])

(defn home-page [] 
  [:body
   (let [{firstname :firstname lastname :lastname} (get-user)] 
     [:div#message (str "Welcome " firstname " " lastname)])
   [:div#logout 
    [:button {:type "button" :onclick "logout()"} "logout"]]])

(defresource home
  :available-media-types ["text/html"]
  :available-charsets ["utf-8"]
  :handle-ok (html5 [:head (include-js
                             "http://ajax.googleapis.com/ajax/libs/jquery/1.8.0/jquery.min.js"
                             "/resources/site.js")]
                    (if (session-get :user) (home-page) login-page)))

(defmacro local-redirect [url]
  `(noir.response/redirect 
     (if-let [context# (:context (noir.request/ring-request))]
       (str context# ~url) ~url)))

(defproject my-website "0.1.0-SNAPSHOT"
            :description "my Noir website"
            :dependencies [[org.clojure/clojure "1.4.0"]
                           [noir "1.3.0-beta3"]
                           [org.clojure/java.jdbc "0.2.3"]
                           [postgresql/postgresql "9.1-901.jdbc4"]
                           [joda-time "2.0"]]
            :dev-dependencies [[lein-ring "0.7.3"]]
            :ring {:handler my-website.server/handler

                   ;;initialization function which will be run 
                   ;;once when the servlet is loaded
                   :init my-website.config/init-config}
            :main my-website.server)

(defproject my-website "0.1.0-SNAPSHOT"
            :description "my Noir website"
            :dependencies [[org.clojure/clojure "1.4.0"]
                           [noir "1.3.0-beta3"]
                           [org.clojure/java.jdbc "0.2.3"]
                           [postgresql/postgresql "9.1-901.jdbc4"]
                           [joda-time "2.0"]]

            ;;lein 2
            :plugins [[lein-ring "0.7.5"]]
            ;;lein 1
            :dev-dependencies [[lein-ring "0.7.3"]]

            :ring {:handler my-website.server/handler

                   ;;initialization function which will be run 
                   ;;once when the servlet is loaded
                   :init my-website.config/init-config}
            :main my-website.server)

(ns my-website.config
  (:use clojure.java.io))

(defn init-config [] 
  (println "servlet has been initialized"))

touch my_webapp/resources/site.config

(def config-file "site.config")

(defn load-config-file []
  (let [url (.. 
              (Thread/currentThread) 
              getContextClassLoader 
              (findResource config-file))] 
    (if (or (nil? url) 
            (.. url 
              getPath 
              (endsWith (str "jar!/" config-file))))
      (doto (new java.io.File config-file) 
        (.createNewFile))
      url)))

(def app-config (atom nil))

(defn init-config []
  (with-open
    [r (java.io.PushbackReader. (reader (load-config-file)))]
    (if-let [config (read r nil nil)]
      (reset! app-config config)))
  (println "servlet has been initialized"))

{:log-path "logs/"}

(ns my-website.views.log-stats
  ...
  (:use ... my-website.config))

(defpage [:post "/get-logs"] params  
  (response/json 
    (hits-per-second 
      (read-logs (last-log (:log-path @app-config))))))

(ns my-website.server
  (:use my-website.config)
  ...)

(defn -main [& m]
  (let [mode (keyword (or (first m) :dev))
        port (Integer. (get (System/getenv) "PORT" "8080"))]
    (init-config)
    (server/start port {:mode mode
                        :ns 'my-website})))

chmod +x bin/catalina.sh
bin/catalina.sh start
Using CATALINA_BASE:   apache-tomcat-7.0.29
Using CATALINA_HOME:   apache-tomcat-7.0.29
Using CATALINA_TMPDIR: apache-tomcat-7.0.29/temp
Using JRE_HOME:        /Library/Java/Home
Using CLASSPATH:       apache-tomcat-7.0.29/bin/bootstrap.jar:apache-tomcat-7.0.29/bin/tomcat-juli.jar

(ns my-website.server
  (:require [noir.server :as server]
            [my-website.views 
             common
             files
             log-stats
             users
             welcome])     
  (:gen-class))

(server/load-views-ns 'my-website.views)

(def base-handler 
  (server/gen-handler 
    {:mode :prod, 
     :ns 'my-website 
     :session-cookie-attrs {:max-age 1800000}}))

(defn fix-base-url [handler]
  (fn [request]    
    (with-redefs [noir.options/resolve-url 
                  (fn [url]                    
                    ;prepend context to the relative URLs
                    (if (.contains url "://") 
                      url (str (:context request) url)))]
      (handler request))))

(def handler (-> base-handler fix-base-url))

(defproject my-website "0.1.0-SNAPSHOT"
            :description "my Noir website"
            :dependencies [[org.clojure/clojure "1.4.0"]
                           [noir "1.3.0-beta3"]
                           [org.clojure/java.jdbc "0.2.3"]
                           [postgresql/postgresql "9.1-901.jdbc4"]]
            :dev-dependencies [[lein-ring "0.7.3"]]
            :ring {:handler my-website.server/handler}
            :main my-website.server)

lein deps
Copying 29 files to Noir-tutorial/lib
[INFO] snapshot thneed:thneed:1.0.0-SNAPSHOT: checking for updates from clojars
[INFO] snapshot thneed:thneed:1.0.0-SNAPSHOT: checking for updates from central
Copying 5 files to Noir-tutorial/lib/dev

lein ring uberwar
Compiling my-website.server
Compilation succeeded.
Created Noir-tutorial/my-website-0.1.0-SNAPSHOT-standalone.war

cp my-website-0.1.0-SNAPSHOT-standalone.war ../apache-tomcat-7/webapps/my-website.war

tail -f logs/catalina.out
...
INFO: Deploying web application archive apache-tomcat-7.0.29/webapps/my-website.war

(ns my-website.views.log-stats
  (:require [my-website.views.common :as common]
            [noir.request :as request]
            [noir.response :as response])
  (:use clojure.java.io hiccup.page hiccup.form noir.core)
  (:import java.text.SimpleDateFormat))

(defpage "/access-chart" []
  (common/basic-layout
    (include-js "/js/site.js")
    (hidden-field "context" (:context (request/ring-request)))
    [:div#hits-by-time "loading..."]))

$(document).ready(function(){	
    var context = $('#context').val();
    var url = '/get-logs';
    if (context) url = context + url;
    var options = {xaxis: { mode: "time", 
                            minTickSize: [1, "minute"]}};
	$.post(url, function(data){
	    $.plot($("#hits-by-time"), [data], options);
	    });		
});

(defn gen-log-line [[cur-time]] 
  (let [new-time (doto (new java.util.Date) (.setTime (+ (.getTime cur-time) (rand-int 5000))))
        browsers ["\"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:15.0) Gecko/20100101 Firefox/15.0\""
                  "\"Mozilla/5.0 (Linux; U; Android 2.2; en-gb; LG-P500 Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko)\""
                  "\"Mozilla/5.0 (X11; Linux i686) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11\""]]
    [new-time
     (->>
       (concat
         (interpose "." (take 4 (repeatedly #(rand-int 255))))
         [" - - [" (.format (new java.text.SimpleDateFormat 
                                  "dd/MMM/YYYY:HH:mm:ss ZZZZ") new-time) "]"]
         [" \"GET /files/test.jpg\" " 200 " " (rand-int 4000) " \"http://my-website/files/test.jpg\" " (first (shuffle browsers))])
       (apply str))]))

(defn gen-test-logs [size]
  (->> (gen-log-line [(new java.util.Date)])
    (iterate gen-log-line)
    (take size)
    (map second)
    (interpose "\n")
    (apply str)))

(spit "test-log.txt" (gen-test-logs 500))

120.138.220.117 - - [31/Aug/2012:21:06:47 -0400] "GET /files/test.jpg" 200 3989 "http://my-website/files/test.jpg" "Mozilla/5.0 (Linux; U; Android 2.2; en-gb; LG-P500 Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko)"
201.59.151.159 - - [31/Aug/2012:21:06:49 -0400] "GET /files/test.jpg" 200 1729 "http://my-website/files/test.jpg" "Mozilla/5.0 (Linux; U; Android 2.2; en-gb; LG-P500 Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko)"
122.39.249.88 - - [31/Aug/2012:21:06:51 -0400] "GET /files/test.jpg" 200 1650 "http://my-website/files/test.jpg" "Mozilla/5.0 (Linux; U; Android 2.2; en-gb; LG-P500 Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko)"
...

(defn round-ms-down-to-nearest-sec [date]
  (let [date (.parse 
               (new SimpleDateFormat 
                    "dd/MMM/yyyy:HH:mm:ss zzzzz") 
               date)] 
    ( * 1000 (quot (.getTime date) 1000))))

(defn parse-line [line]
  {:ip (re-find #"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b" line) 
   :access-time (round-ms-down-to-nearest-sec 
                  (second (re-find #"\[(.*?)\]" line))) })

(defn read-logs [file] 
  (with-open [rdr (reader file)] 
    (doall (map parse-line (line-seq rdr)))))

(defn hits-per-second [logs]
  (->> logs 
    (group-by :ip)
    (map #(first (second %)))
    (group-by :access-time)    
    (map (fn [[t hits]] [t (count hits)]))
    (sort-by first)))

(hits-per-second (read-logs "test-log.txt"))
=>([1346460948000 2] [1346460949000 1] [1346460954000 1] ...)

(defpage [:post "/get-logs"] params
  (response/json (hits-per-second (read-logs "test-log.txt"))))

(defpage "/access-chart" []
  (common/basic-layout
    (include-js "/js/site.js")
    [:div#hits-by-time "loading..."]))

#hits-by-time {
        margin: 25px;
	width: 400px;
	height: 400px;
}

(defpartial basic-layout [& content]
  (html5
    [:head
     [:title "my-website"]
     (include-css "/css/reset.css")
     (include-js "http://code.jquery.com/jquery-1.7.2.min.js"
                 "/js/jquery.flot.min.js"
                 "/js/site.js")]
    [:body content]))

$(document).ready(function(){	
    var options = {xaxis: {mode: "time", 
                           minTickSize: [1, "minute"]}};
	$.post('/get-logs', function(data){
	    $.plot($("#hits-by-time"), [data], options);
	    });		
});

(defmacro private-page [path params & content]
  `(noir.core/defpage 
     ~path 
     ~params 
     (if (session/get :user) 
      (do ~@content) 
      (resp/redirect "/"))))

(common/private-page "/upload" {:keys [info]}
  ...)

(common/private-page [:post "/upload"] {:keys [file]}
  ...)

(common/private-page "/files/:name" {:keys [name]} 
  ...)

(defn menu []
  [:div.menu
   [:ul
    [:li (form-to [:post "/logout"] (submit-button "logout"))]    
    [:li (link-to "/upload" "my files")]
    [:li (link-to "/" "home")]]])

(defpartial layout [& content]
  (html5
    [:head
     [:title "my-website"]
     (include-css "/css/reset.css")]
    [:body               
     (if-let [user (session/get :user)]
       [:div
        (menu)
        [:h2 "welcome " user]]
       [:div.login
        (login-form) [:p "or"] (link-to "/signup" "sign up")])     
     content]))

.menu ul {
    list-style: none;
    margin: 0;
    padding-left: 0;
}
.menu li {
    float: right;
    position: relative;
    margin-right: 20px;
}

(ns my-website.views.users
  (:use [noir.core]
        hiccup.core hiccup.form)
  (:require [my-website.views.common :as common]
            [my-website.models.db :as db]
            [noir.util.crypt :as crypt]
            [noir.session :as session]
            [noir.response :as resp]
            [noir.validation :as vali]))

(defn valid? [{:keys [handle pass pass1]}]
  (vali/rule (vali/has-value? handle)
             [:handle "user ID is required"])
  (vali/rule (vali/min-length? pass 5)
             [:pass "password must be at least 5 characters"])  
  (vali/rule (= pass pass1)
             [:pass "entered passwords do not match"])
  (not (vali/errors? :handle :pass :pass1)))

(rule validator [:filed-name "error message"])

(defpartial error-item [[first-error]]
  [:p.error first-error])

(defpage "/signup" {:keys [handle error]}
  (common/layout
    [:div.error error]
    (form-to [:post "/signup"]
             (vali/on-error :handle error-item)
             (label "user-id" "user id")
             (text-field "handle" handle)
             [:br]
             (vali/on-error :pass error-item)
             (label "pass" "password")
             (password-field "pass")             
             [:br]
             (vali/on-error :pass1 error-item)
             (label "pass1" "retype password")
             (password-field "pass1")             
             [:br]
             (submit-button "create account"))))

(defpage [:post "/signup"] user
  (if (valid? user)
    (try 
      (db/add-user (update-in (dissoc user :pass1) [:pass] crypt/encrypt))
      (resp/redirect "/")
      (catch Exception ex
        (render "/signup" (assoc user :error (.getMessage ex)))))
    (render "/signup" user)))

(defpartial basic-layout [& content]
  (html5
    [:head
     [:title "my-website"]
     (include-css "/css/reset.css")]
    [:body content]))

(defpartial layout [& content]  
  (basic-layout 
    [:div
     (if-let [user (session/get :user)]      
       [:div
        (menu)
        [:h2 "welcome " user]]
       [:div
        [:div.login
         (login-form) 
         [:p "or"] 
         (link-to "/signup" "sign up")]])
     content]))

(defpage "/signup" {:keys [handle error]}
  (common/layout
  ...)

(defpage "/signup" {:keys [handle error]}
  (common/basic-layout
  ...)

label {
    margin-left: 10px;
    width:120px; 
    float:left;
}

(defn file-types []
  (map :type (db-read "select distinct type from file")))

(defn select-files-by-type []  
  (let [file-types (db/file-types)] 
    (form-to [:post "/show-files"]
             "select file types to show"
             (into 
               (with-group "file-types")
               (for [type file-types]
                 [:div 
                  type
                 (check-box type)]))
             (submit-button "show files"))))

(common/private-page "/upload" {:keys [info]}
  (common/layout       
    [:h2.info info]
    (select-files-by-type)
    (list-files)
    (form-to {:enctype "multipart/form-data"}
             [:post "/upload"]
             (label :file "File to upload")
             (file-upload :file)
             [:br]
             (submit-button "upload"))))

{"image/png" "true", "image/jpeg" "true"}

(defn list-files [& [types]]  
  (into [:ul]
        (for [name (db/list-files types)]             
          [:li.file-link (link-to (str "/files/" name) name) 
           [:span "  "] 
           [:div.file]])))

(defn params-query [params]
  (apply str (interpose ", " (repeat (count params) "?"))))

(defn list-files [& [types]]
  (map :name 
       (if types
         (apply (partial db-read (str "select name from file where type in (" (params-query types) ")")) types)
         (db-read "select name from file"))))

(common/private-page [:post "/show-files"] params
  (let [file-types (keys params)] 
    (common/layout 
      [:h2 "showing files types " 
       (apply str (interpose ", " file-types))]
      (list-files file-types)
      (link-to "/upload" "back"))))

(defn create-file-table []
  (sql/with-connection 
    db
    (sql/create-table
      :file
      [:type "varchar(50)"]
      [:name "varchar(50)"]
      [:data "bytea"])))

(defn to-byte-array [f]  
  (with-open [input (new java.io.FileInputStream f)
              buffer (new java.io.ByteArrayOutputStream)]
    (clojure.java.io/copy input buffer)
    (.toByteArray buffer)))

(defn store-file [{:keys [tempfile filename content-type]}]
  (sql/with-connection 
    db
    (sql/update-or-insert-values
      :file
      ["name=?" filename]
      {:type content-type 
       :name filename
       :data (to-byte-array tempfile)})))

(defn list-files []
  (map :name (db-read "select name from file")))

(defn get-file [name]
  (first (db-read "select * from file where name=?" name)))

(ns my-website.views.files
  (:use hiccup.util
        noir.core
        hiccup.core
        hiccup.page
        hiccup.form
        hiccup.element)
  (:require [my-website.views.common :as common]
            [my-website.models.db :as db]
            [noir.response :as resp]))

(defpage "/upload" {:keys [info]}
  (common/layout    
    [:h2.info info]
    (form-to {:enctype "multipart/form-data"}
             [:post "/upload"]
             (label :file "File to upload")
             (file-upload :file)
             [:br]
             (submit-button "upload"))))

(defpage [:post "/upload"] {:keys [file]}
  (render "/upload"
    {:info 
      (try
        (db/store-file file) 
        "file uploaded successfully"
        (catch Exception ex
          (do
            (.printStackTrace ex)
            (str "An error has occured while uploading the file: "
              (.getMessage ex)))))}))

{:size 422668, 
 :tempfile #<File /var/folders/0s/1vrmt9wx6lqdjlg1qtgc34600000gn/T/ring-multipart-3157719234459115704.tmp>, 
 :content-type "image/jpeg", 
 :filename "logo.jpg"}

(defn list-files []
  (into [:ul]
        (for [name (db/list-files)]             
          [:li.file-link (link-to (str "/files/" name) name) 
           [:span "  "] 
           [:div.file]])))

(defpage "/upload" {:keys [info]}
  (common/layout    
    [:h2.info info]
    (list-files)
    (form-to {:enctype "multipart/form-data"}
             [:post "/upload"]
             (label :file "File to upload")
             (file-upload :file)
             [:br]
             (submit-button "upload"))))

(defpage "/files/:name" {:keys [name]}
  (let [{:keys [name type data]} (db/get-file name)]
    (resp/content-type type (new java.io.ByteArrayInputStream data))))

[:tag {:attr "value"} content]

;;compute influence of each metaball
(defn influence [{:keys [x y radius]} px py]
  (let [dx (- x px)
        dy (- y py)]
    (/ radius (Math/sqrt (+ (* dx dx) (* dy dy))))))

;;compute the resulting r g b values based on influence
(defn compute-color [x y [red-cur green-cur blue-cur] ball]   
  (let [influence (influence ball x y)
        [r g b] (:color ball)] 
    [(+ red-cur (* influence r))
     (+ green-cur (* influence g))
     (+ blue-cur (* influence b))]))

...
;;reverse direction if we hit the edge of the screen
(defn direction [p v]
  (if (or (> p SIZE) (neg? p)) (- v) v))

;;compute the position and velocity of the ball
(defn move [{:keys [x y vx vy radius color]}]
  (let [vx (direction x vx)
        vy (direction y vy)]
    {:x (+ x vx)
     :y (+ y vy)
     :vx vx
     :vy vy
     :radius radius
     :color color}))

;;for each x,y coordinate compute the color
(reduce (partial compute-color x y) [0 0 0] balls)

;;run this in a loop where we move the 
;;balls around and render them
(loop [balls (take 2 (repeatedly metaball))]      
      (draw canvas balls)
      (recur (map move balls)))

(loop [balls (take 2 (repeatedly metaball))]      
      (time (draw canvas balls))
      (recur (time (map move balls))))

"Elapsed time: 250.345 msecs"
"Elapsed time: 0.004 msecs"
"Elapsed time: 171.136 msecs"
"Elapsed time: 0.005 msecs"
"Elapsed time: 212.646 msecs"
"Elapsed time: 0.004 msecs"

(set! *warn-on-reflection* true)

Reflection warning, metaballs.clj:32 - call to java.awt.Color ctor can't be resolved.
Reflection warning, metaballs.clj:40 - call to setColor can't be resolved.
Reflection warning, metaballs.clj:40 - call to fillRect can't be resolved.
Reflection warning, metaballs.clj:52 - reference to field getBufferStrategy can't be resolved.
Reflection warning, metaballs.clj:53 - reference to field getDrawGraphics can't be resolved.
Reflection warning, metaballs.clj:64 - reference to field dispose can't be resolved.
Reflection warning, metaballs.clj:65 - reference to field contentsLost can't be resolved.
Reflection warning, metaballs.clj:66 - reference to field show can't be resolved.

(defn color-in-range [c]
  (int
    (cond 
      (< c 0) 0
      (> c 255) 255
      :default c)))

(defn color [r g b]
  (new Color (color-in-range r) (color-in-range g) (color-in-range b)))

(defn color [r g b]
  (new Color (int (color-in-range r)) 
             (int (color-in-range g)) 
             (int (color-in-range b))))

(defn paint-square [g color x y size]
  (doto g
    (.setColor color)
    (.fillRect x y size size)))

(defn paint-square [^Graphics g ^Color color x y size]
  (doto g
    (.setColor color)
    (.fillRect x y size size)))

(defn influence [{:keys [x y radius]} px py]
  (let [dx (double (- x px))
        dy (double (- y py))]
    (double (/ radius (Math/sqrt (+ (* dx dx) (* dy dy)))))))

"Elapsed time: 55.424 msecs"
"Elapsed time: 55.399 msecs"
"Elapsed time: 55.373 msecs"
"Elapsed time: 55.482 msecs"

(def db {:subprotocol "postgresql"
         :subname "//localhost/my_website"
         :user "admin"
         :password "admin"})

(def db {:name "jdbc/myDatasource"})

(def db
  {:datasource
    (doto (new PGPoolingDataSource)
     (.setServerName   "localhost")
     (.setDatabaseName "my_website")
     (.setUser         "admin")
     (.setPassword     "admin")
     (.setMaxConnections 10))})

(defproject my-website "0.1.0-SNAPSHOT"
  :description ""my Noir website""
  :dependencies [[org.clojure/clojure "1.4.0"]
                 [noir "1.3.0-beta3"]
                 [org.clojure/java.jdbc "0.2.3"]
                 [postgresql/postgresql "9.1-901.jdbc4"]]
  :main my-website.server)

(ns my-website.models.db
  (:require [clojure.java.jdbc :as sql]))

(def db 
  {:subprotocol "postgresql"
   :subname "//localhost/my_website"
   :user "admin"
   :password "admin"})

(defn init-db []
  (try
  (sql/with-connection
    db
    (sql/create-table
      :users
      [:id "SERIAL"]
      [:handle "varchar(100)"]
      [:pass   "varchar(100)"]))
  (catch Exception ex
    (.getMessage (.getNextException ex)))))

(init-db)

(defn add-user [user]
  (sql/with-connection 
    db
    (sql/insert-record :users user)))

(add-user {:handle "foo" :pass "bar"})
=>{:pass "bar", :handle "foo", :id 1}

(defn db-read [query & args]
  (sql/with-connection 
    db
    (sql/with-query-results 
      res 
      (vec (cons query args)) (doall res))))

(db-read "select * from users")
({:pass "bar", :handle "foo", :id 1})

(db-read "select * from users where id=?" 1)
({:pass "bar", :handle "foo", :id 1})

(defn get-user [handle]
  (first 
    (db-read "select * from users where handle=?" handle)))

(ns my-website.views.users
  (:use [noir.core]
        hiccup.core hiccup.form)
  (:require [my-website.views.common :as common]
            [my-website.models.db :as db]
            [noir.util.crypt :as crypt]
            [noir.session :as session]
            [noir.response :as resp]))

(defpage "/signup" {:keys [handle error]}
  (common/layout
    [:div.error error]
    (form-to [:post "/signup"]
             (label "user-id" "user id")
             (text-field "handle" handle)
             [:br]
             (label "pass" "password")
             (password-field "pass")             
             [:br]
             (submit-button "create account"))))

(defpage [:post "/signup"] user
  (try 
    (db/add-user (update-in user [:pass] crypt/encrypt))
    (resp/redirect "/")
    (catch Exception ex
      (render "/signup" (assoc user :error (.getMessage ex))))))

(ns my-website.views.common
  ...
  (:require [noir.session :as session])

(defpage [:post "/login"] {:keys [handle pass]}
  (render "/" 
          (let [user (db/get-user handle)] 
            (if (and user (crypt/compare pass (:pass user)))
              (session/put! :user handle)
              {:handle handle :error "login failed"}))))

(defpage [:post "/logout"] []
  (session/clear!)
  (resp/redirect "/"))

(ns my-website.views.common
  (:use [noir.core :only [defpartial]]
        hiccup.element 
        hiccup.form
        [hiccup.page :only [include-css html5]])
  (:require [noir.session :as session]))

(defn login-form []
  (form-to [:post "/login"]           
           (text-field {:placeholder "user id"} "handle")                        
           (password-field {:placeholder "password"} "pass")                        
           (submit-button "login")))

(defpartial layout [& content]
            (html5
              [:head
               [:title "my-website"]
               (include-css "/css/reset.css")]
              [:body               
               (if-let [user (session/get :user)]
                  [:h2 "welcome " user 
                    (form-to [:post "/logout"] (submit-button "logout"))]
                  [:div.login
                   (login-form) [:p "or"] (link-to "/signup" "sign up")])

               content]))

lein new noir my-website
cd my-website

/my-website
  project.clj
  --src/
     --my_website/
       server.clj
       --models/
       --views/common.clj
               welcome.clj
  --test/my_website
  --resources/public/
                  --css/reset.css
                  --img/
                  --js/

(defproject my-site "0.1.0-SNAPSHOT"
            :description "FIXME: write this!"
            :dependencies [[org.clojure/clojure "1.4.0"]
                           [noir "1.3.0-beta3"]]
            :main my-site.server)

lein run

Starting server...
2012-08-16 09:39:22.479:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
Server started on port [8080].
You can view the site at http://localhost:8080
#<Server Server@2206270b>
2012-08-16 09:39:22.480:INFO::jetty-6.1.25
2012-08-16 09:39:22.521:INFO::Started SocketConnector@0.0.0.0:8080

(defpartial foo [content]
  [:p content])

(foo "some stuff")
"<p>some stuff</p>"

(defpage url params content)

(defpage "/welcome/:user" {:keys [user]}
  (html [:html [:body "hello " user]]))

(ns my-website.views.welcome
  (:require [my-website.views.common :as common]
            [noir.content.getting-started])
  (:use [noir.core :only [defpage]]
        hiccup.core hiccup.form))

(defpage "/welcome" {:keys [greeting]}
  (common/layout
    (if greeting [:h2 greeting])
    (form-to [:post "/welcome"]
      (label "name" "name")
      (text-field "name")
      (submit-button "submit"))))

(defpage [:post "/welcome"] {:keys [name]}
  (noir.core/render "/welcome" 
    {:greeting (str "Welcome " name)}))

(ns my-website.server
  (:require [noir.server :as server]) 
  (:gen-class))

lein uberjar
java -jar my-website-0.1.0-SNAPSHOT-standalone.jar

Starting server...
2012-08-16 20:12:47.846:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
2012-08-16 20:12:47.846:INFO::jetty-6.1.x
2012-08-16 20:12:47.882:INFO::Started SocketConnector@0.0.0.0:8080
Server started on port [8080].
You can view the site at http://localhost:8080

[{:title "My document"} "some content here..."]

[:paragraph "a fine paragraph"]

[:paragraph
  {:style :bold :size 10 :family :halvetica :color [0 255 221]}
  "Lorem ipsum dolor sit amet, consectetur adipiscing elit."]

[:paragraph
  {:style :bold :size 12 :family :halvetica :color [0 255 221]}
  "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
  [:phrase "some text here"]]

[:paragraph
  {:style :bold :size 12}
  "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
  [:phrase {:style :normal :size 10} "some text here"]]

[:chart {:type :line-chart 
         :title "Line Chart" 
         :x-label "checkpoints" 
         :y-label "units"} 
  ["Foo" [1 10] [2 13] [3 120] [4 455] [5 300] [6 600]]
  ["Bar" [1 13] [2 33] [3 320] [4 155] [5 200] [6 300]]]

(def mysql-db {:subprotocol "postgresql"
               :subname "//127.0.0.1:3306/clojure_test"
               :user "clojure_test"
               :password "clojure_test"})

(def my-db {:name "jdbc/myDatasource"})

(def db 
  {:datasource 
    (doto (new PGPoolingDataSource)
       (.setServerName   (:host blog-config))
       (.setDatabaseName (:schema blog-config))
       (.setUser         (:user blog-config))
       (.setPassword     (:pass blog-config))
       (.setMaxConnections 10))})

(defn gen-captcha []
  (let [text (gen-captcha-text)
        captcha (doto (new Captcha))]
    (session/put! :captcha 
                  {:text text 
                   :image (.gen captcha text 250 40)})))

(defpage "/captcha" []
  (gen-captcha)
  (resp/content-type 
    "image/jpeg" 
    (let [out (new ByteArrayOutputStream)]
      (ImageIO/write (:image (session/get :captcha)) "jpeg" out)
      (new ByteArrayInputStream (.toByteArray out)))))

lein ring uberwar

web: lein trampoline run -m yuggoth.server

(ns clojure-test.core)

(defn -main
  "I don't do a whole lot."
  [& args]
  (println "Hello, World!"))

(-main)

(defproject clojure-test "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.3.0"]])

[clj-http "0.5.2"]

:dependencies [[org.clojure/clojure "1.3.0"]
               [clj-http "0.5.2"]]

(ns clojure-test.core
 (:require [clj-http.client :as client]))

(client/get "http://google.com")

{:tag :tag-name :attrs attrs-map :content [content]}

(with-out-str 
  (clojure.xml/emit 
    {:tag :channel :attrs nil :content []}))

<?xml version='1.0' encoding='UTF-8'?>
<channel>
</channel>

(defn format-time [time] 
  (.format (new java.text.SimpleDateFormat 
                "EEE, dd MMM yyyy HH:mm:ss ZZZZ") time))

(defmacro tag [id attrs & content]
  `{:tag ~id :attrs ~attrs :content [~@content]})

(tag :foo nil "foo" "bar" "baz")
{:tag :foo, :attrs nil, :content ["foo" "bar" "baz"]}

(defn item [site author {:keys [id title content time]}]
  (let [link (str site "/" id )] 
    (tag :item nil
         (tag :guid nil link)
         (tag :title nil title)
         (tag :dc:creator nil author)
         (tag :description nil content)
         (tag :link nil link)
         (tag :pubDate nil (format-time time))
         (tag :category nil "clojure"))))

(item "http://yogthos.net"
      "Yogthos" 
      {:id 1 
       :title "Test post" 
       :content "Some content" 
       :time (new Date)})

{:content
 [{:content ["http://yogthos.net/1"], :attrs nil, :tag :guid}
  {:content ["Test post"], :attrs nil, :tag :title}
  {:content ["Yogthos"], :attrs nil, :tag :dc:creator}
  {:content ["Some content"], :attrs nil, :tag :description}
  {:content ["http://yogthos.net/1"], :attrs nil, :tag :link}
  {:content ["Sat, 04 Aug 2012 18:16:03 -0400"],
   :attrs nil,
   :tag :pubDate}
  {:content ["clojure"], :attrs nil, :tag :category}],
 :attrs nil,
 :tag :item}

(defn message [site title author posts]
  (let [date (format-time (new Date))] 
    (tag :rss {:version "2.0"
               :xmlns:dc "http://purl.org/dc/elements/1.1/"
               :xmlns:sy "http://purl.org/rss/1.0/modules/syndication/"}
         (update-in 
           (tag :channel nil
                (tag :title nil (:title (first posts)))
                (tag :description nil title)
                (tag :link nil site)
                (tag :lastBuildDate nil date)
                (tag :dc:creator nil author)
                (tag :language nil "en-US")
                (tag :sy:updatePeriod nil "hourly")
                (tag :sy:updateFrequency nil "1"))
           [:content]
           into (map (partial item site author) posts)))))

(message "http://yogthos.net" "My blog" "Yogthos" 
         [{:id 1 
           :title "Test post" 
           :content "Some content" 
           :time (new Date)}])

{:content
 [{:content
   [{:content ["Test post"], :attrs nil, :tag :title}
    {:content ["My blog"], :attrs nil, :tag :description}
    {:content ["http://yogthos.net"], :attrs nil, :tag :link}
    {:content ["Sat, 04 Aug 2012 18:23:06 -0400"],
     :attrs nil,
     :tag :lastBuildDate}
    {:content ["Yogthos"], :attrs nil, :tag :dc:creator}
    {:content ["en-US"], :attrs nil, :tag :language}
    {:content ["hourly"], :attrs nil, :tag :sy:updatePeriod}
    {:content ["1"], :attrs nil, :tag :sy:updateFrequency}
    {:content
     [{:content ["http://yogthos.net/blog/1"], :attrs nil, :tag :guid}
      {:content ["Test post"], :attrs nil, :tag :title}
      {:content ["Yogthos"], :attrs nil, :tag :dc:creator}
      {:content ["Some content"], :attrs nil, :tag :description}
      {:content ["http://yogthos.net/blog/1"], :attrs nil, :tag :link}
      {:content ["Sat, 04 Aug 2012 18:23:06 -0400"],
       :attrs nil,
       :tag :pubDate}
      {:content ["clojure"], :attrs nil, :tag :category}],
     :attrs nil,
     :tag :item}],
   :attrs nil,
   :tag :channel}],
 :attrs
 {:version "2.0",
  :xmlns:dc "http://purl.org/dc/elements/1.1/",
  :xmlns:sy "http://purl.org/rss/1.0/modules/syndication/"},
 :tag :rss}

(defn rss-feed [site title author posts]
  (with-out-str (emit (message site title author posts))))

(defn fix-base-url [handler]
  (fn [request]
    (with-redefs [noir.options/resolve-url 
                  (fn [url] 
                    ;prepend context to the relative URLs
                    (if (.contains url "://")
                      url (str (:context request) url)))]
      (handler request))))

(defmacro private-page [path params & content]
  `(noir.core/defpage 
     ~path 
     ~params 
     (if (session/get :admin) 
       (do ~@content) (resp/redirect "/"))))

(ns yuggoth.server
  (:require 
   ...
   [yuggoth.views archives auth blog comments common profile rss upload])
   (:gen-class))

(server/load-views-ns 'yuggoth.views)

:ring {:handler yuggoth.server/handler}

lein ring uberwar

(ns foo)

(defn get-data []
  ;gets some data from a db
  )

(ns bar
 (:require foo))

(defn display-results []
  (apply str (interpose ", " (foo/get-data))))

(ns tests
  (:use clojure.test)
  (:require foo bar))

(deftest display-results-test
  (with-redefs [foo/get-data (fn[] ["Doe", "John"])]
    (is (= "Doe, John" (bar/display-results)))))

(def cache (atom {}))

(defpage "/blog/:postid" {:keys [id]}
  (let [last-updated (:time (get @cache id))
        cur-time     (.getTime (new java.util.Date))]

    (if (or (nil? last-updated)
            (> (- cur-time last-updated) 10000))
      (swap! cache assoc id {:time cur-time 
                             :content (entry (db/get-post id))}))
    (:content (get @cache id)))

(defn foo [] (println "foo was called"))

(defn bar [f])

(bar (foo))

=>foo was called

(defmacro bar [f])
(bar (foo))
=>

(defmacro bar [f] f)
(bar (foo))
=>foo was called

(macroexpand '(bar (foo)))
=>(foo)

(defmacro cache [id content]
  `(let [last-updated# (:time (get @cached ~id))
         cur-time#     (.getTime (new java.util.Date))]

      (if (or (nil? last-updated#)
              (> (- cur-time# last-updated#) 10000))
        (swap! cached assoc ~id {:time cur-time#
                                 :content ~content}))
      (:content (get @cached ~id))))

(pprint (macroexpand '(cache postid (entry (get-post postid)))))

(let*
 [last-updated__1294__auto__
  (:time (clojure.core/get @agents/cached postid))
  cur-time__1295__auto__
  (.getTime (new java.util.Date))]
 (if
  (clojure.core/or
   (clojure.core/nil? last-updated__1294__auto__)
   (clojure.core/>
    (clojure.core/- cur-time__1295__auto__ last-updated__1294__auto__)
    10000))
  (clojure.core/swap!
   agents/cached
   clojure.core/assoc
   postid
   {:content (entry (get-post postid)), :time cur-time__1295__auto__}))
 (:content (clojure.core/get @agents/cached postid)))

(defpage "/blog/:postid" {:keys [postid]}
  (cache postid (entry (db/get-post postid))))

(loop [count 0
         [head & tail] items]
    (if tail
      (recur (+ count head) tail)
      (+ count head)))

(reduce + items)

    ((fn [x] (* 2 x)) 5)
    10

    (def times-2 (fn [x] (* 2 x)))

    (times-2 5)
    10

    (map times-2 '(1 2 3 4))
    (2 4 6 8)

    (defn foo [x]
      (fn [y] (* x y)))

    ((foo 2) 5)
    10

    public static void foo(String bar, Integer baz) {
        System.out.println(bar + ", " + baz);
    }

    (defn foo [bar baz] 
      (println bar ", " baz))

street: 1 Main street
city: Toronto
posal: A1B 2C3
country: Canada
1 Main street, Toronto, A1B 2C3, Canada
    public static String concat(String... strings) {
        if (null == strings) return null;
        StringBuffer sb = new StringBuffer();
        for (String s : strings) {
            if (null == s || s.equals("")) continue;
            sb.append(s);
            sb.append(',');
        }
        String s =  sb.toString();
        return s.substring(0, s.lastIndexOf(','));
    }

    (defn concat-fields [& fields]
      (apply str (interpose "," (remove empty? fields))))

    (let 
      ((a1 b1) 
       (a2 b2) 
       (an bn))
      (some-code a1 a2 an))

    (let [a1 b1
          a2 b2
          an bn]
      (some-code a1 a2 an))

    (def {:a [1 2 3] :b {:c 4} :d 5})

    (defn foo [{a :a b :b}]
      (println a b))

    (defn bar [{:keys [a b d]]
      (println a b d))

    (defn baz [{[a b c] :a {d :c} :b e :d}]
      (println a b c))

public static List<Integer> filterEven(Collection<Integer> col) {
    if (null == col) return null;
    List<Integer> result = new LinkedList<Integer>();
    for (Integer i  : col) {			
        if (i % 2 == 0) result.add(i);			
     }		
     return result;
}

public interface Predicate<T> {
    public boolean matches(T t);
}

public class EvenPredicate implements Predicate<Integer> {

    public boolean matches(Integer i) {
 	return i % 2 == 0; 
    }			
}

import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

public class Filter {

    public static <T> List<T> filterCollection(Collection<T> col, 
                                          Predicate<T> predicate) {
        List<T> result = new LinkedList<T>();
	    for (T t : col) {			
                    if (predicate.matches(t)) {
                        result.add(t);
                    }
            }		
            return result;
    }
}

(filter even? (range 10))

(loop [nums (range 10)
       even-nums []]
    (if (empty? nums)
        even-nums
        (recur (rest nums) 
                  (if (even? (first nums)) 
                     (conj even-nums (first nums)) even-nums))))

    users.getUser("foo").getAddress().getStreet();

    String street = null;
    User user = users.getUser("foo");
    if (null != user)
       Address address = user.getAddress();
       if (null != address)
           street = address.getStreet();

    (:street (:address (:foo users)))

(f result input) -> new-result
(xf reducing-fn) -> reducing-fn
(defn mapping [f]
  (fn [f1]
    (fn [result input]
      (f1 result (f input)))))

(defn filtering [pred]
  (fn [f1]
    (fn [result input]
      (if (pred input)
        (f1 result input)
        result))))

(defn mapcatting [f]
  (fn [f1]
    (fn [result input]
      (reduce f1 result (f input)))))
(reduce + 0 (map inc [1 2 3 4]))
;;becomes
(reduce ((mapping inc) +) 0 [1 2 3 4])
(defn reducer
  ([coll xf]
   (reify
    clojure.core.protocols/CollReduce
    (coll-reduce [_ f1 init]
      (clojure.core.protocols/coll-reduce coll (xf f1) init)))))
(reduce + 0 (map inc [1 2 3 4]))
;;becomes
(reduce + 0 (reducer [1 2 3 4] (mapping inc)))
(defn rmap [f coll]
  (reducer coll (mapping f)))

(defn rfilter [pred coll]
  (reducer coll (filtering pred)))

(defn rmapcat [f coll]
  (reducer coll (mapcatting f)))

(reduce + 0 (rmap inc [1 2 3 4]))
;=> 14

(reduce + 0 (rfilter even? [1 2 3 4]))
;=> 6

(reduce + 0 (rmapcat range [1 2 3 4 5]))
;=> 20
(defn folder
  ([coll xf]
     (reify
      ;;extend CollReduce as before

      CollFold
      (coll-fold [_ n combinef reducef]
        (coll-fold coll n combinef (xf reducef))))))
(defn rmap [f coll]
  (folder coll (mapping f)))

(defn rfilter [pred coll]
  (folder coll (filtering pred)))

(defn rmapcat [f coll]
  (folder coll (mapcatting f)))
(reduce + (r/map inc [1 2 3])) === (reduce (fn [ret x] (+ ret (inc x))) (+) [1 2 3])
(fn [f1]
  (fn [ret v]
    (f1 ret (f v))))
(require '[clojure.core.reducers :as r])
(reduce + (r/filter even? (r/map inc [1 1 1 2])))
;=> 6
;;red is a reducer awaiting a collection
(def red (comp (r/filter even?) (r/map inc)))
(reduce + (red [1 1 1 2]))
;=> 6
(into [] (r/filter even? (r/map inc [1 1 1 2])))
;=> [2 2 2]
(into #{} (r/filter even? (r/map inc [1 1 1 2])))
;=> #{2}
(r/fold + [1 2 3 4])
;=> 10

operación	haskell	python	python opt
primo 90000	310ms	1450ms	860ms
es primo \(2^{31}-1\)	20ms	10ms	3ms
index 1159531	240ms	N/A	820ms

FASE	Herramientas	Otras
PLAN	Jira, Trello, Gitkraken Boards, GitKraken Timelines.	BaseCamp, MantisBT.
CODE	Hosting: GitHub, Bitbucket, GitLab y Azure DevOps. Git / SCM: GitKraken Git GUI, CLI, GitHub Desktop, Sourcetree. IDE: VS Code, IntelliJ, Visual Studio, Sublime Text.	Eclipse
BUILD	Jenkins, Maven Visual Studio, Gradle
TEST	JUnit, Selenium, Jest, PHPUnit.	Cypress, Postman, Swagger.
RELEASE	Ansible, Azure DevOps, Chef, Jenkins, AWS Codebuild.	Puppet, Circle CI.
DEPLOY	Jenkins,Azure DevOps, AWS Codebuild, GitLab.
OPERATE	Kubernetes, Docker, AWS
MONITOR	Google Analytics, Grafana, Azure Monitor, AWS CloudWatch	Datadog, New Relic

If we call it thus …	The parameters’ values are …
`(foo a)`	`x=a`, `y=nil`, `cxt=null`
`(foo (+ a 1) (- y 1))`	`x=(+ a 1)`, `y=(- y 1)`, `cxt=null`
`(foo a b :cxt (zap zip))`	`x=a`, `y=b`, `cxt=(zap zip)`

? Winners	? Losers
Python / Adobe	AMP
Infraestructura Cloud	Regulación de acceso a internet y privacidad
HTTP3 / Microservicios	MySQL / Chrome

? Héroes del 2019	? Villanos
Guido Van Rossum	Project Manager de Safari
Quincy Larson	Mark Zuckerberg
Fernando Acero y Rasmus Lerdorf	Project Managers de IE6/Edge

route	description	method	content type
/	index page with an html message	GET	text/html
/ping	respond a pong message	GET	text/plain
/users	respond with a list of users in json	GET	application/json
/users	allow to create a new user	POST	application/json

Mutable	Inmutable
`L.append(item)`	`L+[item]`
`L.extend(sequence)`	`L + list(sequence)`
`L.insert(index, item)`	`L[:index] + [item] + L[index:]`
`L.reverse()`	`L[::-1]`
`L.sort()`	`sorted(L)`
`item = L.pop()`	`item,L = L[-1],L[:-1]`
`item = L.pop(0)`	`item,L = L[0],L[1:]`
`item = L.pop(index)`	`item, L = L[item], L[:item]+L[item+1:]`
`L.remove(item)`	`L=L[:item]+L[item+1:]`
`L[i:j] = K`	`L[:i] + K + L[j:]`

	#	Name	Type 1	Type 2	Total	HP	Attack	Defense	Sp. Atk	Sp. Def	Speed	Generation	Legendary
0	1	Bulbasaur	Grass	Poison	318	45	49	49	65	65	45	1	False
1	2	Ivysaur	Grass	Poison	405	60	62	63	80	80	60	1	False
2	3	Venusaur	Grass	Poison	525	80	82	83	100	100	80	1	False
3	3	VenusaurMega Venusaur	Grass	Poison	625	80	100	123	122	120	80	1	False
4	4	Charmander	Fire	NaN	309	39	52	43	60	50	65	1	False

	dt	AverageTemperature	AverageTemperatureUncertainty	Country
0	1743-11-01	4.384	2.294	Åland
1	1743-12-01	NaN	NaN	Åland
2	1744-01-01	NaN	NaN	Åland
3	1744-02-01	NaN	NaN	Åland
4	1744-03-01	NaN	NaN	Åland

	dt	AverageTemperature	AverageTemperatureUncertainty	Country
562339	1824-01-01	24.613	0.824	Venezuela
562340	1824-02-01	24.670	2.017	Venezuela
562341	1824-03-01	25.527	1.065	Venezuela
562342	1824-04-01	25.732	1.771	Venezuela
562343	1824-05-01	24.999	1.157	Venezuela

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2086.0	25.025686	0.703189	22.777	24.52325	24.9825	25.49525	27.807
AverageTemperatureUncertainty	2086.0	0.586000	0.398460	0.084	0.31000	0.4540	0.76000	4.120

	AverageTemperature	AverageTemperatureUncertainty
AverageTemperature	1.000000	-0.319882
AverageTemperatureUncertainty	-0.319882	1.000000

	dt	AverageTemperature	AverageTemperatureUncertainty	Country
25466	1855-05-01	10.745	1.499	Argentina
25467	1855-06-01	6.995	2.073	Argentina
25468	1855-07-01	6.901	1.568	Argentina
25469	1855-08-01	9.097	1.412	Argentina
25470	1855-09-01	11.316	1.384	Argentina

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	1900.0	14.621194	4.846885	4.796	10.13225	14.6305	19.27875	23.290
AverageTemperatureUncertainty	1900.0	0.527338	0.465652	0.083	0.20900	0.3035	0.74525	2.974

	dt	AverageTemperature	AverageTemperatureUncertainty	Country
77110	1832-01-01	24.935	1.372	Brazil
77111	1832-02-01	24.505	1.953	Brazil
77112	1832-03-01	24.617	1.359	Brazil
77113	1832-04-01	23.990	2.013	Brazil
77114	1832-05-01	23.124	1.592	Brazil

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2164.0	24.699256	0.978787	21.797	24.02250	24.8295	25.44975	27.151
AverageTemperatureUncertainty	2164.0	0.572940	0.411794	0.060	0.24375	0.4160	0.84000	3.353

	dt	AverageTemperature	AverageTemperatureUncertainty	Country
108248	1855-05-01	7.152	1.296	Chile
108249	1855-06-01	4.257	1.641	Chile
108250	1855-07-01	4.113	1.313	Chile
108251	1855-08-01	5.508	1.168	Chile
108252	1855-09-01	6.684	1.153	Chile

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	1900.0	9.383474	3.179081	3.206	6.502	9.3815	12.37775	15.493
AverageTemperatureUncertainty	1900.0	0.572654	0.418011	0.114	0.281	0.3825	0.80300	2.408

	dt	AverageTemperature	AverageTemperatureUncertainty	Country
338438	1835-01-01	15.810	1.484	Mexico
338439	1835-02-01	14.911	1.579	Mexico
338440	1835-03-01	16.826	1.858	Mexico
338441	1835-04-01	19.925	1.966	Mexico
338442	1835-05-01	22.037	1.609	Mexico

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2145.0	20.567558	3.753343	12.064	17.109	21.050	24.164	26.926
AverageTemperatureUncertainty	2145.0	0.638233	0.547605	0.091	0.226	0.398	0.970	3.699

	dt	AverageTemperature	AverageTemperatureUncertainty	Country
97255	1768-09-01	5.257	3.107	Canada
97256	1768-10-01	-3.393	2.981	Canada
97257	1768-11-01	-12.829	3.967	Canada
97258	1768-12-01	-20.582	4.622	Canada
97259	1769-01-01	-24.756	4.722	Canada

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2504.0	-5.216659	12.878074	-28.736	-17.7025	-4.7285	7.41275	14.796
AverageTemperatureUncertainty	2504.0	1.256211	1.046127	0.123	0.2870	0.8980	2.12025	5.275

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
1824	24.896545	1.516091	-0.420966
1825	25.071583	1.552083	-0.245928
1826	24.871900	1.440800	-0.445611
1827	25.156273	1.474182	-0.161238
1828	24.751818	1.516727	-0.565693

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
2009	26.084917	0.353917	0.767406
2010	26.150250	0.341333	0.832739
2011	25.677333	0.336750	0.359822
2012	25.688583	0.401417	0.371072
2013	25.912875	0.484500	0.595364

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
1855	11.729250	1.711875	-3.090742
1856	13.998750	1.553167	-0.821242
1857	14.221083	1.993417	-0.598908
1858	14.015667	1.770750	-0.804325
1859	14.414583	1.635583	-0.405408

Software Engineering Manager (Clojure Team)

tl;dr

What we're looking for

What you will do

What we expect

Our architecture

What we're offering

Tell me about the company

Tell me about the culture

How do I apply?

Highlights

In the core

Podcasts and videos

Blogs, discussions, tutorials

Training and hiring

Libraries and tools

Comisiones

Tabla de precios disponibles

Otras comisiones

Conclusión

Más información

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
2009	15.534417	0.215750	0.714425
2010	15.078833	0.218917	0.258842
2011	15.339667	0.219833	0.519675
2012	15.689000	0.265750	0.869008
2013	14.457125	0.276500	-0.362867

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
1832	23.858583	1.734500	-1.072247
1833	24.517833	1.450083	-0.412997
1834	24.346750	1.498083	-0.584081
1835	23.537500	1.298583	-1.393331
1836	23.921167	1.426083	-1.009664

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
2009	25.600583	0.185667	0.669753
2010	25.812417	0.158000	0.881586
2011	25.428917	0.204833	0.498086
2012	25.717083	0.231000	0.786253
2013	25.348125	0.262250	0.417294

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
1855	7.070125	1.424125	-2.510742
1856	8.664083	1.319250	-0.916783
1857	8.645917	1.439250	-0.934950
1858	8.810250	1.428333	-0.770617
1859	9.245583	1.376917	-0.335283

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
2009	9.994417	0.281917	0.413550
2010	9.712833	0.340000	0.131967
2011	10.032250	0.322250	0.451383
2012	10.272583	0.384583	0.691717
2013	9.877375	0.393875	0.296508

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
1835	18.993250	1.684083	-1.745911
1836	19.587167	1.695333	-1.151994
1837	19.671083	1.647667	-1.068078
1838	19.337000	1.862417	-1.402161
1839	19.785833	1.603000	-0.953328

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
2009	21.546083	0.205917	0.806922
2010	20.852917	0.217750	0.113756
2011	21.599333	0.245333	0.860172
2012	21.652417	0.324500	0.913256
2013	22.219222	0.365111	1.480061

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
1768	-7.886750	3.66925	-2.969253
1769	-3.427875	3.50550	1.489622
1770	NaN	NaN	NaN
1771	NaN	NaN	NaN
1772	NaN	NaN	NaN

	AverageTemperature	AverageTemperatureUncertainty	Anomaly
dt
2009	-4.135083	0.231833	0.782414
2010	-1.887917	0.218583	3.029581
2011	-3.557083	0.232583	1.360414
2012	-3.176833	0.300083	1.740664
2013	-1.640667	0.533667	3.276831

	LandAndOceanAverageTemperature	Anomaly	Carbon Dioxide (ppm)
LandAndOceanAverageTemperature	1.000000	1.000000	0.923603
Anomaly	1.000000	1.000000	0.923603
Carbon Dioxide (ppm)	0.923603	0.923603	1.000000