% Options for packages loaded elsewhere
\PassOptionsToPackage{unicode}{hyperref}
\PassOptionsToPackage{hyphens}{url}
\PassOptionsToPackage{dvipsnames,svgnames,x11names}{xcolor}
%
\documentclass[
  12pt,
]{article}
\usepackage{amsmath,amssymb}
\usepackage{iftex}
\ifPDFTeX
  \usepackage[T1]{fontenc}
  \usepackage[utf8]{inputenc}
  \usepackage{textcomp} % provide euro and other symbols
\else % if luatex or xetex
  \usepackage{unicode-math} % this also loads fontspec
  \defaultfontfeatures{Scale=MatchLowercase}
  \defaultfontfeatures[\rmfamily]{Ligatures=TeX,Scale=1}
\fi
\usepackage{lmodern}
\ifPDFTeX\else
  % xetex/luatex font selection
  \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}
\usepackage[a4paper]{geometry}
\usepackage{color}
\usepackage{fancyvrb}
\newcommand{\VerbBar}{|}
\newcommand{\VERB}{\Verb[commandchars=\\\{\}]}
\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
% Add ',fontsize=\small' for more characters per line
\newenvironment{Shaded}{}{}
\newcommand{\AlertTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{#1}}}
\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.49,0.56,0.16}{#1}}
\newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
\newcommand{\BuiltInTok}[1]{\textcolor[rgb]{0.00,0.50,0.00}{#1}}
\newcommand{\CharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\CommentTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textit{#1}}}
\newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.53,0.00,0.00}{#1}}
\newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{#1}}}
\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.56,0.13,0.00}{#1}}
\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
\newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.73,0.13,0.13}{\textit{#1}}}
\newcommand{\ErrorTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{#1}}}
\newcommand{\ExtensionTok}[1]{#1}
\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
\newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.02,0.16,0.49}{#1}}
\newcommand{\ImportTok}[1]{\textcolor[rgb]{0.00,0.50,0.00}{\textbf{#1}}}
\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{#1}}}
\newcommand{\NormalTok}[1]{#1}
\newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.40,0.40,0.40}{#1}}
\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{#1}}
\newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.74,0.48,0.00}{#1}}
\newcommand{\RegionMarkerTok}[1]{#1}
\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.73,0.40,0.53}{#1}}
\newcommand{\StringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.10,0.09,0.49}{#1}}
\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\WarningTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\usepackage{longtable,booktabs,array}
\usepackage{calc} % for calculating minipage widths
% 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}
\usepackage{graphicx}
\makeatletter
\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth\else\Gin@nat@width\fi}
\def\maxheight{\ifdim\Gin@nat@height>\textheight\textheight\else\Gin@nat@height\fi}
\makeatother
% Scale images if necessary, so that they will not overflow the page
% margins by default, and it is still possible to overwrite the defaults
% using explicit options in \includegraphics[width, height, ...]{}
\setkeys{Gin}{width=\maxwidth,height=\maxheight,keepaspectratio}
% Set default figure placement to htbp
\makeatletter
\def\fps@figure{htbp}
\makeatother
\setlength{\emergencystretch}{3em} % prevent overfull lines
\providecommand{\tightlist}{%
  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
\setcounter{secnumdepth}{5}
\ifLuaTeX
\usepackage[bidi=basic]{babel}
\else
\usepackage[bidi=default]{babel}
\fi
\babelprovide[main,import]{spanish}
\ifPDFTeX
\else
\babelfont{rm}[]{Ubuntu}
\fi
% get rid of language-specific shorthands (see #6817):
\let\LanguageShortHands\languageshorthands
\def\languageshorthands#1{}
\ifLuaTeX
  \usepackage{selnolig}  % disable illegal ligatures
\fi
\IfFileExists{bookmark.sty}{\usepackage{bookmark}}{\usepackage{hyperref}}
\IfFileExists{xurl.sty}{\usepackage{xurl}}{} % add URL line breaks if available
\urlstyle{same}
\hypersetup{
  pdftitle={Bitácora Linux Mint 21.1 Vera},
  pdfauthor={Sergio Alvariño salvari@gmail.com},
  pdflang={es-ES},
  pdfsubject={Linux Mint 21.1 Vera},
  pdfkeywords={linux, postinstalación, mint, ulyana},
  colorlinks=true,
  linkcolor={Maroon},
  filecolor={Maroon},
  citecolor={Blue},
  urlcolor={Blue},
  pdfcreator={LaTeX via pandoc}}

\title{Bitácora Linux Mint 21.1 Vera}
\author{Sergio Alvariño
\href{mailto:salvari@gmail.com}{\nolinkurl{salvari@gmail.com}}}
\date{enero-2023}

\begin{document}
\maketitle
\begin{abstract}
Bitácora de mi portatil Instalación de Linux Mint Vera Solo para
referencia rápida y personal.
\end{abstract}

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

Mis portatiles son:

\begin{itemize}
\item
  Un ordenador Acer 5755G con las siguientes características:

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

  Este 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.
\item
  Un Lenovo Legion

  \begin{itemize}
  \item
    Core i7-9750H
  \item
    Nvidia GTX1650-4Gb (+ intel integrada)
  \item
    16Gb RAM
  \item
    512Gb SSD + 1Tb HDD
  \end{itemize}
\end{itemize}

\section{Instalación de Linux Mint}\label{instalaciuxf3n-de-linux-mint}

Lanzamos el programa de instalación desde una memoria USB con la ISO de
la versión Mate.

Al arrancar el USB podemos conectarnos a internet (en mi caso, me
conecto a la wifi)

Mis opciones de instalación:

\begin{itemize}
\tightlist
\item
  Escojo el idioma \emph{Inglés} (manias mias, suelo dejar mi Linux en
  inglés)
\item
  Teclado: \emph{Español}
\item
  Marco la opción de instalar codecs
\end{itemize}

Generalmente hago particiones:

\begin{itemize}
\tightlist
\item
  540 Mb para EFI (opcional, si desactivas UEFI en la Bios no te hace
  falta)
\item
  70 Gb para \emph{root}, es decir \texttt{/}
\item
  El resto del disco SSD para \texttt{/home}
\item
  El disco HDD lo monto en una sola partición en \texttt{/store}
\end{itemize}

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

Lo primero de todo es hacer una actualización completa del sistema:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt upgrade}
\end{Highlighting}
\end{Shaded}

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

Linux Mint incluye \texttt{sudo} y las aplicaciones que uso
habitualmente para gestión de paquetes por defecto (\emph{aptitude} y
\emph{synaptic}).

Interesa tener instalado el paquete \emph{ppa-purge}
(\texttt{sudo\ apt\ install\ ppa-purge}). Sirve para eliminar ppas junto
con los programas instalados desde ese ppa.

Tampoco voy a enredar nada con los orígenes del software (de momento),
es decir no voy a cambiar al depósito regional. Si quieres cambiarlo, en
mi experiencia los más rápidos suelen ser los alemanes.

\subsection{Firmware}\label{firmware}

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

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

Instalamos el driver de Nvidia recomendado, después de la instalación
inicial el \emph{Mint} nos avisará 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 del menú del driver.

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{]}}. También podremos
acceder a las funciones de Nvidia a través del applet en la barra de
estado de nuestro escritorio.

Además de los drivers adicionales, Linux Mint nos dirá que tiene que
instalar unos paquetes de idioma, los instalamos.

\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
todos los cambios que se produzcan en el directorio \texttt{/etc}
durante nuestra instalación queden reflejados en el git.

Yo nunca almaceno esta información en la nube (por seguridad), pero me
permite tener controlados los cambios de configuración y ayuda en caso
de problemas.

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

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ su }\AttributeTok{{-}}
\FunctionTok{git}\NormalTok{ config }\AttributeTok{{-}{-}global}\NormalTok{ init.defaultBranch main}
\FunctionTok{git}\NormalTok{ config }\AttributeTok{{-}{-}global}\NormalTok{ user.email xxxxx@whatever.com}
\FunctionTok{git}\NormalTok{ config }\AttributeTok{{-}{-}global}\NormalTok{ user.name }\StringTok{"Name Surname"}
\ExtensionTok{apt}\NormalTok{ install etckeeper}
\end{Highlighting}
\end{Shaded}

\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{Shaded}
\begin{Highlighting}[]
\BuiltInTok{cd}\NormalTok{ /etc}
\FunctionTok{sudo}\NormalTok{ git log}
\end{Highlighting}
\end{Shaded}

\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, yo suelo usar el directorio
\texttt{\textasciitilde{}/work/repos}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mkdir}\NormalTok{ usrcfg}
\BuiltInTok{cd}\NormalTok{ usrcfg}
\FunctionTok{git}\NormalTok{ init}
\FunctionTok{git}\NormalTok{ config core.worktree }\StringTok{"/home/salvari"}
\end{Highlighting}
\end{Shaded}

Y ya lo tenemos, un repo de git, en la localización que queramos y que
tiene el directorio de trabajo apuntando a nuestro \emph{\$HOME}.

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{git}\NormalTok{ add .bashrc}
\FunctionTok{git}\NormalTok{ commit }\AttributeTok{{-}m} \StringTok{"Add some dotfiles"}
\end{Highlighting}
\end{Shaded}

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 que quiero tener controlados al repo.

Yo no tengo información confidencial en este repositorio (claves ssh por
ejemplo) así que no tengo problemas en almacenarlo en la nube. Facilita
mucho las cosas en casos de upgrade del sistema o copiar configuraciones
entre ordenadores.

\subsection{Editor desde linea de
comandos}\label{editor-desde-linea-de-comandos}

Hasta que instalemos nuestro editor favorito (\emph{Emacs} en mi caso)
podemos usar \emph{nano} desde la linea de comandos para editar
cualquier fichero.

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

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mount} \AttributeTok{{-}o}\NormalTok{ remount /}
\FunctionTok{mount} \AttributeTok{{-}o}\NormalTok{ remount /home}
\FunctionTok{mount}
\end{Highlighting}
\end{Shaded}

\subsubsection{\texorpdfstring{Ajustes adicionales para
\emph{Firefox}}{Ajustes adicionales para Firefox}}\label{ajustes-adicionales-para-firefox}

Las diferencias de rendimiento del Firefox con estos ajustes son
bastante notables.

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}

Y siguiendo
\href{https://linuxreviews.org/HOWTO_Make_Mozilla_Firefox_Blazing_Fast_On_Linux}{esta
otra referencia} cambiamos:

\begin{itemize}
\tightlist
\item
  \texttt{gfx.x11-egl.force-enabled} \textbf{true}
\item
  \textbf{IMPORTANTE} Ajustar el parámetro
  \texttt{network.IDN\_show\_punycode} a \textbf{true} (para evitar
  ataques de URL falsas con caracteres Unicode)
\end{itemize}

Reiniciamos nuestro \emph{Firefox} (podemos visitar
\texttt{about:restartRequired})

\subsection{Fuentes (tipográficas)
adicionales}\label{fuentes-tipogruxe1ficas-adicionales}

Instalamos algunas fuentes desde los orígenes de software:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install ttf{-}mscorefonts{-}installer}
\FunctionTok{sudo}\NormalTok{ apt install fonts{-}noto}
\end{Highlighting}
\end{Shaded}

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}

Puede ser conveniente instalar el paquete \emph{font-manager}
(\texttt{sudo\ apt\ install\ font-manager}), sólo lo uso para visualizar
fuentes, no para hacer configuración.

Instaladas varias de las
\href{https://github.com/ryanoasis/nerd-fonts}{nerd-fonts} en
\texttt{\textasciitilde{}/.local/share/fonts}. Simplemente descargamos
las fuentes interesantes y ejecutamos \texttt{sudo\ fc-cache\ -f\ -v}

Fuentes interesantes:

\begin{itemize}
\tightlist
\item
  \href{https://github.com/ryanoasis/nerd-fonts}{nerd-fonts}
\item
  \href{https://github.com/powerline/fonts}{Powerline fonts}
\item
  \href{https://github.com/ProgrammingFonts/ProgrammingFonts}{Programming
  fonts}
\end{itemize}

\subsection{Firewall}\label{firewall}

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

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{aptitude}\NormalTok{ install ufw}
\ExtensionTok{ufw}\NormalTok{ default deny}
\ExtensionTok{ufw}\NormalTok{ enable}
\ExtensionTok{ufw}\NormalTok{ status verbose}
\ExtensionTok{aptitude}\NormalTok{ install gufw}
\end{Highlighting}
\end{Shaded}

\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. Yo normalmente lo dejo desactivado
excepto cuando valido una nueva configuración.
\end{quote}

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

\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[KeepassXC]
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 que puede instalarse desde la web o desde el
flathub.
\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
\item[tree]
Para ver estructuras de directorios
\item[neofetch]
Este solo vale para presumir de ordenador creo ¬\_¬
\item[fasd]
Para cambiar entre directorios rápidamente
\item[silversearcher-ag]
Una alternativa mejorada al clásico \emph{grep}
\item[ack]
Otro grep mejorado
\item[ncdu]
Un analizador de uso de disco alternativa a \texttt{du}
\item[mate-tweak]
Para \emph{customizar} nuestro escritorio Mate
\item[filezilla]
Un interfaz gráfico para transferencia de ficheros
\item[rofi]
Un conmutador de ventanas capaz de automatizar muchas tareas
\item[Chromium]
Como Chrome pero libre, en Linux Mint no hay snaps, puedes instalarlo
directamente con \texttt{apt}
\end{description}

Para instalar todos los programas ejecutamos:

\begin{verbatim}
sudo apt install keepassxc gnucash deluge rsync grsync rar unrar \
zip unzip unace bzip2 lzop p7zip p7zip-full p7zip-rar \
most mc tree neofetch fasd silversearcher-ag ack ncdu mate-tweak filezilla \
rofi chromium
\end{verbatim}

\subsection{Algunos programas de control del
sistema}\label{algunos-programas-de-control-del-sistema}

Son útiles para control de consumo.

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

\textbf{btop} también está muy bien, así que descargamos los binarios
desde \href{https://github.com/aristocratos/btop}{su página web} dentro
del binario tenemos el ejecutable y un fichero \texttt{.desktop}. En mi
caso hago una cutre-instalación con el ejecutable en
\texttt{\textasciitilde{}/.local/bin} y el fichero \texttt{.desktop}
copiado en mi \texttt{\textasciitilde{}/.local/share/applications} (ver
la sección \hyperref[varias-aplicaciones-instaladas-de-binarios]{Varias
aplicaciones instaladas de binarios})

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

Antes instalaba dos programas de terminal:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install guake terminator}
\end{Highlighting}
\end{Shaded}

\emph{terminator} lo dejamos como aplicación terminal preferida del
sistema.

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

Pero es mucho más sencillo intalar \emph{Terminus} de
\textbf{\emph{rastersoft}}. Descargo el paquete desde su web
\href{https://www.rastersoft.com/programas/terminus.html}{www.rastersoft.com}
Con este programa tienes lo mismo que ofrecen Terminator y Guake por
separado.

También instalo \emph{rxvt} teoricamente más ligero y que puedes
complementar con \emph{tmux}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install rxvt{-}unicode}
\end{Highlighting}
\end{Shaded}

\subsubsection{tmux}\label{tmux}

\emph{tmux} combinado por ejemplo con \emph{rxvt} nos da la misma
funcionalidad que \emph{Terminator}, además merece la pena aprender a
usarlo por que instalado en servidores remotos es increíblemente útil.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install tmux}
\end{Highlighting}
\end{Shaded}

\begin{itemize}
\tightlist
\item
  \href{https://leanpub.com/the-tao-of-tmux/read}{El tao de tmux}
\item
  \href{https://www.askapache.com/linux/rxvt-xresources/}{rxvt
  customizations}
\end{itemize}

\subsection{Dropbox}\label{dropbox}

Lo instalamos desde el software manager. Previamente debemos instalar el
paquete \texttt{python3-gpg} y desde el software manager instalamos
también el paquete \texttt{Caja-dropbox}, para tener las integraciones
de Dropbox en el gestor de ficheros.

\subsection{pCloud}\label{pcloud}

Instalado desde su página web.

\subsection{Chrome}\label{chrome}

No lo he instalado.

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

\subsection{Thorium}\label{thorium}

Bajamos los binarios desde \href{https://thorium.rocks/}{su página web}.
Descomprimimos en \texttt{\textasciitilde{}/apps} y ajustamos los
ficheros \texttt{.desktop} para que apunten a los binarios. (ver la
siguiente sección
\hyperref[varias-aplicaciones-instaladas-de-binarios]{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{}/apps} por que el
portátil es personal e intrasferible. En un ordenador compartido es
mejor usar \texttt{/opt}.

En general cuando instalo en el directorio
\texttt{\textasciitilde{}/apps} sigo los siguientes pasos:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  Descargamos los binarios o \emph{appimage} desde la web
\item
  Descomprimo en un nuevo directorio para la aplicación, tomamos como
  ejemplo freeplane, así que el directorio se llamará:
  \texttt{\textasciitilde{}/apps/mi\_aplicacion} en nuestro ejemplo
  \texttt{\textasciitilde{}/apps/freeplane}
\item
  Creamos enlace simbólico al que llamamos \texttt{current}. Esto es
  para no editar los ficheros \texttt{.desktop} cada vez que
  actualicemos la versión del programa. El enlace puede apuntar a un
  directorio o a un binario, depende de como obtengamos la aplicación.
  En el caso de freeplane yo tengo la siguiente estructura

\begin{verbatim}
freeplane
├── current -> freeplane-1.7.11
├── freeplane-1.7.10
└── freeplane-1.7.11
\end{verbatim}

  Vemos que el enlace apunta a la versión más reciente de
  \emph{freeplane}.
\item
  Añadimos la aplicación a los menús, al hacer esto se creará un fichero
  \texttt{.desktop} en el directorio
  \texttt{\textasciitilde{}/.local/share/applications}
\end{enumerate}

\subsubsection{Freeplane}\label{freeplane}

Para hacer mapas mentales, presentaciones, resúmenes, apuntes\ldots{} La
versión incluida en LinuxMint está un poco anticuada, descargamos el
programa desde \href{https://docs.freeplane.org/}{la página web}.

\subsubsection{Treesheets}\label{treesheets}

Está bien para hacer chuletas rápidamente. Descargamos el
\emph{appimage} desde \href{http://strlen.com/treesheets/}{la web}

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

Cliente de Telegram, descargado desde la
\href{https://desktop.telegram.org/}{página web}. El programa de
instalación de Telegram ya se encarga de crear el fichero
\texttt{.desktop}

\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}

Tor se encarga tanto de crear el fichero \texttt{.desktop} como de
mantenerse actualizado a la última versión.

\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{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install curl}

\FunctionTok{sudo}\NormalTok{ curl }\AttributeTok{{-}fsSLo}\NormalTok{ /usr/local/share/keyrings/brave{-}browser{-}archive{-}keyring.gpg https://brave{-}browser{-}apt{-}release.s3.brave.com/brave{-}browser{-}archive{-}keyring.gpg}

\BuiltInTok{echo} \StringTok{"deb [signed{-}by=/usr/local/share/keyrings/brave{-}browser{-}archive{-}keyring.gpg] https://brave{-}browser{-}apt{-}release.s3.brave.com/ stable main"}\KeywordTok{|}\FunctionTok{sudo}\NormalTok{ tee /etc/apt/sources.list.d/brave{-}browser{-}release.list}

\FunctionTok{sudo}\NormalTok{ apt update}

\FunctionTok{sudo}\NormalTok{ apt install brave{-}browser}
\end{Highlighting}
\end{Shaded}

\subsubsection{TiddlyDesktop}\label{tiddlydesktop}

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

\subsubsection{Joplin}\label{joplin}

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

Instalamos siguiendo las instrucciones de la
\href{https://joplinapp.org/}{página web}

\begin{Shaded}
\begin{Highlighting}[]
 \FunctionTok{wget} \AttributeTok{{-}O} \AttributeTok{{-}}\NormalTok{ https://raw.githubusercontent.com/laurent22/joplin/master/Joplin\_install\_and\_update.sh }\KeywordTok{|} \FunctionTok{bash}
\end{Highlighting}
\end{Shaded}

Joplin se instala en el directorio \texttt{\textasciitilde{}/.joplin} y
crea su propia entrada en el menú.

La primera vez que configuremos la sincronización de Joplin conviene
hacer un borrado local con download desde el remoto.

\subsection{Terminal y shells}\label{terminal-y-shells}

Por defecto tenemos instalado \texttt{bash}.

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

Para dejar configurado el \emph{bash-git-prompt} seguimos las
instrucciones de
\href{https://github.com/magicmonty/bash-git-prompt}{este github}

\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-is-python3
apt install python3-all-dev
apt install python3-virtualenv python3-virtualenvwrapper
apt install pipx python3-poetry
\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}

Para el \texttt{zsh-git-prompt} clonamos el fichero \texttt{zshrc.sh}
desde nuestro repo de configuraciones.

Clonamos el fichero \texttt{\textasciitilde{}/.zshrc} desde nuestro repo
de configuraciones. De momento es mejor comentar la linea del tema :

\begin{verbatim}
antigen theme gnzh
\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/.virtualenvs" ] ; then
    WORKON_HOME="$HOME/.virtualenvs"
fi
\end{verbatim}

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

\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 \texttt{zsh-git-prompt}
cambiando la linea `echo ``\$STATUS'':

\begin{verbatim}
#echo "$STATUS"
if [[ "$__CURRENT_GIT_STATUS" == ": 0 0 0 0 0 0" ]]; then
    echo ""
else
    echo "$STATUS"
fi
\end{verbatim}

También he cambiado el fichero del tema \emph{gnzh} en
\texttt{\textasciitilde{}/.antigen/bundles/robbyrussell/oh-my-zsh/themes/gnzh.zsh-theme}
por que me interesa ver la versión python asociada a cada virtualenv.

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

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

Cuando estemos contentos con nuestro \texttt{zsh} tendremos que ejecutar
\texttt{chsh\ -s\ /usr/bin/zsh}

\subsection{Syncthing}\label{syncthing}

Añadimos el ppa:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{curl} \AttributeTok{{-}s}\NormalTok{ https://syncthing.net/release{-}key.txt }\KeywordTok{|} \FunctionTok{sudo}\NormalTok{ gpg }\AttributeTok{{-}{-}dearmour} \AttributeTok{{-}o}\NormalTok{ /usr/local/share/keyrings/synching{-}archive{-}keyring.gpg}
\BuiltInTok{echo} \StringTok{"deb [ signed{-}by=/usr/local/share/keyrings/synching{-}archive{-}keyring.gpg ] https://apt.syncthing.net/ syncthing stable"} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee /etc/apt/sources.list.d/syncthing.list}
\FunctionTok{sudo}\NormalTok{ apt{-}get update}
\FunctionTok{sudo}\NormalTok{ apt{-}get install syncthing}
\end{Highlighting}
\end{Shaded}

\section{Utilidades}\label{utilidades}

\subsection{Utilidades variadas}\label{utilidades-variadas}

\begin{description}
\item[gpick con]
\emph{Agave} y \emph{pdftk} ya no existen, nos pasamos a \emph{gpick} y
\emph{poppler-utils}

\texttt{sudo\ apt\ install\ gpick}
\item[graphviz]
Una utilidad de generación de gráficos que uso a veces. También es útil
para \texttt{web2py} y para `org-roam

\texttt{sudo\ apt\ install\ graphviz}
\item[sqlite3]
Un motor de bases de datos sencillo que se uso a menudo

\texttt{sudo\ apt\ install\ sqlite3}
\item[cheat]
Chuletas de comandos habituales, se instala desde los fuentes ejecutando
\texttt{go\ install\ github.com/cheat/cheat/cmd/cheat@latest} (ver
\href{https://github.com/cheat/cheat/}{su github})
\item[cheat.sh]
Echa una mirada a su página web: \url{http://cheat.sh/}, es casi
idéntico al anterior pero disponible desde cualquier ordenador con
conexión.
\item[gparted]
Instalamos \emph{gparted} para poder formatear memorias usb

\texttt{sudo\ apt\ install\ gparted}
\item[wkhtmltopdf]
Para pasar páginas web a pdf

\texttt{sudo\ apt\ install\ wkhtmltopdf}
\item[lsd]
\texttt{ls} potenciado, instalamos el paquete desde los fuentes con
\texttt{cargo\ install\ lsd} (ver
\href{https://github.com/Peltoche/lsd}{la página del proyecto}
\item[bat]
\texttt{cat} potenciado, instalamos el paquete desde los fuentes con
\texttt{cargo\ install\ bat} \href{https://github.com/sharkdp/bat}{ver
la página del proyecto}
\item[nmap ndiff ncat]
\texttt{nmap} nos permite realizar mapeos de subredes en nuestras redes
locales. Por ejemplo para localizar dispositivos enganchados a nuestra
red. \texttt{ndiff} nos permite comparar escaneos realizados con
\texttt{nmap} y \texttt{ncat} hace todo tipo de cosas (mira en la red)

\texttt{sudo\ apt\ install\ nmap\ ndiff\ ncat}
\item[rofi]
El super conmutador de ventanas (y muchas más cosas).

Creamos el fichero \texttt{\textasciitilde{}/.config/rofi/config.rasi}
con el siguiente contenido

\begin{Shaded}
\begin{Highlighting}[]
\ErrorTok{configuration} \FunctionTok{\{}
  \ErrorTok{modi}\FunctionTok{:} \StringTok{"drun,run,ssh,combi"}\ErrorTok{;}
  \ErrorTok{font:} \StringTok{"mensch 16"}\ErrorTok{;}
  \ErrorTok{combi{-}modi:} \StringTok{"window,drun,ssh"}\ErrorTok{;}
\FunctionTok{\}}
\ErrorTok{@theme} \ErrorTok{"fancy"}
\end{Highlighting}
\end{Shaded}

Asociamos un atajo de teclado al comando: \texttt{rofi\ -show\ drun}
\end{description}

\subsection{autokey}\label{autokey}

Instalamos \href{https://github.com/autokey/autokey}{autokey} siguiendo
\href{https://github.com/autokey/autokey/wiki/Installing\#debian-and-derivatives}{las
instrucciones para instalarlo con paquetes debian}

Me he descargado la última estable en el Legion y la beta en el Acer.

Después de descargar los paquetes Debian ejecutamos los siguientes
comandos (para la estable):

\begin{Shaded}
\begin{Highlighting}[]
\VariableTok{VERSION}\OperatorTok{=}\NormalTok{0.95.10{-}0}
\FunctionTok{sudo}\NormalTok{ dpkg }\AttributeTok{{-}{-}install}\NormalTok{ autokey{-}common\_0.95.10{-}0\_all.deb autokey{-}gtk\_0.95.10{-}0\_all.deb}
\FunctionTok{sudo}\NormalTok{ apt }\AttributeTok{{-}{-}fix{-}broken}\NormalTok{ install}
\end{Highlighting}
\end{Shaded}

El único paquete que se instala a mayores en el python del sistema sería
\texttt{python3-pyinotify}

Si estamos usando un entorno virtual con pyenv creo que sería mejor usar
la instalación con \texttt{pip}
(\href{https://github.com/autokey/autokey/wiki/Installing\#pip-installation}{ver
documentación})

Para lanzar la aplicación ejecutamos:
\texttt{python3\ -m\ autokey.gtkui}

\section{Internet}\label{internet}

\subsection{Rclone}\label{rclone}

Instalamos desde la página web(https://rclone.org/), descargando el
fichero \texttt{.deb}.

\subsubsection{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}

\subsubsection{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}

\subsection{Nyxt}\label{nyxt}

Descargamos la estable y además instalamos la libreria libssl1.1

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wget}\NormalTok{ http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1\_1.1.0g{-}2ubuntu4\_amd64.deb}
\FunctionTok{sudo}\NormalTok{ dpkg }\AttributeTok{{-}i}\NormalTok{ ./libssl1.1\_1.1.0g{-}2ubuntu4\_amd64.deb}
\end{Highlighting}
\end{Shaded}

\subsection{Qutebrowser}\label{qutebrowser}

Instalamos desde los repos con \texttt{sudo\ apt\ install\ qutebrowser}.

\subsection{Palemoon}\label{palemoon}

Un fork de \emph{Firefox} con menos chorradas. Instalado con el paquete
\texttt{deb} descargado de su
\href{https://software.opensuse.org/download.html?project=home:stevenpusser&package=palemoon}{página
web}

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{curl} \AttributeTok{{-}fsSL}\NormalTok{ https://download.opensuse.org/repositories/home:stevenpusser/xUbuntu\_22.10/Release.key }\KeywordTok{|} \ExtensionTok{gpg} \AttributeTok{{-}{-}dearmor} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee /usr/local/share/keyrings/palemoon.gpg }\OperatorTok{\textgreater{}}\NormalTok{ /dev/null}
\BuiltInTok{echo} \StringTok{\textquotesingle{}deb [ signed{-}by=/usr/local/share/keyrings/palemoon.gpg ] http://download.opensuse.org/repositories/home:/stevenpusser/xUbuntu\_20.04/ /\textquotesingle{}} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee /etc/apt/sources.list.d/palemoon.list}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install palemoon}
\end{Highlighting}
\end{Shaded}

\subsection{LibreWolf}\label{librewolf}

Otro fork de \emph{Firefox} centrado en la privacidad. Instalado como
\emph{appimage} descargado desde su
\href{https://librewolf-community.gitlab.io/}{página web}

\textbf{UPDATE}: Ya está disponible el repo para Mint:

\begin{Shaded}
\begin{Highlighting}[]
\BuiltInTok{echo} \StringTok{"deb [arch=amd64] http://deb.librewolf.net }\VariableTok{$(}\ExtensionTok{lsb\_release} \AttributeTok{{-}sc}\VariableTok{)}\StringTok{ main"} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee /etc/apt/sources.list.d/librewolf.list}
\FunctionTok{sudo}\NormalTok{ wget http://deb.librewolf.net/keyring.gpg }\AttributeTok{{-}O}\NormalTok{ /etc/apt/trusted.gpg.d/librewolf.gpg}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install librewolf }\AttributeTok{{-}y}
\end{Highlighting}
\end{Shaded}

\subsubsection{Plugins instalados}\label{plugins-instalados}

Conviene estudiar la documentación de los \emph{add-ons} recomendados,
disponible
\href{https://librewolf-community.gitlab.io/docs/addons/}{aqui}.

\begin{itemize}
\item
  KeepassXC-Browser

  \begin{itemize}
  \tightlist
  \item
    Necesitamos instalar el KeepassXC, el que viene en los repos es un
    poco antiguo podemos instalar desde PPA
  \item
    Es imprescindible hacer un link con
    \texttt{ln\ -s\ \textasciitilde{}/.mozilla/native-messaging-hosts\ \textasciitilde{}/.librewolf/native-messaging-hosts}
  \end{itemize}
\item
  Clear URLs
\item
  Mozilla Multiaccount Containers
\end{itemize}

\subsection{Netsurf}\label{netsurf}

Un navegador ultraligero (aunque no funciona con muchas páginas, solo
para webs austeras) Instalado via flathub con
\texttt{flatpak\ install\ netsurf}

\subsection{Lagrange}\label{lagrange}

Un navegador para el protocolo \emph{Gemini}. Instalado con la
\emph{appimage} desde su
\href{https://git.skyjake.fi/gemini/lagrange}{página web}

\subsection{Castor}\label{castor}

Otro navegador para el protocolo \emph{Gemini} programado en
\emph{Rust}. Instalado desde las fuentes siguiendo instrucciones de su
\href{https://sr.ht/~julienxx/Castor/}{página web}

\subsection{Whalebird: Cliente de
Mastodon}\label{whalebird-cliente-de-mastodon}

Descargada \emph{appimage} desde \href{https://whalebird.social/en}{la
página web de la aplicación}.

\subsection{Sengi: Cliente de Mastodon}\label{sengi-cliente-de-mastodon}

Instalada \emph{appimage} desde su
\href{https://github.com/NicolasConstant/sengi}{github}

\section{Window Managers adicionales}\label{window-managers-adicionales}

\subsection{i3wm}\label{i3wm}

Añadimos el repo:

\begin{Shaded}
\begin{Highlighting}[]
\BuiltInTok{cd}\NormalTok{ \textasciitilde{}/tmp}
\ExtensionTok{/usr/lib/apt/apt{-}helper}\NormalTok{ download{-}file https://debian.sur5r.net/i3/pool/main/s/sur5r{-}keyring/sur5r{-}keyring\_2021.02.02\_all.deb keyring.deb SHA256:cccfb1dd7d6b1b6a137bb96ea5b5eef18a0a4a6df1d6c0c37832025d2edaa710}

\FunctionTok{sudo}\NormalTok{ dpkg }\AttributeTok{{-}i}\NormalTok{ ./keyring.deb}
\FunctionTok{sudo}\NormalTok{ echo }\StringTok{"deb http://debian.sur5r.net/i3/ }\VariableTok{$(}\FunctionTok{grep} \StringTok{\textquotesingle{}\^{}DISTRIB\_CODENAME=\textquotesingle{}}\NormalTok{ /etc/lsb{-}release }\KeywordTok{|} \FunctionTok{cut} \AttributeTok{{-}f2} \AttributeTok{{-}d}\OperatorTok{=}\VariableTok{)}\StringTok{ universe"} \OperatorTok{\textgreater{}\textgreater{}}\NormalTok{ /etc/apt/sources.list.d/sur5r{-}i3.list}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install i3}
\end{Highlighting}
\end{Shaded}

\subsection{qtile}\label{qtile}

Vamos a describir la instalación del \emph{Qtile} en un
\emph{virtualenv} dedicado. Si te bajas la versión estable de
\emph{Qtile} desde su \href{http://qtile.org}{página web} en el paquete
vienen un montón de script auxiliares que te permiten hacer la
instalación aislada en un \emph{virtualenv} pero lo voy a hacer a mano
para tenerlo controlado con \texttt{pyenv}.

\begin{itemize}
\tightlist
\item
  Creamos el \emph{virtualenv} \texttt{qtile} basado en la versión
  3.10.0 que teniamos instalada previamente:
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# Creamos el directorio de trabajo}
\FunctionTok{mkdir} \OperatorTok{\textless{}}\NormalTok{workPath}\OperatorTok{\textgreater{}}\NormalTok{/qtile}
\BuiltInTok{cd} \OperatorTok{\textless{}}\NormalTok{workPath}\OperatorTok{\textgreater{}}\NormalTok{/qtile}

\CommentTok{\# OPCIONAL: Descargamos el qtile estable de la página web}
\CommentTok{\# sólo si quieres curiosear los scripts auxiliares}
\FunctionTok{wget}\NormalTok{ https://github.com/qtile/qtile/archive/v0.18.1.tar.gz}
\FunctionTok{tar}\NormalTok{ xvzf v0.18.1.tar.gz}
\FunctionTok{rm}\NormalTok{ v0.18.1.tar.gz}

\CommentTok{\# Creamos el entorno virtual}
\ExtensionTok{pyenv}\NormalTok{ virtualenv 3.10.0 qtile}
\ExtensionTok{pyenv}\NormalTok{ local qtile}
\CommentTok{\# Instalamos los paquetes iniciales (comunes a mis entornos)}
\ExtensionTok{pip}\NormalTok{ install }\AttributeTok{{-}{-}upgrade}\NormalTok{ pip setuptools wheel}

\CommentTok{\# instalamos los requisitos}
\ExtensionTok{pip}\NormalTok{ install }\AttributeTok{{-}{-}no{-}cache{-}dir}\NormalTok{ xcffib}
\ExtensionTok{pip}\NormalTok{ install }\AttributeTok{{-}{-}no{-}cache{-}dir}\NormalTok{ cairocffi}

\CommentTok{\# Instalamos la versión estable de qtile}
\ExtensionTok{pip}\NormalTok{ install }\AttributeTok{{-}{-}no{-}cache{-}dir}\NormalTok{ qtile}
\end{Highlighting}
\end{Shaded}

Con esto ya estamos listos, podríamos arrancar \emph{Qtile} con
\texttt{qtile\ start}, pero no puede funcionar claro. Para que arranque
correctamente, tenemos que lanzarlo en un servidor X. (ver el punto
``\hyperref[lanzar-window-managers-con-xephyr]{Lanzar Window Managers
con Xephyr}'')

\subsubsection{\texorpdfstring{Configurar Qtile en \emph{virtualenv}
para arrancer desde el
\emph{Lightdm}}{Configurar Qtile en virtualenv para arrancer desde el Lightdm}}\label{configurar-qtile-en-virtualenv-para-arrancer-desde-el-lightdm}

Como \texttt{root} nos creamos un script \texttt{launch\_qtile} en
\texttt{/usr/local/bin}, con el siguiente contenido

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\#!/bin/bash}
\BuiltInTok{source} \StringTok{\textquotesingle{}/home/user/.pyenv/versions/3.10.0/envs/qtile/bin/activate\textquotesingle{}}
\ExtensionTok{qtile}\NormalTok{ start}
\end{Highlighting}
\end{Shaded}

Le damos permisos de ejecución con \texttt{chmod\ 755\ launch\_qtile}
(ojo a los permisos para \emph{all} que si no son estos no le gusta a
\emph{Lightdm})

También como \texttt{root} creamos el fichero
\texttt{/usr/share/xsessions/qtile.desktop} con el contenido:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{[Desktop}\NormalTok{ Entry]}
\VariableTok{Name}\OperatorTok{=}\NormalTok{Qtile}
\VariableTok{Comment}\OperatorTok{=}\NormalTok{Qtile }\ExtensionTok{Session}
\VariableTok{Exec}\OperatorTok{=}\NormalTok{launch\_qtile}
\VariableTok{Type}\OperatorTok{=}\NormalTok{Application}
\VariableTok{Keywords}\OperatorTok{=}\NormalTok{wm}\KeywordTok{;}\ExtensionTok{tiling}
\end{Highlighting}
\end{Shaded}

Y con esto tendremos Qtile disponible en \emph{Lightdm}.

\subsection{Lanzar Window Managers con
Xephyr}\label{lanzar-window-managers-con-xephyr}

Para probar (o configurar) los \emph{Window Managers} sin salir de
nuestra sesión de Mate podemos usar Xephyr, si no lo tienes instalado
ejecuta:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install xserver{-}xephyr}
\end{Highlighting}
\end{Shaded}

Para lanzar un \emph{Xserver} usaríamos un comando como:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{Xephyr} \AttributeTok{{-}ac} \AttributeTok{{-}screen}\NormalTok{ 800x600 }\AttributeTok{{-}br} \AttributeTok{{-}reset} \AttributeTok{{-}terminate} \DecValTok{2}\OperatorTok{\textgreater{}}\NormalTok{ /dev/null :1 }\KeywordTok{\&}
\end{Highlighting}
\end{Shaded}

\begin{description}
\item[\textbf{-ac}]
Autorizar conexiones de clientes indiscriminadamente (\emph{disable
access restrictions})
\item[\textbf{-screen}]
Especificar la geometría de la pantalla.
\item[\textbf{-br}]
La ventana raiz tendrá fondo negro
\item[\textbf{-reset}]
Reset al terminar el último cliente
\item[\textbf{-terminate}]
Finalizar cuando se resetee el servidor
\item[\textbf{2\textgreater{} /dev/null}]
Mandar los mensajes de error al limbo (alias \textbf{NE} en nuestro pc)
\item[\textbf{:1}]
Arrancar el server en el DISPLAY=1
\end{description}

Asi que si queremos arrancar por ejemplo el \emph{i3wm} podríamos hacer
un script con las siguientes lineas:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{Xephyr} \AttributeTok{{-}ac} \AttributeTok{{-}screen}\NormalTok{ 800x600 }\AttributeTok{{-}br} \AttributeTok{{-}reset} \AttributeTok{{-}terminate} \DecValTok{2}\OperatorTok{\textgreater{}}\NormalTok{ /dev/null :1 }\KeywordTok{\&}
\BuiltInTok{export} \VariableTok{DISPLAY}\OperatorTok{=}\NormalTok{:1}
\ExtensionTok{i3}
\end{Highlighting}
\end{Shaded}

Para \emph{Qtile} bastaria con cambiar \texttt{i3} por
\texttt{qtile\ start}

\section{Comunicación con dispositivos
Android}\label{comunicaciuxf3n-con-dispositivos-android}

\subsection{scrcpy}\label{scrcpy}

\texttt{sudo\ apt\ install\ scrcpy}

\subsection{Heimdall}\label{heimdall}

Para flashear roms en moviles

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install heimdall{-}flash heimdall{-}flash{-}frontend}
\end{Highlighting}
\end{Shaded}

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

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

Para instalar la versión más reciente de LaTeX hago la instalación desde
\href{https://www.ctan.org/}{ctan}

Una vez instalado usamos \emph{equivs} para generar un paquete
\texttt{deb} y que nuestro sistema sepa que tenemos \emph{texlive}
instalado.

\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}

\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. También conviene instalar \emph{texinfo}
(que hará que se instale \emph{texcommon}) y opcionalmente se puede
instalar \emph{lmodern}.

\begin{verbatim}
sudo apt install freeglut3 texinfo
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.

\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}

\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}

\subsection{Fuentes Adicionales}\label{fuentes-adicionales}

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}} aunque parece que las fuentes están un poco anticuadas.

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

La fuente Hack la he instalado directamente desde el
\href{https://sourcefoundry.org/hack/}{sitio web}

\subsection{Pandoc}\label{pandoc}

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

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

Además podríamos descargarnos plantillas de Pandoc 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}

Las plantillas no son imprescindibles pero si quieres aprender a usarlas
o hacer alguna modificación viene bien tenerlas.

\subsection{Quarto}\label{quarto}

Un sistema de generación de documentación que usa \emph{Pandoc},
instalado con el paquete \texttt{.deb} descargado desde
\href{https://quarto.org/docs/get-started/}{la página web del proyecto}

\textbf{TODO}: Completar el tutorial inicial

\subsection{Algunos editores
adicionales}\label{algunos-editores-adicionales}

Dos editores opcionales para hacer pruebas:

\begin{description}
\item[Obsidian]
Instalado con \emph{appimage} descargado desde la
\href{https://obsidian.md/}{página web}
\item[Zettlr]
Instalado con fichero \texttt{.deb} descargado desde
\href{https://www.zettlr.com/}{su página web}
\end{description}

\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://download.calibre-ebook.com/linux-installer.sh | sudo sh /dev/stdin
\end{verbatim}

El programa queda instalado en \texttt{/opt/calibre}. Se puede
desinstalar con el comando \texttt{sudo\ calibre-unistall}.

Para usar el calibre con el ebook \emph{Kobo Glo}:

\begin{itemize}
\tightlist
\item
  Desactivamos todos los plugin de Kobo menos el \emph{Kobo Touch
  Extended}
\item
  En \emph{Preferences::Add your own Columns} creamos una columna
  \emph{MyShelves} con identificativo \texttt{\#myshelves}, esto es para
  crear colecciones en el ebook como me apetezca
\item
  En las opciones del plugin:

  \begin{itemize}
  \tightlist
  \item
    \emph{Collections, covers and uploads}

    \begin{itemize}
    \tightlist
    \item
      En la opción \emph{Collection columns} añadimos las columnas
      \texttt{Series,MyShelves}
    \item
      Marcamos las opciones \emph{Create collections} y \emph{Delete
      empty bookshelves}
    \item
      Marcamos \emph{Modify CSS}
    \end{itemize}
  \item
    \emph{Metadata on device and advanced}

    \begin{itemize}
    \tightlist
    \item
      \emph{Set series information}
    \end{itemize}
  \item
    \emph{Extended}

    \begin{itemize}
    \tightlist
    \item
      \emph{Send books as kepubs}
    \end{itemize}
  \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}

\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.

Instalamos desde los depósitos oficiales de Mint.

Se podría instalar desde ppa cuando lo actualicen para incluir Ubunto 20
con los siguientes comandos:

\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}

\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í}

\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.

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

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

\subsection{Zotero: Gestor de referencias
bibliográficas}\label{zotero-gestor-de-referencias-bibliogruxe1ficas}

Por cortesía de \href{https://github.com/retorquere/zotero-deb}{Emiliano
Heyns} tenemos disponible el paquete de Zotero para Debian y Ubuntu.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wget} \AttributeTok{{-}qO{-}}\NormalTok{ https://raw.githubusercontent.com/retorquere/zotero{-}deb/master/install.sh }\KeywordTok{|} \FunctionTok{sudo}\NormalTok{ bash}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install zotero}
\end{Highlighting}
\end{Shaded}

A mayores instalamos el \emph{addon} \textbf{\emph{Better Bibtex}}
descargando la última versión disponible desde
\href{https://retorque.re/zotero-better-bibtex/installation/}{aquí} e
instalando en Zotero con la opción ``Instalar desde fichero''.

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

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

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install build{-}essential checkinstall make automake cmake autoconf }\DataTypeTok{\textbackslash{}}
\NormalTok{git git{-}core git{-}crypt dpkg wget}
\end{Highlighting}
\end{Shaded}

\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{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ add{-}apt{-}repository ppa:git{-}core/ppa}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt upgrade}
\end{Highlighting}
\end{Shaded}

\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}

\subsection{Emacs}\label{emacs}

Instalado emacs desde los repos:

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

\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.

\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}

\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}

\subsubsection{gdc}\label{gdc}

Instalado con:

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

\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}

\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)

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

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

Para instalar las dependencias, previamente instalamos:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{sudo apt install ncurses{-}dev id{-}utils exuberant{-}ctags python{-}pygments}
\end{Highlighting}
\end{Shaded}

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{Shaded}
\begin{Highlighting}[]
\NormalTok{./configure {-}{-}prefix=/usr/local {-}{-}with{-}exuberant{-}ctags=/usr/bin/ctags}
\NormalTok{make}
\NormalTok{sudo make install}
\end{Highlighting}
\end{Shaded}

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}

\subsection{Rust}\label{rust}

Instalamos siguiendo las instrucciones de
\href{https://www.rust-lang.org/tools/install}{aqui} (Hacemos la
instalación por defecto)

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{curl} \AttributeTok{{-}{-}proto} \StringTok{\textquotesingle{}=https\textquotesingle{}} \AttributeTok{{-}{-}tlsv1.2} \AttributeTok{{-}sSf}\NormalTok{ https://sh.rustup.rs }\KeywordTok{|} \FunctionTok{sh}

  \ExtensionTok{stable}\NormalTok{ installed }\AttributeTok{{-}}\NormalTok{ rustc 1.47.0 }\ErrorTok{(}\ExtensionTok{18bf6b4f0}\NormalTok{ 2020{-}10{-}07}\KeywordTok{)}


\ExtensionTok{Rust}\NormalTok{ is installed now. Great!}

\ExtensionTok{To}\NormalTok{ get started you need Cargo}\StringTok{\textquotesingle{}s bin directory ($HOME/.cargo/bin) in your PATH}
\StringTok{environment variable. Next time you log in this will be done}
\StringTok{automatically.}

\StringTok{To configure your current shell run source $HOME/.cargo/env}
\end{Highlighting}
\end{Shaded}

Yo comento la linea del fichero \texttt{.zprofile} por que mi
\texttt{.zshrc} ya lee el fichero \texttt{.profile}

Para desinstalar \texttt{rust} bastaría con ejecutar
\texttt{rustup\ self\ uninstall}

Para actualizar la instalación: \texttt{rustup\ update}

\subsubsection{RLS}\label{rls}

Seguimos las instrucciones de la página oficial de
\href{https://emacs-lsp.github.io/lsp-mode/page/lsp-rust/}{LSP} y de
\href{https://github.com/rust-lang/rls}{RLS}

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{rustup}\NormalTok{ update}
\ExtensionTok{rustup}\NormalTok{ component add rls rust{-}analysis rust{-}src}
\end{Highlighting}
\end{Shaded}

\subsubsection{Algunas utilidades de sistema escritas en
Rust}\label{algunas-utilidades-de-sistema-escritas-en-rust}

Instalamos:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{cargo}\NormalTok{ install tealdeer        }\CommentTok{\# tldr tldr}
\ExtensionTok{cargo}\NormalTok{ install du{-}dust         }\CommentTok{\# tldr dust}
\ExtensionTok{cargo}\NormalTok{ install fd{-}find         }\CommentTok{\# tldr fd}
\ExtensionTok{cargo}\NormalTok{ install exa             }\CommentTok{\# tldr exa}
\ExtensionTok{cargo}\NormalTok{ install tokei           }\CommentTok{\# tldr tokei}
\ExtensionTok{cargo}\NormalTok{ install gitui           }\CommentTok{\# gitui {-}{-}help}
\ExtensionTok{cargo}\NormalTok{ install ripgrep         }\CommentTok{\# tldr rg}
\ExtensionTok{cargo}\NormalTok{ install bat             }\CommentTok{\# tldr bat}
\ExtensionTok{cargo}\NormalTok{ install lsd             }\CommentTok{\# tldr lsd}
\ExtensionTok{cargo}\NormalTok{ install git{-}delta       }\CommentTok{\# tldr delta}
\ExtensionTok{cargo}\NormalTok{ install }\AttributeTok{{-}{-}locked}\NormalTok{ navi   }\CommentTok{\# navi fn welcome (requires fzf and tldr)}
\ExtensionTok{cargo}\NormalTok{ install }\AttributeTok{{-}{-}locked}\NormalTok{ zoxide }\CommentTok{\# tldr zoxide}
\ExtensionTok{cargo}\NormalTok{ install }\AttributeTok{{-}{-}locked}\NormalTok{ zellij }\CommentTok{\# tldr zellij}
\ExtensionTok{cargo}\NormalTok{ install atuin           }\CommentTok{\# tldr atuin}
\end{Highlighting}
\end{Shaded}

\textbf{Nota}: \texttt{fzf} instalado descargando el binario en
\texttt{\textasciitilde{}/.local/bin} desde su github

\subsection{golang}\label{golang}

Bajamos el paquete con la última versión desde
\href{https://golang.org/dl/}{la página oficial}.

Descomprimimos como \emph{root} en \texttt{/usr/local/}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ tar }\AttributeTok{{-}C}\NormalTok{ /usr/local }\AttributeTok{{-}xvzf}\NormalTok{ go1.15.7.linux{-}amd64.tar.gz}
\end{Highlighting}
\end{Shaded}

Añadimos al path con las siguientes lineas en
\texttt{\textasciitilde{}/.profile}:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\#golang}
\ControlFlowTok{if} \BuiltInTok{[} \OtherTok{{-}d} \StringTok{"/usr/local/go"} \BuiltInTok{]} \KeywordTok{;} \ControlFlowTok{then}
    \BuiltInTok{export} \VariableTok{GOROOT}\OperatorTok{=}\StringTok{"/usr/local/go"}
    \VariableTok{PATH}\OperatorTok{=}\StringTok{"}\VariableTok{$PATH}\StringTok{:}\VariableTok{$GOROOT}\StringTok{/bin"}
\ControlFlowTok{fi}
\ControlFlowTok{if} \BuiltInTok{[} \OtherTok{{-}d} \StringTok{"}\VariableTok{$HOME}\StringTok{/work/development/gocode"} \BuiltInTok{]} \KeywordTok{;} \ControlFlowTok{then}
    \BuiltInTok{export} \VariableTok{GOPATH}\OperatorTok{=}\StringTok{"}\VariableTok{$HOME}\StringTok{/work/development/gocode"}
    \VariableTok{PATH}\OperatorTok{=}\StringTok{"}\VariableTok{$PATH}\StringTok{:}\VariableTok{$GOPATH}\StringTok{/bin"}
\ControlFlowTok{fi}
\end{Highlighting}
\end{Shaded}

\subsubsection{\texorpdfstring{Instalación de \emph{gopls} un servidor
de LSP para
editores:}{Instalación de gopls un servidor de LSP para editores:}}\label{instalaciuxf3n-de-gopls-un-servidor-de-lsp-para-editores}

Desde un directorio \textbf{que no sea el GOPATH}

\begin{Shaded}
\begin{Highlighting}[]
\VariableTok{GO111MODULE}\OperatorTok{=}\NormalTok{on }\ExtensionTok{go}\NormalTok{ get golang.org/x/tools/gopls@latest}
\end{Highlighting}
\end{Shaded}

\subsubsection{golint}\label{golint}

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{go}\NormalTok{ get }\AttributeTok{{-}u}\NormalTok{ golang.org/x/lint/golint}
\end{Highlighting}
\end{Shaded}

\subsubsection{Utilidades escritas en
go}\label{utilidades-escritas-en-go}

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{go}\NormalTok{ install github.com/jesseduffield/lazygit@latest}
\ExtensionTok{go}\NormalTok{ install github.com/cheat/cheat/cmd/cheat@latest}
\end{Highlighting}
\end{Shaded}

\subsection{Processing}\label{processing}

Bajamos el paquete de la \href{https://processing.org/}{página 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.

\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{Shaded}
\begin{Highlighting}[]
\ExtensionTok{installing}\NormalTok{ OF dependencies}
\ExtensionTok{OF}\NormalTok{ needs to install the following packages using apt{-}get:}
\ExtensionTok{curl}\NormalTok{ 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}
\ExtensionTok{Do}\NormalTok{ you want to continue}\PreprocessorTok{?} \PreprocessorTok{[}\SpecialStringTok{Y/n}\PreprocessorTok{]}
\end{Highlighting}
\end{Shaded}

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

\subsection{Python}\label{python}

En Linux Mint Vanessa ya no tenemos \emph{python2} (aunque podemos
instalarlo)

Para dejar a \emph{python3} como python de sistema instalamos el
paquete:

\texttt{sudo\ apt\ install\ python-is-python3}

Después podemos comprobar la versión:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{python} \AttributeTok{{-}V}
\ExtensionTok{Python}\NormalTok{ 3.10.6}
\end{Highlighting}
\end{Shaded}

\subsubsection{Paquetes de sistema relacionados con python que
instalamos}\label{paquetes-de-sistema-relacionados-con-python-que-instalamos}

Son los que ya comentamos en la sección de instalación de zsh, como ya
dijimos conviene que instalemos los paquetes de desarrollo:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install python3{-}dev}
\FunctionTok{sudo}\NormalTok{ apt install python3{-}all{-}dev}
\FunctionTok{sudo}\NormalTok{ apt install python3{-}virtualenv python3{-}virtualenvwrapper python3{-}virtualenv{-}clone}
\FunctionTok{sudo}\NormalTok{ apt install pipx}
\CommentTok{\# sudo apt install python3{-}poetry}
\end{Highlighting}
\end{Shaded}

Ademas añadimos las siguientes lineas al fichero
\texttt{\textasciitilde{}/.profile}:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# WORKON\_HOME for virtualenvwrapper}
\ControlFlowTok{if} \BuiltInTok{[} \OtherTok{{-}d} \StringTok{"}\VariableTok{$HOME}\StringTok{/.virtualenvs"} \BuiltInTok{]} \KeywordTok{;} \ControlFlowTok{then}
\VariableTok{WORKON\_HOME}\OperatorTok{=}\StringTok{"}\VariableTok{$HOME}\StringTok{/.virtualenvs"}
\ControlFlowTok{fi}
\end{Highlighting}
\end{Shaded}

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

\subsubsection{pyenv}\label{pyenv}

Instalamos los pre-requisitos:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt{-}get update}
\FunctionTok{sudo}\NormalTok{ apt{-}get install }\AttributeTok{{-}{-}no{-}install{-}recommends}\NormalTok{ make build{-}essential }\DataTypeTok{\textbackslash{}}
\NormalTok{libssl{-}dev zlib1g{-}dev libbz2{-}dev libreadline{-}dev libsqlite3{-}dev }\DataTypeTok{\textbackslash{}}
\NormalTok{wget curl llvm libncurses5{-}dev xz{-}utils tk{-}dev }\DataTypeTok{\textbackslash{}}
\NormalTok{libxml2{-}dev libxmlsec1{-}dev libffi{-}dev liblzma{-}dev}
\end{Highlighting}
\end{Shaded}

Podemos clonar el repo en nuestro \texttt{home}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{git}\NormalTok{ clone https://github.com/pyenv/pyenv.git \textasciitilde{}/.pyenv}
\end{Highlighting}
\end{Shaded}

Pero también podemos añadir el \emph{bundle} para \emph{Antigen} en el
fichero \texttt{.zshrc} y dejar que se encargue de todo. (Este es el
camino que yo sigo)

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{antigen}\NormalTok{ bundle mattberther/zsh{-}pyenv}
\end{Highlighting}
\end{Shaded}

Añadimos al fichero \texttt{\textasciitilde{}/.profile}:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# pyenv}
\ControlFlowTok{if} \BuiltInTok{[} \OtherTok{{-}d} \StringTok{"}\VariableTok{$HOME}\StringTok{/.pyenv"} \BuiltInTok{]} \KeywordTok{;} \ControlFlowTok{then}
    \BuiltInTok{export} \VariableTok{PYENV\_ROOT}\OperatorTok{=}\StringTok{"}\VariableTok{$HOME}\StringTok{/.pyenv"}
    \BuiltInTok{export} \VariableTok{PATH}\OperatorTok{=}\StringTok{"}\VariableTok{$PYENV\_ROOT}\StringTok{/bin:}\VariableTok{$PATH}\StringTok{"}
\ControlFlowTok{fi}
\end{Highlighting}
\end{Shaded}

Y configuramos en \texttt{\textasciitilde{}/.bashrc} y en
\texttt{\textasciitilde{}/.zshrc} (aunque en el último no es necesario
tocar nada si usamos el \emph{bundle} para \emph{Antigen}):

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if} \BuiltInTok{command} \AttributeTok{{-}v}\NormalTok{ pyenv }\DecValTok{1}\OperatorTok{\textgreater{}}\NormalTok{/dev/null }\DecValTok{2}\OperatorTok{\textgreater{}\&}\DecValTok{1}\KeywordTok{;} \ControlFlowTok{then}
  \BuiltInTok{eval} \StringTok{"}\VariableTok{$(}\ExtensionTok{pyenv}\NormalTok{ init }\AttributeTok{{-}}\VariableTok{)}\StringTok{"}
\ControlFlowTok{fi}
\end{Highlighting}
\end{Shaded}

Podemos probar que todo funciona con: \texttt{pyenv\ install\ -l}

Una vez instalado hay que estudiarse
\href{https://github.com/pyenv/pyenv/blob/master/COMMANDS.md}{la
referencia de comandos}

\subsubsection{poetry}\label{poetry}

Podríamos instalar con:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{curl} \AttributeTok{{-}sSL}\NormalTok{ https://raw.githubusercontent.com/python{-}poetry/poetry/master/get{-}poetry.py }\KeywordTok{|} \ExtensionTok{python3} \AttributeTok{{-}}
\end{Highlighting}
\end{Shaded}

Dejamos la activación solo en el fichero
\texttt{\textasciitilde{}\ /.profile}, añadiendo las siguientes lineas:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# poetry}
\ControlFlowTok{if} \BuiltInTok{[} \OtherTok{{-}d} \StringTok{"}\VariableTok{$HOME}\StringTok{/.poetry"}\NormalTok{] }\ErrorTok{;} \ControlFlowTok{then}
    \VariableTok{PATH}\OperatorTok{=}\StringTok{"}\VariableTok{$HOME}\StringTok{/.poetry/bin:}\VariableTok{$PATH}\StringTok{"}
\ControlFlowTok{fi}
\end{Highlighting}
\end{Shaded}

Las actualizaciones se realizan con \texttt{poetry\ self\ update}

También podríamos instalarlo como un paquete de Ubuntu.

\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}

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

\subsubsection{Jupyter}\label{jupyter}

Una instalación para pruebas.

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{mkvirtualenv} \AttributeTok{{-}p}\NormalTok{ /usr/bin/python3 jupyter}
\ExtensionTok{python} \AttributeTok{{-}m}\NormalTok{ pip install jupyter}
\end{Highlighting}
\end{Shaded}

\subsubsection{\texorpdfstring{Instalamos
\texttt{python3.11}}{Instalamos python3.11}}\label{instalamos-python3.11}

\texttt{python3.11} está ya disponible en los repos oficiales.

Para dejarla instalada (yo no lo instalo):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install python3.11 python3.11{-}dev python3.11{-}venv}
\end{Highlighting}
\end{Shaded}

\subsection{neovim}\label{neovim}

Vamos a probar \emph{neovim}, ahora mismo la versión de los repos de
Ubuntu está actualizada a la penúltima versión (0.4.3). También podemos
descargar el appimage desde
\href{https://github.com/neovim/neovim/releases}{la página web}

Es de esperar que alguna vez vuelvan a tener el neovim disponible en los
repos de la aplicación:

\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{center}\rule{0.5\linewidth}{0.5pt}\end{center}

\textbf{NOTA}: El siguiente paso ya no parece necesario, las
alternativas se han actualizado con la instalación del \emph{neovim}.

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

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}

\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
por comando ejecutando: \texttt{:PlugInstall}

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

\begin{longtable}[]{@{}l@{}}
\toprule\noalign{}
\endhead
\bottomrule\noalign{}
\endlastfoot
\textbf{Nota}: \\
Solo hay que instalar uno de los dos o \emph{dein} o \emph{plug-vim}. Yo
uso \\
\emph{plug-vim} así que esto es sólo una referencia. \\
\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}

\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.

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

Herramientas útiles para depuración web

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install httpie links}
\end{Highlighting}
\end{Shaded}

\subsection{MariaDB}\label{mariadb}

Ahora siempre uso los servidores de base de datos dockerizados. Pero
sigue siendo interesante instalar los clientes en nuestro sistema con
\texttt{sudo\ apt\ install\ mariadb-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.

El fichero \texttt{squirrel-sql.sh} necesita que lo lancemos desde el
directorio del script.

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

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wget} \AttributeTok{{-}qO{-}}\NormalTok{ https://cloud.r{-}project.org/bin/linux/ubuntu/marutter\_pubkey.asc }\DataTypeTok{\textbackslash{}}
 \KeywordTok{|}\ExtensionTok{gpg} \AttributeTok{{-}{-}dearmor} \AttributeTok{{-}o}\NormalTok{ /usr/local/share/keyrings/cran{-}archive{-}keyring.gpg}

\BuiltInTok{.}\NormalTok{ /etc/os{-}release}
\FunctionTok{sudo}\NormalTok{ echo }\StringTok{"deb [signed{-}by=/usr/local/share/keyrings/cran{-}archive{-}keyring.gpg ] }\DataTypeTok{\textbackslash{}}
\StringTok{https://cloud.r{-}project.org/bin/linux/ubuntu }\VariableTok{$\{UBUNTU\_CODENAME\}}\StringTok{{-}cran40/"} \DataTypeTok{\textbackslash{}}
\KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee /etc/apt/sources.list.d/cran.list}

\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install r{-}base}
\end{Highlighting}
\end{Shaded}

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

Ojo, tenemos \emph{R-studio Server} y \emph{R-studio Desktop}, en tu
portátil casi seguro que quieres el \emph{Desktop} y no el
\emph{Server}.

Para \emph{R-studio Server} descargamos la última versión disponible de
\emph{R-studio} desde la
\href{https://rstudio.com/products/rstudio/download-server/debian-ubuntu/}{página
web}

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

Para \emph{R-studio Desktop} descargamos la última versión disponible
desde la
\href{https://www.rstudio.com/products/rstudio/download/\#download}{página
web}

Igual que el \emph{Server} instalamos el paquete del \emph{Desktop} con
\emph{gedebi}.

\subsection{Octave}\label{octave}

Instalado desde flatpak

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

\subsection{go Hugo}\label{go-hugo}

Generador de sitios web estáticos.

Instalado fichero \texttt{.deb} desde las sección de \emph{releases} de
la página web: \href{https://github.com/gohugoio/hugo}{hugo github}
\textbf{Asegúrate de instalar el Hugo Extended}

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

\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 comentamos la sección
que borra el \emph{modemmanager} del fichero
\texttt{arduino-linux-setup.sh} y lo ejecutamos para que instale el
resto.

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

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# for arduino brand, stop ModemManager grabbing port}
\ExtensionTok{ATTRS\{idVendor\}==}\StringTok{"2a03"}\ExtensionTok{,}\NormalTok{ ENV\{ID\_MM\_DEVICE\_IGNORE\}=}\StringTok{"1"}
\CommentTok{\# for sparkfun brand, stop ModemManager grabbing port}
\ExtensionTok{ATTRS\{idVendor\}==}\StringTok{"1b4f"}\ExtensionTok{,}\NormalTok{ ENV\{ID\_MM\_DEVICE\_IGNORE\}=}\StringTok{"1"}
\end{Highlighting}
\end{Shaded}

Después de añadir ficheros de reglas podemos recargar las reglas
ejecutando:

\texttt{udevadm\ control\ -\/-reload-rules\ \&\&\ udevadm\ trigger}

Tenemos que crear los ficheros \texttt{.desktop}.

\subsubsection{Arduino IDE 2}\label{arduino-ide-2}

Descargamos el fichero \emph{appmimage} de la página de Arduino y
creamos el fichero \texttt{.desktop}.

\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
Board 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}

\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}

\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{https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json}
  (esta deber ser la oficial)
\end{itemize}

Pero la oficial no da soporte para usar el \emph{st-link}, necesitamos
añadir alguna más.

\begin{itemize}
\tightlist
\item
  \url{http://dan.drown.org/stm32duino/package_STM32duino_index.json}
  (recomendada por Tutoelectro, nos da soporte para el st-link)
\end{itemize}

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

\textbf{NOTA}: Hasta donde yo se la de arriba es la única URL que
permite usar el st-link

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

He optado por añadir los dos ficheros json al IDE, la oficial tiene
buena pinta pero parece que no soporta st-link. Con la otra podremos
usarlo sin problemas.

Instalamos la biblioteca \texttt{stm32\ cores} que corresponde al origen
de software oficial y la biblioteca \texttt{STM32F1xx/GD32F1xx}, esta
última es la que nos dará soporte explícito para el st-link

Lo probamos con el \emph{Blink} y funciona perfectamente con las
opciones de la \hyperref[figura_1]{Figura 1}

\begin{figure}
\centering
\includegraphics[width=0.3\textwidth,height=\textheight]{src/img/stm32_arduino_opts.jpg}
\caption{Opciones Arduino para STM32 con st-link}\label{figura_1}
\end{figure}

\subsubsection{Añadir soporte para ESP32 y
ESP8266}\label{auxf1adir-soporte-para-esp32-y-esp8266}

Añadimos las URL:

\begin{itemize}
\tightlist
\item
  \url{https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json}
  (soporte para ESP32)
\item
  \url{http://arduino.esp8266.com/stable/package_esp8266com_index.json}
  (soporte para ESP8266)
\end{itemize}

Añadimos la librería:

\begin{itemize}
\tightlist
\item
  ESP32 (de espressif)
\end{itemize}

\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.

\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.

\subsection{stm32 cubeide}\label{stm32-cubeide}

Nos bajamos el instalador genérico. Tendremos que:

\begin{itemize}
\tightlist
\item
  aceptar un montón de acuerdos de licencias
\item
  indicarle un directorio de instalación (en mi caso
  \texttt{\textasciitilde{}/apps/st/st/stm32cubeide\_1.4.0})
\item
  darle la password de root para instalar ficheros de udev,
  concretamente:

  \begin{itemize}
  \tightlist
  \item
    \texttt{udev/rules.d/49-stlinkv1.rules}
  \item
    \texttt{udev/rules.d/49-stlinkv2-1.rules}
  \item
    \texttt{udev/rules.d/49-stlinkv2.rules}
  \item
    \texttt{udev/rules.d/49-stlinkv3.rules}
  \item
    \texttt{udev/rules.d/99-jlink.rules}
  \end{itemize}
\end{itemize}

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

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

\textbf{MUY IMPORTANTE} es más fácil instalar el esp-idf a través de
\emph{Platformio} pero dejo las instrucciones de instalación que usé en
su dia como referencia.

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

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{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt{-}get install gperf  cmake ninja{-}build ccache libffi{-}dev libssl{-}dev}
\end{Highlighting}
\end{Shaded}

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mkdir}\NormalTok{ \textasciitilde{}/esp}
\BuiltInTok{cd}\NormalTok{ \textasciitilde{}/esp}
\FunctionTok{git}\NormalTok{ clone }\AttributeTok{{-}{-}recursive}\NormalTok{ https://github.com/espressif/esp{-}idf}
\end{Highlighting}
\end{Shaded}

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{Shaded}
\begin{Highlighting}[]
\BuiltInTok{cd}\NormalTok{ \textasciitilde{}/esp/esp{-}idf}
\ExtensionTok{./install.sh}
\end{Highlighting}
\end{Shaded}

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

\textbf{Nota}: para que funcione correctamente en Linux Mint es
necesario que el script \texttt{tools/idf\_tools.py} apunte al python3
de nuestro sistema. Basta con editar la primera linea \emph{shebang} del
script.

Estas son las bibliotecas que deja instaladas:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{Installing}\NormalTok{ ESP{-}IDF tools}
\ExtensionTok{Installing}\NormalTok{ tools: xtensa{-}esp32{-}elf, xtensa{-}esp32s2{-}elf, esp32ulp{-}elf, esp32s2ulp{-}elf, openocd{-}esp32}
\end{Highlighting}
\end{Shaded}

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

\begin{Shaded}
\begin{Highlighting}[]
\BuiltInTok{.}\NormalTok{ \textasciitilde{}/apps/esp/esp{-}idf/export.sh}
\end{Highlighting}
\end{Shaded}

\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:kicad/kicad-5.1-releases
sudo apt-get update
sudo apt install kicad
\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}

\subsubsection{Actualizar a KiCAD 6.0}\label{actualizar-a-kicad-6.0}

Hacemos un \texttt{sudo\ apt\ purge} de todos los paquetes del antiguo
KiCAD. Desactivamos el antiguo repo y ejecutamos:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ add{-}apt{-}repository }\AttributeTok{{-}{-}yes}\NormalTok{ ppa:kicad/kicad{-}6.0{-}releases}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install }\AttributeTok{{-}{-}install{-}recommends}\NormalTok{ kicad}
\CommentTok{\# If you want demo projects}
\CommentTok{\# sudo apt install kicad{-}demos}
\end{Highlighting}
\end{Shaded}

No hay \texttt{demos} de momento en el nuevo KiCAD 6.0

\subsubsection{Actualizar a KiCAD 7}\label{actualizar-a-kicad-7}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ add{-}apt{-}repository }\AttributeTok{{-}{-}yes}\NormalTok{ ppa:kicad/kicad{-}7.0{-}releases}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install }\AttributeTok{{-}{-}install{-}recommends}\NormalTok{ kicad}
\end{Highlighting}
\end{Shaded}

\subsection{Wireviz}\label{wireviz}

Una herramienta para documentar cableados de proyectos. Es una
aplicación \emph{Python} que usa \emph{Graphviz}, lo he instalado con
\texttt{pipx}.

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{pyenv}\NormalTok{ global ve\_sys}
\ExtensionTok{pipx}\NormalTok{ install wireviz}
\ExtensionTok{pyenv}\NormalTok{ global system}
\end{Highlighting}
\end{Shaded}

\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}

\subsubsection{Sigrok}\label{sigrok}

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ aptitude install sigrok}
\end{Highlighting}
\end{Shaded}

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}.

\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{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install librxtx{-}java}
\end{Highlighting}
\end{Shaded}

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.

\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}

\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}

\subsection{PlatformIO}\label{platformio}

\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}

\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}

\subsubsection{vscodium}\label{vscodium}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wget} \AttributeTok{{-}qO} \AttributeTok{{-}}\NormalTok{ https://gitlab.com/paulcarroty/vscodium{-}deb{-}rpm{-}repo/raw/master/pub.gpg }\KeywordTok{|} \ExtensionTok{gpg} \AttributeTok{{-}{-}dearmor} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ dd of=/etc/apt/trusted.gpg.d/vscodium.gpg}
\BuiltInTok{echo} \StringTok{\textquotesingle{}deb https://paulcarroty.gitlab.io/vscodium{-}deb{-}rpm{-}repo/debs/ vscodium main\textquotesingle{}} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee }\AttributeTok{{-}{-}append}\NormalTok{ /etc/apt/sources.list.d/vscodium.list}
\FunctionTok{sudo}\NormalTok{ apt update }\KeywordTok{\&\&} \FunctionTok{sudo}\NormalTok{ apt install codium}
\end{Highlighting}
\end{Shaded}

\subsection{RepRap}\label{reprap}

\subsubsection{OpenScad}\label{openscad}

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

\subsubsection{Slic3r}\label{slic3r}

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

\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.

\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.

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

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

\subsubsection{Pronterface}\label{pronterface}

Seguimos las instrucciones para Ubuntu Focal:

Instalamos las dependencias: \texttt{sudo\ apt\ install\ libsdl2-dev}

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.

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

\subsubsection{Inkcut}\label{inkcut}

Instalado en un entorno virtual:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{mkvirtualenv} \AttributeTok{{-}p} \KeywordTok{\textasciigrave{}}\FunctionTok{which}\NormalTok{ python3}\KeywordTok{\textasciigrave{}}\NormalTok{ inkcut}

\FunctionTok{sudo}\NormalTok{ apt install libxml2{-}dev libxslt{-}dev libcups2{-}dev}

\ExtensionTok{pip}\NormalTok{ install PyQt5}

\ExtensionTok{pip}\NormalTok{ install inkcut}
\end{Highlighting}
\end{Shaded}

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

Instalamos dependencias:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{pip}\NormalTok{ install python{-}usb}
\end{Highlighting}
\end{Shaded}

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

\subsection{Drone}\label{drone}

\subsubsection{qgroundcontrol}\label{qgroundcontrol}

Descargamos
\href{https://s3-us-west-2.amazonaws.com/qgroundcontrol/latest/QGroundControl.AppImage}{el
appimage}

\subsubsection{missionplanner}\label{missionplanner}

Para usar \emph{Mission Planner} en Linux Mint se recomienda instalar
los paquetes:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install mono{-}complete festival}
\end{Highlighting}
\end{Shaded}

Descargamos el MissionPlanner desde
\href{https://firmware.ardupilot.org/Tools/MissionPlanner/MissionPlanner-latest.zip}{aquí}

\href{https://www.rcgroups.com/forums/showthread.php?2179591-Installing-MissionPlanner-1-3-X-on-Ubuntu-17-04}{Descripción
de la instalación}

Una vez descomprimido el \texttt{zip} ejecutamos:
\texttt{mono\ MissionPlanner.exe}

\subsection{node-red}\label{node-red}

Para instalar node-red en linux necesitamos instalar primero
\texttt{node.js}. Hay varias formas de instalar \texttt{node.js}, yo voy
a optar por instalar \texttt{nvm} que es el \textbf{n}ode
\textbf{v}ersion \textbf{m}anager.

Para ello ejecutamos el siguiente comando (la versión actual de
\texttt{nvm} es la 0.37.0)

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{curl} \AttributeTok{{-}o{-}}\NormalTok{ https://raw.githubusercontent.com/nvm{-}sh/nvm/v0.37.0/install.sh }\KeywordTok{|} \FunctionTok{bash}
\end{Highlighting}
\end{Shaded}

El script de instalación añade las siguientes lineas al fichero
\texttt{\textasciitilde{}/.bashrc}, nosotros las movemos al fichero
\texttt{\textasciitilde{}/.profile}

\begin{Shaded}
\begin{Highlighting}[]
\BuiltInTok{export} \VariableTok{NVM\_DIR}\OperatorTok{=}\StringTok{"}\VariableTok{$HOME}\StringTok{/.nvm"}
\BuiltInTok{[} \OtherTok{{-}s} \StringTok{"}\VariableTok{$NVM\_DIR}\StringTok{/nvm.sh"} \BuiltInTok{]} \KeywordTok{\&\&} \ExtensionTok{\textbackslash{}.} \StringTok{"}\VariableTok{$NVM\_DIR}\StringTok{/nvm.sh"}  \CommentTok{\# This loads nvm}
\BuiltInTok{[} \OtherTok{{-}s} \StringTok{"}\VariableTok{$NVM\_DIR}\StringTok{/bash\_completion"} \BuiltInTok{]} \KeywordTok{\&\&} \ExtensionTok{\textbackslash{}.} \StringTok{"}\VariableTok{$NVM\_DIR}\StringTok{/bash\_completion"}  \CommentTok{\# This loads nvm bash\_completion}
\end{Highlighting}
\end{Shaded}

Para comprobar la instalación usamos \texttt{command\ -v\ nvm} que nos
devolverá \texttt{nvm}. \texttt{which} no funciona en este caso por que
es un script para aplicarle \texttt{source}

\subsubsection{\texorpdfstring{Instalación de
\texttt{node.js}}{Instalación de node.js}}\label{instalaciuxf3n-de-node.js}

Ahora que tenemos \texttt{nvm} instalado, ya podemos instalar fácilmente
la versión o versiones que queramos de \texttt{node.js}

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{nvm}\NormalTok{ ls{-}remote      }\CommentTok{\# para listar las versiones disponibles}
\ExtensionTok{nvm}\NormalTok{ install node   }\CommentTok{\# instala la última versión disponible}
\end{Highlighting}
\end{Shaded}

\subsubsection{\texorpdfstring{Instalación de
\texttt{mosquitto}}{Instalación de mosquitto}}\label{instalaciuxf3n-de-mosquitto}

\texttt{mosquitto} es un \emph{mqtt broker} muy sencillo y completo,
aunque no es capaz de aguantar cargas grandes, para aprender es
perfecto.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt{-}add{-}repository ppa:mosquitto{-}dev/mosquitto{-}ppa}
\FunctionTok{sudo}\NormalTok{ apt{-}get update}
\FunctionTok{sudo}\NormalTok{ apt install mosquitto mosquitto{-}clients}
\end{Highlighting}
\end{Shaded}

Con esto queda el servicio instalado y funcionando
(\texttt{scs\ mosquitto} o \texttt{systemctl\ status\ mosquitto})

Si queremos el servicio parado para arrancarlo nosotros manualmente:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{scsp}\NormalTok{ mosquitto.service}
\ExtensionTok{scd}\NormalTok{ mosquitto.service}
\end{Highlighting}
\end{Shaded}

Y sin alias sería:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ systemctl stop mosquitto.service}
\FunctionTok{sudo}\NormalTok{ systemctl disable mosquitto.service}
\end{Highlighting}
\end{Shaded}

Para arrancarlo cuando lo necesitemos le damos un \emph{start} con
\texttt{scst\ mosquitto.service} o
\texttt{sudo\ systemctl\ start\ mosquitto.service}

\subsubsection{Instalación de
Influxdb}\label{instalaciuxf3n-de-influxdb}

Seguimos el método para ubuntu:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wget} \AttributeTok{{-}qO{-}}\NormalTok{ https://repos.influxdata.com/influxdb.key }\KeywordTok{|} \FunctionTok{sudo}\NormalTok{ apt{-}key add }\AttributeTok{{-}}
\CommentTok{\#source /etc/lsb{-}release}
\VariableTok{DISTRIB\_ID}\OperatorTok{=}\NormalTok{ubuntu}
\VariableTok{DISTRIB\_CODENAME}\OperatorTok{=}\NormalTok{focal}
\BuiltInTok{echo} \StringTok{"deb https://repos.influxdata.com/}\VariableTok{$\{DISTRIB\_ID\}}\StringTok{ }\VariableTok{$\{DISTRIB\_CODENAME\}}\StringTok{ stable"} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee /etc/apt/sources.list.d/influxdb.list}

\ExtensionTok{apt}\NormalTok{ update}
\ExtensionTok{apt}\NormalTok{ install influxdb}
\ExtensionTok{apt}\NormalTok{ install telegraf}
\end{Highlighting}
\end{Shaded}

\subsubsection{\texorpdfstring{Instalación de
\texttt{node-red}}{Instalación de node-red}}\label{instalaciuxf3n-de-node-red}

Una vez instalado el \texttt{node.js} instalar el \texttt{node-red} es
muy fácil

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{nvm}\NormalTok{ use node}
\ExtensionTok{npm}\NormalTok{ install }\AttributeTok{{-}g} \AttributeTok{{-}{-}unsafe{-}perm}\NormalTok{ node{-}red}
\end{Highlighting}
\end{Shaded}

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

\subsection{LibreCAD}\label{librecad}

Diseño en 2D

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

\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}

\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}

\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. Así
que bastaría con:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install gimp gimp{-}data gimp{-}texturize }\DataTypeTok{\textbackslash{}}
\NormalTok{gimp{-}data{-}extras gimp{-}gap gmic gimp{-}gmic}
\end{Highlighting}
\end{Shaded}

De todas formas dejo aquí las instrucciones para instalar desde el ppa
por si hacen falta algún dia:

\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}

\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}

\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}

\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.

\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}.

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

El \href{https://flameshot.org}{\emph{flameshot}} cubre el 99\% de mis
necesidades: \texttt{sudo\ apt\ install\ flameshot} funciona bien pero
podemos instalar la última version descargando el paquete \texttt{.deb}
desde la página web.

El \href{https://github.com/DamirPorobic/ksnip}{\emph{ksnip}} por si
tenemos que hacer una captura con retardo, puede instalarse también
bajando el paquete \texttt{.deb} desde la página web.

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

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ add{-}apt{-}repository ppa:linuxuprising/shutter}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install shutter}
\end{Highlighting}
\end{Shaded}

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

\subsubsection{ImageMagick}\label{imagemagick}

Instalamos desde los repos, simplemente:

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

\subsubsection{Imagine}\label{imagine}

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

Tiene toda la pinta de que Imagine no me va con los graficos nvidia (con
el doble monitor)

\subsection{dia}\label{dia}

Un programa para crear diagramas

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

\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}.

El paquete incluye un fichero \texttt{blender.desktop} que podemos
editar y copiar en \texttt{\textasciitilde{}/.local/share/applications}.

\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}

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

El proyecto parece abandonado. El software ya no funciona en el último
linux.

\subsection{Stopmotion}\label{stopmotion}

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

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

Descargamos el fichero \texttt{.deb} de
\href{https://github.com/DIGImend/digimend-kernel-drivers}{la página
web} y funciona perfectamente.

Para comprobar:

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

La referencia para el antiguo método que usaba para instalar los
drivers:

\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}

\section{Sonido}\label{sonido}

\subsection{Spotify}\label{spotify}

Spotify instalado desde las opciones de Linux Mint via flatpak.

\subsection{Audacity}\label{audacity}

Instalamos Audacity desde la página web descargando un \emph{Appimage}.

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

\subsection{Clementine}\label{clementine}

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

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

\subsection{somafm}\label{somafm}

Instalamos el cli con:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install jq mpv}
\BuiltInTok{cd}\NormalTok{ \textasciitilde{}/.local/bin}
\FunctionTok{wget}\NormalTok{ https://raw.githubusercontent.com/rockymadden/somafm{-}cli/master/src/somafm}
\FunctionTok{chmod}\NormalTok{ 744 somafm}

\ExtensionTok{somafm} \AttributeTok{{-}{-}help}

\ExtensionTok{somafm}\NormalTok{ ls}
\ExtensionTok{somafm}\NormalTok{ listen defcon }\AttributeTok{{-}{-}quality}\OperatorTok{=}\NormalTok{highest}
\end{Highlighting}
\end{Shaded}

\section{Video}\label{video}

\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/video/shotcut} y:

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

\subsection{kdenlive}\label{kdenlive}

Está disponible \href{https://kdenlive.org}{en la web} como ppa o como
\emph{appimage}. Lo he bajado como \emph{appimage} para probarlo.

\subsection{Openshot}\label{openshot}

También descargado desde \href{https://www.openshot.org}{su web} como
\emph{appimage}, para probar. Tienen un ppa disponible.

\subsection{Avidemux}\label{avidemux}

Descargado \emph{appimage} desde
\href{http://avidemux.sourceforge.net/}{la web}

\subsection{Handbrake}\label{handbrake}

Instalado como flatpak desde \href{https://handbrake.fr/}{su web}.

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

\subsubsection{Vokoscreen, Kazam y
SimpleScreenRecorder}\label{vokoscreen-kazam-y-simplescreenrecorder}

Instalados desde los repos oficiales:

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

Escoge el que más te guste.

\subsubsection{OBS}\label{obs}

Añadimos el repositorio

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ add{-}apt{-}repository ppa:obsproject/obs{-}studio}
\FunctionTok{sudo}\NormalTok{ apt update}
\FunctionTok{sudo}\NormalTok{ apt install obs{-}studio}
\end{Highlighting}
\end{Shaded}

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

\subsubsection{Mumble}\label{mumble}

Podemos instalarlo desde flatpak o bajarnos
\href{https://launchpad.net/~mumble/+archive/ubuntu/release/+packages}{el
paquete antiguo} (parece que funciona bien).

Mumble no está disponible desde el PPA, aunque dejo aquí las
instrucciones por si lo corrigen.

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

\subsection{Clientes de youtube}\label{clientes-de-youtube}

\subsubsection{smtube}\label{smtube}

Instalado el ppa siguiendo instrucciones de
\href{http://www.smtube.org/}{su página web}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ add{-}apt{-}repository ppa:rvm/smplayer}
\FunctionTok{sudo}\NormalTok{ apt{-}get update}
\FunctionTok{sudo}\NormalTok{ apt{-}get install smtube}
\end{Highlighting}
\end{Shaded}

\subsubsection{Freetube}\label{freetube}

Descargado el \texttt{.deb} desde
\href{https://freetubeapp.io/\#download}{su página web}.

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

\subsection{Rawtherapee}\label{rawtherapee}

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

Como siempre:

\begin{enumerate}
\tightlist
\item
  Hacemos el fichero ejecutable
\item
  Creamos un enlace \texttt{current}
\item
  Creamos un fichero \texttt{.desktop}
\end{enumerate}

\subsection{Darktable}\label{darktable}

Instalamos ppa (ver
\href{https://software.opensuse.org/download/package?package=darktable&project=graphics\%3Adarktable}{esta
web})

\begin{verbatim}
echo 'deb [signed-by=/usr/share/keyrings/darktable-archive-keyring.gpg] http://download.opensuse.org/repositories/graphics:/darktable/xUbuntu_22.04/ /' | sudo tee /etc/apt/sources.list.d/graphics:darktable.list
curl -fsSL https://download.opensuse.org/repositories/graphics:darktable/xUbuntu_22.04/Release.key | gpg --dearmor | sudo tee /usr/share/keyrings/darktable-archive-keyring.gpg > /dev/null
sudo apt update
sudo apt install darktable
\end{verbatim}

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

\subsection{Digikam}\label{digikam}

Instalado desde la \href{https://www.digikam.org/}{página web} de la
aplicación con appimage.

\subsection{Webcamoid}\label{webcamoid}

Descargada la appimage desde la
\href{https://webcamoid.github.io/}{página web}

\section{Seguridad}\label{seguridad}

\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?}

\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}

\subsection{Seahorse}\label{seahorse}

Para manejar todas nuestras claves con comodidad:

\texttt{sudo\ apt\ install\ seahorse}

\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.

\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}

\subsection{Signal}\label{signal}

El procedimiento recomendado en la página oficial lo modifico para dejar
las claves GPG en \texttt{/usr/local/keyrings}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# 1. Install our official public software signing key}
\FunctionTok{wget} \AttributeTok{{-}O{-}}\NormalTok{ https://updates.signal.org/desktop/apt/keys.asc }\KeywordTok{|} \ExtensionTok{gpg} \AttributeTok{{-}{-}dearmor} \OperatorTok{\textgreater{}}\NormalTok{ signal{-}desktop{-}keyring.gpg}
\FunctionTok{cat}\NormalTok{ signal{-}desktop{-}keyring.gpg }\KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee }\AttributeTok{{-}a}\NormalTok{ /usr/local/share/keyrings/signal{-}desktop{-}keyring.gpg }\OperatorTok{\textgreater{}}\NormalTok{ /dev/null}

\CommentTok{\# 2. Add our repository to your list of repositories}
\BuiltInTok{echo} \StringTok{\textquotesingle{}deb [arch=amd64 signed{-}by=/usr/local/share/keyrings/signal{-}desktop{-}keyring.gpg] https://updates.signal.org/desktop/apt xenial main\textquotesingle{}} \KeywordTok{|}\DataTypeTok{\textbackslash{}}
  \FunctionTok{sudo}\NormalTok{ tee }\AttributeTok{{-}a}\NormalTok{ /etc/apt/sources.list.d/signal{-}xenial.list}

\CommentTok{\# 3. Update your package database and install signal}
\FunctionTok{sudo}\NormalTok{ apt update }\KeywordTok{\&\&} \FunctionTok{sudo}\NormalTok{ apt install signal{-}desktop}
\end{Highlighting}
\end{Shaded}

Parece que todo funciona correctamente pero necesité un reinicio del
ordenador para que Signal arrancase correctamente.

\subsection{Element (cliente de
matrix.org)}\label{element-cliente-de-matrix.org}

Instalamos con:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install }\AttributeTok{{-}y}\NormalTok{ wget apt{-}transport{-}https}

\FunctionTok{sudo}\NormalTok{ wget }\AttributeTok{{-}O}\NormalTok{ /usr/local/share/keyrings/riot{-}im{-}archive{-}keyring.gpg https://packages.riot.im/debian/riot{-}im{-}archive{-}keyring.gpg}

\BuiltInTok{echo} \StringTok{"deb [signed{-}by=/usr/local/share/keyrings/riot{-}im{-}archive{-}keyring.gpg] https://packages.riot.im/debian/ default main"} \KeywordTok{|} \FunctionTok{sudo}\NormalTok{ tee /etc/apt/sources.list.d/riot{-}im.list}

\FunctionTok{sudo}\NormalTok{ apt update}

\FunctionTok{sudo}\NormalTok{ apt install element{-}desktop}
\end{Highlighting}
\end{Shaded}

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

Descargamos la aplicación en formato \texttt{.deb} desde
\href{https://www.dnielectronico.es/PortalDNIe/PRF1_Cons02.action?pag=REF_1112}{la
página de descargas del portal DNIe}.

Automáticamente nos instalará las dependecias: \texttt{libccid},
\texttt{pcsd} y \texttt{pinentry-gtk2}. A mayores instalamos:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt{-}get install pcsc{-}tools opensc}
\end{Highlighting}
\end{Shaded}

El opensc no es necesario para el DNIe, pero nos permite usar otras
tarjetas.

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

Para abrir los certificados en el navegador Firefox, nos lo explica
\href{https://www.agenciatributaria.es/AEAT.internet/Inicio/Ayuda/_comp_Consultas_informaticas/Categorias/Firma_digital__certificado_o_DNIe__y_sistema_Cl_ve_PIN/DNI_electronico__DNIe_/Comprobaciones_tecnicas_para_el_funcionamiento_del_DNIe/Comprobaciones_tecnicas_del_DNIe_con_Mozilla_Firefox_y_Linux/Comprobaciones_tecnicas_del_DNIe_con_Mozilla_Firefox_y_Linux.shtml}{esta
página de la AEAT}

Como se puede ver el link de la AEAT, los pasos necesarios para Firefox
son:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Vamos a preferencias y buscamos `cert'
\item
  En el diálogo de certificados abrimos los
  \texttt{Dispositivos\ de\ Seguridad} (\emph{Security Devices})
\item
  Para dar de alta un nuevo dispositivo pulsamos el botón
  \texttt{Cargar} (\emph{Load})
\item
  Damos un nombre (p.ej. \texttt{DNIe}) y asociamos el driver:
  \texttt{/usr/lib/libpkcs11-dnie.so}
\item
  Adicionalmente podemos \texttt{Cargar} (crear), otro dispositivo con
  el driver \texttt{opensc}, no es necesario para el DNIe pero nos añade
  soporte para otras tarjetas. (Nombre: OtrasTarjetas, Driver:
  `/usr/lib/x86\_64-linux-gnu/pkcs11/opensc-pkcs11.so)
\end{enumerate}

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

\textbf{NOTA}:

Para cada tarjeta puede hacer falta un driver diferente, tendrás que
investigar con ayuda del \texttt{pcsc\_scan} y herramientas similares.

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

\subsection{Instalación de
wireguard.}\label{instalaciuxf3n-de-wireguard.}

Instalamos con:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install wireguard}
\end{Highlighting}
\end{Shaded}

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

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

Instalamos desde los repos de Ubuntu

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install virtualbox virtualbox{-}ext{-}pack virtualbox{-}guest{-}additions{-}iso virtualbox{-}guest{-}x11}
\end{Highlighting}
\end{Shaded}

\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 gnupg lsb-release

# Import the GPG key
 sudo mkdir -m 0755 -p /usr/local/share/keyrings
 curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/local/share/keyrings/docker.gpg

# Add the repo for Docker

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/local/share/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update the package database

sudo apt update
#

apt-cache policy docker-ce

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

sudo gpasswd -a username docker
\end{verbatim}

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

La forma de pararlo es:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ systemctl stop docker}
\FunctionTok{sudo}\NormalTok{ systemctl disable docker}
\ExtensionTok{systemctl}\NormalTok{ status docker}
\end{Highlighting}
\end{Shaded}

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{Shaded}
\begin{Highlighting}[]
\ExtensionTok{scst}\NormalTok{ docker  }\CommentTok{\# para arrancar el servicio}

\ExtensionTok{scsp}\NormalTok{ docker  }\CommentTok{\# para parar el servicio}
\end{Highlighting}
\end{Shaded}

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

\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
siguiente comando, pero tendréis actualizaciones diarias:

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

Ya estamos listos para editar Open Street Map offline.

\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}

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

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

\subsection{QGIS}\label{qgis}

Añadimos la clave gpg:

\begin{verbatim}
wget -q  https://qgis.org/downloads/qgis-2019.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}

\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}

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

\subsection{Añadir las claves GPG de un
repo}\label{auxf1adir-las-claves-gpg-de-un-repo}

\textbf{Este método está obsoleto y no se recomienda}

\begin{verbatim}
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys  F7E06F06199EF2F2
\end{verbatim}

Hasta ahora añadíamos las claves usando el programa \texttt{apt-key}
como se describe arriba. El programa añade las claves en el ``llavero''
\texttt{/etc/apt/trusted.gpg}. El gestor de paquetes \texttt{apt} confía
ciegamente en las claves de este llavero. Eso permite que cualquier
clave presente en el ``llavero'' sirva para instalar cualquier programa.
No hay una relación unívoca entre claves y programas.

Para evitar el \emph{warning} podríamos almacenar las claves en
\texttt{/etc/apt/trusted.d}, cada clave en si fichero separado. Pero eso
dejaría el verdadero problema de establecer una relación entre clave y
repo sin solucionar.

Si seguimos las recomendaciones de \textbf{\emph{Debian}}, deberíamos
tener un directorio solo accesible por \texttt{root}. Por ejemplo
\texttt{/usr/local/share/keyring} y deberíamos almacenar las claves con
nombres de la forma:
\texttt{\textless{}keyword\textgreater{}-archive-keyring.gpg}.

Una vez que tengamos la clave disponible debemos especificar para cada
origen de software que clave le aplica para la autenticación de
paquetes.

\textbf{En resumen}:

\begin{itemize}
\tightlist
\item
  Las claves gpg de los repo se quedarán almacenadas en
  \texttt{/usr/local/share/keyring}, estarán en formato \emph{dearmored}
  y con los nombres en la forma canónica
  \texttt{\textless{}keyword\textgreater{}-archive-keyring.gpg}
\item
  Las especificaciones de los orígenes de software harán referencia
  explícita a la clave que hay que usar para comprobarlas, es decir,
  tendrán la forma:
  \texttt{deb\ {[}signed-by=/usr/share/keyrings/\textless{}myrepository\textgreater{}-archive-keyring.gpg{]}\ \textless{}https://repository.example.com/debian/\ stable\ main\textgreater{}}
\end{itemize}

\subsubsection{\texorpdfstring{Si la clave ya estaba en
\texttt{trusted.gpg}}{Si la clave ya estaba en trusted.gpg}}\label{si-la-clave-ya-estaba-en-trusted.gpg}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt{-}key list}

\CommentTok{\# Obtendremos un lista de claves e identificamos la conflictiva:}
\CommentTok{\#}
\CommentTok{\# pub   rsa1024 2009{-}01{-}22 [SC]}
\CommentTok{\#       E1DD 2702 88B4 E603 0699  E45F A171 5D88 E1DF 1F24}
\CommentTok{\# uid           [ unknown] Launchpad PPA for Ubuntu Git Maintainers}
\CommentTok{\#}


\CommentTok{\# Exportamos la clave al "llavero":}
\FunctionTok{sudo}\NormalTok{ apt{-}key export E1DF1F24 }\KeywordTok{|}\FunctionTok{sudo}\NormalTok{ gpg }\AttributeTok{{-}{-}dearmour} \AttributeTok{{-}o}\NormalTok{ /usr/local/share/gitMaintainers{-}archive{-}keyring.gpg}

\CommentTok{\# Editamos el fichero de orígenes del sw y probamos a actualizar}
\FunctionTok{sudo}\NormalTok{ apt update}

\CommentTok{\# si todo va bien podemos borrar la clave del trusted.gpg}
\FunctionTok{sudo}\NormalTok{ apt{-}key del E1DF1F24}
\end{Highlighting}
\end{Shaded}

\subsubsection{Descargando una clave con
wget}\label{descargando-una-clave-con-wget}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wget} \AttributeTok{{-}O{-}} \OperatorTok{\textless{}}\NormalTok{https://example.com/key/repo{-}key.gpg}\OperatorTok{\textgreater{}} \KeywordTok{|} \DataTypeTok{\textbackslash{}}
\ExtensionTok{gpg} \AttributeTok{{-}{-}dearmor} \AttributeTok{{-}o}\NormalTok{ /usr/local/share/keyrings/}\OperatorTok{\textless{}}\NormalTok{myrepository}\OperatorTok{\textgreater{}}\NormalTok{{-}archive{-}keyring.gpg}
\end{Highlighting}
\end{Shaded}

\subsubsection{Importando claves directamente de un
keyserver}\label{importando-claves-directamente-de-un-keyserver}

** REVISAR, ESTO FALLA **

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ gpg }\AttributeTok{{-}{-}no{-}default{-}keyring} \AttributeTok{{-}{-}keyring}\NormalTok{ /usr/local/share/keyrings/}\OperatorTok{\textless{}}\NormalTok{myrepository}\OperatorTok{\textgreater{}}\NormalTok{{-}archive{-}keyring.gpg }\DataTypeTok{\textbackslash{}}
\NormalTok{{-}{-}keyserver }\OperatorTok{\textless{}}\NormalTok{hkp://keyserver.ubuntu.com:80}\OperatorTok{\textgreater{}}\NormalTok{ {-}{-}recv{-}keys }\OperatorTok{\textless{}}\NormalTok{fingerprint}\OperatorTok{\textgreater{}}
\end{Highlighting}
\end{Shaded}

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

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

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

\subsection{Mapear un servidor webdav en nuestro sistema de
ficheros}\label{mapear-un-servidor-webdav-en-nuestro-sistema-de-ficheros}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install davfs2}

\FunctionTok{sudo}\NormalTok{ mount }\AttributeTok{{-}t}\NormalTok{ davfs }\OperatorTok{\textless{}}\NormalTok{server{-}url + path}\OperatorTok{\textgreater{}} \OperatorTok{\textless{}}\NormalTok{mount point}\OperatorTok{\textgreater{}}\NormalTok{ {-}o uid=}\OperatorTok{\textless{}}\NormalTok{user login}\OperatorTok{\textgreater{}}
\end{Highlighting}
\end{Shaded}

Si en algún momento queremos reconfigurar el paquete podemos ejecutar
\texttt{dpkg-reconfigure\ davfs2}

Finalmente para mi usuario:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# añadimos el usuario al grupo davfs2}
\FunctionTok{sudo}\NormalTok{ gpasswd }\AttributeTok{{-}a} \OperatorTok{\textless{}}\NormalTok{userlogin}\OperatorTok{\textgreater{}}\NormalTok{ davfs2}
\end{Highlighting}
\end{Shaded}

Añadimos al fichero \texttt{/etc/fstab} la linea del servidor webdav:

\begin{Shaded}
\begin{Highlighting}[]
\OperatorTok{\textless{}}\NormalTok{server{-}url }\ExtensionTok{+}\NormalTok{ path}\OperatorTok{\textgreater{}}  \OperatorTok{\textless{}}\NormalTok{mount point}\OperatorTok{\textgreater{}}\NormalTok{  davfs  rw,user,uid=salvari,noauto  0  0}
\end{Highlighting}
\end{Shaded}

Añadimos las credenciales al fichero
\texttt{\textasciitilde{}/.davfs2/secrets} que sería una linea con
\texttt{\textless{}mount\ point\textgreater{}\ \ \textless{}webdav-user\textgreater{}\ \textless{}webdav-passwd\textgreater{}}

Con eso ya podremos montar el webdav con nuestro usuario sin mas que
ejecutar \texttt{mount\ \textless{}mount\ point\textgreater{}}

\subsection{\texorpdfstring{Solucionar el problema de ``paquetes
mantenidos'' (\emph{The following packages have been kept
back})}{Solucionar el problema de ``paquetes mantenidos'' (The following packages have been kept back)}}\label{solucionar-el-problema-de-paquetes-mantenidos-the-following-packages-have-been-kept-back}

Cuando hacemos \texttt{sudo\ apt\ upgrade} si alguno de los paquetes que
se va a actualizar tiene \textbf{nuevas dependencias} no se actualizará
y nos dará el error del título. La solución pasa por ejecutar:

\texttt{sudo\ apt\ install\ -\/-only-upgrade\ \textless{}paquete\textgreater{}}

\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.

\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}

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

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

\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}

\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

\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.

\subsection{\texorpdfstring{Linux Mint 20 es \emph{python
agnostic}}{Linux Mint 20 es python agnostic}}\label{linux-mint-20-es-python-agnostic}

En principio no podemos invocar a \texttt{python} por que no se ha
escogido una versión por defecto.

Tenemos dos opciones:

\begin{Shaded}
\begin{Highlighting}[]
\ExtensionTok{apt}\NormalTok{ install python{-}is{-}python2}
\ExtensionTok{apt}\NormalTok{ install python{-}is{-}python3}
\end{Highlighting}
\end{Shaded}

\subsection{Instalar chromium sin
snapdrop}\label{instalar-chromium-sin-snapdrop}

Este rodeo ya no es necesario en las versiones modernas de Linux Mint

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sudo}\NormalTok{ apt install keepassxc gnucash deluge rsync grsync rar unrar }\DataTypeTok{\textbackslash{}}
\NormalTok{zip unzip unace bzip2 lzop p7zip p7zip{-}full p7zip{-}rar }\DataTypeTok{\textbackslash{}}
\NormalTok{most mc tree neofetch fasd silversearcher{-}ag ack mate{-}tweak filezilla }\DataTypeTok{\textbackslash{}}
\NormalTok{rofi}
\end{Highlighting}
\end{Shaded}

\subsection{Especificar como debe abrir los enlaces ``magnet'' el
navegador
mozilla}\label{especificar-como-debe-abrir-los-enlaces-magnet-el-navegador-mozilla}

\begin{itemize}
\tightlist
\item
  Vamos al url \texttt{about:config}
\item
  Añadimos la opción \texttt{network.protocol-handler.external.magnet}
  con valor \texttt{True}
\item
  En \emph{Settings} buscamos \emph{Applications} y nos aseguramos de
  que no tenga marcado por defecto \emph{Save} sino \emph{Ask}
\item
  La próxima vez que queramos descargar un enlace magnet nos preguntará
  que aplicación queremos usar.
\end{itemize}

\end{document}