% Options for packages loaded elsewhere
\PassOptionsToPackage{unicode}{hyperref}
\PassOptionsToPackage{hyphens}{url}
\PassOptionsToPackage{dvipsnames,svgnames*,x11names*}{xcolor}
%
\documentclass[
  12pt,
  spanish,
]{article}
\usepackage{lmodern}
\usepackage{amssymb,amsmath}
\usepackage{ifxetex,ifluatex}
\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
  \usepackage[T1]{fontenc}
  \usepackage[utf8]{inputenc}
  \usepackage{textcomp} % provide euro and other symbols
\else % if luatex or xetex
  \usepackage{unicode-math}
  \defaultfontfeatures{Scale=MatchLowercase}
  \defaultfontfeatures[\rmfamily]{Ligatures=TeX,Scale=1}
  \setmainfont[]{Ubuntu}
  \setmonofont[]{Ubuntu Mono}
\fi
% Use upquote if available, for straight quotes in verbatim environments
\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
\IfFileExists{microtype.sty}{% use microtype if available
  \usepackage[]{microtype}
  \UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
}{}
\makeatletter
\@ifundefined{KOMAClassName}{% if non-KOMA class
  \IfFileExists{parskip.sty}{%
    \usepackage{parskip}
  }{% else
    \setlength{\parindent}{0pt}
    \setlength{\parskip}{6pt plus 2pt minus 1pt}}
}{% if KOMA class
  \KOMAoptions{parskip=half}}
\makeatother
\usepackage{xcolor}
\IfFileExists{xurl.sty}{\usepackage{xurl}}{} % add URL line breaks if available
\IfFileExists{bookmark.sty}{\usepackage{bookmark}}{\usepackage{hyperref}}
\hypersetup{
  pdftitle={Bitácora Linux Mint Ulyana 20},
  pdfauthor={Sergio Alvariño salvari@gmail.com},
  pdflang={es-ES},
  colorlinks=true,
  linkcolor=Maroon,
  filecolor=Maroon,
  citecolor=Blue,
  urlcolor=Blue,
  pdfcreator={LaTeX via pandoc}}
\urlstyle{same} % disable monospaced font for URLs
\usepackage[a4paper]{geometry}
\usepackage{longtable,booktabs}
% Correct order of tables after \paragraph or \subparagraph
\usepackage{etoolbox}
\makeatletter
\patchcmd\longtable{\par}{\if@noskipsec\mbox{}\fi\par}{}{}
\makeatother
% Allow footnotes in longtable head/foot
\IfFileExists{footnotehyper.sty}{\usepackage{footnotehyper}}{\usepackage{footnote}}
\makesavenoteenv{longtable}
\setlength{\emergencystretch}{3em} % prevent overfull lines
\providecommand{\tightlist}{%
  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
\setcounter{secnumdepth}{5}
\ifxetex
  % Load polyglossia as late as possible: uses bidi with RTL langages (e.g. Hebrew, Arabic)
  \usepackage{polyglossia}
  \setmainlanguage[]{spanish}
\else
  \usepackage[shorthands=off,main=spanish]{babel}
\fi

\title{Bitácora Linux Mint Ulyana 20}
\author{Sergio Alvariño
\href{mailto:salvari@gmail.com}{\nolinkurl{salvari@gmail.com}}}
\date{junio-2020}

\begin{document}
\maketitle
\begin{abstract}
Bitácora de mi portatil

Solo para referencia rápida y personal.
\end{abstract}

{
\hypersetup{linkcolor=}
\setcounter{tocdepth}{3}
\tableofcontents
}
\hypertarget{introducciuxf3n}{%
\section{Introducción}\label{introducciuxf3n}}

Mi portátil es un ordenador Acer 5755G con las siguientes
características:

\begin{itemize}
\item
  Core i5 2430M 2.4GHz
\item
  NVIDIA Geforce GT 540M
\item
  8Gb RAM
\item
  750Gb HD
\end{itemize}

Mi portátil equipa una tarjeta \emph{Nvidia Geforce GT540M} que resulta
pertenecer a una rama muerta en el árbol de desarrollo de Nvidia.

Esta tarjeta provocaba todo tipo de problemas de sobrecalientamiento,
pero en las últimas versiones de Linux instalando el driver de Nvidia
parece funcionar correctamente.

\hypertarget{programas-buxe1sicos}{%
\section{Programas básicos}\label{programas-buxe1sicos}}

\hypertarget{linux-mint}{%
\subsection{Linux Mint}\label{linux-mint}}

Linux Mint incluye \texttt{sudo} \footnote{ya no incluye gksu pero
  tampoco es imprescindible} y las aplicaciones que uso habitualmente
para gestión de paquetes por defecto (\emph{aptitude} y
\emph{synaptic}).

Tampoco voy a enredar nada con los orígenes del software (de momento)

\hypertarget{firmware}{%
\subsection{Firmware}\label{firmware}}

Ya no es necesario intalar los paquetes de \emph{microcode} la
instalación de Tricia se encargó de instalar:

\begin{itemize}
\tightlist
\item
  \texttt{amd64-microcode}
\item
  \texttt{intel-microcode}
\end{itemize}

Instalamos el driver de nvidia recomendado, el \emph{Mint} nos avisa de
que tenemos que revisar la instalación de los drivers.

El driver de Nvidia viene muy mejorado. Merece la pena ver todas las
opciones.

Una vez instalado el driver de nvidia, el comando
\texttt{prime-select\ query}debe indicarnos la tarjeta activa y podremos
cambiar de tarjeta ejecutando
\texttt{prime-select\ {[}nvidia\textbar{}intel{]}}

\hypertarget{control-de-configuraciones-con-git}{%
\subsection{Control de configuraciones con
git}\label{control-de-configuraciones-con-git}}

Una vez instalado el driver de nvidia y antes de seguir con la
instalación instalamos el \texttt{git} y el \texttt{etckeeper} para que
toda nuestra instalación quede reflejada en los repos.

\hypertarget{instalaciuxf3n-de-etckeeper}{%
\subsubsection{\texorpdfstring{Instalación de
\texttt{etckeeper}}{Instalación de etckeeper}}\label{instalaciuxf3n-de-etckeeper}}

¡Ojo!, nos hacemos \texttt{root} para ejecutar:

\begin{verbatim}
sudo su -
git config --global user.email xxxxx@whatever.com
git config --global user.name "Name Surname"
apt install etckeeper
\end{verbatim}

\emph{etckeeper} hara un control automático de tus ficheros de
configuración en \texttt{/etc}

Para echar una mirada a los \emph{commits} creados puedes ejecutar:

\begin{verbatim}
cd /etc
sudo git log
\end{verbatim}

\hypertarget{controlar-dotfiles-con-git}{%
\subsubsection{Controlar dotfiles con
git}\label{controlar-dotfiles-con-git}}

Vamos a crear un repo de git para controlar nuestros ficheros personales
de configuración.

Creamos el repo donde queramos

\begin{verbatim}
mkdir usrcfg
cd usrcfg
git init
git config core.worktree "/home/salvari"
\end{verbatim}

Y ya lo tenemos, un repo que tiene el directorio de trabajo apuntando a
nuestro \emph{\$HOME}.

Podemos añadir los ficheros de configuración que queramos al repo:

\begin{verbatim}
git add .bashrc
git commit -m "Add some dotfiles"
\end{verbatim}

Una vez que tenga añadidos los ficheros que quiero tener controlados
pondré \texttt{*} en el fichero \texttt{.git/info/exclude} de mi repo
para que ignore todos los ficheros de mi \texttt{\$HOME}.

Cuando instalo algún programa nuevo añado a mano los ficheros de
configuración al repo.

\hypertarget{paruxe1metros-de-disco-duro}{%
\subsection{Parámetros de disco
duro}\label{paruxe1metros-de-disco-duro}}

Tengo un disco duro ssd y otro hdd normal.

El area de intercambio la hemos creado en el disco duro hdd, no se usará
mucho pero evitamos multiples operaciones de escritura en el disco ssd
en caso de que se empiece a tirar del swap.

Añadimos el parámetro \texttt{noatime} para las particiones de
\texttt{root} y \texttt{/home}, que si que se han creado en el ssd.

\begin{verbatim}
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
# / was on /dev/sda5 during installation
UUID=d96a5501-75b9-4a25-8ecb-c84cd4a3fff5 /               ext4    noatime,errors=remount-ro 0       1
# /home was on /dev/sda7 during installation
UUID=8fcde9c5-d694-4417-adc0-8dc229299f4c /home           ext4    defaults,noatime        0       2
# /store was on /dev/sdc7 during installation
UUID=0f0892e0-9183-48bd-aab4-9014dc1bd03a /store          ext4    defaults        0       2
# swap was on /dev/sda6 during installation
UUID=ce11ccb0-a67d-4e8b-9456-f49a52974160 none            swap    sw              0       0
# swap was on /dev/sdc5 during installation
UUID=11090d84-ce98-40e2-b7be-dce3f841d7b4 none            swap    sw              0       0
\end{verbatim}

Una vez modificado el \texttt{/etc/fstab} no hace falta arrancar, basta
con ejecutar lo siguiente:

\begin{verbatim}
mount -o remount /
mount -o remount /home
mount
\end{verbatim}

\hypertarget{ajustar-firefox}{%
\subsubsection{\texorpdfstring{Ajustar
\emph{Firefox}}{Ajustar Firefox}}\label{ajustar-firefox}}

Seguimos
\href{https://easylinuxtipsproject.blogspot.com/p/ssd.html\#ID10}{esta
referencia}

Visitamos \texttt{about::config} con el navegador.

Cambiamos

\begin{itemize}
\tightlist
\item
  \texttt{browser.cache.disk.enable} \textbf{false}
\item
  \texttt{browser.cache.memory.enable} \textbf{true}
\item
  \texttt{browser.cache.memory.capacity} \textbf{204800}
\item
  \texttt{browser.sessionstore.interval} \textbf{15000000}
\end{itemize}

TODO: Comprobar \emph{trim} en mi disco duro. Y mirar
\href{https://easylinuxtipsproject.blogspot.com/p/speed-mint.html}{esto}

\hypertarget{fuentes-adicionales}{%
\subsection{Fuentes adicionales}\label{fuentes-adicionales}}

Instalamos algunas fuentes desde los orígenes de software:

\begin{verbatim}
sudo apt install ttf-mscorefonts-installer
sudo apt install fonts-noto
\end{verbatim}

Y la fuente
\href{https://robey.lag.net/2010/06/21/mensch-font.html}{Mensch} la
bajamos directamente al directorio
\texttt{\textasciitilde{}/.local/share/fonts}

\hypertarget{firewall}{%
\subsection{Firewall}\label{firewall}}

\texttt{ufw} y \texttt{gufw} vienen instalados por defecto, pero no
activados.

\begin{verbatim}
aptitude install ufw
ufw default deny
ufw enable
ufw status verbose
aptitude install gufw
\end{verbatim}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\begin{quote}
\textbf{Nota}: Ojo con el log de \texttt{ufw}, tampoco le sienta muy
bien al ssd esa escritura masiva.
\end{quote}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\hypertarget{aplicaciones-variadas}{%
\subsection{Aplicaciones variadas}\label{aplicaciones-variadas}}

\begin{quote}
\textbf{Nota}: Ya no instalamos \emph{menulibre}, Linux Mint tiene una
utilidad de edición de menús.
\end{quote}

\begin{description}
\item[Keepass2]
Para mantener nuestras contraseñas a buen recaudo
\item[Gnucash]
Programa de contabilidad, la versión de los repos está bastante atrasada
habrá que probar la nueva.
\item[Deluge]
Programa de descarga de torrents (acuérdate de configurar tus
cortafuegos)
\item[rsync, grsync]
Para hacer backups de nuestros ficheros
\item[Descompresores variados]
Para lidiar con los distintos formatos de ficheros comprimidos
\item[mc]
Midnight Comander, gestor de ficheros en modo texto
\item[most]
Un \texttt{less} mejorado
\end{description}

\begin{verbatim}
sudo apt install keepass2 gnucash deluge rsync grsync rar unrar \
zip unzip unace bzip2 lzop p7zip p7zip-full p7zip-rar chromium-browser\
most mc
\end{verbatim}

\begin{description}
\item[Chromium]
Como Chrome pero libre, ahora en Ubuntu solo está disponible como snap
así que tendremos que dar un rodeo.
\end{description}

\begin{verbatim}
sudo add-apt-repository ppa:xalt7x/chromium-deb-vaapi
cat <<EOF | sudo tee /etc/apt/preferences.d/pin-xalt7x-chromium-deb-vaapi
Package: *
Pin: release o=LP-PPA-xalt7x-chromium-deb-vaapi
Pin-Priority: 1337
EOF

sudo apt update
sudo apt install chromium-browser chromium-codecs-ffmpeg
\end{verbatim}

\hypertarget{algunos-programas-de-control}{%
\subsection{Algunos programas de
control}\label{algunos-programas-de-control}}

Son útiles para control de consumo.

\begin{verbatim}
sudo apt install tlp tlp-rdw htop powertop
\end{verbatim}

\hypertarget{programas-de-terminal}{%
\subsection{Programas de terminal}\label{programas-de-terminal}}

Dos imprescindibles:

\begin{verbatim}
sudo apt install guake terminator
\end{verbatim}

\textbf{TODO:} asociar \emph{Guake} a una combinación apropiada de
teclas.

\hypertarget{dropbox}{%
\subsection{Dropbox}\label{dropbox}}

Lo instalamos desde el software manager.

\hypertarget{chrome}{%
\subsection{Chrome}\label{chrome}}

Instalado desde \href{https://www.google.com/chrome/}{la página web de
Chrome}

\hypertarget{varias-aplicaciones-instaladas-de-binarios}{%
\subsection{Varias aplicaciones instaladas de
binarios}\label{varias-aplicaciones-instaladas-de-binarios}}

Lo recomendable en un sistema POSIX es instalar los programas
adicionales en \texttt{/usr/local} o en \texttt{/opt}. Yo soy más
chapuzas y suelo instalar en \texttt{\textasciitilde{}/apt} por que el
portátil es personal e intrasferible. En un ordenador compartido es
mejor usar \texttt{/opt}.

\hypertarget{freeplane}{%
\subsubsection{Freeplane}\label{freeplane}}

Para hacer mapas mentales, presentaciones, resúmenes, apuntes\ldots{} La
versión incluida en LinuxMint está un poco anticuada.

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  descargamos desde
  \href{http://freeplane.sourceforge.net/wiki/index.php/Home}{la web}.
\item
  Descomprimimos en \texttt{\textasciitilde{}/apps/freeplane}
\item
  Creamos enlace simbólico
\item
  Añadimos a los menús
\end{enumerate}

\hypertarget{telegram-desktop}{%
\subsubsection{Telegram Desktop}\label{telegram-desktop}}

Cliente de Telegram, descargado desde la
\href{https://desktop.telegram.org/}{página web}.

\hypertarget{tor-browser}{%
\subsubsection{Tor browser}\label{tor-browser}}

Descargamos desde la \href{https://www.torproject.org/}{página oficial
del proyecto} Descomprimimos en \texttt{\textasciitilde{}/apps/} y
ejecutamos desde terminal:

\begin{verbatim}
cd ~/apps/tor-browser
./start-tor-browser.desktop --register-app
\end{verbatim}

\hypertarget{brave-browser}{%
\subsubsection{Brave browser}\label{brave-browser}}

Instalamos siguiendo las instrucciones de la
\href{https://brave-browser.readthedocs.io/en/latest/installing-brave.html\#linux}{página
web oficial}

\begin{verbatim}
curl -s https://brave-browser-apt-release.s3.brave.com/brave-core.asc | sudo apt-key --keyring /etc/apt/trusted.gpg.d/brave-browser-release.gpg add -

echo "deb [arch=amd64] https://brave-browser-apt-release.s3.brave.com/ stable main" | sudo tee /etc/apt/sources.list.d/brave-browser-release.list

sudo apt update

sudo apt install brave-browser
\end{verbatim}

\hypertarget{tiddlydesktop}{%
\subsubsection{TiddlyDesktop}\label{tiddlydesktop}}

Descargamos desde la
\href{https://github.com/Jermolene/TiddlyDesktop}{página web},
descomprimimos y generamos la entrada en el menú.

\hypertarget{joplin}{%
\subsubsection{Joplin}\label{joplin}}

Una herramienta libre para mantener notas sincronizadas entre el móvil y
el portátil.

La instalamos en el directorio \texttt{\textasciitilde{}/apps/joplin}
descargando el AppImage desde la \href{https://joplinapp.org/}{página
web}

Como siempre nos creamos una entrada en el menú.

\hypertarget{terminal-y-shell}{%
\subsection{Terminal y Shell}\label{terminal-y-shell}}

Por defecto tenemos instalado \texttt{bash}.

\hypertarget{bash-git-promt}{%
\subsubsection{bash-git-promt}\label{bash-git-promt}}

Seguimos las instrucciones de
\href{https://github.com/magicmonty/bash-git-prompt}{este github}

\hypertarget{zsh}{%
\subsubsection{zsh}\label{zsh}}

Nos adelantamos a los acontecimientos, pero conviene tener instaladas
las herramientas de entornos virtuales de python antes de instalar
\emph{zsh} con el plugin para \emph{virtualenvwrapper}.

\begin{verbatim}
apt install python-all-dev
apt install python3-all-dev
apt install python-pip python-virtualenv virtualenv python3-pip
apt install virtualenvwrapper
\end{verbatim}

\emph{zsh} viene por defecto en mi instalación, en caso contrario:

\begin{verbatim}
apt install zsh
\end{verbatim}

Para \emph{zsh} vamos a usar
\href{https://github.com/zsh-users/antigen}{antigen}, así que nos lo
clonamos en \texttt{\textasciitilde{}/apps/}

\begin{verbatim}
cd ~/apps
git clone https://github.com/zsh-users/antigen
\end{verbatim}

También vamos a usar
\href{https://github.com/olivierverdier/zsh-git-prompt}{zsh-git-prompt},
así que lo clonamos también:

\begin{verbatim}
cd ~/apps
git clone https://github.com/olivierverdier/zsh-git-prompt)
\end{verbatim}

Y editamos el fichero \texttt{\textasciitilde{}/.zshrc} para que
contenga:

\begin{verbatim}
# This line loads .profile, it's experimental
[[ -e ~/.profile ]] && emulate sh -c 'source ~/.profile'

source ~/apps/zsh-git-prompt/zshrc.sh
source ~/apps/antigen/antigen.zsh

# Load the oh-my-zsh's library.
antigen use oh-my-zsh

# Bundles from the default repo (robbyrussell's oh-my-zsh).
antigen bundle git
antigen bundle command-not-found

# must install autojump for this
#antigen bundle autojump

# extracts every kind of compressed file
antigen bundle extract

# jump to dir used frequently
antigen bundle z

#antigen bundle pip

antigen bundle common-aliases

antigen bundle robbyrussell/oh-my-zsh plugins/virtualenvwrapper

antigen bundle zsh-users/zsh-completions

# Syntax highlighting bundle.
antigen bundle zsh-users/zsh-syntax-highlighting
antigen bundle zsh-users/zsh-history-substring-search ./zsh-history-substring-search.zsh

# Arialdo Martini git needs awesome terminal font
#antigen bundle arialdomartini/oh-my-git
#antigen theme arialdomartini/oh-my-git-themes oppa-lana-style

# autosuggestions
antigen bundle tarruda/zsh-autosuggestions

#antigen theme agnoster
antigen theme gnzh

# Tell antigen that you're done.
antigen apply

# Correct rm alias from common-alias bundle
unalias rm
alias rmi='rm -i'
\end{verbatim}

Para usar \emph{virtualenvwrapper} hay que decidir en que directorio
queremos salvar los entornos virtuales. El obvio seria
\texttt{\textasciitilde{}/.virtualenvs} la alternativa sería
\texttt{\textasciitilde{}/.local/share/virtualenvs}.

El que escojamos lo tenemos que crear y añadirlo a nuestro
\texttt{\textasciitilde{}/.profile} con las líneas:

\begin{verbatim}
# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then
    WORKON_HOME="$HOME/.local/share/virtualenvs"
fi
\end{verbatim}

\emph{Antigen} ya se encarga de descargar todos los plugins que queramos
utilizar en zsh. Todos el software se descarga en
\texttt{\textasciitilde{}/.antigen}

Para configurar el
\href{https://github.com/olivierverdier/zsh-git-prompt}{zsh-git-prompt},
que inspiró el bash-git-prompt, he modificado el fichero
\texttt{zshrc.sh} de \emph{zsh-git-prompt} y el fichero del tema
\emph{gnzh} en
\texttt{\textasciitilde{}/.antigen/bundles/robbyrussell/oh-my-zsh/themes/gnzh.zsh-theme}

Después de seguir estos pasos basta con arrancar el \emph{zsh}

\hypertarget{tmux}{%
\subsubsection{tmux}\label{tmux}}

Esto no tiene mucho que ver con los shell, lo he instalado para aprender
a usarlo.

\begin{verbatim}
sudo apt install tmux
\end{verbatim}

\href{https://leanpub.com/the-tao-of-tmux/read}{El tao de tmux}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\begin{quote}
\textbf{Nota}: Instalar \emph{rxvt} junto con tmux como terminal
alternativo
\end{quote}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\hypertarget{utilidades}{%
\subsection{Utilidades}\label{utilidades}}

\emph{Agave} y \emph{pdftk} ya no existen, nos pasamos a \emph{gpick} y
\emph{poppler-utils}:

Instalamos \emph{gpick} con \texttt{sudo\ apt\ install\ gpick}

\hypertarget{codecs}{%
\subsection{Codecs}\label{codecs}}

\begin{verbatim}
sudo apt-get install mint-meta-codecs
\end{verbatim}

\hypertarget{syncthing}{%
\subsection{Syncthing}\label{syncthing}}

Añadimos el ppa:

\begin{verbatim}
curl -s https://syncthing.net/release-key.txt | sudo apt-key add -

echo "deb https://apt.syncthing.net/ syncthing stable" | sudo tee /etc/apt/sources.list.d/syncthing.list


sudo apt-get update
sudo apt-get install syncthing
\end{verbatim}

\hypertarget{utilidades-1}{%
\section{Utilidades}\label{utilidades-1}}

\hypertarget{htop}{%
\subsection{htop}\label{htop}}

\begin{verbatim}
sudo apt install htop
\end{verbatim}

\hypertarget{gparted}{%
\subsection{gparted}\label{gparted}}

Instalamos \emph{gparted} para poder formatear memorias usb

\texttt{sudo\ apt\ install\ gparted}

\hypertarget{wkhtmltopdf}{%
\subsection{wkhtmltopdf}\label{wkhtmltopdf}}

\begin{verbatim}
sudo apt install wkhtmltopdf
\end{verbatim}

\hypertarget{internet}{%
\section{Internet}\label{internet}}

\hypertarget{rclone}{%
\section{Rclone}\label{rclone}}

Instalamos desde la página web, siempre que te fies obviamente.

\begin{verbatim}
curl https://rclone.org/install.sh | sudo bash
\end{verbatim}

\hypertarget{recetas-rclone}{%
\subsection{Recetas rclone}\label{recetas-rclone}}

Copiar directorio local en la nube:

\begin{verbatim}
rclone copy /localdir hubic:backup -vv
\end{verbatim}

Si queremos ver el directorio en la web de Hubic tenemos que copiarlo en
\emph{default}:

\begin{verbatim}
rclone copy /localdir hubic:default/backup -vv
\end{verbatim}

Sincronizar una carpeta remota en local:

\begin{verbatim}
rclone sync hubic:directorio_remoto /home/salvari/directorio_local -vv
\end{verbatim}

\hypertarget{referencias}{%
\subsection{Referencias}\label{referencias}}

\begin{itemize}
\tightlist
\item
  \href{https://elblogdelazaro.gitlab.io//articles/rclone-sincroniza-ficheros-en-la-nube/}{Como
  usar rclone (blogdelazaro)}
\item
  \href{https://elblogdelazaro.gitlab.io//articles/rclone-cifrado-de-ficheros-en-la-nube/}{y
  con cifrado (blogdelazaro)}
\item
  \href{https://rclone.org/docs/}{Documentación}
\end{itemize}

\hypertarget{documentaciuxf3n}{%
\section{Documentación}\label{documentaciuxf3n}}

\hypertarget{vanilla-latex}{%
\subsection{Vanilla LaTeX}\label{vanilla-latex}}

Para instalar la versión más reciente de LaTeX hay que aplicar este
truco.

\begin{verbatim}
cd ~
mkdir tmp
cd tmp
wget http://mirror.ctan.org/systems/texlive/tlnet/install-tl-unx.tar.gz
tar xzf install-tl-unx.tar.gz
cd install-tl-xxxxxx
\end{verbatim}

La parte xxxxxx varía en función del estado de la última versión de
LaTeX disponible.

\begin{verbatim}
sudo ./install-tl
\end{verbatim}

Una vez lanzada la instalación podemos desmarcar las opciones que
instalan la documentación y las fuentes. Eso nos obligará a consultar la
documentación on line pero ahorrará practicamente el 50\% del espacio
necesario. En mi caso sin doc ni src ocupa 2,3Gb

\begin{verbatim}
mkdir -p /opt/texbin
sudo ln -s /usr/local/texlive/2020/bin/x86_64-linux/* /opt/texbin
\end{verbatim}

Por último para acabar la instalación añadimos \texttt{/opt/texbin} al
\emph{PATH}. Para \emph{bash} y \emph{zsh} basta con añadir al fichero
\texttt{\textasciitilde{}/.profile} las siguientes lineas:

\begin{verbatim}
# adds texlive to my PATH
if [ -d "/opt/texbin" ] ; then
    PATH="$PATH:/opt/texbin"
fi
\end{verbatim}

En cuanto a \emph{fish} (si es que lo usas, claro) tendremos que
modificar (o crear) el fichero
\texttt{\textasciitilde{}/.config/fish/config.fish} y añadir la
siguiente linea:

\begin{verbatim}
set PATH $PATH /opt/texbin
\end{verbatim}

\hypertarget{falsificando-paquetes}{%
\subsubsection{Falsificando paquetes}\label{falsificando-paquetes}}

Ya tenemos el \emph{texlive} instalado, ahora necesitamos que el gestor
de paquetes sepa que ya lo tenemos instalado.

\begin{verbatim}
sudo apt install equivs --no-install-recommends
mkdir -p /tmp/tl-equivs && cd /tmp/tl-equivs
equivs-control texlive-local
\end{verbatim}

Alternativamente para hacerlo más fácil podemos descargarnos un fichero
\texttt{texlive-local}ya preparado, ejecutando:

\begin{verbatim}
wget http://www.tug.org/texlive/files/debian-equivs-2018-ex.txt
/bin/cp -f debian-equivs-2020-ex.txt texlive-local
\end{verbatim}

Editamos la versión (si queremos) y procedemos a generar el paquete
\emph{deb}.

\begin{verbatim}
equivs-build texlive-local
\end{verbatim}

El paquete que hemos generado tiene una dependencia: \emph{freeglut3},
hay que instalarla previamente.

\begin{verbatim}
sudo apt install freeglut3
sudo dpkg -i texlive-local_2020-1_all.deb
\end{verbatim}

Todo listo, ahora podemos instalar cualquier paquete debian que dependa
de \emph{texlive} sin problemas de dependencias, aunque no hayamos
instalado el \emph{texlive} de Debian.

\hypertarget{fuentes}{%
\subsubsection{Fuentes}\label{fuentes}}

Para dejar disponibles las fuentes opentype y truetype que vienen con
texlive para el resto de aplicaciones:

\begin{verbatim}
sudo cp $(kpsewhich -var-value TEXMFSYSVAR)/fonts/conf/texlive-fontconfig.conf /etc/fonts/conf.d/09-texlive.conf
sudo nano /etc/fonts/conf.d/09-texlive.conf
\end{verbatim}

Borramos la linea:

\begin{verbatim}
<dir>/usr/local/texlive/20xx/texmf-dist/fonts/type1</dir>
\end{verbatim}

Y ejecutamos:

\begin{verbatim}
sudo fc-cache -fsv
\end{verbatim}

Actualizaciones Para actualizar nuestro \emph{latex} a la última versión
de todos los paquetes:

\begin{verbatim}
sudo /opt/texbin/tlmgr update --self
sudo /opt/texbin/tlmgr update --all
\end{verbatim}

También podemos lanzar el instalador gráfico con:

\begin{verbatim}
sudo /opt/texbin/tlmgr --gui
\end{verbatim}

Para usar el instalador gráfico hay que instalar previamente:

\begin{verbatim}
sudo apt-get install perl-tk --no-install-recommends
\end{verbatim}

Lanzador para el actualizador de \emph{texlive}:

\begin{verbatim}
mkdir -p ~/.local/share/applications
/bin/rm ~/.local/share/applications/tlmgr.desktop
cat > ~/.local/share/applications/tlmgr.desktop << EOF
[Desktop Entry]
Version=1.0
Name=TeX Live Manager
Comment=Manage TeX Live packages
GenericName=Package Manager
Exec=gksu -d -S -D "TeX Live Manager" '/opt/texbin/tlmgr -gui'
Terminal=false
Type=Application
Icon=system-software-update
EOF
\end{verbatim}

\hypertarget{tipos-de-letra}{%
\subsection{Tipos de letra}\label{tipos-de-letra}}

Creamos el directorio de usuario para tipos de letra:

\begin{verbatim}
mkdir ~/.local/share/fonts
\end{verbatim}

\hypertarget{fuentes-adicionales-1}{%
\subsection{Fuentes Adicionales}\label{fuentes-adicionales-1}}

Me he descargado de internet la fuente
\href{https://robey.lag.net/downloads/mensch.ttf}{Mensch} el directorio
de usuario para los tipos de letra:
\texttt{\textasciitilde{}/.local/share/fonts}

Además he clonado el repo
\href{https://github.com/ProgrammingFonts/ProgrammingFonts}{\emph{Programming
Fonts}} y enlazado algunas fuentes (Hack y Menlo)

\begin{verbatim}
cd ~/wherever
git clone https://github.com/ProgrammingFonts/ProgrammingFonts
cd ~/.local/share/fonts
ln -s ~/wherever/ProgrammingFonts/Hack .
ln -s ~/wherever/ProgrammingFonts/Menlo .
\end{verbatim}

\hypertarget{pandoc}{%
\subsection{Pandoc}\label{pandoc}}

\emph{Pandoc} es un traductor entre formatos de documento. Está escrito
en Python y es increiblemente útil. De hecho este documento está escrito
con \emph{Pandoc}.

Instalado el \emph{Pandoc} descargando paquete deb desde
\href{http://pandoc.org/installing.html}{la página web del proyecto}.

Además descargamos plantillas adicionales desde
\href{https://github.com/jgm/pandoc-templates}{este repo} ejecutando los
siguientes comandos:

\begin{verbatim}
mkdir ~/.pandoc
cd ~/.pandoc
git clone https://github.com/jgm/pandoc-templates templates
\end{verbatim}

\hypertarget{calibre}{%
\subsection{Calibre}\label{calibre}}

La mejor utilidad para gestionar tu colección de libros electrónicos.

Ejecutamos lo que manda la página web:

\begin{verbatim}
sudo -v && wget -nv -O- https://raw.githubusercontent.com/kovidgoyal/calibre/master/setup/linux-installer.py \
| sudo python -c "import sys; main=lambda:sys.stderr.write('Download failed\n'); exec(sys.stdin.read()); main()"
\end{verbatim}

Para usar el calibre con el Kobo Glo:

\begin{itemize}
\tightlist
\item
  Desactivamos todos los plugin de Kobo menos el Kobo Touch Extended
\item
  Creamos una columna MyShelves con identificativo \#myshelves
\item
  En las opciones del plugin:

  \begin{itemize}
  \tightlist
  \item
    En la opción Collection columns añadimos las columnas
    series,\#myshelves
  \item
    Marcamos las opciones Create collections y Delete empy collections
  \item
    Marcamos \emph{Modify CSS}
  \item
    Update metadata on device y Set series information
  \end{itemize}
\end{itemize}

Algunos enlaces útiles:

\begin{itemize}
\tightlist
\item
  (https://github.com/jgoguen/calibre-kobo-driver)
\item
  (http://www.lectoreselectronicos.com/foro/showthread.php?15116-Manual-de-instalaci\%C3\%B3n-y-uso-del-plugin-Kobo-Touch-Extended-para-Calibre)
\item
  (http://www.redelijkheid.com/blog/2013/7/25/kobo-glo-ebook-library-management-with-calibre)
\item
  (https://www.netogram.com/kobo.htm)
\end{itemize}

\hypertarget{scribus}{%
\subsection{Scribus}\label{scribus}}

Scribus es un programa libre de composición de documentos. con Scribus
puedes elaborar desde los folletos de una exposición hasta una revista o
un poster.

Para tener una versión más actualizada instalamos:

\begin{verbatim}
sudo add-apt-repository ppa:scribus/ppa
sudo apt update
sudo apt install scribus scribus-ng scribus-template scribus-ng-doc
\end{verbatim}

\hypertarget{cambiados-algunos-valores-por-defecto}{%
\subsubsection{Cambiados algunos valores por
defecto}\label{cambiados-algunos-valores-por-defecto}}

He cambiado los siguientes valores en las dos versiones, non están
exactamente en el mismo menú pero no son díficiles de encontrar:

\begin{itemize}
\tightlist
\item
  Lenguaje por defecto: \textbf{English}
\item
  Tamaño de documento: \textbf{A4}
\item
  Unidades por defecto: \textbf{milimeters}
\item
  Show Page Grid: \textbf{Activado}
\item
  Dimensiones de la rejilla:

  \begin{itemize}
  \tightlist
  \item
    Mayor: \textbf{30 mm}
  \item
    Menor: \textbf{6mm}
  \end{itemize}
\item
  En opciones de salida de \emph{pdf} indicamos que queremos salida a
  impresora y no a pantalla. Y también que no queremos \emph{spot
  colors}, que serían sólo para ciertas impresoras industriales, así que
  activamos la opción \emph{Convert Spot Colors to Process Colors}.
\end{itemize}

Siempre se puede volver a los valores por defecto sin mucho problema
(hay una opción para ello)

Referencia
\href{https://www.youtube.com/watch?v=3sEoYZGABQM\&list=PL3kOqLpV3a67b13TY3WxYVzErYUOLYekI}{aquí}

\hypertarget{solucionados-problemas-de-hyphenation}{%
\subsubsection{\texorpdfstring{Solucionados problemas de
\emph{hyphenation}}{Solucionados problemas de hyphenation}}\label{solucionados-problemas-de-hyphenation}}

\emph{Scribus} no hacia correctamente la separación silábica en
castellano, he instalado los paquetes:

\begin{itemize}
\tightlist
\item
  hyphen-es
\item
  hyphen-gl
\end{itemize}

Y ahora funciona correctamente.

\hypertarget{foliate-lector-de-libros-electruxf3nicos}{%
\subsection{Foliate: lector de libros
electrónicos}\label{foliate-lector-de-libros-electruxf3nicos}}

Instalado el paquete deb desde
\href{https://github.com/johnfactotum/foliate/releases}{su propio
github}

\hypertarget{desarrollo-software}{%
\section{Desarrollo software}\label{desarrollo-software}}

\hypertarget{paquetes-esenciales}{%
\subsection{Paquetes esenciales}\label{paquetes-esenciales}}

Estos son los paquetes esenciales para empezar a desarrollar software en
Linux.

\begin{verbatim}
sudo apt install build-essential checkinstall make automake cmake autoconf \
git git-core git-crypt dpkg wget
\end{verbatim}

\hypertarget{git}{%
\subsection{Git}\label{git}}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{NOTA}: Si quieres instalar la última versión de git, los git
developers tienen un ppa para ubuntu, si quieres tener el git más
actualizado:

\begin{verbatim}
sudo add-apt-repository ppa:git-core/ppa
sudo apt update
sudo apt upgrade
\end{verbatim}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

Control de versiones distribuido. Imprescindible. Para \emph{Linux Mint}
viene instalado por defecto.

Configuración básica de git:

\begin{verbatim}
git config --global ui.color auto
git config --global user.name "Pepito Pérez"
git config --global user.email "pperez@mikasa.com"

git config --global alias.cl clone

git config --global alias.st "status -sb"
git config --global alias.last "log -1 --stat"
git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %Cblue<%an>%Creset' --abbrev-commit --date=relative --all"
git config --global alias.dc "diff --cached"

git config --global alias.unstage "reset HEAD --"

git config --global alias.ci commit
git config --global alias.ca "commit -a"

git config --global alias.ri "rebase -i"
git config --global alias.ria "rebase -i --autosquash"
git config --global alias.fix "commit --fixup"
git config --global alias.squ "commit --squash"

git config --global alias.cp cherry-pick
git config --global alias.co checkout
git config --global alias.br branch
git config --global core.editor emacs
\end{verbatim}

\hypertarget{emacs}{%
\subsection{Emacs}\label{emacs}}

Instalado emacs desde los repos:

\begin{verbatim}
sudo aptitude install emacs
\end{verbatim}

\hypertarget{lenguaje-de-programaciuxf3n-d-d-programming-language}{%
\subsection{Lenguaje de programación D (D programming
language)}\label{lenguaje-de-programaciuxf3n-d-d-programming-language}}

El lenguaje de programación D es un lenguaje de programación de sistemas
con una sintaxis similar a la de C y con tipado estático. Combina
eficiencia, control y potencia de modelado con seguridad y
productividad.

\hypertarget{d-apt-e-instalaciuxf3n-de-programas}{%
\subsubsection{D-apt e instalación de
programas}\label{d-apt-e-instalaciuxf3n-de-programas}}

Configurado \emph{d-apt}, instalados todos los programas incluidos

\begin{verbatim}
sudo wget http://master.dl.sourceforge.net/project/d-apt/files/d-apt.list -O /etc/apt/sources.list.d/d-apt.list
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys  EBCF975E5BA24D5E
sudo apt update
\end{verbatim}

Instalamos todos los programas asociados excepto \emph{textadept} que no
uso.

\begin{verbatim}
sudo apt install dmd-compiler dmd-tools dub dcd dfix dfmt dscanner
\end{verbatim}

\hypertarget{dcd}{%
\subsubsection{DCD}\label{dcd}}

Una vez instalado el DCD tenemos que configurarlo creando el fichero
\texttt{\textasciitilde{}/.config/dcd/dcd.conf} con el siguiente
contenido:

\begin{verbatim}
/usr/include/dmd/druntime/import
/usr/include/dmd/phobos
\end{verbatim}

Podemos probarlo con:

\begin{verbatim}
dcd-server &
echo | dcd-client --search toImpl
\end{verbatim}

\hypertarget{gdc}{%
\subsubsection{gdc}\label{gdc}}

Instalado con:

\begin{verbatim}
sudo aptitude install gdc
\end{verbatim}

\hypertarget{ldc}{%
\subsubsection{ldc}\label{ldc}}

Instalado con:

\begin{verbatim}
sudo aptitude install ldc
\end{verbatim}

Para poder ejecutar aplicaciones basadas en Vibed, necesitamos instalar:

\begin{verbatim}
sudo apt-get install -y libssl-dev libevent-dev
\end{verbatim}

\hypertarget{emacs-para-editar-d}{%
\subsubsection{Emacs para editar D}\label{emacs-para-editar-d}}

Instalados los siguientes paquetes desde Melpa

\begin{itemize}
\tightlist
\item
  d-mode
\item
  flymake-d
\item
  flycheck
\item
  flycheck-dmd-dub
\item
  flychek-d-unittest
\item
  auto-complete (desde melpa)
\item
  ac-dcd
\end{itemize}

Referencias * (https://github.com/atilaneves/ac-dcd) *
(https://github.com/Hackerpilot/DCD)

\hypertarget{c-c}{%
\subsection{C, C++}\label{c-c}}

\hypertarget{instalaciuxf3n-de-gnu-global}{%
\subsubsection{Instalación de Gnu
Global}\label{instalaciuxf3n-de-gnu-global}}

Para instalar las dependencias, previamente instalamos:

\begin{verbatim}
sudo apt install ncurses-dev id-utils exuberant-ctags python-pygments
\end{verbatim}

Con \texttt{ctags\ -\/-version} nos aseguramos de que se llama a
Exuberant y no el ctags que instala Emacs. Si no es así habrá que
revisar la definición del \texttt{PATH}

\texttt{python-pygments} no es necesario para C o C++, pero añade
funcionalidad a Global (hasta 25 lenguajes de programación más)

No podemos instalar Global desde los repos de Ubuntu, está muy anticuado
y genera bases de datos enormes y lentas. Tendremos que compilarlo.

Nos bajamos las fuentes del programa desde
\href{https://www.gnu.org/software/global/}{la página oficial} En el
momento de escribir esto se trata de la versión 6.6.4.

Descomprimimos los fuentes y los compilamos con:

\begin{verbatim}
./configure --prefix=/usr/local --with-exuberant-ctags=/usr/bin/ctags
make
sudo make install
\end{verbatim}

He comprobado que make uninstall funciona correctamente, las librerías
quedan instaladas en \texttt{/usr/local/lib/gtags} y los ejecutables en
\texttt{/usr/local/bin}

\hypertarget{processing}{%
\subsection{Processing}\label{processing}}

Bajamos los paquetes de las respectivas páginas web, descomprimimimos en
\texttt{\textasciitilde{}/apps/}, en las nuevas versiones incorpora un
script de instalación que ya se encarga de crear el fichero
\emph{desktop}.

La última versión incorpora varios modos de trabajo, he descargado el
modo \emph{Python} para probarlo.

\hypertarget{openframeworks}{%
\subsection{openFrameworks}\label{openframeworks}}

Nos bajamos los fuentes para linux 64bits desde
\href{https://openframeworks.cc}{la página web del proyecto}, y las
descomprimimos en un directorio para proceder a compilarlas.

No hay más que seguir
\href{https://openframeworks.cc/setup/linux-install/}{las instrucciones
de instalación para linux}.

La instalación no es demasiado intrusiva si tienes Ubuntu 18 o mayor y
una versión reciente del gcc.

En la primera pregunta que nos hace es necesario contestar que no. De lo
contrario falla la compilación.

Añade los siguientes paquetes a nuestro sistema

\begin{verbatim}
installing OF dependencies
OF needs to install the following packages using apt-get:
curl libjack-jackd2-0 libjack-jackd2-dev freeglut3-dev libasound2-dev libxmu-dev libxxf86vm-dev g++ libgl1-mesa-dev libglu1-mesa-dev libraw1394-dev libudev-dev libdrm-dev libglew-dev libopenal-dev libsndfile-dev libfreeimage-dev libcairo2-dev libfreetype6-dev libssl-dev libpulse-dev libusb-1.0-0-dev libgtk-3-dev libopencv-dev libassimp-dev librtaudio-dev libboost-filesystem-dev libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev gstreamer1.0-libav gstreamer1.0-pulseaudio gstreamer1.0-x gstreamer1.0-plugins-bad gstreamer1.0-alsa gstreamer1.0-plugins-base gstreamer1.0-plugins-good gdb libglfw3-dev liburiparser-dev libcurl4-openssl-dev libpugixml-dev libgconf-2-4 libgtk2.0-0 libpoco-dev
Do you want to continue? [Y/n]
\end{verbatim}

No te olvides de compilar también el \emph{Project Generator}.

\hypertarget{python}{%
\subsection{Python}\label{python}}

De partida tenemos instalado dos versiones: \emph{python} y
\emph{python3}

\begin{verbatim}
python -V
Python 2.7.12

python3 -V
Python 3.5.2
\end{verbatim}

\hypertarget{paquetes-de-desarrollo}{%
\subsubsection{Paquetes de desarrollo}\label{paquetes-de-desarrollo}}

Para que no haya problemas a la hora de instalar paquetes en el futuro
conviene que instalemos los paquetes de desarrollo:

\begin{verbatim}
sudo apt install python-dev
sudo apt install python3-dev
\end{verbatim}

\hypertarget{pip-virtualenv-virtualenvwrapper-virtualfish}{%
\subsubsection{pip, virtualenv, virtualenvwrapper,
virtualfish}\label{pip-virtualenv-virtualenvwrapper-virtualfish}}

Los he instalado a nivel de sistema.

\emph{pip} es un gestor de paquetes para \textbf{Python} que facilita la
instalación de librerías y utilidades.

Para poder usar los entornos virtuales instalaremos también
\emph{virtualenv}.

Instalamos los dos desde aptitude:

\begin{verbatim}
sudo apt install python-pip python-virtualenv virtualenv python3-pip
\end{verbatim}

\emph{virtualenv} es una herramienta imprescindible en Python, pero da
un poco de trabajo, así que se han desarrollado algunos frontends para
simplificar su uso, para \emph{bash} y \emph{zsh} usaremos
\emph{virtualenvwrapper}, y para \emph{fish} el \emph{virtualfish}. Como
veremos son todos muy parecidos.

Instalamos el virtualwrapper:

\begin{verbatim}
sudo apt install virtualenvwrapper -y
\end{verbatim}

Para usar \emph{virtualenvwrapper} tenemos que hacer:

\begin{verbatim}
source /usr/share/virtualenvwrapper/virtualenvwrapper.sh
\end{verbatim}

O añadir esa linea a nuestros ficheros \emph{.bashrc} y/o \emph{.zshrc}

Definimos la variable de entorno \emph{WORKON\_HOME} para que apunte al
directorio por defecto,
\texttt{\textasciitilde{}/.local/share/virtualenvs}. En ese directorio
es donde se guardarán nuestros entornos virtuales.

En el fichero \texttt{.profile} añadimos:

\begin{verbatim}
# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.local/share/virtualenvs" ] ; then
    WORKON_HOME="$HOME/.local/share/virtualenvs"
fi
\end{verbatim}

\href{http://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html}{Aquí}
tenemos la referencia de comandos de \emph{virtualenvwrapper}

Por último, si queremos tener utilidades parecidas en nuestro \emph{fish
shell} instalamos \emph{virtualfish}:

\begin{verbatim}
sudo pip install virtualfish
\end{verbatim}

\href{http://virtualfish.readthedocs.io/en/latest/index.html}{Aquí}
tenemos la documentación de \emph{virtualfish} y la descripción de todos
los comandos y plugins disponibles.

\hypertarget{pipenv}{%
\subsubsection{pipenv}\label{pipenv}}

No lo he instalado, pero en caso de instalación mejor lo instalamos a
nivel de usuario con:

\begin{verbatim}
pip install --user pipenv
\end{verbatim}

\hypertarget{instalaciuxf3n-del-python-3.8-uxfaltima-disponible}{%
\subsubsection{Instalación del Python 3.8 (última
disponible)}\label{instalaciuxf3n-del-python-3.8-uxfaltima-disponible}}

Ejecutamos:

\begin{verbatim}
sudo apt install python3.8 python3.8-dev python3.8-venv
\end{verbatim}

\hypertarget{instalaciuxf3n-de-bpython-y-ptpython}{%
\subsubsection{Instalación de bpython y
ptpython}\label{instalaciuxf3n-de-bpython-y-ptpython}}

\href{https://bpython-interpreter.org/}{\emph{bpython}} instalado desde
repos \texttt{sudo\ apt\ install\ bpython\ bpython3}

\href{https://github.com/prompt-toolkit/ptpython}{\emph{ptpython}}
instalado en un virtualenv para probarlo

\hypertarget{emacs-para-programar-python}{%
\subsubsection{Emacs para programar
python}\label{emacs-para-programar-python}}

\hypertarget{elpy-emacs-python-development-enviroment}{%
\paragraph{elpy: Emacs Python Development
Enviroment}\label{elpy-emacs-python-development-enviroment}}

Para instalar \texttt{elpy} necesitamos intalar previamente \emph{venv}
el nuevo gestor de \emph{virtualenvs} en Python 3.:

\begin{verbatim}
sudo apt install python3-venv
\end{verbatim}

En el fichero \texttt{\textasciitilde{}/.emacs} necesitamos activar el
módulo \emph{elpy}:

\begin{verbatim}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
\end{verbatim}

En cuanto activemos \emph{elpy} tendremos autocompletado del código y
errores sintácticos. Merece la pena leerse toda la
\href{https://elpy.readthedocs.io/en/latest/}{documentación}

\hypertarget{flycheck}{%
\paragraph{Flycheck}\label{flycheck}}

Para tener análisis sintáctico en tiempo real mientras estamos
programando:

Añadimos a nuestro fichero \texttt{\textasciitilde{}/.emacs}:

\begin{verbatim}
;; Enable Flycheck

(when (require 'flycheck nil t)

  (setq elpy-modules (delq 'elpy-module-flymake elpy-modules))

  (add-hook 'elpy-mode-hook 'flycheck-mode))
\end{verbatim}

\hypertarget{formateado}{%
\paragraph{Formateado}\label{formateado}}

Usando \emph{autopep8} o \emph{black} tendremos autoformateado del
código como paso previo a salvar el mismo en disco. (Yo aún no he
probado \emph{black})

\begin{verbatim}
# and autopep8 for automatic PEP8 formatting
sudo apt install python-autopep8
# and yapf for code formatting (innecesario)
# sudo apt install yapf yapf3
\end{verbatim}

Y añadimos la sección siguiente a nuestro fichero
\texttt{\textasciitilde{}/.emacs}

\begin{verbatim}
;; Enable autopep8

(require 'py-autopep8)

(add-hook 'elpy-mode-hook 'py-autopep8-enable-on-save)
\end{verbatim}

\hypertarget{jedi}{%
\paragraph{jedi}\label{jedi}}

Jedi le da ciertos superpoderes al autocompletado visualizando la
documentación de cada propuesta de autocompletado.

Instalamos previamente:

\begin{verbatim}
sudo apt install python-jedi python3-jedi
# flake8 for code checks
sudo apt install flake8 python-flake8 python3-flake8
\end{verbatim}

Y añadimos la sección en el fichero \texttt{\textasciitilde{}/.emacs}:

\begin{verbatim}
;;----------------------------------------------------------------------
;; elpy
(elpy-enable)
(setq elpy-rpc-backend "jedi")

(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:complete-on-dot t)
\end{verbatim}

Desde \emph{Emacs} ejecutamos: \texttt{alt-x\ jedi:install-server}

\hypertarget{jupyter}{%
\subsubsection{Jupyter}\label{jupyter}}

Una instalación para pruebas.

\begin{verbatim}
mkvirtualenv -p /usr/bin/python3 jupyter
python -m pip install jupyter
\end{verbatim}

\hypertarget{neovim}{%
\subsection{neovim}\label{neovim}}

Vamos a probar \emph{neovim}:

\begin{verbatim}
sudo apt-add-repository ppa:neovim-ppa/stable
sudo apt update
sudo apt install neovim
\end{verbatim}

Para instalar los módulos de python creamos un \emph{virtualev} que más
tarde añadiremos al fichero \texttt{init.vim}.

\begin{verbatim}
mkvirtualenv -p /usr/bin/python3 neovim3
sudo pip install --upgrade neovim
deactivate
\end{verbatim}

Revisar
\href{https://neovim.io/doc/user/provider.html\#provider-python}{esto}

\begin{longtable}[]{@{}l@{}}
\toprule
\endhead
\textbf{NOTA}: El siguiente paso ya no parece necesario, las
alternativas\tabularnewline
se han actualizado con la instalación del \emph{neovim}.\tabularnewline
\bottomrule
\end{longtable}

Para actualizar las alternativas:

\begin{verbatim}
sudo update-alternatives --install /usr/bin/vi vi /usr/bin/nvim 60
sudo update-alternatives --config vi
sudo update-alternatives --install /usr/bin/vim vim /usr/bin/nvim 60
sudo update-alternatives --config vim
\end{verbatim}

\hypertarget{install-vim-plug}{%
\paragraph{\texorpdfstring{Install
\emph{vim-plug}}{Install vim-plug}}\label{install-vim-plug}}

Ejecutamos:

\begin{verbatim}
curl -fLo ~/.local/share/nvim/site/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
\end{verbatim}

Configuramos el fichero de configuración de \emph{nvim}
(\texttt{\textasciitilde{}/.config/nvim/init.vim}):

\begin{verbatim}
" Specify a directory for plugins
" - For Neovim: ~/.local/share/nvim/plugged
" - Avoid using standard Vim directory names like 'plugin'
call plug#begin('~/.local/share/nvim/plugged')

if has('nvim')
  Plug 'Shougo/deoplete.nvim', { 'do': ':UpdateRemotePlugins' }
else
  Plug 'Shougo/deoplete.nvim'
  Plug 'roxma/nvim-yarp'
  Plug 'roxma/vim-hug-neovim-rpc'
endif

Plug 'deoplete-plugins/deoplete-jedi'

" Initialize plugin system
call plug#end()

let g:deoplete#enable_at_startup = 1

" set python enviroments
let g:python_host_prog = '/full/path/to/neovim2/bin/python'
let g:python3_host_prog = '/home/salvari/.virtualenvs/neovim3/bin/python'

\end{verbatim}

La primera vez que abramos \emph{nvim} tenemos que instalar los plugin
porn comando ejecutando: \texttt{:PlugInstall}

\textbf{Instalación de \texttt{dein}}

\begin{longtable}[]{@{}l@{}}
\toprule
\endhead
\textbf{Nota}:\tabularnewline
Solo hay que instalar uno de los dos o \emph{dein} o \emph{plug-vim}. Yo
uso\tabularnewline
\emph{plug-vim} así que esto es sólo una referencia.\tabularnewline
\bottomrule
\end{longtable}

\url{https://github.com/Shougo/dein.vim}

\begin{verbatim}
" Add the dein installation directory into runtimepath
set runtimepath+=~/.config/nvim/dein/repos/github.com/Shougo/dein.vim

if dein#load_state('~/.config/nvim/dein')
  call dein#begin('~/.config/nvim/dein')

  call dein#add('~/.config/nvim/dein/repos/github.com/Shougo/dein.vim')
  call dein#add('Shougo/deoplete.nvim')
  call dein#add('Shougo/denite.nvim')
  if !has('nvim')
    call dein#add('roxma/nvim-yarp')
    call dein#add('roxma/vim-hug-neovim-rpc')
  endif

  call dein#end()
  call dein#save_state()
endif

filetype plugin indent on
syntax enable
\end{verbatim}

\hypertarget{firefox-developer-edition}{%
\subsection{Firefox developer edition}\label{firefox-developer-edition}}

El rollo de siempre, descargar desde
\href{https://www.mozilla.org/en-US/firefox/developer/}{la página web}
descomprimir en \texttt{\textasciitilde{}/apps} y crear un lanzador.

\hypertarget{navegadores-cli}{%
\subsection{Navegadores cli}\label{navegadores-cli}}

Herramientas útiles para depuración web

\begin{verbatim}
sudo apt install httpie links
\end{verbatim}

\hypertarget{mariadb}{%
\subsection{MariaDB}\label{mariadb}}

Instalamos la última estable para Ubuntu Bionic desde los repos
oficiales.

Primero añadimos los reports

Añadimos la clave de firma:

\begin{verbatim}
sudo apt-get install software-properties-common
sudo apt-key adv --fetch-keys 'https://mariadb.org/mariadb_release_signing_key.asc'
\end{verbatim}

Ahora tenemos dos opciones:

Podemos ejecutar:

\begin{verbatim}
sudo add-apt-repository 'deb [arch=amd64,arm64,ppc64el] http://ftp.icm.edu.pl/pub/unix/database/mariadb/repo/10.4/ubuntu bionic main'
\end{verbatim}

O podemos crear un fichero \texttt{/etc/apt/apt.sources.list.d/MariaDB}
con el siguiente contenido (yo dejo las fuentes comentadas):

\begin{verbatim}
# MariaDB 10.4 repository list - created 2020-01-26 10:37 UTC
# http://downloads.mariadb.org/mariadb/repositories/
deb [arch=amd64,arm64,ppc64el] http://ftp.ubuntu-tw.org/mirror/mariadb/repo/10.4/ubuntu bionic main
# deb-src http://ftp.ubuntu-tw.org/mirror/mariadb/repo/10.4/ubuntu bionic main
\end{verbatim}

Y ya solo nos queda lo de siempre:

\begin{verbatim}
sudo apt update
sudo apt upgrade
sudo apt install mariadb-server
\end{verbatim}

Podemos comprobar con \texttt{systemctl\ status\ mariadb}

También podemos hacer login con el usuario \texttt{root}:

\begin{verbatim}
sudo mariadb -u root
\end{verbatim}

Y ahora aseguramos la instación con:

\begin{verbatim}
sudo mysql_secure_installation
\end{verbatim}

Yo diría que tienes que decir que si a todas las preguntas, excepto
quizás al \emph{unix\_socket\_authentication}.

Por último sólo nos queda decidir si el servicio mariadb debe estar
ejecutándose permanentemente o no.

Si queremos pararlo y que no se arranque automáticamente al arrancar el
ordenador:

\begin{verbatim}
sudo systemctl stop mariadb
sudo systemctl disable mariadb
\end{verbatim}

\hypertarget{squirrel-sql-client}{%
\subsection{Squirrel SQL Client}\label{squirrel-sql-client}}

Bajamos el zip de estándar desde \href{http://www.squirrelsql.org/}{la
página web de Squirrel} (yo prefiero no usar el instalador)

Como de costumbre descomprimimos en \texttt{\textasciitilde{}/apps} y
creamos una entrada en nuestro menú de aplicaciones.

Nos descargamos también el \emph{java connector} para MariaDB. Desde la
página oficial. Nos interesa el fichero
\texttt{maria-java-client-2.6.0.jar}

Configuramos el driver para que sepa donde está el fichero \texttt{.jar}
y ya estamos listos para trabajar.

\hypertarget{r-y-r-studio}{%
\subsection{R y R-studio}\label{r-y-r-studio}}

Primero instalamos la última versión de R en nuestro pc:

\begin{verbatim}
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu bionic-cran35/'
sudo apt install r-base
\end{verbatim}

\hypertarget{r-studio}{%
\subsubsection{R-studio}\label{r-studio}}

Descargamos la última versión disponible de \emph{R-studio} desde la
\href{https://cloud.r-project.org/bin/linux/ubuntu}{página web}

Instalamos con \emph{gdebi} (basta con clicar sobre el fichero
\emph{.deb})

\hypertarget{octave}{%
\subsection{Octave}\label{octave}}

Instalado desde flatpak

\begin{verbatim}
sudo flatpak install flathub org.octave.Octave
\end{verbatim}

\hypertarget{desarrollo-hardware}{%
\section{Desarrollo hardware}\label{desarrollo-hardware}}

\hypertarget{arduino-ide}{%
\subsection{Arduino IDE}\label{arduino-ide}}

Bajamos los paquetes de la página \href{https://www.arduino.cc}{web},
descomprimimimos en \emph{\textasciitilde/apps/arduino}.

La distribución del IDE incluye ahora un fichero \texttt{install.sh}que
se encarga de hacer la integración del IDE en los menús de Linux.

Además también incluye un script (\texttt{arduino-linux-setup.sh}) para
crear las \emph{devrules} y que además desinstala el driver
\emph{modemmanager} y crea grupos nuevos en el sistema si no existen.

No tengo claro lo de desinstalar el driver así que creamos las
\emph{devrules} a mano mirando por el fichero.

Hay que añadir nuestro usuario a los grupos \emph{tty}, \emph{dialout},
\emph{uucp} y \emph{plugdev} (no hay que crear grupos nuevos, ya tenemos
todos en el sistema)

\begin{verbatim}
sudo gpasswd --add <usrname> tty
sudo gpasswd --add <usrname> dialout
sudo gpasswd --add <usrname> uucp
sudo gpasswd --add <usrname> plugdev
\end{verbatim}

Creamos los siguientes ficheros en el directorio
\texttt{/etc/udev/rules.d}

Fichero \texttt{90-extraacl.rules} mete mi usario en el fichero de
reglas (¬\_¬)

\begin{verbatim}
# Setting serial port rules

KERNEL=="ttyUSB[0-9]*", TAG+="udev-acl", TAG+="uaccess", OWNER="salvari"
KERNEL=="ttyACM[0-9]*", TAG+="udev-acl", TAG+="uaccess", OWNER="salvari"
\end{verbatim}

Fichero \texttt{98-openocd.rules}

\begin{verbatim}
# Adding Arduino M0/M0 Pro, Primo UDEV Rules for CMSIS-DAP port

ACTION!="add|change", GOTO="openocd_rules_end"
SUBSYSTEM!="usb|tty|hidraw", GOTO="openocd_rules_end"

#Please keep this list sorted by VID:PID

#CMSIS-DAP compatible adapters
ATTRS{product}=="*CMSIS-DAP*", MODE="664", GROUP="plugdev"

LABEL="openocd_rules_end"
\end{verbatim}

Fichero \texttt{avrisp.rules}

\begin{verbatim}
# Adding AVRisp UDEV rules

SUBSYSTEM!="usb_device", ACTION!="add", GOTO="avrisp_end"
# Atmel Corp. JTAG ICE mkII
ATTR{idVendor}=="03eb", ATTRS{idProduct}=="2103", MODE="660", GROUP="dialout"
# Atmel Corp. AVRISP mkII
ATTR{idVendor}=="03eb", ATTRS{idProduct}=="2104", MODE="660", GROUP="dialout"
# Atmel Corp. Dragon
ATTR{idVendor}=="03eb", ATTRS{idProduct}=="2107", MODE="660", GROUP="dialout"

LABEL="avrisp_end"
\end{verbatim}

Fichero \texttt{40-defuse.rules}:

\begin{verbatim}
# Adding STM32 bootloader mode UDEV rules

# Example udev rules (usually placed in /etc/udev/rules.d)
# Makes STM32 DfuSe device writeable for the "plugdev" group

ACTION=="add", SUBSYSTEM=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE="664", GROUP="plugdev", TAG+="uaccess"
\end{verbatim}

Fichero \texttt{99-arduino-101.rules}:

\begin{verbatim}
# Arduino 101 in DFU Mode

SUBSYSTEM=="tty", ENV{ID_REVISION}=="8087", ENV{ID_MODEL_ID}=="0ab6", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1", ENV{ID_MM_CANDIDATE}="0"
SUBSYSTEM=="usb", ATTR{idVendor}=="8087", ATTR{idProduct}=="0aba", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
\end{verbatim}

Yo añado el fichero \texttt{99-arduino.rules} que se encarga de inhibir
el modemmanager para que no capture al \emph{CircuitPlayground Express}:

\begin{verbatim}
# for arduino brand, stop ModemManager grabbing port
ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
# for sparkfun brand, stop ModemManager grabbing port
ATTRS{idVendor}=="1b4f", ENV{ID_MM_DEVICE_IGNORE}="1"
\end{verbatim}

\hypertarget{auxf1adir-soporte-para-feather-m0}{%
\subsubsection{\texorpdfstring{Añadir soporte para \emph{Feather
M0}}{Añadir soporte para Feather M0}}\label{auxf1adir-soporte-para-feather-m0}}

Arrancamos el IDE Arduino y en la opción de \emph{Preferences::Aditional
Boar Managers URLs} añadimos la dirección
\texttt{https://adafruit.github.io/arduino-board-index/package\_adafruit\_index.json},
si tenemos otras URL, simplemente añadimos esta separada por una coma.

Ahora desde el \emph{Board Manager} instalamos:

\begin{itemize}
\tightlist
\item
  Arduino SAMD Boards
\item
  Adafruit SAMD Boards
\end{itemize}

\hypertarget{auxf1adir-soporte-para-circuit-playground-express}{%
\subsubsection{\texorpdfstring{Añadir soporte para \emph{Circuit
Playground
Express}}{Añadir soporte para Circuit Playground Express}}\label{auxf1adir-soporte-para-circuit-playground-express}}

Bastaría con instalar \emph{Arduino SAMD Boards}

\hypertarget{auxf1adir-soporte-para-stm32}{%
\subsubsection{Añadir soporte para
STM32}\label{auxf1adir-soporte-para-stm32}}

Tenemos varias URL posibles para configurar en las preferencias del IDE
Arduino:

\begin{itemize}
\tightlist
\item
  \url{http://dan.drown.org/stm32duino/package_STM32duino_index.json}
  (recomendada por Tutoelectro)
\item
  \url{https://github.com/stm32duino/BoardManagerFiles/raw/master/STM32/package_stm_index.json}
  (parece la oficial, y tiene mejor pinta)
\end{itemize}

\hypertarget{auxf1adir-soporte-para-esp32}{%
\subsubsection{Añadir soporte para
ESP32}\label{auxf1adir-soporte-para-esp32}}

\hypertarget{auxf1adir-biblioteca-de-soporte-para-makeblock}{%
\subsubsection{Añadir biblioteca de soporte para
Makeblock}\label{auxf1adir-biblioteca-de-soporte-para-makeblock}}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{Nota}: Pendiente de instalar

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

Clonamos el
\href{https://github.com/Makeblock-official/Makeblock-Libraries}{repo
oficial en github}.

Una vez que descarguemos las librerias es necesario copiar el directorio
\texttt{Makeblock-Libraries/makeblock} en nuestro directorio de
bibliotecas de Arduino. En mi caso
\texttt{\textasciitilde{}/Arduino/libraries/}.

Una vez instaladas las bibliotecas es necesario reiniciar el IDE Arduino
si estaba arrancado. Podemos ver si se ha instalado correctamente
simplemente echando un ojo al menú de ejemplos en el IDE, tendríamos que
ver los ejemplos de \emph{Makeblock}.

Un detalle importante para programar el Auriga-Me es necesario
seleccionar el micro Arduino Mega 2560 en el IDE Arduino.

\hypertarget{pinguino-ide}{%
\subsection{Pinguino IDE}\label{pinguino-ide}}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{Nota}: Pendiente de instalar

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

Tenemos el paquete de instalación disponible en su página
\href{http://pinguino.cc/download.php}{web}

Ejecutamos el programa de instalación. El programa descargará los
paquetes Debian necesarios para dejar el IDE y los compiladores
instalados.

Al acabar la instalación he tenido que crear el directorio
\emph{\textasciitilde/Pinguino/v11}, parece que hay algún problema con
el programa de instalación y no lo crea automáticamente.

El programa queda correctamente instalado en \emph{/opt} y arranca
correctamente, habrá que probarlo con los micros.

\hypertarget{esp-idf}{%
\subsection{esp-idf}\label{esp-idf}}

Instalamos las dependencias (cmake ya lo tenemos instalado)

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{NOTA}: No es necesario instalar los paquetes de python que nos
especifican en las instrucciones de instalación del \emph{esp-idf}, se
instalarán automáticamente en el siguiente paso.

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\begin{verbatim}
sudo apt-get install gperf  cmake ninja-build ccache libffi-dev libssl-dev
\end{verbatim}

Ahora creamos un directorio para nuestro \emph{tool-chain}:

\begin{verbatim}
mkdir ~/esp
cd ~/esp
git clone --recursive https://github.com/espressif/esp-idf
\end{verbatim}

También es necesario que nuestro usuario pertenezca al grupo
\texttt{dialout}, pero eso ya deberíamos tenerlo hecho de antes.

Una vez clonado el repo ejecutamos el script de instalación

\begin{verbatim}
cd ~/esp/esp-idf
./install.sh
\end{verbatim}

Este script nos va a dejar instaladas todas las herramientas necesarias
en el directorio \texttt{\textasciitilde{}/.expressif}

Para empezar a trabajar bastará con hacer un \emph{source} del fichero
\texttt{\textasciitilde{}/esp/esp-idf/export.sh}:

\begin{verbatim}
. ~/esp/esp-idf/export.sh
\end{verbatim}

\hypertarget{kicad}{%
\subsection{KiCAD}\label{kicad}}

En la \href{http://kicad-pcb.org/download/linux-mint/}{página web del
proyecto} nos recomiendan el ppa a usar para instalar la última versión
estable:

\begin{verbatim}
sudo add-apt-repository --yes ppa:js-reynaud/kicad-5
sudo apt-get update
sudo apt-get install kicad
sudo apt install kicad-footprints kicad-libraries kicad-packages3d kicad-symbols kicad-templates
\end{verbatim}

Paciencia, el paquete \texttt{kicad-packages3d} tarda un buen rato en
descargarse.

Algunas librerías alternativas:

\begin{itemize}
\tightlist
\item
  \href{https://github.com/freetronics/freetronics_kicad_library}{Freetronics}
  una libreria que no solo incluye Shield para Arduino sino una completa
  colección de componentes que nos permitirá hacer proyectos completos.
  \href{http://www.freetronics.com}{Freetronics} es una especie de
  BricoGeek australiano, publica tutoriales, vende componentes, y al
  parecer mantiene una biblioteca para KiCAD. La biblioteca de
  Freetronics se mantiene en un repo de github. Lo suyo es incorporarla
  a cada proyecto, por que si la actualizas se pueden romper los
  proyectos que estes haciendo.
\item
  \href{http://meta-blog.eklablog.com/kicad-librairie-arduino-pretty-p930786}{eklablog}
  Esta biblioteca de componentes está incluida en el github de KiCAD,
  así que teoricamente no habría que instalarla en nuestro disco duro.
\end{itemize}

\hypertarget{analizador-luxf3gico}{%
\subsection{Analizador lógico}\label{analizador-luxf3gico}}

Mi analizador es un OpenBench de Seedstudio,
\href{http://dangerousprototypes.com/docs/Open_Bench_Logic_Sniffer}{aquí
hay mas info}

\hypertarget{sigrok}{%
\subsubsection{Sigrok}\label{sigrok}}

Instalamos \textbf{Sigrok}, simplemente desde los repos de Debian:

\begin{verbatim}
sudo aptitude install sigrok
\end{verbatim}

Al instalar \textbf{Sigrok} instalamos también \textbf{Pulseview}.

Si al conectar el analizador, echamos un ojo al fichero \emph{syslog}
vemos que al conectarlo se mapea en un puerto tty.

Si arrancamos \textbf{Pulseview} (nuestro usuario tiene que estar
incluido en el grupo \emph{dialout}), en la opción \emph{File::Connect
to device}, escogemos la opción \emph{Openbench} y le pasamos el puerto.
Al pulsar la opción \emph{Scan for devices} reconoce el analizador
correctamente como un \emph{Sump Logic Analyzer}.

\hypertarget{sump-logic-analyzer}{%
\subsubsection{Sump logic analyzer}\label{sump-logic-analyzer}}

Este es el software recomendado para usar con el analizador.

Descargamos el paquete de la \href{https://www.sump.org}{página del
proyecto}, o más concretamente de
\href{https://www.sump.org/projects/analyzer/}{esta página} y
descomprimimos en \emph{\textasciitilde/apps}.

Instalamos las dependencias:

\begin{verbatim}
sudo apt install librxtx-java
\end{verbatim}

Editamos el fichero \emph{\textasciitilde/apps/Logic
Analyzer/client/run.sh} y lo dejamos así:

\begin{verbatim}
#!/bin/bash

# java -jar analyzer.jar $*
java -cp /usr/share/java/RXTXcomm.jar:analyzer.jar org.sump.analyzer.Loader
\end{verbatim}

Y ya funciona.

\hypertarget{ols}{%
\subsubsection{OLS}\label{ols}}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{Nota}: Pendiente de instalar

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\href{https://www.lxtreme.nl/ols/}{Página oficial}

\hypertarget{icestudio}{%
\subsection{IceStudio}\label{icestudio}}

Instalamos dependencias con \texttt{sudo\ apt\ install\ xclip}

Bajamos el \emph{AppImage} desde el
\href{https://github.com/FPGAwars/icestudio}{github de IceStudio} y lo
dejamos en \texttt{\textasciitilde{}/apps/icestudio}

\hypertarget{platformio}{%
\subsection{PlatformIO}\label{platformio}}

\hypertarget{vs-code}{%
\subsubsection{VS Code}\label{vs-code}}

Añadimos el origen de software:

\begin{verbatim}
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /usr/share/keyrings/
sudo sh -c 'echo "deb [arch=amd64 signed-by=/usr/share/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/vscode stable main" > /etc/apt/sources.list.d/vscode.list'
\end{verbatim}

E instalamos

\begin{verbatim}
sudo apt update
sudo apt install code   # alternativamente code-insiders (es como la versión beta, se pueden instalar los dos)
\end{verbatim}

Ahora

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  lanzamos el editor
\item
  abrimos el gestor de extensiones
\item
  buscamos el platformio ide
\item
  instalamos
\end{enumerate}

Seguimos las instrucciones de
\href{https://docs.platformio.org/en/latest/ide/vscode.html\#quick-start}{aqui}

\hypertarget{incluir-platform.io-cli-en-el-path}{%
\subsubsection{Incluir platform.io CLI en el
PATH}\label{incluir-platform.io-cli-en-el-path}}

Esto es una malísima idea, \textbf{NO LO HAGAS}

Las instrucciones indican que hagamos lo siguiente para usar Platformio
desde linea de comandos pero no es conveniente hacerlo.

Modificamos el fichero \texttt{\textasciitilde{}/.profile} añadiendo las
siguientes lineas:

\begin{verbatim}
if [ -d "$HOME/.platformio/penv/bin"] ; then
    PATH="$PATH:$HOME/.platformio/penv/bin"
fi
\end{verbatim}

Si quieres usar Platformio desde linea de comandos, es mejor activar
manualmente el entorno virtual con
\texttt{source\ \textasciitilde{}/.platformio/penv/bin/activate}

\hypertarget{vscodium}{%
\subsubsection{vscodium}\label{vscodium}}

\begin{verbatim}
wget -qO - https://gitlab.com/paulcarroty/vscodium-deb-rpm-repo/raw/master/pub.gpg | sudo apt-key add -
echo 'deb https://gitlab.com/paulcarroty/vscodium-deb-rpm-repo/raw/repos/debs/ vscodium main' | sudo tee --append /etc/apt/sources.list.d/vscodium.list
sudo apt update && sudo apt install codium
\end{verbatim}

\hypertarget{editor-atom}{%
\subsubsection{Editor Atom}\label{editor-atom}}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\emph{NOTA}: Parece que antes recomendaban instalar Atom para disponer
del Platformio CLI, ahora en cambio recomiendan VS Code.

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\begin{verbatim}
wget -qO - https://packagecloud.io/AtomEditor/atom/gpgkey | sudo apt-key add -
sudo sh -c 'echo "deb [arch=amd64] https://packagecloud.io/AtomEditor/atom/any/ any main" > /etc/apt/sources.list.d/atom.list'
sudo apt update
sudo apt install atom
\end{verbatim}

\hypertarget{reprap}{%
\subsection{RepRap}\label{reprap}}

\hypertarget{openscad}{%
\subsubsection{OpenScad}\label{openscad}}

El OpenSCAD está disponible en los orígenes de software, así que
\texttt{sudo\ apt\ install\ openscad}.

\hypertarget{slic3r}{%
\subsubsection{Slic3r}\label{slic3r}}

Descargamos la estable desde la \href{https://dl.slic3r.org}{página web}
y como de costumbre descomprimimos en \texttt{\textasciitilde{}/apps} y
creamos un lanzador con \emph{MenuLibre}

\hypertarget{slic3r-prusa-edition}{%
\subsubsection{Slic3r Prusa Edition}\label{slic3r-prusa-edition}}

Una nueva versión del clásico \emph{Slic3r} con muchas mejoras.
Descargamos la \emph{appimage} desde la
\href{https://www.prusa3d.com/slic3r-prusa-edition/}{página web} y ya
sabeis, descomprimir en \texttt{\textasciitilde{}/apps} y dar permisos
de ejecución.

\hypertarget{ideamaker}{%
\subsubsection{ideaMaker}\label{ideamaker}}

Una aplicación más para generar gcode con muy buena pinta, tenemos el
paquete \emph{deb} disponible en su
\href{https://www.raise3d.com/pages/ideamaker}{página web}. Instalamos
con el gestor de software.

\hypertarget{ultimaker-cura}{%
\subsubsection{Ultimaker Cura}\label{ultimaker-cura}}

Descargamos el \emph{AppImage} desde la
\href{https://github.com/Ultimaker/Cura/releases}{página web}

\hypertarget{pronterface}{%
\subsubsection{Pronterface}\label{pronterface}}

Seguimos las instrucciones para Ubuntu Bionic:

Instalamos las dependencias:

Clonamos el repo:

\begin{verbatim}
cd ~/apps
git clone https://github.com/kliment/Printrun.git
cd Printrun
mkvirtualenv -p /usr/bin/python3 printrun
python -m pip install https://extras.wxpython.org/wxPython4/extras/linux/gtk3/ubuntu-20.04/wxPython-4.1.0-cp38-cp38-linux_x86_64.whl
pip install -r requirements.txt
# sudo apt-get install libdbus-glib-1-dev libdbus-1-dev
\end{verbatim}

Y ya lo tenemos todo listo para ejecutar.

\hypertarget{cortadora-de-vinilos}{%
\subsection{Cortadora de vinilos}\label{cortadora-de-vinilos}}

\hypertarget{inkcut}{%
\subsubsection{Inkcut}\label{inkcut}}

Instalado en un entorno virtual:

\begin{verbatim}
mkvirtualenv -p `which python3` inkcut

sudo apt install libxml2-dev libxslt-dev libcups2-dev

pip install PyQt5

pip install inkcut
\end{verbatim}

\hypertarget{plugin-para-inkscape}{%
\subsubsection{Plugin para inkscape}\label{plugin-para-inkscape}}

Instalamos dependencias:

\begin{verbatim}
pip install python-usb
\end{verbatim}

Instalamos el fichero \texttt{.deb} desde la web
\url{https://github.com/fablabnbg/inkscape-silhouette/releases}

\hypertarget{aplicaciones-de-gruxe1ficos}{%
\section{Aplicaciones de gráficos}\label{aplicaciones-de-gruxe1ficos}}

\hypertarget{librecad}{%
\subsection{LibreCAD}\label{librecad}}

Diseño en 2D

\begin{verbatim}
sudo apt install librecad
\end{verbatim}

\hypertarget{freecad}{%
\subsection{FreeCAD}\label{freecad}}

No hay ppa disponible para Ubuntu 20.

Instalamos \emph{AppImage} desde
\href{https://wiki.freecadweb.org/AppImage\#FreeCAD_AppImages}{aquí}

Dejo la instalación desde ppa como recordatorio.

\begin{verbatim}
sudo add-apt-repository ppa:freecad-maintainers/freecad-stable
sudo apt update
sudo install freecad
\end{verbatim}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{NOTA:} the ccx package brings CalculiX support to the FEM
workbench, and needs to be installed separately.

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\hypertarget{inkscape}{%
\subsection{Inkscape}\label{inkscape}}

El programa libre para creación y edición de gráficos vectoriales.

\begin{verbatim}
sudo add-apt-repository ppa:inkscape.dev/stable
sudo apt update
sudo apt install inkscape
\end{verbatim}

\hypertarget{gimp}{%
\subsection{Gimp}\label{gimp}}

El programa para edición y retocado de imágenes.

Parece que ahora mismo los repos están más actualizados que el ppa.

\begin{verbatim}
sudo apt remove gimp gimp-data
sudo add-apt-repository ppa:otto-kesselgulasch/gimp
sudo apt update
sudo apt upgrade
sudo apt install gimp gimp-data gimp-texturize \
gimp-data-extras gimp-gap gmic gimp-gmic gimp-python
\end{verbatim}

\hypertarget{plugins-de-gimp}{%
\subsubsection{Plugins de Gimp}\label{plugins-de-gimp}}

Para instalar los principales plugins basta con:

\begin{verbatim}
sudo apt install gimp-plugin-registry
\end{verbatim}

\begin{longtable}[]{@{}l@{}}
\toprule
\endhead
\begin{minipage}[t]{0.96\columnwidth}\raggedright
Esta sección ya no está vigente\strut
\end{minipage}\tabularnewline
\begin{minipage}[t]{0.96\columnwidth}\raggedright
\#\#\#\# resynthesizer\strut
\end{minipage}\tabularnewline
\begin{minipage}[t]{0.96\columnwidth}\raggedright
Descargamos el plugin desde
\href{https://github.com/bootchk/resynthesizer}{aquí} y descomprimimos
el fichero en
\texttt{\textasciitilde{}/.config/GIMP/2.10/plug-ins}\strut
\end{minipage}\tabularnewline
\begin{minipage}[t]{0.96\columnwidth}\raggedright
Tenemos que asegurarnos que los fichero \emph{python} son
ejecutables:\strut
\end{minipage}\tabularnewline
\begin{minipage}[t]{0.96\columnwidth}\raggedright
\textasciitilde\textasciitilde\textasciitilde\textasciitilde{} chmod 755
\textasciitilde/.config/GIMP/2.10/plug-ins/*.py
\textasciitilde\textasciitilde\textasciitilde\textasciitilde{}\strut
\end{minipage}\tabularnewline
\bottomrule
\end{longtable}

\hypertarget{krita}{%
\subsection{Krita}\label{krita}}

La versión disponible en orígenes de software está bastante por detrás
de la disponible en la web. Basta con descargar el \emph{Appimage} desde
la \href{https://krita.org}{página web}

Lo copiamos a \texttt{\textasciitilde{}/apps/krita} y creamos un
lanzador con el editor de menús.

Alternativamente también lo tenemos disponible por ppa en
\url{https://launchpad.net/~kritalime/+archive/ubuntu/ppa}

\hypertarget{mypaint}{%
\subsection{MyPaint}\label{mypaint}}

Desde el \href{https://github.com/mypaint/}{github} tenemos disponible
la última versión en formato \emph{appimage}. La descargamos la dejamos
en \texttt{\textasciitilde{}/apps} y creamos un acceso con
\emph{Menulibre}, como siempre.

\hypertarget{alchemy}{%
\subsection{Alchemy}\label{alchemy}}

Igual que el \emph{MyPaint} descargamos desde
\href{http://al.chemy.org}{la página web}, descomprimimos en
\texttt{\textasciitilde{}/apps} y creamos un accso con \emph{Menulibre}.

\hypertarget{capturas-de-pantalla}{%
\subsection{Capturas de pantalla}\label{capturas-de-pantalla}}

El \href{https://flameshot.js.org/\#/}{\emph{flameshot}} cubre el 99\%
de mis necesidades: \texttt{sudo\ apt\ install\ flameshot}

El \href{https://github.com/DamirPorobic/ksnip}{\emph{ksnip}} por si
tenemos que hacer una captura con retardo lo instalé con un
\emph{appimage}.

Shutter vuelve a estar disponible, al instalar desde este ppa ya queda
con las opciones de edición habilitadas:

\begin{verbatim}
sudo add-apt-repository ppa:linuxuprising/shutter
sudo apt update
sudo apt install shutter
\end{verbatim}

\hypertarget{reoptimizar-imuxe1genes}{%
\subsection{Reoptimizar imágenes}\label{reoptimizar-imuxe1genes}}

\hypertarget{imagemagick}{%
\subsubsection{ImageMagick}\label{imagemagick}}

Instalamos desde los repos, simplemente:

\begin{verbatim}
sudo apt install imagemagick
\end{verbatim}

\hypertarget{imagine}{%
\subsubsection{Imagine}\label{imagine}}

Nos bajamos un \emph{AppImage} desde el
\href{https://github.com/meowtec/Imagine/releases}{github} de la
aplicación

\hypertarget{dia}{%
\subsection{dia}\label{dia}}

Un programa para crear diagramas

\begin{verbatim}
sudo apt install dia dia-shapes gsfonts-x11
\end{verbatim}

\hypertarget{blender}{%
\subsection{Blender}\label{blender}}

Bajamos el Blender linkado estáticamente de
\href{https://www.blender.org}{la página web} y lo descomprimimos en
\texttt{\textasciitilde{}/apps/blender}.

\hypertarget{structure-synth}{%
\subsection{Structure Synth}\label{structure-synth}}

Instalado desde repos, junto con sunflow para explorar un poco.

\begin{verbatim}
sudo apt install structure-synth sunflow
\end{verbatim}

\hypertarget{heron-animation}{%
\subsection{Heron animation}\label{heron-animation}}

Descargamos el programa desde
\href{https://heronanimation.brunolefevre.net/}{su página web} y como
siempre descomprimimos en \texttt{\textasciitilde{}/apps/heron}

\hypertarget{stopmotion}{%
\subsection{Stopmotion}\label{stopmotion}}

Primero probamos el del repo: \texttt{sudo\ apt\ install\ stopmotion}

\hypertarget{instalaciuxf3n-del-driver-digiment-para-tabletas-gruxe1ficas-huion}{%
\subsection{Instalación del driver digiment para tabletas gráficas
Huion}\label{instalaciuxf3n-del-driver-digiment-para-tabletas-gruxe1ficas-huion}}

He intentado un par de veces instalar con el fichero \texttt{deb} pero
parece que no funciona.

Para hacer la instalación via DKMS el truco está en:

\begin{itemize}
\tightlist
\item
  Dejar el código fuente en un directorio de la forma
  \texttt{/usr/src/\textless{}PROJECTNAME\textgreater{}-\textless{}VERSION\textgreater{}}
\item
  Lanzar el \texttt{build} pero usando esta vez
  \texttt{\textless{}PROJECTNAME\textgreater{}/\textless{}VERSION\textgreater{}}
\end{itemize}

Descargamos los últimos drivers desde
\href{https://github.com/DIGImend/digimend-kernel-drivers/releases}{la
página oficial de releases}, en el momento de escribir esto descargamos
la versión V9.

Descomprimimos en \texttt{/usr/src/digimend-9}

\begin{verbatim}
cd /usr/src
sudo xvzf <path-to-digimend-kernel-drivers-9> .
sudo dkms build digimend-kernel-drivers/9
sudo dkms install digimend/9
\end{verbatim}

Para comprobar:

\begin{verbatim}
xinput --list
dkms status
\end{verbatim}

Referencia:

\begin{itemize}
\tightlist
\item
  \href{https://davidrevoy.com/article331/setup-huion-giano-wh1409-tablet-on-linux-mint-18-1-ubuntu-16-04}{Aquí}
\end{itemize}

\hypertarget{sonido}{%
\section{Sonido}\label{sonido}}

\hypertarget{spotify}{%
\subsection{Spotify}\label{spotify}}

Spotify instalado desde las opciones de Linux Mint

\hypertarget{audacity}{%
\subsection{Audacity}\label{audacity}}

Añadimos ppa:

\begin{verbatim}
sudo add-apt-repository ppa:ubuntuhandbook1/audacity
sudo apt-get update
sudo apt install audacity
\end{verbatim}

Instalamos también el plugin
\href{https://theaudacitytopodcast.com/chriss-dynamic-compressor-plugin-for-audacity/}{Chris's
Dynamic Compressor plugin}

\hypertarget{clementine}{%
\subsection{Clementine}\label{clementine}}

La version disponible en los orígenes de software parece al dia:

\begin{verbatim}
sudo apt install clementine
\end{verbatim}

\hypertarget{video}{%
\section{Video}\label{video}}

\hypertarget{shotcut}{%
\subsection{Shotcut}\label{shotcut}}

Nos bajamos la \emph{AppImage} para Linux desde la
\href{https://www.shotcut.org/}{página web}.

La dejamos en \texttt{\textasciitilde{}/apps/shotcut} y:

\begin{verbatim}
cd
chmod 744 Shotcutxxxxxx.AppImage
./Shotcutxxxxxx.AppImage
\end{verbatim}

\hypertarget{kdenlive}{%
\subsection{kdenlive}\label{kdenlive}}

Está disponible como ppa o como \emph{appimage}. Lo he bajado como
\emph{appimage} para probarlo.

\hypertarget{openshot}{%
\subsection{Openshot}\label{openshot}}

También descargado desde su web como \emph{appimage}.

\hypertarget{grabaciuxf3n-de-screencast}{%
\subsection{Grabación de screencast}\label{grabaciuxf3n-de-screencast}}

\hypertarget{vokoscreen-y-kazam}{%
\subsubsection{Vokoscreen y Kazam}\label{vokoscreen-y-kazam}}

Instalados desde los repos oficiales:

\begin{verbatim}
sudo apt update
sudo apt install vokoscreen kazam
\end{verbatim}

\hypertarget{grabaciuxf3n-de-podcast}{%
\subsection{Grabación de podcast}\label{grabaciuxf3n-de-podcast}}

\hypertarget{mumble}{%
\subsubsection{Mumble}\label{mumble}}

Instalamos desde PPA

\begin{verbatim}
sudo add-apt-repository ppa:mumble/release
sudo apt update
    sudo apt install mumble
\end{verbatim}

\hypertarget{fotografuxeda}{%
\section{Fotografía}\label{fotografuxeda}}

\hypertarget{rawtherapee}{%
\subsection{Rawtherapee}\label{rawtherapee}}

Bajamos el AppImage desde la \href{http://rawtherapee.com/}{página web}
al directorio \texttt{\textasciitilde{}/apps/rawtherapee}.

\begin{verbatim}
cd
chmod 744 RawTherapeexxxxxx.AppImage
./RawTherapeexxxxxx.AppImage
\end{verbatim}

Al ejecutarla la primera vez ya se encarga la propia aplicación de
integrarse en nuestro sistema.

\hypertarget{darktable}{%
\subsection{Darktable}\label{darktable}}

Instalamos ppa:

\begin{verbatim}
sudo sh -c "echo 'deb http://download.opensuse.org/repositories/graphics:/darktable/xUbuntu_18.04/ /' > /etc/apt/sources.list.d/graphics:darktable.list"
wget -nv https://download.opensuse.org/repositories/graphics:darktable/xUbuntu_18.04/Release.key -O Release.key
sudo apt-key add - < Release.key
sudo apt update
sudo apt install darktable
\end{verbatim}

Se instala la última versión de Darktable (3.0.0)

\hypertarget{seguridad}{%
\section{Seguridad}\label{seguridad}}

\hypertarget{autenticaciuxf3n-en-servidores-por-clave-puxfablica}{%
\subsection{Autenticación en servidores por clave
pública}\label{autenticaciuxf3n-en-servidores-por-clave-puxfablica}}

Generar contraseñas para conexión servidores remotos:

\begin{verbatim}
cd ~
ssh-keygen -b 4096 [-t dsa | ecdsa | ed25519 | rsa | rsa1]
cat .ssh/
\end{verbatim}

Solo resta añadir nuestra clave pública en el fichero
\texttt{authorized\_keys} del servidor remoto.

\begin{verbatim}
cat ~/.ssh/id_xxx.pub | ssh user@hostname 'cat >> .ssh/authorized_keys'
\end{verbatim}

\href{https://www.digitalocean.com/community/tutorials/understanding-the-ssh-encryption-and-connection-process}{¿Cómo
funciona esto?}

\hypertarget{claves-gpg}{%
\subsection{Claves gpg}\label{claves-gpg}}

\texttt{gpg\ -\/-gen-key} Para generar nuestra clave.

\begin{itemize}
\tightlist
\item
  \textbf{Siempre} hay que ponerle una fecha de expiración, la puedes
  cambiar más tarde.
\item
  \textbf{Siempre} hay que escoger la máxima longitud posible
\end{itemize}

\hypertarget{seahorse}{%
\subsection{Seahorse}\label{seahorse}}

Para manejar todas nuestras claves con comodidad:

\texttt{sudo\ apt\ install\ seahorse}

\hypertarget{conexiuxf3n-a-github-con-claves-ssh}{%
\subsection{Conexión a github con claves
ssh}\label{conexiuxf3n-a-github-con-claves-ssh}}

Usando este método podemos conectarnos a github sin tener que teclear la
contraseña en cada conexión.

\hypertarget{claves-ssh}{%
\subsubsection{Claves ssh}\label{claves-ssh}}

Podemos echar un ojo a nuestras claves desde \texttt{seahorse} la
aplicación de gestión de claves que hemos instalado. También podemos ver
las claves que tenemos generadas:

\begin{verbatim}
ls -al ~/.ssh
\end{verbatim}

En las claves listadas nuestras claves públicas aparecerán con extensión
\texttt{.pub}

También podemos comprobar que claves hemos añadido ya a nuestro agente
ssh con:

\begin{verbatim}
ssh-add -l
\end{verbatim}

Para generar una nueva pareja de claves ssh:

\begin{verbatim}
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
\end{verbatim}

Podremos dar un nombre distintivo a los ficheros de claves generados y
poner una contraseña adecuada a la clave. Si algún dia queremos cambiar
la contraseña:

\begin{verbatim}
ssh-keygen -p
\end{verbatim}

Ahora tenemos que añadir nuestra clave ssh en nuestra cuenta de github,
para ello editamos con nuestro editor de texto favorito el fichero
\texttt{\textasciitilde{}/.ssh/id\_rsa.pub} y copiamos el contenido
integro. Después pegamos ese contenido en el cuadro de texto de la web
de github.

Para comprobar que las claves instaladas en github funcionan
correctamente:

\begin{verbatim}
ssh -T git@github.com
Hi salvari! You've successfully authenticated, but GitHub does not provide shell access.
\end{verbatim}

Este mensaje indica que todo ha ido bien.

Ahora en los repos donde queramos usar ssh debemos cambiar el remote:

\begin{verbatim}
git remote set-url origin git@github.com:$USER/$REPONAME.git
\end{verbatim}

\hypertarget{signal}{%
\subsection{Signal}\label{signal}}

El procedimiento recomendado en la página oficial:

\begin{verbatim}
curl -s https://updates.signal.org/desktop/apt/keys.asc | sudo apt-key add -
echo "deb [arch=amd64] https://updates.signal.org/desktop/apt xenial main" | sudo tee -a /etc/apt/sources.list.d/signal-xenial.list
sudo apt update && sudo apt install signal-desktop
\end{verbatim}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{NOTA}: Parece que no funciona. Lo he instalado via
\emph{flatpack}

\begin{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\hypertarget{lector-dni-electruxf3nico}{%
\subsection{Lector DNI electrónico}\label{lector-dni-electruxf3nico}}

Instalamos:

\begin{verbatim}
sudo apt-get install pcscd pcsc-tools libccid
\end{verbatim}

Como root ejecutamos pcsc\_scan:

\begin{verbatim}
root@rasalhague:~# pcsc_scan 
PC/SC device scanner
V 1.4.23 (c) 2001-2011, Ludovic Rousseau <ludovic.rousseau@free.fr>
Compiled with PC/SC lite version: 1.8.11
Using reader plug'n play mechanism
Scanning present readers...
Waiting for the first reader...
\end{verbatim}

Si insertamos el lector veremos algo como esto:

\begin{verbatim}
root@rasalhague:~# pcsc_scan 
PC/SC device scanner
V 1.4.23 (c) 2001-2011, Ludovic Rousseau <ludovic.rousseau@free.fr>
Compiled with PC/SC lite version: 1.8.11
Using reader plug'n play mechanism
Scanning present readers...
Waiting for the first reader...found one
Scanning present readers...
0: C3PO LTC31 v2 (11061005) 00 00

Wed Jan 25 01:17:20 2017
Reader 0: C3PO LTC31 v2 (11061005) 00 00
  Card state: Card removed,
\end{verbatim}

Si insertamos un DNI veremos que se lee la información de la tarjeta
insertada:

\begin{verbatim}
Reader 0: C3PO LTC31 v2 (11061005) 00 00
  Card state: Card inserted, 
\end{verbatim}

y mas rollo

Instalamos ahora el modulo criptográfico desde
\href{https://www.dnielectronico.es/PortalDNIe/PRF1_Cons02.action?pag=REF_1112}{este
enlace}

Y además:

\begin{verbatim}
aptitude install pinentry-gtk2 opensc
\end{verbatim}

\hypertarget{virtualizaciones-y-contenedores}{%
\section{Virtualizaciones y
contenedores}\label{virtualizaciones-y-contenedores}}

\hypertarget{instalaciuxf3n-de-virtualbox}{%
\subsection{\texorpdfstring{Instalación de
\emph{virtualBox}}{Instalación de virtualBox}}\label{instalaciuxf3n-de-virtualbox}}

Lo hacemos con los origenes de software oficiales (alternativamente,
podríamos hacerlo manualmente):

\begin{verbatim}
# Importamos la clave gpg
wget -q https://www.virtualbox.org/download/oracle_vbox_2016.asc -O- | sudo apt-key add -

# Añadimos el nuevo origen de software
sudo add-apt-repository "deb [arch=amd64] https://download.virtualbox.org/virtualbox/debian $(. /etc/os-release; echo "$UBUNTU_CODENAME") contrib"

# Actualizamos la base de datos de paquetes
sudo apt update
\end{verbatim}

Ahora podemos comprobar que además del paquete \emph{virtualbox} tenemos
varios paquetes con número de versión (p.ej. \_virtualbox.6.1), estos
últimos son los que hemos añadido (compruebalo con
\texttt{apt-cache\ policy\ {[}nombrepaquete{]}})

Instalamos el que nos interesa:

\begin{verbatim}
sudo apt install virtualbox-6.1
\end{verbatim}

Descargamos también el
\href{https://www.virtualbox.org/wiki/Downloads}{VirtualBox Extension
Pack}, este paquete lo instalaremos desde el propio interfaz de usuario
del \emph{VirtualBox}. Y lo instalamos con el comando:

\begin{verbatim}
sudo VBoxManage extpack install ./Oracle_VM_VirtualBox_Extension_Pack-6.1.2.vbox-extpack 
\end{verbatim}

Sólo nos queda añadir nuestro usuario al grupo \texttt{vboxusers}, con
el comando \texttt{sudo\ gpasswd\ -a\ username\ vboxusers}, y tendremos
que cerrar la sesión para refrescar nuestros grupos.

\hypertarget{qemu}{%
\subsection{qemu}\label{qemu}}

Instalamos desde el repo oficial:

\begin{verbatim}
sudo apt install qemu-kvm qemu virt-manager virt-viewer libvirt-bin
\end{verbatim}

\hypertarget{docker}{%
\subsection{Docker}\label{docker}}

Tenemos que añadir el repositorio correspondiente a nuestra
distribución:

\begin{verbatim}
# Be safe
sudo apt remove docker docker-engine docker.io
sudo apt autoremove
sudo apt update

# Install pre-requisites
sudo apt install ca-certificates curl

# Import the GPG key

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

# Next, point the package manager to the official Docker repository

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(. /etc/os-release; echo "$UBUNTU_CODENAME") stable"

# Update the package database

sudo apt update
#

apt-cache policy docker-ce

sudo apt install docker-ce

sudo gpasswd -a salvari docker
\end{verbatim}

Esto dejará el servicio \emph{docker} funcionando y habilitado
(arrancará en cada reinicio del ordenador)

La forma de pararlo es:

\begin{verbatim}
sudo systemctl stop docker
sudo systemctl disable docker
systemctl status docker
\end{verbatim}

Añadimos el \emph{bundle} \textbf{docker} en nuestro fichero
\texttt{\textasciitilde{}/.zshrc} para tener autocompletado en comandos
de docker.

Para usar \emph{docker} tendremos que arrancarlo, con los alias de
nuestro sistema para \emph{systemd} ejecutamos:

\begin{verbatim}
scst docker  # para arrancar el servicio

scsp docker  # para parar el servicio
\end{verbatim}

\hypertarget{docker-compose}{%
\subsubsection{docker-compose}\label{docker-compose}}

\begin{itemize}
\tightlist
\item
  Nos bajamos la última versión disponible de
  \href{https://github.com/docker/compose/releases}{las releases de
  github}
\item
  Movemos el fichero que hemos descargado a
  \texttt{/usr/local/bin/docker-compose}
\item
  Y le damos permisos de ejecución
  \texttt{sudo\ chmod\ +x\ /usr/local/bin/docker-compose}
\end{itemize}

\hypertarget{utilidades-para-mapas-y-cartografuxeda}{%
\section{Utilidades para mapas y
cartografía}\label{utilidades-para-mapas-y-cartografuxeda}}

\hypertarget{josm}{%
\subsection{josm}\label{josm}}

Descargamos y añadimos la clave gpg:

\begin{verbatim}
wget -q https://josm.openstreetmap.de/josm-apt.key -O- | sudo apt-key add -
\end{verbatim}

Añadimos el origen de software:

\begin{verbatim}
sudo add-apt-repository "deb [arch=amd64] https://josm.openstreetmap.de/apt $(. /etc/os-release; echo "$UBUNTU_CODENAME") universe"
\end{verbatim}

Y ahora procedemos a la instalación:

\begin{verbatim}
sudo apt update
sudo apt install openjfx josm 
\end{verbatim}

Alternativamente también podemos instalar la versión ``nightly'' con el
siguienete comando, pero tendréis actualizaciones diarias:

\begin{verbatim}
sudo apt josm-latest
\end{verbatim}

Ya estamos listos para editar Open Street Map offline.

\hypertarget{mobac}{%
\subsection{MOBAC}\label{mobac}}

Bajamos el paquete desde \href{http://mobac.sourceforge.net/}{la página
web} y descomprimimos en \texttt{\textasciitilde{}/apps/mobac} como de
costumbre nos creamos una entrada de menú con \emph{MenuLibre}.

Conviene bajarse wms adicionales para MOBAC y leerse
\href{http://mobac.sourceforge.net/wiki/index.php/Custom_XML_Map_Sources}{la
wiki}

\hypertarget{referencias-1}{%
\subsubsection{Referencias}\label{referencias-1}}

*{[}Cartografía digital{]}
(https://digimapas.blogspot.com.es/2015/01/oruxmaps-vii-mapas-de-mobac.html)

\hypertarget{qgis}{%
\subsection{QGIS}\label{qgis}}

Añadimos la clave gpg:

\begin{verbatim}
wget -q  https://qgis.org/downloads/qgis-2017.gpg.key -O- | sudo apt-key add -
\end{verbatim}

Ejecutamos:

\begin{verbatim}
sudo add-apt-repository "deb [arch=amd64] https://qgis.org/debian $(. /etc/os-release; echo "$UBUNTU_CODENAME") main"
\end{verbatim}

E instalamos como siempre

\begin{verbatim}
sudo apt update
sudo apt install qgis
\end{verbatim}

\hypertarget{referencias-2}{%
\subsubsection{Referencias}\label{referencias-2}}

\begin{itemize}
\tightlist
\item
  \href{https://mappinggis.com/2015/09/como-conectar-con-servicios-wms-y-wfs-con-arcgis-qgis-y-gvsig/}{Conectar
  WMS con QGIS}
\item
  \href{https://www.altergeosistemas.com/blog/2014/03/28/importando-datos-de-osm-en-qgis-2/}{Importar
  OSM en QGIS}
\item
  \href{http://learnosm.org/es/osm-data/osm-in-qgis/}{Learn OSM}
\item
  \href{http://www.qgistutorials.com/es/docs/downloading_osm_data.html}{QGIS
  Tutorials}
\end{itemize}

\hypertarget{recetas-variadas}{%
\section{Recetas variadas}\label{recetas-variadas}}

\hypertarget{solucionar-problemas-de-menuxfas-duplicados-usando-menulibre}{%
\subsection{Solucionar problemas de menús duplicados usando
menulibre}\label{solucionar-problemas-de-menuxfas-duplicados-usando-menulibre}}

\begin{longtable}[]{@{}l@{}}
\toprule
\endhead
\textbf{Nota}: Ya no uso \emph{MenuLibre}\tabularnewline
\bottomrule
\end{longtable}

En el directorio
\texttt{\textasciitilde{}/.config/menus/applications-merged} borramos
todos los ficheros que haya.

\hypertarget{formatear-memoria-usb}{%
\subsection{Formatear memoria usb}\label{formatear-memoria-usb}}

``The driver descriptor says the physical block size is 2048 bytes, but
Linux says it is 512 bytes.''

Este comando borró todas las particiones de la memoria:

\texttt{sudo\ dd\ if=/dev/zero\ of=/dev/sdd\ bs=2048\ count=32\ \&\&\ sync}

I'm assuming your using gparted.

First delete whatever partitions you can\ldots just keep pressing
ignore.

There will be one with a black outline\ldots you will have to unmount
it\ldots just right click on it and unmount.

Again you will have to click your way through ignore..if fix is an
option choose it also.

Once all this is done\ldots{} you can select the device menu and choose
new partition table.

Select MSdos

Apply and choose ignore again.

Once it's done it show it's real size.

Next you can format the drive to whichever file system you like.

It's a pain in the behind this way, but it's the only way I get it
done..I put live iso's on sticks all the time and have to remove them. I
get stuck going through this process every time.

\hypertarget{copiar-la-clave-puxfablica-ssh-en-un-servidor-remoto}{%
\subsection{Copiar la clave pública ssh en un servidor
remoto}\label{copiar-la-clave-puxfablica-ssh-en-un-servidor-remoto}}

\texttt{cat\ /home/tim/.ssh/id\_rsa.pub\ \textbar{}\ ssh\ tim@just.some.other.server\ \textquotesingle{}cat\ \textgreater{}\textgreater{}\ .ssh/authorized\_keys\textquotesingle{}}

O también:

\texttt{ssh-copy-id\ -i\ \textasciitilde{}/.ssh/id\_rsa.pub\ username@remote.server}

\hypertarget{ssh-access-from-termux}{%
\subsection{ssh access from termux}\label{ssh-access-from-termux}}

\url{https://linuxconfig.org/ssh-into-linux-your-computer-from-android-with-termux}

\hypertarget{sdr-instalaciones-varias}{%
\subsection{SDR instalaciones varias}\label{sdr-instalaciones-varias}}

Vamos a trastear con un dispositivo
\href{https://www.rtl-sdr.com/}{RTL-SDR.com}.

Tenemos un montón de información en el blog de
\href{https://sdrgal.wordpress.com/}{SDR Galicia} y tienen incluso una
guia de instalación muy completa, pero yo voy a seguir una guía un poco
menos ambiciosa, por lo menos hasta que pueda hacer el curso que
imparten ellos mismos (SDR Galicia)

La guía en cuestión la podemos encontrar
\href{https://ranous.wordpress.com/rtl-sdr4linux/}{aquí}

Seguimos los pasos de instalación:

\begin{itemize}
\tightlist
\item
  La instalación de \texttt{git}, \texttt{cmake} y
  \texttt{build-essential} ya la tengo hecha.
\end{itemize}

\begin{verbatim}
sudo apt-get install libusb-1.0-0-dev
\end{verbatim}

\hypertarget{posible-problema-con-modemmanager-y-micros-programables}{%
\subsection{Posible problema con modemmanager y micros
programables}\label{posible-problema-con-modemmanager-y-micros-programables}}

Programando el \emph{Circuit Playground Express} con el \emph{Arduino
IDE} tenía problemas continuos para hacer los \emph{uploads}, al parecer
el servicio \emph{ModemManager} es el culpable, se pasa todo el tiempo
capturando los nuevos puertos serie por que considera que todo es un
modem.

Una prueba rápida para comprobarlo:
\texttt{sudo\ systemctl\ stop\ ModemManager}

Con esto funciona todo bien, pero en el siguiente arranque volvera a
cargarse.

Para dar una solución definitiva se puede programar una regla para
impedir que el \emph{ModemManager} capture el puerto con un dispositivo

Creamos un fichero con permisos de \texttt{root} en el directorio
\texttt{/etc/udev/rules.d} que llamaremos: \texttt{99-arduino.rules}

Dentro de ese fichero especificamos los codigos VID/PID que se deben
ignorar:

\begin{verbatim}
# for arduino brand, stop ModemManager grabbing port
ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
# for sparkfun brand, stop ModemManager grabbing port
ATTRS{idVendor}=="1b4f", ENV{ID_MM_DEVICE_IGNORE}="1"
\end{verbatim}

Ojo que si tienes SystemV no va a funcionar.

https://starter-kit.nettigo.eu/2015/serial-port-busy-for-avrdude-on-ubuntu-with-arduino-leonardo-eth/

https://www.codeproject.com/Tips/349002/Select-a-USB-Serial-Device-via-its-VID-PID

\hypertarget{programar-los-nanos-con-chip-ch340-o-ch341}{%
\subsection{Programar los nanos con chip ch340 o
ch341}\label{programar-los-nanos-con-chip-ch340-o-ch341}}

Linux mapea el chip correctamente en un puerto \texttt{/dev/ttyUSB0} y
con eso basta, que no te lien con el cuento de ``drivers para linux''

Todo lo que hace falta es configurar correctamente el \emph{Arduino
IDE}, hay que escoger:

\begin{verbatim}
Board: "Arduino Nano"
Processor: "ATmega168"
Port: "/dev/ttyUSB0"
\end{verbatim}

Y ya funciona todo.

\end{document}