Desarrollo de Aplicaciones en Ambientes Emergentes

0
DESARROLLO DE
APLICACIONES EN
AMBIENTES EMERGENTES
Contenido
UNIDAD 1 INTRODUCCIÓN A UNIX Y AL SOFTWARE LIBRE ..................................................................................... 1
HISTORIA DE UNIX ..........................................................................................................................................................3

EL PROYECTO GNU ........................................................................................................................................................9
¿Qué es GNU? .......................................................................................................................................................9
Filosofía del proyecto GNU..................................................................................................................................10
EL SOFTWARE LIBRE......................................................................................................................................................11
Sobre el Software Libre .......................................................................................................................................11
¿Qué es el software libre? ...................................................................................................................................11
Más allá del software..........................................................................................................................................11
¿Código abierto? .................................................................................................................................................12
LICENCIAS DE SOFTWARE LIBRE .......................................................................................................................................13
Licencia Pública General de GNU ........................................................................................................................13
Licencia Pública General Reducida de GNU ........................................................................................................13
Licencia Pública General de Affero de GNU ........................................................................................................13
Licencia de Documentación Libre de GNU ..........................................................................................................13
¿Qué es el Copyleft? ............................................................................................................................................13
UNIDAD 2 DISTRIBUCIONES DE SISTEMAS UNIX’ LIKE .......................................................................................... 16
CONCEPTO DE DISTRIBUCIÓN..........................................................................................................................................18
COMPONENTES DE UNA DISTRIBUCIÓN .............................................................................................................................19
KERNEL ......................................................................................................................................................................20
Unix .....................................................................................................................................................................20
Tipos de núcleo ...................................................................................................................................................22
UNIDAD 3 SHELL DE SISTEMAS UNIX’ LIKE ........................................................................................................... 23
INTRODUCCIÓN ............................................................................................................................................................25
¿Qué es una shell? ..............................................................................................................................................25
¿Qué es Bash? .....................................................................................................................................................25
CARACTERÍSTICAS BÁSICAS DE LA SHELL.............................................................................................................................27
Sintaxis de la Shell ...............................................................................................................................................27
Operación de la Shell...........................................................................................................................................27
Citado ..................................................................................................................................................................28
ESTRUCTURA DEL SISTEMA DE ARCHIVOS ...........................................................................................................................30
SWAP...................................................................................................................................................................31
SISTEMA DE ARCHIVOS UNIX’ LIKE ...................................................................................................................................33
Introducción al Sistema de Archivos Unix’ Like ...................................................................................................33
Tipos de Archivos ................................................................................................................................................34
Navegación del Sistema de Archivos...................................................................................................................36
Atributos de Archivo Adicionales ........................................................................................................................39
COMANDOS ................................................................................................................................................................40
Comando ls .......................................................................................................................................................40
Comando cp .......................................................................................................................................................43
Comando mv .......................................................................................................................................................45
Comando rm .......................................................................................................................................................46
Comando mkdir ................................................................................................................................................47
Comando rmdir ................................................................................................................................................48
Comando cat .....................................................................................................................................................49
Comando find ..................................................................................................................................................50
Comando locate..............................................................................................................................................51
Comando updatedb .........................................................................................................................................52
Comando gzip ..................................................................................................................................................53
Comando bzip2 ................................................................................................................................................54
Comando tar .....................................................................................................................................................55
Comando ln .......................................................................................................................................................61
Comando chown ................................................................................................................................................62
Comando chgrp ................................................................................................................................................63
Comando chmod ................................................................................................................................................64
Comando useradd ...........................................................................................................................................65
Commando usermod ........................................................................................................................................66
Comando userdel ...........................................................................................................................................67
Comando groupadd .........................................................................................................................................68
Comando groupmod .........................................................................................................................................69
Comando tail ..................................................................................................................................................70
Comando grep ..................................................................................................................................................71
Comando apt-get ...........................................................................................................................................73
Comando apt-cache ......................................................................................................................................74
Comando df .......................................................................................................................................................75
Comando mount ................................................................................................................................................76
Comando umount..............................................................................................................................................77
UNIDAD 4 ENTORNOS GRÁFICOS ......................................................................................................................... 78
KDE ..........................................................................................................................................................................80
GNOME ......................................................................................................................................................................81
AQUA ........................................................................................................................................................................82
UNIDAD 5 DESARROLLO EN QT ............................................................................................................................ 83
BASES, HERRAMIENTAS Y PRIMER CÓDIGO ........................................................................................................................85

Primer programa en Qt .......................................................................................................................................85
Layouts, Jerarquía de Objetos, y Manejo de Memoria .......................................................................................88
Señales y Slots .....................................................................................................................................................92
Clases Base en Qt ................................................................................................................................................96
HERRAMIENTAS NECESARIAS PARA CREACIÓN DE DIÁLOGOS ..................................................................................................98
Diálogos y Widgets .............................................................................................................................................98
UNIDAD 6 DESARROLLO PARA MAC OS X .......................................................................................................... 108
UNIDAD 7 DESARROLLO PARA IOS ..................................................................................................................... 111

UNIDAD 1
INTRODUCCIÓN A UNIX Y AL
SOFTWARE LIBRE
Desarrollo de Aplicaciones en Ambientes Emergentes UNIDAD 1
Ing. Juan Carlos Rodríguez Ulloa INTRODUCCIÓN A UNIX Y AL SOFTWARE LIBRE
Historia de Unix
A pesar de que muchos usuarios han descubierto las bondades de Unix gracias a las más
recientes distribuciones de Linux, como Ubuntu, Mandriva o Debian, lo cierto es que este
sistema operativo tiene casi cuatro décadas de desarrollo. La historia de Unix comienza a
finales de los años 1960, cuando el Instituto Tecnológico de Massachusetts (MIT), los
Laboratorios Bell de AT&T y laGeneral Electric trabajaban en la creación de un sistema
operativo de carácter experimental llamado Multics (por Multiplexed Information and
Computing Service). Multics corría en un “mainframe” (una clase de computadoras muy
comunes en la época que constaba de una unidad central que “atendía” a varias terminales
“tontas”) de General Electric modelo GE-645.
Estas empresas buscaban desarrollar “un gran sistema operativo interactivo” que incorporara
sólidas políticas de seguridad. Hasta ese momento, la seguridad de los datos la proporcionaba
la escasa disponibilidad de las computadoras, de las que había una pequeña cantidad y solo
personal autorizado podía tener acceso a ellas. Pero la baja de precios y la popularización de
los sistemas informáticos hacían indispensable integrar en el mismo corazón del SO las
herramientas destinadas a proteger la información. El proyecto fue relativamente exitoso, e
incluso existieron algunas “versiones para producción” de Multics, pero su pobre rendimiento
hizo que AT&T decidiera desvincularse del proyecto.
Ken Thompson, uno de los programadores del equipo de los laboratorios Bell de AT&T, siguió
escribiendo software para la computadora GE-635. Entre otros programas, escribió un juego
llamado Space Travel (Viaje espacial). Sin embargo, descubrió que el juego era lento en la
máquina de General Electric y resultaba realmente caro, algo así como 75 dólares de EE.UU.
por cada partida. Así fue como, junto a su amigo Dennis Ritchie, escribió nuevamente el
programa, pero esta vez utilizando el lenguaje ensamblador de una computadora más popular
(y barata) llamada DEC PDP-7.
3
Ken Thompson y Dennis Ritchie, trabajando en el DEC PDP-7.
Thompson y Ritchie descubrieron que trabajar juntos era divertido. En 1969, y siempre dentro
de los laboratorios Bell, armaron un equipo programadores -entre los que se encontraba Rudd
Canaday- con la idea de desarrollar un sistema operativo que cumpliera con las premisas
originales del proyecto Multics, pero que corriera en una DEC PDP-7. Comenzaron a trabajar
en el sistema de archivos y en el núcleo del sistema operativo, que sería capaz de ejecutar
procesos en simultáneo (multitarea). Además, crearon un pequeño intérprete de órdenes (o de
comandos) y un reducido grupo de programas accesorios. El proyecto fue bautizado UNICS
(por Uniplexed Information and Computing System) y, en principio, solo podía “atender” a dos
usuarios a la vez. El mismo Kernighan fue el que eligió el nombre del nuevo sistema operativo,
pero culpa de un juego de palabras UNICS se convertía un sistema Multics castrado (pues
“eunuchs”, en inglés, es un homófono de UNICS). Entonces, se decidió cambiarle el nombre a
UNIX, denominación que se mantiene hasta la actualidad.
UNIX rápidamente llamó la atención de los niveles gerenciales de los laboratorios Bell, que de
pronto tenían entre sus manos un sólido sistema operativo. La empresa no había gastado un
solo dólar en el desarrollo de UNIX, pero cuando el Grupo de Investigación en Ciencias de la
Computación decidió utilizarlo en una máquina más potente que el PDP-7, Thompson y Ritchie
consiguieron el apoyo económico de AT&T. Comenzaron a reescribir el software para que
4
funcionara en una computadora PDP-11/20 y, por primera vez, en 1970, UNIX corrió en esa
plataforma. Los programadores habían incluido entre las herramientas del paquete un
programa capaz de dar formato a textos -llamado runoff- y un primitivo editor de texto. Todo el
trabajo se realizó utilizando el lenguaje ensamblador de la PDP-11/20, y los laboratorios Bell
utilizaron este primitivo “sistema de procesamiento de texto” para procesar las solicitudes de
patentes que recibían. En poco tiempo runoff recibió importantes mejoras y su nombre cambió
a troff, considerado el primer programa de edición electrónica capaz de realizar composición
tipográfica. El 3 de noviembre de 1971, Thomson y Ritchie publicaron el primer manual de
programación de UNIX, el “UNIX Programmer's Manual”.
En 1972, Ken Thompson y Dennis Ritchie crearon el lenguaje de programación C. Si

querían que UNIX fuese portado a otras plataformas, necesitaban un lenguaje de alto nivel pero
que se mantuviera cerca del ensamblador. Su idea era que el código generado por el
compilador de C fuese lo suficientemente rápido como para utilizarlo en la creación de sistemas
operativos. Así, en 1972 se tomó la decisión de escribir nuevamente UNIX, pero esta vez
en el lenguaje de programación C. Esto permitiría que fuera modificado para funcionar en
otras computadoras y que diferentes versiones pudieran ser desarrolladas por otros
programadores. AT&T puso UNIX a disposición de las universidades, empresas privadas y del
gobierno de los Estados Unidos, a través de licencias. El Departamento de Computación de la
Universidad de California, con sede en Berkeley recibió una de estas licencias, y en 1975
desarrolló y publicó su propio “clon” de UNIX, conocido como Berkeley Software Distribution
(BSD), que más tarde se convertiría en un fuerte competidor del UNIX de AT&T. Para tener una
idea de los alcances de UNIX en esa época, basta con una frase de junio de 1972 atribuida a
Dennis Ritchie y Ken Thompson: “...el número de instalaciones Unix ha alcanzado el número
de10, y esperamos que aumente...”.
5
"Arbol genealógico" de Unix.
AT&T creó una división comercial, denominada Unix Systems Laboratories, para que se
encargase de la explotación comercial del sistema operativo. La aparición de nuevas
computadoras y el impulso recibido de parte de nuevos programadores -que utilizaban C para
introducir mejoras- hicieron que fueran liberadas diferentes versiones de UNIX. En 1975, el SO
alcanzó la versión 6, que incluía “pipes” (tuberías). Esto permitió dar una orientación modular al
proyecto, consiguiendo aumentar aún más la velocidad de desarrollo. Se estima que en 1978,
unas 600 computadoras alrededor del mundo ya corrían alguna versión de UNIX. La
versión 7, última basada en el UNIX original que tuvo una gran distribución, entró en circulación
en 1979 y sirvió de base para la creación de Plan 9, un nuevo sistema operativo portable y
distribuido, diseñado por los Laboratorios Bell para ser el sucesor de UNIX en tareas de
investigación.
6
Plan 9 (virtualizado), basado en el UNIX versión 7, de 1979.
La empresa AT&T desarrolló y vendió UNIX System III (basado en la versión 7) a partir de
1981.La proliferación de versiones daba lugar a confusiones, así que la empresa decidió
combinar todos los desarrollos propios con los de distintas universidades y empresas en 1983,
dando origen al Unix System V Release 1. Esta versión introdujo características como el editor
Vi y la biblioteca curses, desarrolladas por Berkeley Software Distribution. La división Unix
Systems Laboratories de AT&T fue adquirida por Novell dos años más tarde, y se hizo cargo
de la demanda por infracción de los derechos de copyright, revelación de secretos y violación
de marca de mercado existente entre Unix Systems Laboratories y BSD. Los accionistas de
Novell tuvieron que pasar el mal trago de descubrir grandes porciones del código de BSD
habían sido copiadas ilegalmente en UNIX System V, y fueron contra demandados. Como la
propiedad intelectual de Novell se reducía a unos pocos archivos fuente, todo acabó en un
acuerdo extrajudicial cuyos términos permanecieron bajo secreto a petición de Novell.
De forma paralela al UNIX “oficial”, desde mediados de los ochenta, Richard Stallman, del
Instituto Tecnológico de Massachussets, trabajaba en lo que más tarde se conocería como
“software libre”. Stallman creo un sistema similar a UNIX con intenciones de cederlo
gratuitamente, con el nombre de GNU (Gnu's Not Unix. GNU no es Unix). En esos meses, un
joven estudiante de ciencias de la computación finlandés llamado Linus Torvalds comenzaba
el desarrollo del núcleo de un sistema operativo para computadoras basadas en la arquitectura
“Intel x86”, que reproducía muchas de las funciones existentes en UNIX. El embrionario
sistema operativo fue lanzado en forma de código abierto en 1991, con el nombre de Linux. El
7
año siguiente ese núcleo Linux fue combinado con los programas desarrollados por el Proyecto
GNU, dando como resultado el Sistema Operativo GNU/Linux.
HP ofrecia sistemas como este, capaces de correr UNIX por menos de 5000 dólares.
El resto es historia: lo que comenzó casi como un pasatiempo de dos geniales programadores
se convirtió en un potente, seguro y flexible sistema operativo, capaz de funcionar en un
teléfono móvil, una computadora personal o un cluster de computadoras. Incluso el aplaudido
sistema operativo Mac OSX es UNIX completo y aprobado por The Open Group. Se diferencia
en que posee una interfaz gráfica propietaria (Aqua), desarrollada en Objective-C en lugar de C
o C++. A pesar de tener más de 40 años sobre sus espaldas, UNIX está más vigente que
nunca.
8
El proyecto GNU
¿Qué es GNU?
GNU se inició en 1984 para desarrollar un sistema operativo completo tipo Unix de software
libre, un software que respecta completamente su libertad.
Los sistemas operativos parecidos a Unix se construyen a partir de un conjunto de bibliotecas,

aplicaciones y herramientas de programación, además de un programa para alojar recursos y
interactuar con el hardware, denominado núcleo.
Hurd, el núcleo de GNU, se está desarrollando activamente, pero todavía no está listo para el
uso diario; por esa razón, habitualmente se usa GNU con un núcleo llamado Linux.
La combinación de GNU y Linux es el sistema operativo GNU/Linux, usado hoy en día por
millones y en ocasiones denominado simplemente, e incorrectamente, «Linux».
¿Lo sabía? El nombre «GNU» (que significa «ñu» en inglés) es un acrónimo recursivo de
«¡GNU No es Unix» y en español se pronuncia fonéticamente, como una sílaba sin vocal entre
la g y la n.
9
Filosofía del proyecto GNU

El desarrollo de el sistema operativo de software libre GNU se motiva por la filosofía del
movimiento para el software libre.
10
El Software Libre
Sobre el Software Libre
El software libre es una cuestión de libertad: las personas deberían ser libres para usar el
software de todas las maneras que sean socialmente útiles. El software difiere de los objetos
materiales (como las sillas, los bocadillos o la gasolina) en el hecho de que puede copiarse y
modificarse mucho más fácilmente. Estas posibilidades hacen al software tan útil como es; y
creemos que los usuarios de software deberían ser capaces de usarlos.
¿Qué es el software libre?

El «Software Libre» es un asunto de libertad, no de precio. Para entender el concepto, debe
pensarse en «libre» como en «libertad de expresión», no como en «cerveza gratis».
El software libre es una cuestión de libertad de los usuarios para ejecutar, copiar,
distribuir, estudiar, cambiar y modificar el software. Más concretamente se refiere a los
cuatro tipos de libertades para los usuarios de software:
• La libertad de usar el programa, con cualquier propósito (libertad 0).

• La libertad de estudiar el funcionamiento del programa, y adaptarlo a las necesidades
(libertad 1). El acceso al código fuente es una condición previa para esto.
• La libertad de distribuir copias, con lo que puede ayudar a otros (libertad 2).
• La libertad de mejorar el programa y hacer públicas las mejoras, de modo que toda la
comunidad se beneficie (libertad 3). De igual forma que la libertad 1 el acceso al código
fuente es un requisito previo.
Más allá del software

Los manuales de software deben ser libres, por las mismas razones que el software debe ser
libre, y porque en efecto los manuales son parte del software.
Los mismos argumentos también tienen sentido para otros tipos de trabajos de uso práctico; es
decir, trabajos que incorporen conocimiento útil, tal como trabajos educativos y de referencia.
La Wikipedia es el ejemplo más conocido.
Cualquier tipo de trabajo puede ser libre, y la definición de software libre se ha extendido a una
definición de trabajos culturales libres aplicable a cualquier tipo de trabajo.
11
¿Código abierto?
Otro grupo ha comenzado a usar el término «código abierto» (del inglés «open source») que
significa algo parecido (pero no idéntico) a «software libre». Preferimos el término «software
libre» porque, una vez que ha escuchado que se refiere a la libertad en lugar del precio, le hace
pensar en la libertad. La palabra «abierto» nunca se refiere a la libertad.
12
Licencias de Software Libre

Licencia Pública General de GNU
La Licencia Pública General de GNU, llamada comúnmente GPL de GNU, lausan la mayoría de
los programas de GNU y más de la mitad de los paquetes de software libre. La última versión
es la 3.
Ver texto de la licencia
Licencia Pública General Reducida de GNU

La licencia pública general reducida de GNU (LGPL, por sus siglas en inglés la usan algunas,
pero no todas, bibliotecas GNU. La última versión es la versión 3.
Licencia Pública General de Affero de GNU

La licencia pública general de Affero esta basada en GPL de GNU, pero añade una clausula
adicional para permitir a los usuarios que interactúan con el programa licenciado a través de
una red, recibir el código fuente de ese programa. Recomendamos que se considere utilizar la
licencia AGPL de GNU para cualquier programa que vaya a utilizarse a través de una red. La
última versión es la 3.
Licencia de Documentación Libre de GNU

La Licencia de Documentación Libre de GNU es una forma de copyleft para ser usada en un
manual, libro de texto u otro documento que asegure que todo el mundo tiene la libertad de
copiarlo y redistribuirlo, con o sin modificaciones, de modo comercial o no comercial. La última
versión es la 1.3.
¿Qué es el Copyleft?
13
Copyleft es la forma general de hacer un programa software libre y requerir que todas las
modificaciones y versiones extendidas del programa sean también software libre.
El modo más sencillo de hacer un programa libre es ponerlo en el dominio público, es decir, sin
copyright. Esto permitirá que la gente comparte el programa y sus mejoras, si así lo desean.
Pero también permitirá que gente que no quiera cooperar pueda convertirlo en software
privativo. Pueden hacer cambios, tantos como deseen, y distribuir el resultado como un
producto privativo. Los que reciban el programa en su forma modificada no poseerán libertad
que el autor original les dio debido a que el intermediario se la ha retirado.
En el Proyecto GNU, la intención es dar a todos los usuarios la libertad de redistribuir y cambiar
software de GNU. Si el intermediario pudiera coartar la libertad, podríamos tener muchos
usuarios, pero esos usuarios no tendrían libertad. Así, en vez de poner software de GNU bajo
dominio público, lo hacemos «copyleft». Copyleft significa que cualquiera que redistribuya el
software, con o sin cambios, no podrá restringir a nadie la libertad de copiarlo, redistribuirlo o
modificarlo. Copyleft garantiza que el usuario mantenga su libertad.
El copyleft también proporciona un incentivo a otros programadores a unirse al software libre.

Software libre importante como el compilador C++ de GNU existe sólo gracias a esto.
El copyleft también ayuda a los programadores que deseen contribuir conmejoras al software
libre a obtener permiso para hacerlo. Estos programadores habitualmente trabajan para
empresas o universidades que casi harían cualquier cosa para obtener más dinero. Un
programador podría contribuir con sus cambios a la comunidad, pero su superior puede querer
hacer de esos cambios un producto de software privativo.
Cuando nosotros le explicamos a ese superior que es ilegal distribuir la versión mejorada del
producto salvo como software libre, el empresario normalmente decide liberarlo como software
libre en lugar de tirarlo a la basura.
Para hacer un programa copyleft, lo primero que hacemos proclamar que está bajo los
derechos de autor. Luego añadimos las cláusulas de distribución, que son un instrumento legal
que le da a cualquiera el derecho de usar, modificar y redistribuir el código fuente del programa
o de cualquier programa derivado de éste; pero sólo si los términos de distribución no se
cambian. De este modo, el código y las libertades se vuelven legalmente inseparables.
14
Los desarrolladores de software privativo emplean el copyright para quitar la libertad a los
usuarios; nosotros empleamos ese copyright para garantizar su libertad. Por esto cambiamos el
nombre «copyright» por «copyleft» [N. del T.: se trata de un juego de palabras en inglés.
«copyright» puede traducirse literalmente como «derecho de copia», mientras que «copyleft»
como «izquierdo de copia»).
Copyleft es un concepto general; hay muchos detalles distintos que se pueden especificar. En
el Proyecto GNU, las cláusulas específicas de distribución que empleamos están contenidas en
la Licencia Pública General de GNU, la Licencia Pública General Reducida de GNU y la
Licencia de Documentación Libre de GNU.
La licencia apropiada está incluida en muchos manuales y en cada distribución de código

fuente GNU.
La GPL de GNU se diseñó para que pueda aplicarla fácilmente a sus programas si es el titular
de los derechos de autor. Para hacerlo no tiene que modificar la GPL de GNU, sólo poner
anuncios en su programa que hagan la referencia apropiada a la GPL de GNU. Por favor, tenga
en cuenta que si usa la GPL de GNU debe conservar el texto íntegro de la licencia. Es un todo
en conjunto; las copias parciales no están permitidas (de igual modo para la LGPL, la AGPL y
la FDL).
Emplear los mismos términos de distribución para los diferentes programas hace fácil compartir
el código entre ellos. Como todos poseen los mismos términos de distribución, no hay
necesidad de pensar si los términos son compatibles. La GPL reducida incluye una cláusula
que le permite alterar los términos de distribución de su programa adaptándolos a la GPL, para
así poder copiar código en otros programas que estén cubiertos por la GPL.
15
UNIDAD 2
Distribuciones de Sistemas Unix’
Like
Ing. Juan Carlos Rodríguez Ulloa DISTRIBUCIONES DE SISTEMAS UNIX’ LIKE
Concepto de Distribución
Una distribución Linux (coloquialmente llamada distro) es una distribución de software
basada en el núcleo Linux que incluye determinados paquetes de software para
satisfacer las necesidades de un grupo específico de usuarios, dando así origen a ediciones
domésticas, empresariales y para servidores. Por lo general están compuestas, total o
mayoritariamente, de software libre, aunque a menudo incorporan aplicaciones o controladores
propietarios.
Además del núcleo Linux, las distribuciones incluyen habitualmente las bibliotecas y
herramientas del proyecto GNU y el sistema de ventanas X Window System. Dependiendo del
tipo de usuarios a los que la distribución esté dirigida se incluye también otro tipo de software
como procesadores de texto, hoja de cálculo, reproductores multimedia, herramientas
administrativas, etcétera. En el caso de incluir herramientas del proyecto GNU, también se
utiliza el términodistribución GNU/Linux.
Existen distribuciones que están soportadas comercialmente, como Fedora (Red Hat),
openSUSE (Novell), Ubuntu (Canonical Ltd.), Mandriva, y distribuciones mantenidas por la
comunidad como Debian y Gentoo. Aunque hay otras distribuciones que no están
relacionadas con alguna empresa o comunidad, como es el caso de Slackware.
18
Componentes de una distribución

Una distribución Linux típica contiene un núcleo, herramientas y librerías, software adicional,
documentación, un sistema de ventanas, un administrador de ventanasy un entorno de
escritorio, generalmente es GNOME o KDE. Gran parte del software incluido es de fuente
abierta o software libre y distribuido por sus desarrolladores tanto en binario compilado como
en forma de código fuente, permitiendo a sus usuarios modificar o compilar el código fuente
original si lo desean. Muchas distribuciones incorporan software privativo, no disponible en
forma de código fuente.
Muchas distribuciones proveen un sistema de instalación gráfica como lo hacen otros sistemas
modernos. Distribuciones independientes como Gentoo Linux, T2y Linux From Scratch proveen
el código fuente de todo el software y solo incluyen los binarios del núcleo, herramientas de
compilación y de un instalador; el instalador compila todo el software para el CPU especifico de
la PC del usuario.
El software incluido en las distribuciones viene en forma de paquetes, es decir, cada aplicación
se encuentra contenida en un paquete, por ejemplo puede ser la traducción de una aplicación
al español, un lector de pdf, un visualizador de png, etc. La mayoría de las distribuciones
actuales contienen un manejador de paquetes que se encarga de manipular todo el software
contenido en paquetes (lo instala, desinstala, actualiza, busca e instala dependencias) para que
el usuario tenga una experiencia más placentera y use su computadora para lo que necesita.
19
Kernel
Es el principal responsable de facilitar a los distintos programas acceso seguroal hardware de
la computadora o en forma más básica, es el encargado de gestionar recursos, a través de
servicios de llamada al sistema. Como hay muchos programas y el acceso al hardware es
limitado, también se encarga de decidir qué programa podrá hacer uso de un dispositivo de
hardware y durante cuánto tiempo, lo que se conoce como multiplexado. Acceder al hardware
directamente puede ser realmente complejo, por lo que los núcleos suelen implementar una
serie de abstracciones del hardware. Esto permite esconder la complejidad, y proporciona una
interfaz limpia y uniforme al hardware subyacente, lo que facilita su uso al programador.
El kernel es el programa que se encarga de:

• La comunicación entre los programas que solicitan recursos y el hardware.
• Administración de los distintos programas informáticos (tareas) de una máquina.
• Administración del hardware (memoria, procesador, periférico, forma de
almacenamiento, etc.).
Unix
Un núcleo Unix es un programa escrito casi en su totalidad en lenguaje C, con excepción de
una parte del manejo de interrupciones, expresada en el lenguaje ensamblador del procesador
en el que opera. Las funciones del núcleo son permitir la existencia de un ambiente en el que
sea posible atender a varios usuarios y múltiples tareas en forma concurrente, repartiendo al
procesador entre todos ellos, e intentando mantener en grado óptimo la atención individual.
El núcleo opera como asignador de recursos para cualquier proceso que necesite hacer uso de
las facilidades de cómputo.
• Creación de procesos, asignación de tiempos de atención y sincronización.

• Asignación de la atención del procesador a los procesos que lo requieren.
• Administración de espacio en el sistema de archivos, que incluye: acceso,
protección y administración de usuarios; comunicación entre usuarios y entre
procesos, y manipulación de E/S y administración de periféricos.
• Supervisión de la transmisión de datos entre la memoria principal y los dispositivos
periféricos.
Reside siempre en la memoria principal y tiene el control sobre la computadora, por lo que
ningún otro proceso puede interrumpirlo; sólo pueden llamarlo para que proporcione algún
servicio de los ya mencionados. Un proceso llama al núcleo mediante módulos especiales
conocidos como llamadas al sistema.
20
Consta de dos partes principales: la sección de control de procesos y la decontrol de

dispositivos. La primera asigna recursos, programas, procesos y atiende sus requerimientos
de servicio; la segunda, supervisa la transferencia de datos entre la memoria principal y los
dispositivos de la computadora. En términos generales, cada vez que algún usuario oprime una
tecla de una terminal, o que se debe leer o escribir información del disco duro, se interrumpe al
procesador central y el núcleo se encarga de efectuar la operación de transferencia.
Cuando se inicia la operación de la computadora, debe cargarse en la memoria una copia del
núcleo, que reside en el disco duro (operación denominada bootstrap). Para ello, se deben
inicializar algunas interfaces básicas de hardware; entre ellas, el reloj que proporciona
interrupciones periódicas. El núcleo también prepara algunas estructuras de datos que abarcan
una sección de almacenamiento temporal para transferencia de información entre terminales y
procesos, una sección para almacenamiento de descriptores de archivos y una variable que
indica la cantidad de memoria principal.
Enseguida, el núcleo inicializa un proceso especial, llamado proceso 0. En Unix, los procesos
se crean mediante una llamada a una rutina del sistema (fork), que funciona por un mecanismo
de duplicación de procesos. Sin embargo, esto no es suficiente para crear el primero de ellos,
por lo que el núcleo asigna una estructura de datos y establece apuntadores a una sección
especial de la memoria, llamada tabla de procesos, que contendrá los descriptores de cada uno
de los procesos existentes en el sistema.
Después de haber creado el proceso 0, se hace una copia del mismo, con lo que se crea el
proceso 1; éste muy pronto se encargará de "dar vida" al sistema completo, mediante la
activación de otros procesos que también forman parte del núcleo. Es decir, se inicia una
cadena de activaciones de procesos, entre los cuales destaca el conocido como despachador,
o planificador, que es el responsable de decidir cuál proceso se ejecutará y cuáles van a
entrar o salir de la memoria central. A partir de ese momento se conoce el número 1 como
proceso de inicialización del sistema, init.
El proceso init es el responsable de establecer la estructura de procesos en Unix.

Normalmente, es capaz de crear al menos dos estructuras distintas de procesos: el modo
monousuario y el multiusuario. Comienza activando el intérprete del lenguaje de control Shell
de Unix en la terminal principal, o consola del sistema, proporcionándole privilegios de
"superusuario". En la modalidad de un solo usuario la consola permite iniciar una primera
sesión, con privilegios especiales, e impide que las otras líneas de comunicación acepten
iniciar sesiones nuevas. Esta modalidad se usa con frecuencia para revisar y reparar sistemas
de archivos, realizar pruebas de funciones básicas del sistema y para otras actividades que
requieren uso exclusivo de la computadora.
Init crea otro proceso, que espera a que alguien entre en sesión en alguna línea de
comunicación. Cuando esto sucede, realiza ajustes en el protocolo de la línea y ejecuta el
21
programa login, que se encarga de atender inicialmente a los nuevos usuarios. Si el nombre de
usuario y la contraseña proporcionadas son correctos, entonces entra en operación el
programa Shell, que en lo sucesivo se encargará de la atención normal del usuario que se dio
de alta en esa terminal.
A partir de ese momento el responsable de atender al usuario en esa terminal es el intérprete

Shell. Cuando se desea terminar la sesión hay que desconectarse de Shell (y, por lo tanto, de
Unix), mediante una secuencia especial de teclas (usualmente. < CTL > - D). A partir de ese
momento la terminal queda disponible para atender a un nuevo usuario.
Tipos de núcleo
No necesariamente se necesita un núcleo para usar una computadora. Los programas pueden
cargarse y ejecutarse directamente en una computadora «vacía», siempre que sus autores
quieran desarrollarlos sin usar ninguna abstracción del hardware ni ninguna ayuda del sistema
operativo. Ésta era la forma normal de usar muchas de las primeras computadoras: para usar
distintos programas se tenía que reiniciar y reconfigurar la computadora cada vez. Con el
tiempo, se empezó a dejar en memoria (aún entre distintas ejecuciones) pequeños programas
auxiliares, como el cargador y el depurador, o se cargaban desde memoria de sólo lectura. A
medida que se fueron desarrollando, se convirtieron en los fundamentos de lo que llegarían a
ser los primeros núcleos de sistema operativo.
Hay cuatro grandes tipos de núcleos:

• Los núcleos monolíticos facilitan abstracciones del hardware subyacente
realmente potentes y variadas.
• Los micronúcleos (en inglés microkernel) proporcionan un pequeño conjunto de
abstracciones simples del hardware, y usan las aplicaciones llamadas servidores
para ofrecer mayor funcionalidad.
• Los núcleos híbridos (micronúcleos modificados) son muy parecidos a los
micronúcleos puros, excepto porque incluyen código adicional en el espacio de
núcleo para que se ejecute más rápidamente.
• Los exonúcleos no facilitan ninguna abstracción, pero permiten el uso debibliotecas
que proporcionan mayor funcionalidad gracias al acceso directo o casi directo al
hardware.
22
UNIDAD 3
Shell de Sistemas Unix’ Like
Ing. Juan Carlos Rodríguez Ulloa SHELL DE SISTEMAS UNIX’ LIKE
Introducción
¿Qué es una shell?
Básicamente, una shell es un procesador de macros que ejecuta comandos. El término
procesador de macros significa que la funcionalidad del texto y símbolos es expandida para
crear grandes expresiones.
Una shell de Unix es un intérprete de comandos y un lenguaje de programación. Como un

intérprete de comandos, la shell provee la interfaz de usuario hacia el rico juego de utilerías de
GNU. Las características de lenguaje de programación permiten a dichas utilerías ser
combinadas. Se pueden crear archivos conteniendo comandos, que serán comandos por si
mismos. Esos nuevos comandos tendrán el mismo estatus como comandos del sistema en
directorios como /bin, permitiendo a usuarios o grupos establecer entornos automatizados para
automatizar sus tareas más comunes.
Las shells pueden ser utilizadas interactiva o no interactivamente. En modo interactivo, los
comandos aceptan entrada tecleada desde el teclado. Cuando los comandos se ejecutan en
modo no-interactivo, leen desde un archivo.
Una shell permite la ejecución de comandos, síncrona y asíncronamente. La shell espera a que
se completen los comandos síncronos antes de aceptar más entradas; los comandos
asíncronos continúan ejecutándose en paralelo con la shell mientras los lee y ejecuta
comandos adicionales. La redirección permite un control preciso de la entrada y salida de esos
comandos.
La shell provee un pequeño conjunto de comandos incorporados, implementando funcionalidad

imposible o inconveniente de obtener mediante utilerías separadas. Por ejemplo: cd, break,
continue y exec no pueden ser implementados fuera de la shell porque directamente
manipulan la shell por si mismos. Los comandos incorporados history, getopts, kill o
pwd pueden ser implementados en utilerías separadas, pero es más conveniente utilizarlos
como comandos incorporados.
¿Qué es Bash?
Bash es una shell o lenguaje de intérprete de comandos. El nombre es un acrónimo para el
"Bourne-Again SHell", un juego de palabras de Stephen Bourne, el autor del antecesor
directo de la shell de Unix sh, la cual apareció en la versión de Unix "Seventh Edition Bell
Labs Research".
25
Bash es ampliamente compatible con sh e incorpora características útiles de Korn Shell ksh y
de C shell csh. Su objetivo es ser una implementación conforme a la porción IEEE POSIX
Shell and Tools de la especificación IEEE POSIX. Esto ofrece mejoras funcionales sobre sh
para uso interactivo y de programación.
Bash es una shell portable, actualmente corre sobre casi cualquier versión de Unix y algunos
otros sistemas operativos (existen puertos soportados independientemente para plataformas
como MS-DOS, OS/2, Windows).
26
Características básicas de la Shell

Bash es un acrónimo para “Bourne-Again SHell”. La Bourne shell es la shell tradicional de Unix
originalmente escrita por Stephen Bourne. Todos los comandos incorporados en la Bourne
Shell están disponibles en Bash, las reglas de evaluación y cadenas son tomadas de la
especificación POSIX para la shell ‘estándar’ de Unix.
Sintaxis de la Shell
Cuando la shell lee entradas, procede a través de una secuencia de operaciones. Si la entrada
indica el inicio de un comentario, la shell ignora el símbolo de comentario (‘#’), y el resto de la
línea.
Sin embargo, en términos generales, la shell lee su entrada y la divide en palabras y

operadores, empleando las reglas de citado para seleccionar que significado asignar a las
diferentes palabras y caracteres.
La shell en seguida analiza esos tokens en comandos y otras construcciones, remueve el

significado especial de ciertas palabras o caracteres, expande otros, redirecciona entradas y
salidas como se necesite, ejecuta el comando especificado, espera por el estatus de salida del
comando, y hace que ese estatus de salida esté disponible para futuras inspecciones o
procesos.
Operación de la Shell
Lo siguiente es una breve descripción de la operación de la shell cuando lee y ejecuta un
comando. Básicamente, la shell hace lo siguiente:
1. Lee su entrada de un archivo, de una cadena provista como un argumento a la

opción de invocación –c, o de la terminal del usuario.
2. Separa la entrada en palabras y operadores, obedeciendo las reglas de citado
descritas más adelante. Esos tokens son separados por metacaracteres.
3. Analiza los tokens en comandos simples y compuestos.
4. Realiza las varias expansiones de la shell separando los tokens expandidos en una
lista de nombres de archivos, comandos y argumentos.
5. Realiza cualquier redirección necesaria y remueve los operadores de redirección y
sus operandos de la lista de argumentos.
6. Ejecuta el comando.
7. Opcionalmente espera a que el comando se complete y captura el estatus de salida.
27
Citado
El citado es utilizado para remover el significado principal de ciertos caracteres o palabras a la
shell. El citado puede ser utilizado para deshabilitar algún tratamiento especial para caracteres
especiales, para prevenir palabras reservadas de ser reconocidas como tales, y prevenir
expansión de parámetros.
Cada uno de los metacaracteres tienen un significado especial para la shell y deben ser citados
si se van a representar a si mismos.
Existen tres mecanismos de citado: el carácter de escape, comillas simples, y comillas dobles.
Carácter de Escape
Una diagonal invertida no citada ‘\’ es el carácter de escape de Bash. Este preserva el
valor literal del siguiente carácter que lo sigue, con la excepción de nueva línea. Si
un par de \nueva línea aparecen, y la diagonal invertida no se cita a si misma, el
\nueva línea es tratado como una continuación de línea.
Comillas simples
Delimitando caracteres en comillas simples (‘’’) preservan el valor literal de todos los
caracteres entre las comillas. Una comilla simple no debe estar entre comillas simples,
aun cuando sea precedida por una diagonal inversa.
Comillas dobles
Delimitando caracteres en comillas dobles (‘”’) preservan el valor literal de todos los
caracteres entre las comillas, con excepción de ‘$’, ‘‘’, ‘”’, ‘\’ y cuando la expansión de
historia está habilitada ‘!’. Los caracteres ‘$’ y ‘‘’ mantienen su significado especial
dentro de comillas dobles. La diagonal invertida mantiene su significado especial solo
cuando es seguida por uno de los siguientes caracteres: ‘$’, ‘‘’, ‘”’, ‘\’ o nueva línea.
Dentro de comillas dobles, las diagonales invertidas que sean seguidas por uno de
estos caracteres son removidas. Diagonales inversas que precedan caracters sin un
significado especial son dejadas sin modificación. Una comilla doble puede ser citada
dentro de comillas dobles precediéndola por una diagonal inversa.
Citado ANSI-C
Palabras de la forma $’string’ son tratadas especialmente. La palabra expande a la

cadena, con caracteres escapados con diagonal inversa remplazados como se
28
especifica en el estándar ANSI-C. Las secuencias de escape de diagonal inversa, son

decodificadas como sigue:
\a alerta (campana)
\b retroceso
\e
\E un carácter de escape (no ANSI-C)
\f salto de página
\n nueva línea
\r retorno de carro
\t tabulación horizontal
\v tabulación vertical
\\ diagonal inversa
\’ comilla simple
\” comilla doble
Comentarios
En una shell no-interactiva, una palabra iniciando con ‘#’ causa que esa palabra y todos
los caracteres restantes en esa línea serán ignorados. Una shell interactiva sin la opción
interactive_comments habilitada no permite comentarios.
29
Estructura del sistema de archivos

El sistema de archivos es sobre el cual funciona todo sistema operativo, en este caso
revisaremos los sistemas Unix’ Like.
En Unix’ Like existe la frase “Todo es un archivo”, esto es que cada componente de hardware
es representado por un archivo. Por ejemplo si queremos enviar a imprimir algo, simplemente
lo guardamos dentro del archivo que es representado por la impresora.
Estos archivos son administrados mediante el sistema de archivos, que se encuentra

almacenado en un dispositivo de almacenamiento, pero no se almacena directamente sobre el
dispositivo de almacenamiento, ya que este tiene una estructura básica, la cual está formada
por particiones, definidas en un área llamada tabla de particiones.
Se tienen tres tipos de particiones:
• Primarias (o físicas). Este tipo de particiones es el básico dentro de los dispositivos

de almacenamiento, del cual pueden existir un máximo de 4.
• Secundarias (o lógicas). Estas particiones son más flexibles que las primarias, ya
que podemos crearlas sin existir un máximo.
• Extendidas (también físicas). Este tipo de partición realmente es una partición

primaria adaptada para albergar particiones secundarias (también llamadas
unidades lógicas), puede existir solo una partición de este tipo, la cual se cuenta
entre las cuatro máximas primarias.
1 2 3 4
NTFS 5 6 7 8 9 EXT2 ZFS
EXT3 HFS+ EXT4 FAT32 JFS
Las particiones primarias y extendida siempre reciben un número de 1 a 4. Las particiones

secundarias invariablemente reciben números de 5 hacia arriba.
En cada partición se puede establecer un sistema de archivos de acuerdo a las necesidades

que tengamos.
Para un sistema Linux se requieren mínimo dos particiones, una para datos, y otra para
memoria virtual o de intercambio, comúnmente denominada swap.
30
1 2
/ 5 6 7 8 9 10
/boot/ /home/ SWAP /usr/ /var/ /tmp/
SWAP
Linux divide su RAM física (memoria de acceso aleatorio) en trozos de memoria llamados
páginas. El intercambio es el proceso donde una página de memoria es copiada al espacio
preconfigurado en el disco duro, llamado espacio swap, para liberar esa página de memoria.
Los tamaños combinados de la memoria física y el espacio swap es la cantidad de memoria
virtual disponible.
El intercambio es necesario por dos importantes razones. Primero, cuando el sistema requiere
más memoria que la que está físicamente disponible, el kernel intercambia las páginas menos
utilizadas y da memoria a la aplicación (proceso) actual que necesita la memoria
inmediatamente. Segundo, un número significante de las páginas usadas por una aplicación
durante su fase de inicio puede solo ser utilizada para su inicialización y nunca más se utiliza.
El sistema puede intercambiar esas páginas y liberar la memoria para otras aplicaciones.
Sin embargo, el intercambio tiene una desventaja. Comparado con la memoria, los discos son
muy lentos. Las velocidades de la memoria pueden ser medidas en nanosegundos, mientras
que la de los discos es medida en milisegundos, entonces el acceso a disco es decenas de
miles de veces más lento que el acceso a la memoria física. Entre más intercambio ocurra, más
lento será el sistema. Algunas veces el intercambio excesivo o “trashing” ocurre cuando una
página es intercambiada hacia el disco, y muy pronto es intercambiada hacia la memoria física,
y nuevamente intercambiada hacia el disco, y otra vez hacia la memoria. En esas situaciones el
sistema está luchando por encontrar memoria libre y mantener las aplicaciones corriendo al
mismo tiempo. En este caso solo agregar más RAM ayudará.
Linux tiene dos formas de espacio swap: la partición swap y el archivo swap. La partición swap
es una partición independiente del disco duro utilizada únicamente para intercambio; ningún
otro archivo puede residir ahí. El archivo swap es un archivo especial en el sistema de archivos
entre su sistema y archivos de datos.
Para visualizar el espacio swap que se tiene, usar el comando swapon -s. la salida será algo
como esto:
Filename Type Size Used Priority

/dev/sda5 partition 859436 0 -1
31
Cada linea lista un espacio swap separado que está siendo utilizado por el sistema. Aquí el
campo ‘Type’ indica que este espacio swap es una partición en vez de un archivo, del campo
‘Filename’ podemos ver que se encuentra en el disco sda5. El tamaño está listado en
kilobytes, y el campo ‘Used’ nos dice cuantos kilobytes de espacio swap están utilizándose (en
este caso nada). ‘Priority’ nos dice cual espacio swap utilizará primero el sistema.
Para agregar una partición de intercambio extra, se necesita preparar. El paso uno es verificar
que la partición este marcada como partición swap y el paso dos es hacer el sistema de
archivos swap. Para verificar que la partición esté marcada para swap, ejecutar como root:
fdisk -l /dev/hdb. Remplazar /dev/hdb con el dispositivo del disco duro en el sistema con
la partición swap en él. La salida debería de verse como esto:
Device Boot Start End Blocks Id System

/dev/hdb1 2328 2434 859446 82 Linux swap / Solaris
Si la partición no ha sido marcada como swap se requiere modificarla ejecutando fdisk y

usando la opción del menú ‘t’. Se debe tener cuidado cuando se trabaja con particiones, se
pueden eliminar los datos por error de una partición. Todos los datos de la partición swap serán
eliminados. También hay que notar que Solaris utiliza el mismo ID que las particiones swap en
Linux, así que hay que tener cuidado de no eliminar la partición de Solaris por error.
Una vez que la partición está marcada como swap, se necesita prepararla utilizando el
comando mkswap como root: mkswap /dev/hdb1.
¿Qué tan grande debe ser el espacio swap?
Es posible correr un sistema Linux sin un espacio swap, y el sistema correra bien si se tiene
una gran cantidad de memoria, pero si se ejecuta algo fuera de la memoria física el sistema
fallará, como no se puede hacer nada, es mejor tener un espacio swap.
La pregunta clave es ¿Cuánta? Versiones antiguas de sistemas Unix’ Like (como Sun OS)
demandaban un espacio swap de dos a tres veces la memoria física. Implementaciones
modernas (como Linux) no requieren tanta. Una regla de oro es la siguiente:
a) Para sistemas de escritorio, usar para espacio swap del doble de la memoria, esto
permitirá ejecutar un gran número de aplicaciones.
b) Para un servidor, tener una cantidad menor de espacio swap (por decir la mitad de
la memoria física).
c) Para maquinas de escriotrio viejas (con solo algunos 128MB), utilizar tanto espacio
swap como sea posible, inclusive 1GB.
32
Sistema de Archivos Unix’ Like

Introducción al Sistema de Archivos Unix’ Like
El sistema de archivos Unix’ Like es una metodología para organizar y almacenar lógicamente
grandes cantidades de datos de tal forma que el sistema sea fácil de manejar. Un archivo
puede ser informalmente definido como una colección de datos (típicamente relacionados), el
cual puede ser lógicamente visto como un flujo de bytes (por ejemplo caracteres). Un archivo
es la más pequeña unidad de almacenamiento en el sistema de archivos Unix’ Like.
En contraste, un sistema de archivos consiste de archivos, relaciones a otros archivos, como

también los atributos de cada archivo. Los atributos de archivos son información relacionada al
archivo, pero no incluye los datos contenidos en el archivo. Los atributos de archivo para un
sistema operativo genérico pueden incluir (pero no están limitados a):
• Un tipo de archivo (tipo de dato que esta en el archivo)

• Un nombre de archivo (que puede o no incluir una extensión)
• Un tamaño físico
• Un propietario
• Capacidad de protección/privacidad del archivo
• Tiempo del archivo (tiempo y fecha de creación/modificación)
Adicionalmente, los sistemas de archivos proveen herramientas que permiten la manipulación

de archivos, proveen una organización lógica, así como proporcionar servicios que mapean la
organización lógica de archivos a dispositivos físicos.
Desde una perspectiva de novatos, els sistema de archivos Unix’ Like esta compuesto
esencialmente de archivos y directorios. Los directorios son archivos especiales que pueden
contener otros archivos.
El sistema de archivos Unix’ Like tiene una estructura jerárquica (o como un árbol) con su
directorio de más alto nivel llamado raiz (denotado por /). Inmediatamente debajo del nivel del
directorio raíz se encuentran algunos subdirectorios, donde la mayoría contienen archivos del
sistema. Debajo de estos pueden existir sistemas de archivos, archivos de aplicaciones, y/o
archivos de datos de usuario. Similar al concepto de la relación padre-hijo, todos los archivos
en un sistema Unix’ Like están relacionados a otro. Esto es, los archivos también tienen una
existencia padre-hijo. Entonces, todos los archivos (excepto uno) comparten un enlace
parental, el archivo de nivel más alto (/) es la excepción.
En seguida se muestra un diagrama de un “típico” sistema de archivos Unix’ Like. Como se

puede ver, el directorio de nivel superior es / (raíz), con los directorios debajo siendo sistemas
33
de directorios. Note que esto varía entre la variedad de implementaciones y vendedores de

Unix. Sin embargo, la organización de mayoría de los sistemas de archivos es similar.
bin/ boot/ dev/ etc/ home/ lib/ media/ mnt/ proc/ root/ sbin/ tmp/ usr/ var/
bash grub/ lilo/ apt/ passwd squid/ hugo/ cdrom/ mac/ cpuinfo ifconfig bin/ local/ sbin/ log/ spool/
cp menu.lst sources.lst squid.conf paco/ floppy/ win_c/ meminfo bin/ qmail/ squid/
ksh luis/ usb/ win_d/ sbin/ current access.log
ls src/
pwd
Este diagrama no tiene todo incluido, los siguientes directorios están presentes en la mayoría
de los sistemas de archivos Unix’ Like.
• bin/ - contiene los comandos que comúnmente se utilizan

• boot/ - contiene información del menú de arranque
• dev/ - contiene archivos de dispositivos específicos
• etc/ - contiene archivos de configuración del sistema
• home/ - contiene directorios y archivos de usuarios
• lib/ - contiene todos los archivos de librerías
• media/ - contiene sistemas de archivos montados de dispositivos de
almacenamiento extraíbles
• mnt/ - contiene sistemas de archivos montados de dispositivos de
almacenamiento fijos
• proc/ - contiene archivos relacionados a procesos del sistema
• root/ - directorio base para el usuario root
• sbin/ - contiene comandos del sistema. Si no existe /sbin, los archivos
pueden estar en /etc
• tmp/ - almacenamiento para archivos temporales, los cuales son removidos
periódicamente del sistema de archivos
• usr/ - también contiene comandos ejecutables y archivos de aplicaciones
• var/ - contiene archivos de datos de aplicaciones, como logs y bases de
datos
Tipos de Archivos
34
Desde una perspectiva de usuario en sistema Unix’ Like, todo es tratado como un archivo.
Inclusive los dispositivos como impresoras y unidades de disco.
¿Cómo puede ser esto posible? Desde que todos los datos son esencialmente un flujo de
bytes, cada dispositivo puede ser visto lógicamente como un archivo.
Todos los archivos en el sistema de archivos Unix’ Like pueden ser libremente categorizados
en tres tipos, específicamente:
1. archivos ordinarios
2. archivos directorios
3. archivos de dispositivos
Mientras que los dos últimos intuitivamente pueden no ser vistos como archivos, ellos son
considerados archivos “especiales”.
El primer tipo de archivo listado arriba es un archivo ordinario, esto es, un archivo no “muy
especial”. Los archivos ordinarios están compuestos por flujos de datos (bytes) almacenados
en algún dispositivo físico. Ejemplos de archivos ordinarios incluyen archivos de texto simple,
archivos de datos de aplicación,archivos conteniendo código fuente de alto nivel, archivos de
texto ejecutables, archivos binarios ejecutables, archivos binarios de imágenes, archivos
binarios de audio y de video. Note que no como en otras implementaciones de sistemas
operativos, los archivos no tienen que ser binarios para ser ejecutables.
El segundo tipo de archivo listado arriba es un archivo especial llamado directorio (carpeta).
Archivos de directorio actúan como contenedor para otros archivos, de cualquier categoría.
Entonces se puede tener un archivo directorio conteniendo otro archivo de directorio (esto
comúnmente se refiere a un subdirectorio). Los archivos de directorio no contienen datos en el
sentido de datos de usuario, ellos meramente contienen referencias a los archivos contenidos
en ellos.
Esto es tal vez notable a este punto mencionar que cualquier “archivo” que tiene archivos
directamente debajo (contenidos en él) en la jerarquía debe ser un directorio, y cualquier
“archivo” que no contenga archivos debajo de él en la jerarquía pueden ser un archivo
ordinario, o un directorio (vacío).
La tercer categoría de archivo mencionada arriba es un archivo de dispositivo. Este es otro

archivo especial que es usado para describir un dispositivo físico, tal como una impresora o una
unidad de dvd. Este archivo no contiene dato alguno, solamente asigna cualquier dato que va
hacia el dispositivo físico que describe.
El tipo de archivo de dispositivo típicamente incluye: archivos de dispositivos de caracteres,

archivos de dispositivos de bloque, sockets a dominios de Unix, tuberías nombradas y enlaces
35
simbólicos. Sin embargo, no todos los archivos de este tipo pueden estar presentes a través de
varias implementaciones de Unix’ Like.
Navegación del Sistema de Archivos

Para iniciar, debemos iniciar con el concepto de nombres de archivos. Esto es, después de
todo, el nombre de un archivo que permite su manipulación. En términos simples, el nombre de
un archivo es un descriptor nombrado para un archivo. Este debe consistir de uno o más
caracteres (con un máximo de 255), donde los caracteres pueden ser casi cualquier carácter
que pueda ser interpretado por la shell (excepto por / desde que tiene un significado especial).
Sin embargo se pueden utilizar nombres que describan la función del archivo en cuestión.
Por regla, los nombres de archivos en Unix’ Like no tienen que tener extensiones al final (como
.txt o .exe) como en algunos otros sistemas operativos. Sin embargo, ciertas aplicaciones con
las cuales se interactúa pueden requerir extensiones, tales como Adobe Acrobat Reader (.pdf)
o un navegador web (.html). Y como siempre, importan las mayúsculas y minúsculas (no lo
olviden). Entonces los siguientes pueden ser todos nombres de archivos Unix’ Like válidos
(note que estos pueden ser de cualquier tipo):
Mis_Cosas un archivo llamado Mis_Cosas

Mis_cosas un archivo distinto al de arriba
hipoteca.c un programa en C...de que se trata?
a.out un binario ejecutable en lenguaje C
.bashrc archivo inicial por default de bash
Mientras los nombres de archivo son ciertamente importantes, existen otros conceptos también
importantes, y es el concepto de una ruta de archivo. Una ruta de archivo puede simplemente
consistir de un nombre de archivo, o puede también incluir más información acerca del archivo,
como donde reside en todo el sistema de archivos. Hay dos técnicas para describir rutas de
archivos, absoluta y relativa.
Con las rutas absolutas de archivo, la ruta de archivo siempre inicia desde el directorio raíz,
completa e inequívoca. Entonces, las rutas absolutas de archivo siempre inician con /. Por
ejemplo, los siguientes son todas rutas absolutas de archivo del diagrama de arriba:
/etc/passwd
/bin
/usr/bin
/home/hugo/bin
/home/paco/clase_cosas/loquesea
Note que la primer diagonal indica el nivel superior del árbol (raíz), pero cada diagonal que
sigue en la ruta de archivo actua meramente como un separador. También note que los
36
archivos nombrados bin en la ruta de archivo de /bin, /usr/bin, y /home/hugo/bin son diferentes
archivos bin, debido a las diferentes ubicaciones en la jerarquía del sistema de archivos.
Con las rutas relativas de archivo, la ruta siempre es relacionada a la posición actual del
usuario o ubicación en el sistema de archivos. Entonces el inicio (parte más izquierda) de una
ruta relativa de archivo describe cualquiera:
• un archivo ordinario, lo cual implica que el archivo esta contenido dentro del
directorio actual
• un directorio, lo cual implica un hijo del directorio actual (un nivel abajo)
• una referencia al padre del directorio actual (un nivel arriba)
Lo que quiere decir entonces es que una ruta relativa de archivo que es valida desde una
posición del sistema de archivos, probablemente no sea valida desde otra ubicación. Los
usuarios novatos siempre se preguntan “¿Cómo hago para saber donde estoy?” El comando a
usar para encontrar esto es el comando pwd (print working directory), el cual indicará la
posición actual del usuario (en forma absoluta) en el sistema de archivos.
Como se mencionó arriba, parte de una ruta relativa de archivo puede ser una referencia a un
directorio padre. La única forma de referenciar un padre del directorio (actual) es con los
caracteres .. (pronunciados punto punto, NO dos puntos). Estos caracteres (sin espacios
separadores) describen el directorio padre realtivo al directorio actual, de nuevo, un nivel de
directorio hacia arriba en el sistema de archivos.
Los siguientes son ejemplos referenciando el diagrama de arriba:
Para identificar en donde estamos, tecleamos y el sistema retorna lo siguiente:
$ pwd
/home/luis/clase_cosas
Entonces el padre de este directorio es:
/home/luis # en forma absoluta

.. # en forma relativa
Otro ejemplo:
$ pwd
/home/paco
Entonces el padre de este directorio es:
/home # en forma absoluta

.. # en forma relativa
37
Y otro (note que pueden ser muchos) hijo del directorio /home/hugo es:
/home/hugo/bin # en forma absoluta

bin # en forma relativa
La pregunta ahora es ¿Cómo voy a usar esto? Se utiliza esto para navegar o moverse a través
del sistema de archivos. Moverse a través del sistema de archivos es mediante el comando cd
(change directory), el cual le permite a un usuario moverse entre directorios. El uso más simple
de este comando es intruduciendo:
$ cd
Esto nos moverá al directorio base del usuario. Lo mismo que el siguiente:
$ cd ~
Nos moverá también al directorio base del usuario. Si el usuario desea cambiarse a otro
directorio, se introduce lo siguiente:
$ cd ruta_archivo
Asumiendo que ruta_archivo es un directorio válido, el directorio de trabajo actual del usuario
será ahora esta ubicación de directorio. Recuerde, que la ruta de archivo puede ser siempre
una ruta relativa o absoluta.
Como antes, teclearemos y el sistema retornará lo siguiente:
$ pwd
/home/luis/clase_cosas
Si deseamos cambiar directorio a /home/luis/bin, podemos teclear:
$ cd /home/luis/bin # absoluta, trabajará de donde sea
$ cd .. # relativa, se mueve un directorio arriba

$ cd bin # relativa, se mueve abajo al directorio bin
$ cd ../bin # relativa, ambos pasos en una sola ruta
Usuarios novatos a veces preguntan cual ruta deben de usar, o cual es la mejor. La respuesta
simple y abierta es “depende”. Eso es que depende que tan larga es la ruta del archivo; o que
38
tan fácil es teclearla, incluyendo cualquier carácter especial; o que tan familiarizado se está con
la ubicación actual en la jerarquía del sistema de archivos, etc.
Tome algún tiempo para navegar el sistema de archivos de su implementación Unix’ Like y vea
como se compara al diagrama de arriba.
Atributos de Archivo Adicionales

Cuando ejecutamos el comando ls -l obtenemos una salida como la siguiente:
De la salida de arriba, podemos observar siete campos de atributos listados para cada archivo.
De derecha a izquierda los atributos son:
• file name: nombre asociado con el archivo (este puede ser cualquier tipo de
archivo)
• modification date: última fecha de modificación del archivo. Si no ha sido
modificado en el último año (o seis meses para Linux), el año de la última
modificación es mostrado
• size: tamaño del archivo en bytes
• group: grupo asociado para el archivo
• owner: propietario del archivo
• number of links: número de otros enlaces asociados con el archivo
• permission modes: permisos asignados al archivo para el propietario, grupo y los
demás.
Note que esta lista es para propósitos de ejemplo y no necesariamente coincide o es una
representación completa del directorio raíz (/).
El tamaño indica el número de caracteres en el archivo, no necesariamente el tamaño en disco.

Note también si el archivo es un directorio, este es el tamaño de la estructura necesaria para
manejar la jerarquía del directorio.
39
Comandos
Comando ls
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuvSUX nor --sort.
Mandatory arguments to long options are mandatory for short options too.
-a, --all do not ignore entries starting with .
-A, --almost-all do not list implied . and ..
--author with -l, print the author of each file
-b, --escape print octal escapes for nongraphic characters
--block-size=SIZE use SIZE-byte blocks
-B, --ignore-backups do not list implied entries ending with ~
-c with -lt: sort by, and show, ctime (time of last
modification of file status information)
with -l: show ctime and sort by name
otherwise: sort by ctime
-C list entries by columns
--color[=WHEN] control whether color is used to distinguish
file
types. WHEN may be `never', àlways', or
àuto'
-d, --directory list directory entries instead of contents,
and do not dereference symbolic links
-D, --dired generate output designed for Emacs' dired mode
-f do not sort, enable -aU, disable -ls --color
-F, --classify append indicator (one of */=>@|) to entries
--file-type likewise, except do not append `*'
--format=WORD across -x, commas -m, horizontal -x, long -l,
single-column -1, verbose -l, vertical -C
--full-time like -l --time-style=full-iso
-g like -l, but do not list owner
--group-directories-first
group directories before files
-G, --no-group in a long listing, don't print group names
-h, --human-readable with -l, print sizes in human readable format
(e.g., 1K 234M 2G)
--si likewise, but use powers of 1000 not 1024
-H, --dereference-command-line
follow symbolic links listed on the command line
--dereference-command-line-symlink-to-dir
follow each command line symbolic link
that points to a directory
40
--hide=PATTERN do not list implied entries matching shell

PATTERN
(overridden by -a or -A)
--indicator-style=WORD append indicator with style WORD to entry
names:
none (default), slash (-p),
file-type (--file-type), classify (-F)
-i, --inode print the index number of each file
-I, --ignore=PATTERN do not list implied entries matching shell
PATTERN
-k like --block-size=1K
-l use a long listing format
-L, --dereference when showing file information for a symbolic
link, show information for the file the link
references rather than for the link itself
-m fill width with a comma separated list of
entries
-n, --numeric-uid-gid like -l, but list numeric user and group IDs
-N, --literal print raw entry names (don't treat e.g. control
characters specially)
-o like -l, but do not list group information
-p, --indicator-style=slash
append / indicator to directories
-q, --hide-control-chars print ? instead of non graphic characters
--show-control-chars show non graphic characters as-is (default
unless program is `ls' and output is a terminal)
-Q, --quote-name enclose entry names in double quotes
--quoting-style=WORD use quoting style WORD for entry names:
literal, locale, shell, shell-always, c,
escape
-r, --reverse reverse order while sorting
-R, --recursive list subdirectories recursively
-s, --size print the size of each file, in blocks
-S sort by file size
--sort=WORD sort by WORD instead of name: none -U,
extension -X, size -S, time -t, version -v
--time=WORD with -l, show time as WORD instead of
modification
time: atime -u, access -u, use -u, ctime -c,
or status -c; use specified time as sort key
if --sort=time
--time-style=STYLE with -l, show times using style STYLE:
full-iso, long-iso, iso, locale, +FORMAT.
FORMAT is interpreted like `date'; if FORMAT is
FORMAT1<newline>FORMAT2, FORMAT1 applies to
non-recent files and FORMAT2 to recent files;
if STYLE is prefixed with `posix-', STYLE
takes effect only outside the POSIX locale
-t sort by modification time
41
-T, --tabsize=COLS assume tab stops at each COLS instead of 8

-u with -lt: sort by, and show, access time
with -l: show access time and sort by name
otherwise: sort by access time
-U do not sort; list entries in directory order
-v sort by version
-w, --width=COLS assume screen width instead of current value
-x list entries by lines instead of by columns
-X sort alphabetically by entry extension
-Z, --context print any SELinux security context of each file
-1 list one file per line
--help display this help and exit
--version output version information and exit
SIZE may be (or may be an integer optionally followed by) one of following:
kB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.
By default, color is not used to distinguish types of files. That is

equivalent to using --color=none. Using the --color option without the
optional WHEN argument is equivalent to using --color=always. With
--color=auto, color codes are output only if standard output is connected
to a terminal (tty). The environment variable LS_COLORS can influence the
colors, and can be set easily by the dircolors command.
Exit status is 0 if OK, 1 if minor problems, 2 if serious trouble.
42
Comando cp
Usage: cp [OPTION]... [-T] SOURCE DEST
or: cp [OPTION]... SOURCE... DIRECTORY
or: cp [OPTION]... -t DIRECTORY SOURCE...
Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.
-a, --archive same as -dpR
--backup[=CONTROL] make a backup of each existing destination
file
-b like --backup but does not accept an argument
--copy-contents copy contents of special files when recursive
-d same as --no-dereference --preserve=links
-f, --force if an existing destination file cannot be
opened, remove it and try again
-i, --interactive prompt before overwrite
-H follow command-line symbolic links in SOURCE
-l, --link link files instead of copying
-L, --dereference always follow symbolic links in SOURCE
-P, --no-dereference never follow symbolic links in SOURCE
-p same as --preserve=mode,ownership,timestamps
--preserve[=ATTR_LIST] preserve the specified attributes (default:
mode,ownership,timestamps), if possible
additional attributes: context, links, all
--no-preserve=ATTR_LIST don't preserve the specified attributes
--parents use full source file name under DIRECTORY
-R, -r, --recursive copy directories recursively
--remove-destination remove each existing destination file before
attempting to open it (contrast with --
force)
--sparse=WHEN control creation of sparse files
--strip-trailing-slashes remove any trailing slashes from each SOURCE
argument
-s, --symbolic-link make symbolic links instead of copying
-S, --suffix=SUFFIX override the usual backup suffix
-t, --target-directory=DIRECTORY copy all SOURCE arguments into DIRECTORY
-T, --no-target-directory treat DEST as a normal file
-u, --update copy only when the SOURCE file is newer
than the destination file or when the
destination file is missing
-v, --verbose explain what is being done
-x, --one-file-system stay on this file system
By default, sparse SOURCE files are detected by a crude heuristic and the
corresponding DEST file is made sparse as well. That is the behavior
43
selected by --sparse=auto. Specify --sparse=always to create a sparse DEST

file whenever the SOURCE file contains a long enough sequence of zero bytes.
Use --sparse=never to inhibit creation of sparse files.
The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.

The version control method may be selected via the --backup option or through
the VERSION_CONTROL environment variable. Here are the values:
none, off never make backups (even if --backup is given)

numbered, t make numbered backups
existing, nil numbered if numbered backups exist, simple otherwise
simple, never always make simple backups
As a special case, cp makes a backup of SOURCE when the force and backup
options are given and SOURCE and DEST are the same name for an existing,
regular file.
44
Comando mv
Usage: mv [OPTION]... [-T] SOURCE DEST
or: mv [OPTION]... SOURCE... DIRECTORY
or: mv [OPTION]... -t DIRECTORY SOURCE...
Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.
--backup[=CONTROL] make a backup of each existing destination
file
-f, --force do not prompt before overwriting
-i, --interactive prompt before overwrite
--strip-trailing-slashes remove any trailing slashes from each SOURCE
argument
-t, --target-directory=DIRECTORY move all SOURCE arguments into DIRECTORY
-T, --no-target-directory treat DEST as a normal file
-u, --update move only when the SOURCE file is newer
than the destination file or when the
destination file is missing


45
Comando rm
Usage: rm [OPTION]... FILE...
Remove (unlink) the FILE(s).
-f, --force ignore nonexistent files, never prompt

-i prompt before every removal
-I prompt once before removing more than three files, or
when removing recursively. Less intrusive than -i,
while still giving protection against most mistakes
--interactive[=WHEN] prompt according to WHEN: never, once (-I), or
always (-i). Without WHEN, prompt always
--one-file-system when removing a hierarchy recursively, skip any
directory that is on a file system different from
that of the corresponding command line argument
--no-preserve-root do not treat `/' specially
--preserve-root do not remove `/' (default)
-r, -R, --recursive remove directories and their contents recursively
By default, rm does not remove directories. Use the --recursive (-r or -R)
option to remove each listed directory, too, along with all of its contents.
To remove a file whose name starts with a `-', for example `-foo',
use one of these commands:
rm -- -foo
rm ./-foo
Note that if you use rm to remove a file, it is usually possible to recover

the contents of that file. If you want more assurance that the contents are
truly unrecoverable, consider using shred.
46
Comando mkdir
Usage: mkdir [OPTION] DIRECTORY...
Create the DIRECTORY(ies), if they do not already exist.
-m, --mode=MODE set file mode (as in chmod), not a=rwx - umask
-p, --parents no error if existing, make parent directories as needed
-v, --verbose print a message for each created directory
-Z, --context=CTX set the SELinux security context of each created
directory to CTX
47
Comando rmdir
Usage: rmdir [OPTION]... DIRECTORY...
Remove the DIRECTORY(ies), if they are empty.
--ignore-fail-on-non-empty
ignore each failure that is solely because a directory
is non-empty
-p, --parents Remove DIRECTORY and its ancestors. E.g., `rmdir -p a/b/c'
is
similar to `rmdir a/b/c a/b a'.
-v, --verbose output a diagnostic for every directory processed
48
Comando cat
Usage: cat [OPTION] [FILE]...
Concatenate FILE(s), or standard input, to standard output.
-A, --show-all equivalent to -vET

-b, --number-nonblank number nonempty output lines
-e equivalent to -vE
-E, --show-ends display $ at end of each line
-n, --number number all output lines
-s, --squeeze-blank suppress repeated empty output lines
-t equivalent to -vT
-T, --show-tabs display TAB characters as Î
-u (ignored)
-v, --show-nonprinting use ^ and M- notation, except for LFD and TAB
With no FILE, or when FILE is -, read standard input.
Examples:
cat f - g Output f's contents, then standard input, then g's contents.
cat Copy standard input to standard output.
49
Comando find
Usage: find [-H] [-L] [-P] [-Olevel] [-D
help|tree|search|stat|rates|opt|exec] [path...] [expression]
default path is the current directory; default expression is -print

expression may consist of: operators, options, tests, and actions:
operators (decreasing precedence; -and is implicit where no others are

given):
( EXPR ) ! EXPR -not EXPR EXPR1 -a EXPR2 EXPR1 -and EXPR2
EXPR1 -o EXPR2 EXPR1 -or EXPR2 EXPR1 , EXPR2
positional options (always true): -daystart -follow -regextype
normal options (always true, specified before other expressions):

-depth --help -maxdepth LEVELS -mindepth LEVELS -mount -noleaf
--version -xdev -ignore_readdir_race -noignore_readdir_race
tests (N can be +N or -N or N): -amin N -anewer FILE -atime N -cmin N

-cnewer FILE -ctime N -empty -false -fstype TYPE -gid N -group NAME
-ilname PATTERN -iname PATTERN -inum N -iwholename PATTERN -iregex
PATTERN
-links N -lname PATTERN -mmin N -mtime N -name PATTERN -newer FILE
-nouser -nogroup -path PATTERN -perm [+-]MODE -regex PATTERN
-readable -writable -executable
-wholename PATTERN -size N[bcwkMG] -true -type [bcdpflsD] -uid N
-used N -user NAME -xtype [bcdpfls]
actions: -delete -print0 -printf FORMAT -fprintf FILE FORMAT -print

-fprint0 FILE -fprint FILE -ls -fls FILE -prune -quit
-exec COMMAND ; -exec COMMAND {} + -ok COMMAND ;
-execdir COMMAND ; -execdir COMMAND {} + -okdir COMMAND ;
50
Comando locate
Usage: locate [OPTION]... [PATTERN]...
Search for entries in a mlocate database.
-b, --basename match only the base name of path names

-c, --count only print number of found entries
-d, --database DBPATH use DBPATH instead of default database (which is
/var/lib/mlocate/mlocate.db)
-e, --existing only print entries for currently existing files
-L, --follow follow trailing symbolic links when checking file
existence (default)
-h, --help print this help
-i, --ignore-case ignore case distinctions when matching patterns
-l, --limit, -n LIMIT limit output (or counting) to LIMIT entries
-m, --mmap ignored, for backward compatibility
-P, --nofollow, -H don't follow trailing symbolic links when checking
file
existence
-0, --null separate entries with NUL on output
-S, --statistics don't search for entries, print statistics about
each
used database
-q, --quiet report no error messages about reading databases
-r, --regexp REGEXP search for basic regexp REGEXP instead of patterns
--regex patterns are extended regexps
-s, --stdio ignored, for backward compatibility
-V, --version print version information
-w, --wholename match whole path name (default)
51
Comando updatedb
Usage: updatedb [OPTION]...
Update a mlocate database.
-f, --add-prunefs FS omit also FS

-n, --add-prunenames NAMES omit also NAMES
-e, --add-prunepaths PATHS omit also PATHS
-U, --database-root PATH the subtree to store in database (default
"/")
-h, --help print this help
-o, --output FILE database to update (default
`/var/lib/mlocate/mlocate.db')
--prune-bind-mounts FLAG omit bind mounts (default "no")
--prunefs FS filesystems to omit from database
--prunenames NAMES directory names to omit from database
--prunepaths PATHS paths to omit from database
-l, --require-visibility FLAG check visibility before reporting files
(default "yes")
-v, --verbose print paths of files as they are found
-V, --version print version information
The configuration defaults to values read from

`/etc/updatedb.conf'.
52
Comando gzip
Usage: gzip [OPTION]... [FILE]...
Compress or uncompress FILEs (by default, compress FILES in-place).
-c, --stdout write on standard output, keep original files unchanged

-d, --decompress decompress
-f, --force force overwrite of output file and compress links
-h, --help give this help
-l, --list list compressed file contents
-L, --license display software license
-n, --no-name do not save or restore the original name and time stamp
-N, --name save or restore the original name and time stamp
-q, --quiet suppress all warnings
-r, --recursive operate recursively on directories
-S, --suffix=SUF use suffix SUF on compressed files
-t, --test test compressed file integrity
-v, --verbose verbose mode
-V, --version display version number
-1, --fast compress faster
-9, --best compress better
--rsyncable Make rsync-friendly archive
53
Comando bzip2
bzip2, a block-sorting file compressor. Version 1.0.5, 10-Dec-2007.
usage: bzip2 [flags and input files in any order]
-h --help print this message

-d --decompress force decompression
-z --compress force compression
-k --keep keep (don't delete) input files
-f --force overwrite existing output files
-t --test test compressed file integrity
-c --stdout output to standard out
-q --quiet suppress noncritical error messages
-v --verbose be verbose (a 2nd -v gives more)
-L --license display software version & license
-V --version display software version & license
-s --small use less memory (at most 2500k)
-1 .. -9 set block size to 100k .. 900k
--fast alias for -1
--best alias for -9
If invoked as `bzip2', default action is to compress.

as `bunzip2', default action is to decompress.
as `bzcat', default action is to decompress to stdout.
If no file names are given, bzip2 compresses or decompresses

from standard input to standard output. You can combine
short flags, so `-v -4' means the same as -v4 or -4v, &c.
54
Comando tar
Usage: tar [OPTION...] [FILE]...
GNU `tar' saves many files together into a single tape or disk archive, and
can
restore individual files from the archive.
Examples:
tar -cf archive.tar foo bar # Create archive.tar from files foo and bar.
tar -tvf archive.tar # List all files in archive.tar verbosely.
tar -xf archive.tar # Extract all files from archive.tar.
Main operation mode:
-A, --catenate, --concatenate append tar files to an archive

-c, --create create a new archive
-d, --diff, --compare find differences between archive and file system
--delete delete from the archive (not on mag tapes!)
-r, --append append files to the end of an archive
-t, --list list the contents of an archive
--test-label test the archive volume label and exit
-u, --update only append files newer than copy in archive
-x, --extract, --get extract files from an archive
Operation modifiers:
--check-device check device numbers when creating incremental

archives (default)
-g, --listed-incremental=FILE handle new GNU-format incremental backup
-G, --incremental handle old GNU-format incremental backup
--ignore-failed-read do not exit with nonzero on unreadable files
-n, --seek archive is seekable
--no-check-device do not check device numbers when creating
incremental archives
--occurrence[=NUMBER] process only the NUMBERth occurrence of each
file
in the archive; this option is valid only in
conjunction with one of the subcommands --
delete,
--diff, --extract or --list and when a list of
files is given either on the command line or via
the -T option; NUMBER defaults to 1
--sparse-version=MAJOR[.MINOR]
set version of the sparse format to use (implies
--sparse)
-S, --sparse handle sparse files efficiently
Overwrite control:
55
-k, --keep-old-files don't replace existing files when extracting

--keep-newer-files don't replace existing files that are newer than
their archive copies
--no-overwrite-dir preserve metadata of existing directories
--overwrite overwrite existing files when extracting
--overwrite-dir overwrite metadata of existing directories when
extracting (default)
--recursive-unlink empty hierarchies prior to extracting directory
--remove-files remove files after adding them to the archive
-U, --unlink-first remove each file prior to extracting over it
-W, --verify attempt to verify the archive after writing it
Select output stream:
--ignore-command-error ignore exit codes of children

--no-ignore-command-error treat non-zero exit codes of children as
error
-O, --to-stdout extract files to standard output
--to-command=COMMAND pipe extracted files to another program
Handling of file attributes:
--atime-preserve[=METHOD] preserve access times on dumped files,

either
by restoring the times after reading
(METHOD='replace'; default) or by not setting
the
times in the first place (METHOD='system')
--delay-directory-restore delay setting modification times and
permissions of extracted directories until the
end
of extraction
--group=NAME force NAME as group for added files
--mode=CHANGES force (symbolic) mode CHANGES for added files
--mtime=DATE-OR-FILE set mtime for added files from DATE-OR-FILE
-m, --touch don't extract file modified time
--no-delay-directory-restore
cancel the effect of --delay-directory-restore
option
--no-same-owner extract files as yourself
--no-same-permissions apply the user's umask when extracting
permissions
from the archive (default for ordinary users)
--numeric-owner always use numbers for user/group names
--owner=NAME force NAME as owner for added files
-p, --preserve-permissions, --same-permissions
extract information about file permissions
(default for superuser)
56
--preserve same as both -p and -s

--same-owner try extracting files with the same ownership
-s, --preserve-order, --same-order
sort names to extract to match archive
Device selection and switching:
-f, --file=ARCHIVE use archive file or device ARCHIVE

--force-local archive file is local even if it has a colon
-F, --info-script=NAME, --new-volume-script=NAME
run script at end of each tape (implies -M)
-L, --tape-length=NUMBER change tape after writing NUMBER x 1024 bytes
-M, --multi-volume create/list/extract multi-volume archive
--rmt-command=COMMAND use given rmt COMMAND instead of rmt
--rsh-command=COMMAND use remote COMMAND instead of rsh
--volno-file=FILE use/update the volume number in FILE
Device blocking:
-b, --blocking-factor=BLOCKS BLOCKS x 512 bytes per record

-B, --read-full-records reblock as we read (for 4.2BSD pipes)
-i, --ignore-zeros ignore zeroed blocks in archive (means EOF)
--record-size=NUMBER NUMBER of bytes per record, multiple of 512
Archive format selection:
-H, --format=FORMAT create archive of the given format
FORMAT is one of the following:
gnu GNU tar 1.13.x format

oldgnu GNU format as per tar <= 1.12
pax POSIX 1003.1-2001 (pax) format
posix same as pax
ustar POSIX 1003.1-1988 (ustar) format
v7 old V7 tar format
--old-archive, --portability
same as --format=v7
--pax-option=keyword[[:]=value][,keyword[[:]=value]]...
control pax keywords
--posix same as --format=posix
-V, --label=TEXT create archive with volume name TEXT; at
list/extract time, use TEXT as a globbing
pattern
for volume name
Compression options:
57
-a, --auto-compress use archive suffix to determine the compression

program
-j, --bzip2 filter the archive through bzip2
--lzma filter the archive through lzma
--use-compress-program=PROG
filter through PROG (must accept -d)
-z, --gzip, --gunzip, --ungzip filter the archive through gzip
-Z, --compress, --uncompress filter the archive through compress
Local file selection:
--add-file=FILE add given FILE to the archive (useful if its

name
starts with a dash)
--backup[=CONTROL] backup before removal, choose version CONTROL
-C, --directory=DIR change to directory DIR
--exclude=PATTERN exclude files, given as a PATTERN
--exclude-caches exclude contents of directories containing
CACHEDIR.TAG, except for the tag file itself
--exclude-caches-all exclude directories containing CACHEDIR.TAG
--exclude-caches-under exclude everything under directories containing
CACHEDIR.TAG
--exclude-tag=FILE exclude contents of directories containing FILE,
except for FILE itself
--exclude-tag-all=FILE exclude directories containing FILE
--exclude-tag-under=FILE exclude everything under directories
containing FILE
--exclude-vcs exclude version control system directories
-h, --dereference follow symlinks; archive and dump the files they
point to
--hard-dereference follow hard links; archive and dump the files
they
refer to
-K, --starting-file=MEMBER-NAME
begin at member MEMBER-NAME in the archive
--newer-mtime=DATE compare date and time when data changed only
--no-recursion avoid descending automatically in directories
--no-unquote do not unquote filenames read with -T
--null -T reads null-terminated names, disable -C
-N, --newer=DATE-OR-FILE, --after-date=DATE-OR-FILE
only store files newer than DATE-OR-FILE
--one-file-system stay in local file system when creating archive
-P, --absolute-names don't strip leading `/'s from file names
--recursion recurse into directories (default)
--suffix=STRING backup before removal, override usual suffix
('~'
unless overridden by environment variable
SIMPLE_BACKUP_SUFFIX)
-T, --files-from=FILE get names to extract or create from FILE
58
--unquote unquote filenames read with -T (default)

-X, --exclude-from=FILE exclude patterns listed in FILE
File name transformations:
--strip-components=NUMBER strip NUMBER leading components from file

names on extraction
--transform=EXPRESSION use sed replace EXPRESSION to transform file
names
File name matching options (affect both exclude and include patterns):
--anchored patterns match file name start

--ignore-case ignore case
--no-anchored patterns match after any `/' (default for
exclusion)
--no-ignore-case case sensitive matching (default)
--no-wildcards verbatim string matching
--no-wildcards-match-slash wildcards do not match `/'
--wildcards use wildcards (default for exclusion)
--wildcards-match-slash wildcards match `/' (default for exclusion)
Informative output:
--checkpoint[=NUMBER]display progress messages every NUMBERth record

(default 10)
--checkpoint-action=ACTION execute ACTION on each checkpoint
--index-file=FILE send verbose output to FILE
-l, --check-links print a message if not all links are dumped
--no-quote-chars=STRING disable quoting for characters from STRING
--quote-chars=STRING additionally quote characters from STRING
--quoting-style=STYLE set name quoting style; see below for valid
STYLE
values
-R, --block-number show block number within archive with each
message
--show-defaults show tar defaults
--show-omitted-dirs when listing or extracting, list each directory
that does not match search criteria
--show-transformed-names, --show-stored-names
show file or archive names after transformation
--totals[=SIGNAL] print total bytes after processing the archive;
with an argument - print total bytes when this
SIGNAL is delivered; Allowed signals are:
SIGHUP,
SIGQUIT, SIGINT, SIGUSR1 and SIGUSR2; the names
without SIG prefix are also accepted
--utc print file modification dates in UTC
-v, --verbose verbosely list files processed
59
-w, --interactive, --confirmation

ask for confirmation for every action
Compatibility options:
-o when creating, same as --old-archive; when

extracting, same as --no-same-owner
Other options:
-?, --help give this help list

--restrict disable use of some potentially harmful options
--usage give a short usage message
--version print program version
Mandatory or optional arguments to long options are also mandatory or

optional
for any corresponding short options.

The version control may be set with --backup or VERSION_CONTROL, values are:
none, off never make backups

t, numbered make numbered backups
nil, existing numbered if numbered backups exist, simple otherwise
never, simple always make simple backups
Valid arguments for --quoting-style options are:
literal
shell
shell-always
c
c-maybe
escape
locale
clocale
*This* tar defaults to:

--format=gnu -f- -b20 --quoting-style=escape --rmt-command=/usr/sbin/rmt
--rsh-command=/usr/bin/rsh
60
Comando ln
Usage: ln [OPTION]... [-T] TARGET LINK_NAME (1st form)
or: ln [OPTION]... TARGET (2nd form)
or: ln [OPTION]... TARGET... DIRECTORY (3rd form)
or: ln [OPTION]... -t DIRECTORY TARGET... (4th form)
In the 1st form, create a link to TARGET with the name LINK_NAME.
In the 2nd form, create a link to TARGET in the current directory.
In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.
Create hard links by default, symbolic links with --symbolic.
When creating hard links, each TARGET must exist.
--backup[=CONTROL] make a backup of each existing destination file
-d, -F, --directory allow the superuser to attempt to hard link
directories (note: will probably fail due to
system restrictions, even for the superuser)
-f, --force remove existing destination files
-n, --no-dereference treat destination that is a symlink to a
directory as if it were a normal file
-i, --interactive prompt whether to remove destinations
-s, --symbolic make symbolic links instead of hard links
-t, --target-directory=DIRECTORY specify the DIRECTORY in which to create
the links
-T, --no-target-directory treat LINK_NAME as a normal file
-v, --verbose print name of each linked file


61
Comando chown
Usage: chown [OPTION]... [OWNER][:[GROUP]] FILE...
or: chown [OPTION]... --reference=RFILE FILE...
Change the owner and/or group of each FILE to OWNER and/or GROUP.
With --reference, change the owner and group of each FILE to those of RFILE.
-c, --changes like verbose but report only when a change is made
--dereference affect the referent of each symbolic link (this is
the default), rather than the symbolic link itself
-h, --no-dereference affect each symbolic link instead of any referenced
file (useful only on systems that can change the
ownership of a symlink)
--from=CURRENT_OWNER:CURRENT_GROUP
change the owner and/or group of each file only if
its current owner and/or group match those specified
here. Either may be omitted, in which case a match
is not required for the omitted attribute.
--no-preserve-root do not treat `/' specially (the default)
--preserve-root fail to operate recursively on `/'
-f, --silent, --quiet suppress most error messages
--reference=RFILE use RFILE's owner and group rather than
specifying OWNER:GROUP values
-R, --recursive operate on files and directories recursively
-v, --verbose output a diagnostic for every file processed
The following options modify how a hierarchy is traversed when the -R

option is also specified. If more than one is specified, only the final
one takes effect.
-H if a command line argument is a symbolic link

to a directory, traverse it
-L traverse every symbolic link to a directory
encountered
-P do not traverse any symbolic links (default)

Owner is unchanged if missing. Group is unchanged if missing, but changed

to login group if implied by a `:' following a symbolic OWNER.
OWNER and GROUP may be numeric as well as symbolic.
Examples:
chown root /u Change the owner of /u to "root".
chown root:staff /u Likewise, but also change its group to "staff".
chown -hR root /u Change the owner of /u and subfiles to "root".
62
Comando chgrp
Usage: chgrp [OPTION]... GROUP FILE...
or: chgrp [OPTION]... --reference=RFILE FILE...
Change the group of each FILE to GROUP.
With --reference, change the group of each FILE to that of RFILE.
--dereference affect the referent of each symbolic link (this is
the default), rather than the symbolic link itself
-h, --no-dereference affect each symbolic link instead of any referenced
file (useful only on systems that can change the
ownership of a symlink)
--reference=RFILE use RFILE's group rather than specifying a
GROUP value
-R, --recursive operate on files and directories recursively
The following options modify how a hierarchy is traversed when the -R

option is also specified. If more than one is specified, only the final
one takes effect.
-H if a command line argument is a symbolic link

to a directory, traverse it
-L traverse every symbolic link to a directory
encountered
-P do not traverse any symbolic links (default)

Examples:
chgrp staff /u Change the group of /u to "staff".
chgrp -hR staff /u Change the group of /u and subfiles to "staff".
63
Comando chmod
Usage: chmod [OPTION]... MODE[,MODE]... FILE...
or: chmod [OPTION]... OCTAL-MODE FILE...
or: chmod [OPTION]... --reference=RFILE FILE...
Change the mode of each FILE to MODE.
--reference=RFILE use RFILE's mode instead of MODE values
-R, --recursive change files and directories recursively
Each MODE is of the form `[ugoa]*([-+=]([rwxXst]*|[ugo]))+'.
64
Comando useradd
Usage: useradd [options] LOGIN
Options:
-b, --base-dir BASE_DIR base directory for the new user account
home directory
-c, --comment COMMENT set the GECOS field for the new user account
-d, --home-dir HOME_DIR home directory for the new user account
-D, --defaults print or save modified default useradd
configuration
-e, --expiredate EXPIRE_DATE set account expiration date to EXPIRE_DATE
-f, --inactive INACTIVE set password inactive after expiration
to INACTIVE
-g, --gid GROUP force use GROUP for the new user account
-G, --groups GROUPS list of supplementary groups for the new
user account
-h, --help display this help message and exit
-k, --skel SKEL_DIR specify an alternative skel directory
-K, --key KEY=VALUE overrides /etc/login.defs defaults
-l, do not add the user to the lastlog and
faillog databases
-m, --create-home create home directory for the new user
account
-N, --no-user-group do not create a group with the same name as
the user
-o, --non-unique allow create user with duplicate
(non-unique) UID
-p, --password PASSWORD use encrypted password for the new user
account
-r, --system create a system account
-s, --shell SHELL the login shell for the new user account
-u, --uid UID force use the UID for the new user account
-U, --user-group create a group with the same name as the user
65
Commando usermod
Usage: usermod [options] LOGIN
Options:
-c, --comment COMMENT new value of the GECOS field
-d, --home HOME_DIR new home directory for the user account
-e, --expiredate EXPIRE_DATE set account expiration date to EXPIRE_DATE
-f, --inactive INACTIVE set password inactive after expiration
to INACTIVE
-g, --gid GROUP force use GROUP as new primary group
-G, --groups GROUPS new list of supplementary GROUPS
-a, --append append the user to the supplemental GROUPS
mentioned by the -G option without removing
him/her from other groups
-l, --login NEW_LOGIN new value of the login name
-L, --lock lock the user account
-m, --move-home move contents of the home directory to the
new location (use only with -d)
-o, --non-unique allow using duplicate (non-unique) UID
-p, --password PASSWORD use encrypted password for the new password
-s, --shell SHELL new login shell for the user account
-u, --uid UID new UID for the user account
-U, --unlock unlock the user account
66
Comando userdel
Usage: userdel [options] LOGIN
Options:
-f, --force force removal of files,
even if not owned by user
-r, --remove remove home directory and mail spool
67
Comando groupadd
Usage: groupadd [options] GROUP
Options:
-f, --force force exit with success status if the
specified group already exists
-g, --gid GID use GID for the new group
-K, --key KEY=VALUE overrides /etc/login.defs defaults
-o, --non-unique allow create group with duplicate
(non-unique) GID
-p, --password PASSWORD use encrypted password for the new group
-r, --system create a system account
68
Comando groupmod
Usage: groupmod [options] GROUP
Options:
-g, --gid GID force use new GID by GROUP
-n, --new-name NEW_GROUP force use NEW_GROUP name by GROUP
-o, --non-unique allow using duplicate (non-unique) GID by
GROUP
-p, --password PASSWORD use encrypted password for the new password
69
Comando tail
Usage: tail [OPTION]... [FILE]...
Print the last 10 lines of each FILE to standard output.
With more than one FILE, precede each with a header giving the file name.
--retry keep trying to open a file even if it is
inaccessible when tail starts or if it becomes
inaccessible later; useful when following by name,
i.e., with --follow=name
-c, --bytes=N output the last N bytes; alternatively, use +N to
output bytes starting with the Nth of each file
-f, --follow[={name|descriptor}]
output appended data as the file grows;
-f, --follow, and --follow=descriptor are
equivalent
-F same as --follow=name --retry
-n, --lines=N output the last N lines, instead of the last 10;
or use +N to output lines starting with the Nth
--max-unchanged-stats=N
with --follow=name, reopen a FILE which has not
changed size after N (default 5) iterations
to see if it has been unlinked or renamed
(this is the usual case of rotated log files)
--pid=PID with -f, terminate after process ID, PID dies
-q, --quiet, --silent never output headers giving file names
-s, --sleep-interval=S with -f, sleep for approximately S seconds
(default 1.0) between iterations.
-v, --verbose always output headers giving file names
If the first character of N (the number of bytes or lines) is a `+',

print beginning with the Nth item from the start of each file, otherwise,
print the last N items in the file. N may have a multiplier suffix:
b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,
GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.
With --follow (-f), tail defaults to following the file descriptor, which
means that even if a tail'ed file is renamed, tail will continue to track
its end. This default behavior is not desirable when you really want to
track the actual name of the file, not the file descriptor (e.g., log
rotation). Use --follow=name in that case. That causes tail to track the
named file by reopening it periodically to see if it has been removed and
recreated by some other program.
70
Comando grep
Usage: grep [OPTION]... PATTERN [FILE]...
Search for PATTERN in each FILE or standard input.
PATTERN is, by default, a basic regular expression (BRE).
Example: grep -i 'hello world' menu.h main.c
Regexp selection and interpretation:

-E, --extended-regexp PATTERN is an extended regular expression (ERE)
-F, --fixed-strings PATTERN is a set of newline-separated fixed
strings
-G, --basic-regexp PATTERN is a basic regular expression (BRE)
-P, --perl-regexp PATTERN is a Perl regular expression
-e, --regexp=PATTERN use PATTERN for matching
-f, --file=FILE obtain PATTERN from FILE
-i, --ignore-case ignore case distinctions
-w, --word-regexp force PATTERN to match only whole words
-x, --line-regexp force PATTERN to match only whole lines
-z, --null-data a data line ends in 0 byte, not newline
Miscellaneous:
-s, --no-messages suppress error messages
-v, --invert-match select non-matching lines
-V, --version print version information and exit
--mmap use memory-mapped input if possible
Output control:
-m, --max-count=NUM stop after NUM matches
-b, --byte-offset print the byte offset with output lines
-n, --line-number print line number with output lines
--line-buffered flush output on every line
-H, --with-filename print the filename for each match
-h, --no-filename suppress the prefixing filename on output
--label=LABEL print LABEL as filename for standard input
-o, --only-matching show only the part of a line matching PATTERN
-q, --quiet, --silent suppress all normal output
--binary-files=TYPE assume that binary files are TYPE;
TYPE is `binary', `text', or `without-match'
-a, --text equivalent to --binary-files=text
-I equivalent to --binary-files=without-match
-d, --directories=ACTION how to handle directories;
ACTION is `read', `recurse', or `skip'
-D, --devices=ACTION how to handle devices, FIFOs and sockets;
ACTION is `read' or `skip'
-R, -r, --recursive equivalent to --directories=recurse
--include=FILE_PATTERN search only files that match FILE_PATTERN
71
--exclude=FILE_PATTERN skip files and directories matching

FILE_PATTERN
--exclude-from=FILE skip files matching any file pattern from FILE
--exclude-dir=PATTERN directories that match PATTERN will be skipped.
-L, --files-without-match print only names of FILEs containing no match
-l, --files-with-matches print only names of FILEs containing matches
-c, --count print only a count of matching lines per FILE
-T, --initial-tab make tabs line up (if needed)
-Z, --null print 0 byte after FILE name
Context control:
-B, --before-context=NUM print NUM lines of leading context
-A, --after-context=NUM print NUM lines of trailing context
-C, --context=NUM print NUM lines of output context
-NUM same as --context=NUM
--color[=WHEN],
--colour[=WHEN] use markers to highlight the matching strings;
WHEN is àlways', `never', or àuto'
-U, --binary do not strip CR characters at EOL (MSDOS)
-u, --unix-byte-offsets report offsets as if CRs were not there (MSDOS)
ègrep' means `grep -E'. `fgrep' means `grep -F'.

Direct invocation as either ègrep' or `fgrep' is deprecated.
With no FILE, or when FILE is -, read standard input. If less than two FILEs
are given, assume -h. Exit status is 0 if any line was selected, 1
otherwise;
if any error occurs and -q was not given, the exit status is 2.
72
Comando apt-get
apt 0.7.20.2 for i386 compiled on Apr 20 2009 21:52:39
Usage: apt-get [options] command
apt-get [options] install|remove pkg1 [pkg2 ...]
apt-get [options] source pkg1 [pkg2 ...]
apt-get is a simple command line interface for downloading and

installing packages. The most frequently used commands are update
and install.
Commands:
update - Retrieve new lists of packages
upgrade - Perform an upgrade
install - Install new packages (pkg is libc6 not libc6.deb)
remove - Remove packages
autoremove - Remove automatically all unused packages
purge - Remove and purge packages
source - Download source archives
build-dep - Configure build-dependencies for source packages
dist-upgrade - Distribution upgrade, see apt-get(8)
dselect-upgrade - Follow dselect selections
clean - Erase downloaded archive files
autoclean - Erase old downloaded archive files
check - Verify that there are no broken dependencies
Options:
-h This help text.
-q Loggable output - no progress indicator
-qq No output except for errors
-d Download only - do NOT install or unpack archives
-s No-act. Perform ordering simulation
-y Assume Yes to all queries and do not prompt
-f Attempt to correct a system with broken dependencies in place
-m Attempt to continue if archives are unlocatable
-u Show a list of upgraded packages as well
-b Build the source package after fetching it
-V Show verbose version numbers
-c=? Read this configuration file
-o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp
See the apt-get(8), sources.list(5) and apt.conf(5) manual
pages for more information and options.
This APT has Super Cow Powers.
73
Comando apt-cache
apt 0.7.20.2 for i386 compiled on Apr 20 2009 21:52:36
Usage: apt-cache [options] command
apt-cache [options] add file1 [file2 ...]
apt-cache [options] showpkg pkg1 [pkg2 ...]
apt-cache [options] showsrc pkg1 [pkg2 ...]
apt-cache is a low-level tool used to manipulate APT's binary

cache files, and query information from them
Commands:
add - Add a package file to the source cache
gencaches - Build both the package and source cache
showpkg - Show some general information for a single package
showsrc - Show source records
stats - Show some basic statistics
dump - Show the entire file in a terse form
dumpavail - Print an available file to stdout
unmet - Show unmet dependencies
search - Search the package list for a regex pattern
show - Show a readable record for the package
depends - Show raw dependency information for a package
rdepends - Show reverse dependency information for a package
pkgnames - List the names of all packages in the system
dotty - Generate package graphs for GraphViz
xvcg - Generate package graphs for xvcg
policy - Show policy settings
Options:
-h This help text.
-p=? The package cache.
-s=? The source cache.
-q Disable progress indicator.
-i Show only important deps for the unmet command.
-c=? Read this configuration file
-o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp
See the apt-cache(8) and apt.conf(5) manual pages for more information.
74
Comando df
Usage: df [OPTION]... [FILE]...
Show information about the file system on which each FILE resides,
or all file systems by default.
-a, --all include dummy file systems
-B, --block-size=SIZE use SIZE-byte blocks
-h, --human-readable print sizes in human readable format (e.g., 1K 234M
2G)
-H, --si likewise, but use powers of 1000 not 1024
-i, --inodes list inode information instead of block usage
-k like --block-size=1K
-l, --local limit listing to local file systems
--no-sync do not invoke sync before getting usage info
(default)
-P, --portability use the POSIX output format
--sync invoke sync before getting usage info
-t, --type=TYPE limit listing to file systems of type TYPE
-T, --print-type print file system type
-x, --exclude-type=TYPE limit listing to file systems not of type TYPE
-v (ignored)
SIZE may be (or may be an integer optionally followed by) one of following:
kB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.
75
Comando mount
Usage: mount -V : print version
mount -h : print this help
mount : list mounted filesystems
mount -l : idem, including volume labels
So far the informational part. Next the mounting.
The command is `mount [-t fstype] something somewhere'.
Details found in /etc/fstab may be omitted.
mount -a [-t|-O] ... : mount all stuff from /etc/fstab
mount device : mount device at the known place
mount directory : mount known device here
mount -t type dev dir : ordinary mount command
Note that one does not really mount a device, one mounts
a filesystem (of the given type) found on the device.
One can also mount an already visible directory tree elsewhere:
mount --bind olddir newdir
or move a subtree:
mount --move olddir newdir
One can change the type of mount containing the directory dir:
mount --make-shared dir
mount --make-slave dir
mount --make-private dir
mount --make-unbindable dir
One can change the type of all the mounts in a mount subtree
containing the directory dir:
mount --make-rshared dir
mount --make-rslave dir
mount --make-rprivate dir
mount --make-runbindable dir
A device can be given by name, say /dev/hda1 or /dev/cdrom,
or by label, using -L label or by uuid, using -U uuid .
Other options: [-nfFrsvw] [-o options] [-p passwdfd].
For many more details, say man 8 mount .
76
Comando umount
Usage: umount [-hV]
umount -a [-f] [-r] [-n] [-v] [-t vfstypes] [-O opts]
umount [-f] [-r] [-n] [-v] special | node...
77
UNIDAD 4
ENTORNOS GRÁFICOS
Ing. Juan Carlos Rodríguez Ulloa ENTORNOS GRÁFICOS
KDE
80
Gnome
81
Aqua
82
UNIDAD 5
DESARROLLO EN QT
Ing. Juan Carlos Rodríguez Ulloa DESARROLLO EN QT
Bases, Herramientas y Primer Código

Primer programa en Qt
Siguiendo la tradición se iniciará con el obligado “Hello, world!”. Esta aplicación mínima de Qt
se guardará en un archivo llamado main.cpp dentro de un directorio vacío con el nombre
helloWorld. Solo mostrará una pequeña ventana mostrando el texto “Hello, world!” cuando se
ejecute esto:
// helloWorld/main.cpp
#include <QApplication>
#include <QLabel>
int main(int argc, char *argv[])

{
QApplication a(argc, argv);
QLabel label("Hello World!");
label.show();
return a.exec();
}
Para este propósito, las primeras dos líneas de código incluyen los archivos de cabecera para
las clases de Qt que usaremos en el código que le sigue. En este caso esos archivos de
cabecera contienen la declaración de las clases QApplicatio y QLabel.
En Qt 4 se tiene un archivo de cabecera por cada clase de Qt, el cual es nombrado son la
extensión estándar .h: esto corresponde exactamente al nombre de la clase. Cuando se utilice
la directiva #include, se debe de asegurar de utilizar correctamente mayúsculas y
minúsculas.
La cuarta línea muestra una función main() típica de un programa de Qt. Primero se crea un
objeto QApplication y pasa a su constructor los parámetros recibidos al ejecutar el programa.
Programas en modo texto se pueden manipular sin el objeto QApplication.
Después se crea un objeto QLabel que muestra el texto “Hello, world!”. Inicialmente este objeto
es invisible, se debe llamar el método show() para hacerlo aparecer.
Finalmente se llama el método exec() para iniciar la aplicación.
85
Compilando un Programa de Qt
Cuando se compile este programa, nos encontraremos con un pequeño problema: Qt es

soportado por varias plataformas, y los detalles del proceso de compilación varían para cada
tipo de sistema. Este problema se resuelve con un simple programa que es utilizado para crear
proyectos en bases multiplataforma: qmake.
qmake genera un Makefile de un archivo de proyecto que describe la aplicación de una forma
que es independiente del sistema operativo en el cual la aplicación es actualmente compilada.
Primero ejecutamos el programa qmake con el parámetro -project dentro del directorio donde
se encuentra el programa.
alumno@debian:~/helloWorld$ qmake –project
esto generará un archivo llamado helloWorld.por con el siguiente contenido:
######################################################################
# Automatically generated by qmake (2.01a) Mon Oct 1 01:38:56 2012
######################################################################
TEMPLATE = app
TARGET =
DEPENDPATH += .
INCLUDEPATH += .
# Input
SOURCES += main.cpp
Después ejecutamos nuevamente el programa qmake, pero esta vez sin parámetros (en Mac
OS X se debe utilizar el parámetro –spec mac-g++):
alumno@debian:~/helloWorld$ qmake
Esto nos generará el archivo Makefile con las instrucciones necesarias de compilación.
Finalmente ejecutamos el comando make con el parámetro release o debug:
alumno@debian:~/helloWorld$ make release
Esto nos genera un archivo llamado helloWorld (mismo nombre de directorio que contiene al
programa), que al ejecutarlo se ve de la siguiente forma:
86
87
Layouts, Jerarquía de Objetos, y Manejo de Memoria
Como Organizar Widgets Automáticamente
Para extender el programa “Hello, world!” que no solo muestre texto en un simple objeto
QLabel, se organizarán dos QLabels uno debajo del otro, como se muestra en la siguiente
figura, utilizando el sistema de layouts incluido en Qt. este organiza automáticamente los
elementos gráficos, referidos en Qt como widgets o controles.
// layout/main.cpp
#include <QVBoxLayout>
#include <QLabel>

{
QWidget window;
QVBoxLayout* mainLayout = new QVBoxLayout(&window);

QLabel* label1 = new QLabel("<span style=\"font-size: 42px; color:
#0000AA;\">Uno</span>");
QLabel* label2 = new QLabel("<span style=\"font-size: 42px; color:
#00AA00;\">Dos</span>");
mainLayout->addWidget(label1);
mainLayout->addWidget(label2);
window.show();
return a.exec();
}
88
Adicionalmente a las clases QApplication y QLabel, ahora se utilizó también la clase

QVBoxLayout, esta es usada para organizar los widgets verticalmente. En esta ocasión en vez
del objeto QLabel, hay un objeto QWidget para la ventana principal de la aplicación, a la cual
llamamos window. Se llama al constructor QWidget, si no se pasan parámetros, como en este
caso, el nuevo objeto no tendrá un widget padre, y estará en la raíz de la jerarquía de objetos.
Más adelante, un widget se convierte en ventana solo cuando se muestra utilizando el método
show().
Después de crear el QWidget, se crea un objeto QVBoxLayout, el cual sabrá que es

responsable de la organización de window, el constructor pasa un puntero al objeto QWidget
como parámetro.
De forma similar, los dos objetos QLabel con los textos Uno y Dos son creados, pero ahora
utilizando código HTML para darles formato. Para ser manejados por el objeto de organización,
se agregan al objeto QVBoxLayout con el método addWidget().
Esta aplicación demuestra la principal ventaja de los layouts: No se requiere preocuparse por la
posición exacta de los widgets. Adicionalmente el usuario puede escalar ventanas con layouts,
y el layout automáticamente se asegura de que los componentes de la ventana se ajustarán
para llenar el espacio disponible, sin la necesidad de que el programador tenga que escribir
código explícito para implementar esta tarea.
Manejo de Memoria y Jerarquía de Objetos
La aplicación anterior no solo introduce al uso de layouts, también difiere de “Hello, world!” en
otro aspecto: Aunque la declaración de la variable QWidget window; es usada para alojar el
objeto QWidget, se utilizó:
En vez de:
QVBoxLayout mainLayout(&window);
Para crear el layout.
Se tomó este enfoque porque C++ no provee manejo de memoria automáticamente. En general
el programador debe cuidar esto por si mismo. Sin embargo, Qt puede hacerse cargo de
algunos de los trabajos de manejo de memoria. Los objetos de clases derivadas de la clase
QObject pueden ser ordenados en una estructura de árbol. Los objetos pueden contener
objetos “hijos”. Si un objeto es eliminado, entonces Qt automáticamente elimina todos sus
objetos “hijos”.
89
QWidget
QVBoxLayout QLabel QLabel
Para ponerlo de otra forma, si la raíz de un árbol de objetos desaparece, Qt automáticamente

elimina el árbol entero. Esto releva al programador de tener que eliminar los descendientes del
objeto y liberar la memoria que ocupan. Sin embargo para que funcione el manejo automático
de memoria, todos los “hijos” se deben crear utilizando new. Los objetos que son creados con
new son referenciados con un puntero. Esta es la razón por la cual mainLayout se declaró
como un puntero a un QVBoxLayout, en vez de un objeto QVBoxLayout.
Otros Tipos de Layouts
La clase QHBoxLayout es utilizada para organizar elementos horizontalmente, de la misma

manera que la clase QVBoxLayout es usada para layouts verticales. Se cambiamos
QVBoxLayout por QHBoxLayout, el resultado será el siguiente:
Existe una clase que organiza widgets en una matriz, QGridLayout:
// gridLayout/main.cpp
#include <QGridLayout>
#include <QLabel>

{
QWidget window;
QGridLayout* mainLayout = new QGridLayout(&window);

QLabel* label1 = new QLabel("Uno");
QLabel* label2 = new QLabel("Dos");
90
QLabel* label3 = new QLabel("Tres");

QLabel* label4 = new QLabel("Cuatro");
QLabel* label5 = new QLabel("Cinco");
QLabel* label6 = new QLabel("Seis");
mainLayout->addWidget(label1, 0, 0);
window.show();
return a.exec();
}
Este programa es como el ejemplo anterior: en vez de QVBoxLayout, esta vez se utiliza
QGridLayout como un “contenedor”, esta vez para seis objetos QLabel.a diferencia del método
addWidget() de las clases de layouts horizontales y verticales, QGridLayout::addWidget()
requiere tres parámetros: el widget que alojará, además del renglón y columna de la matriz
donde se ubicarán. La primer celda de la matriz tiene las coordenadas (0, 0) y está ubicada en
la esquina superior izquierda. El resultado se muestra a continuación:
91
Señales y Slots
Los programas analizados hasta ahora solo generan salida. Pero si se requiere manejar
entrada del usuario, no es posible manejarla sin comunicación entre objetos.
Muchos kits de herramientas GUI usan funciones callback o event listeners para manejar la
comunicación entre objetos, pero Qt utiliza el concepto señal/slot. Comparado con las funciones
callback, este mecanismo tiene la ventaja de que Qt automáticamente elimina una conexión si
cualquiera de los dos objetos comunicándose es eliminado. Esto elimina errores de tiempo de
ejecución, y hace más simple la programación.
El caso más simple: Un Slot responde a una Señal
La forma más simple para explicar como los slots y señales permiten a los objetos comunicarse
es con un ejemplo simple. Consideremos el siguiente programa, el cual muestra un simple
botón con el texto Salir. Si el usuario hace clic sobre el botón, la aplicación finaliza.
// signalSlot/main.cpp
#include <QPushButton>

{
QPushButton button("Salir");
button.show();
QObject::connect(&button, SIGNAL(clicked()), &a, SLOT(quit()));
return a.exec();
}
Comparado con el programa “Hello, world!”, solo dos cosas cambiaron. La primera, el objeto
QLabel fue remplazado por un objeto QPushButton. Esta clase es usada para mostrar un botón
y procesar los clics del ratón sobre este botón.
92
La segunda diferencia consiste de la llamada a QObject::connect(). connect() es una función

estática de la clase QObject que crea una conexión entre una señal que se origina desde un
objeto y un slot en un objeto de destino. Los primeros dos parámetros especifican el objeto que
envía la señal, y la señal que se desea que reciba el slot. Los últimos dos parámetros
especifican el objeto que es el receptor de la señal, y el slot que la recibe. El carácter & es
necesario porque la función espera las direcciones de los objetos emisores y receptores como
parámetros.
Los slots son funcionesnormales de una clase que es especialmente marcada para poder
reaccionar a las señales. Las señales por otro lado son enviadas por objetos. Una señal de un
objeto puede ser conectada a uno o varios slots de un solo objeto receptor o de varios objetos
receptores distintos. Si un objeto envía una señal, entonces son llamados todos los slots que
están conectados a la señal. Si no existe un enlace coincidente, no pasa nada.
Señales Enviando Información Adicional y como es Procesada
El enlace entre una señal y un slot puede ser también usado para transmitir información
adicional que controle la reacción precisa del slot. Por ejemplo, el siguiente programa consiste
de tres elementos de control: una etiqueta, que muestra un valor numérico, un spin box, que se
utiliza para cambiar el valor vía el teclado o el mouse (y que también muestra el valor); y un
slider, el cual muestra el valor actual gráficamente y puede ser manipulado para cambiar el
valor.
El objetivo de este programa es que los tres widgets siempre muestren el mismo valor. Si el
usuario cambia el valor mediante el slider, el valor también se debe ajustar en el spin box y la
etiqueta. Lo mismo aplica al slider y la etiqueta si el usuario modifica el valor en el spin box.
// signalSlot2/main.cpp
#include <QLabel>
#include <QSpinBox>
#include <QSlider>
93
{
QWidget window;

QLabel* label = new QLabel("0");
QSpinBox* spinBox = new QSpinBox;
QSlider* slider = new QSlider(Qt::Horizontal);
mainLayout->addWidget(label);
mainLayout->addWidget(spinBox);
mainLayout->addWidget(slider);
QObject::connect(spinBox, SIGNAL(valueChanged(int)),
label, SLOT(setNum(int)));
QObject::connect(spinBox, SIGNAL(valueChanged(int)),
slider, SLOT(setValue(int)));
QObject::connect(slider, SIGNAL(valueChanged(int)),
label, SLOT(setNum(int)));
QObject::connect(slider, SIGNAL(valueChanged(int)),
spinBox, SLOT(setValue(int)));
window.show();
return a.exec();
}
Se organizan los tres widgets en un layout vertical. Para hacer esto la clase QSpinBox se utiliza
para el elemento spin box, y la clase QSlider es responsable del slider.
Para asegurar la sincronía de los widgets, utilizamos cuatro llamadas a connect(): si el valor del
spin box cambia, entonces la etiqueta y el slider se deben actualizar; si el estado del slider
varía, la etiqueta y el spin box necesitarán actualizarse.
QSlider QSpinBox
setValue(int) setValue(int)
valueChanged(int) valueChanged(int)
QLabel
setNum(int)
Un cambio hecho al valor por el usuario es reportado por las clases QSpinBox y QSlider
mediante la señal QSpinBox::valueChanged(int) o QSlider::valueChanged(int). En cada caso, el
94
parámetro entero indicado por la palabra int, es transmitido de la señal al slot, especifica el
nuevo valor del spin box o el slider.
Un nuevo valor se establece para la etiqueta usando el slot QLabel::setNum(int), un método

que es llamado con un valor entero como parámetro. El spin box y el slider son controlados
similarmente utilizando los slots QSpinBox::setValue(int) y QSlider::setValue(int).
Las flechas en la figura anterior muestran que una señal puede estar conectada a varios slots y
que un slot puede reaccionar a varias señales.
Qt no especifica el orden en el que esto pasa. Cualquiera de la etiqueta o el slider pueden ser
actualizados primero, el comportamiento exacto puede ser impredecible.
En este ejemplo las señales y slots usan la misma lista de parámetros porque en las
conexiones señal/slot no se realizan conversiones de tipo. Esto es que el slot setText() del
objeto QLabel, el cual toma una cadena como un parámetro y lo muestra, no se puede conectar
a la señal valueChanged(int), debido a que el parámetro int no será convertido a string.
Si la conversión de tipo no puede ser omitida, entonces se debe derivar la clase e implementar
el slot correspondiente. El nuevo slot implementará la conversión de tipo en el valor enviado por
la señal, y entonces llamará el slot anterior.
95
Clases Base en Qt
Clases derivadas de QObject
Varias clases de Qttienen la clase QObject como una clase base. Esto es que todos los widgets
(todos los elementos que muestran algo en la pantalla) son derivados de la clase QWidget, la
cual es derivada de QObject. Las clases de layout también son derivadas de QObject, entonces
sus objetos también pueden ser organizados jerárquicamente de la cual derivan beneficios
como el manejo automático de memoria. Los objetos no visuales, no son derivados de
QWidget.
Otras clases no gráficas también se originan en QObject, tales como QThread o QTcpSocket.
Estas clases tienen a QObject como su clase base, entonces se pueden comunicar a través de
señales y slots.
QString y otras clases no derivadas de QObject
Qt contiene muchas clases que no son basadas en QObject, desde que no requieren señales y
slots, ni manejo automático de memoria. Estas clases incluyen una de las clases más
importantes: QString, la cual es responsable de las cadenas. Las cadenas en QString son
almacenadas y procesadas por Qt en formato Unicode, habilitando texto en casi cualquier
lenguaje del mundo; esto es, no solo caracteres en Europeo Occidental, sino también en
Cirílico, Árabe, Hebreo, Chino y muchos más. Por esta razón Qt puede ser utilizado muy
eficientemente para programas que se muestran en muchos idiomas. Las clases QImage,
QColor y muchas otras tampoco se basan en QObject; todas ellas trabajan basadas en valor.
Jerarquía de herencia en Qt
En la siguiente figura se muestra una pequeña muestra de la jerarquía de la herencia en Qt.

Note que QLabel hereda no solo de QObject y QWidget, sino también de QFrame. Esta es la
clase base para todos los widgets que tienen un recuadro visible rodeándolos.
96
QObject QString QColor
QWidget QLayout QThread
QFrame QAbstractButton QGridLayout
QLabel QPushButton
97
Herramientas necesarias para creación

de diálogos
Diálogos y Widgets
El primer programa extensivo que se mostrará convertirá números entre notación decimal,
hexadecimal y binaria. El usuario podrá introducir cualquier número (de un byte, de 0 a 255) en
cualquiera de los tres campos de entrada. Cuando se cambie el contenido de un campo de
entrada, el programa actualizará los otros dos.
La función main() del programa es casi idéntica a la función main() del programa “Hello, world!”:
// byteConverter/main.cpp
#include "DialogoConversor.h"

{
DialogoConversor bc;
bc.setAttribute(Qt::WA_QuitOnClose);
bc.show();
return a.exec();
}
Solo existe una diferencia: la clase QLabel fue remplazada por DialogoConversor. Esta clase
hereda de QDialog, y la definición de la clase se encuentra en el archivo de cabecera
DialogoConversor.h. la directiva #include que integra este archivo de cabecera en el código de
la aplicación utiliza comillas (“) en vez de mayor y menor que (<>), esto es debido a que el
archivo se encuentra en el mismo directorio que main.cpp.
También se agregó el atributo WA_QuitOnClose al diálogo para asegurar que el programa

termine cuando el diálogo se cierre. Esto no fue necesario en los ejemplos anteriores, porque
no se utilizó ninguna clase heredada de QDialog como ventana principal. Usualmente los
diálogos se usan solo para información auxiliar, así que el atributo no está activo por defecto en
98
QDialog. Si no se modificara esto, al cerrar el diálogo no se terminaría la aplicación, y sería un

serio error.
El contenido del archivo DialogoConversor.h se acota por las instrucciones de preprocesador

#ifndef, #define y #endif:
// byteConverter/DialogoConversor.h
#ifndef DIALOGOCONVERSOR_H
#define DIALOGOCONVERSOR_H
#include <QDialog>
class QLineEdit;
class DialogoConversor : public QDialog

{
Q_OBJECT
public:
DialogoConversor();
private:
QLineEdit* decEdit;
QLineEdit* hexEdit;
QLineEdit* binEdit;
};
#endif
Utilizando estas instrucciones del preprocesador es una técnica estándar en C/C++ para evitar
problemas que puedan ocurrir si más de un archivo fuente utiliza #include para un mismo
archivo de cabecera, lo cual puede ocurrir en grandes programas con muchos módulos
desarrollados independientemente. En este ejemplo si no se ha definido
DIALOGOCONVERSOR_H (la primera vez que se manta llamar DialogoConversor.h), se
ejecuta todo lo que se encuentra después de #ifndef hasta antes de #endif, iniciando por la
definición de DIALOGOCONVERSOR_H. Si no se realiza esta protección, cada vez que se
incluya el archivo de cabecera se tratará de declarar la clase, provocando un error.
class DialogoConversor : public QDialogindica que la clase declarada

DialogoConversor hereda desde la clase QDialog. Para que el contenido de la clase QDialog
esté accesible fuera de la clase DialogoConversor se utiliza el control public.
La declaración de clase class QLineEdit; es útil ya que en DialogoConversor.h se tienen tres

variables privadas que apuntan a objetos QLineEdit, para esto C++ necesita saber que
QLineEdit es una clase, pero no necesita conocer la definición exacta de la clase en este punto.
99
La macro Q_OBJECT debe ser usada en todas las derivaciones de la clase base QObject,
incluyendo herencia indirecta, porque esta define funciones sin las que el concepto señal/slot
no trabajaría.
Heredando de QObject
Como se menciono anteriormente, siempre se debe usar la macro Q_OBJECT cuando una
clase hereda, directa o indirectamente, desde QObject. Esta macro define algunas funciones
que implementan el concepto de señal/slot. Desafortunadamente si se omite la macro en la
definición de la clase que hereda de QObject, ni el compilador ni el enlazador reportarán algún
error. En vez de eso, las señales y slots de la clase serán desconocidas a Qt, y en tiempo de
ejecución las conexiones correspondientes no trabajarán.
Las aplicaciones con información de debug mostrarán warnings en tiempo de ejecución (en la
ventana de la terminal) que una señal o slot no existe, donde el código ejecutado intenta
acceder a una señal o slot desconocidos. El mensaje de error es:
Object::connect: No such slot QObject::decChanged(QString)
Sin embargo, este error no es muy específico. También se verá si se ha escrito

incorrectamente el nombre de la señal o slot, o si la lista de parámetros es incorrecta.
Layouts más complejos
Cuando se creen instancias de la clase DialogoConversor, el método constructor genera todos

los widgets QLineEdit mostrados en el objeto DialogoConversor dentro de un layout. Sin
embargo esto no es tan simple como en los ejemplos anteriores: para que la aplicación se
comporte de una forma intuitiva cuando el usuario cambie el tamaño del diálogo, se requiere
usar layouts anidados.
// byteConverter/DialogoConversor.cpp
#include "DialogoConversor.h"
#include <QLabel>
#include <QLineEdit>
#include <QPushButton>
#include <QHBoxLayout>
#include <QGridLayout>
DialogoConversor::DialogoConversor()
{
100
// Genera layouts necesarios

QVBoxLayout* mainLayout = new QVBoxLayout(this);
QGridLayout* editLayout = new QGridLayout;
QHBoxLayout* buttonLayout = new QHBoxLayout;
mainLayout->addLayout(editLayout);
mainLayout->addStretch();
mainLayout->addLayout(buttonLayout);
// Genera etiquetas y line-edits y los agrega

// al objeto apuntado por editLayout
QLabel* decLabel = new QLabel(tr("Decimal"));
QLabel* hexLabel = new QLabel(tr("Hexadecimal"));
QLabel* binLabel = new QLabel(tr("Binario"));
decEdit = new QLineEdit;
hexEdit = new QLineEdit;
binEdit = new QLineEdit;
editLayout->addWidget(decLabel, 0, 0);
editLayout->addWidget(decEdit, 0, 1);
editLayout->addWidget(hexLabel, 1, 0);
editLayout->addWidget(hexEdit, 1, 1);
editLayout->addWidget(binLabel, 2, 0);
editLayout->addWidget(binEdit, 2, 1);
// Crea el boton Salir y lo agrega al objeto apuntado

// por buttonLayout
QPushButton* exitButton = new QPushButton("Salir");
buttonLayout->addStretch();
buttonLayout->addWidget(exitButton);
...
El objeto mainLayout es un vertical box layout, es responsable para la organización del diálogo
completo. Por lo tanto se pasa como parámetro un apuntador al objeto DialogoConversor
cuando su constructor es llamado para que realice esta organización.
El objeto editLayout es responsable de las etiquetas y line-edits. Estos widgets se organizan en

dos columnas, para esto se usa un grid layout.
El buttonLayout, será responsable de manejar el botón Salir. Sin embargo, antes de que se
puedan agregar widgets como este botón, primero se deben agregar los dos layouts al
mainLayout usando el método addLayout(), el cual es el equivalente para layouts de
addWidget(). Si se agregan widgets a un layout aún no asociado con un widget, se recibirá este
error en tiempo de ejecución:
101
QLayout::addChildWidget: add layout to parent before adding children to

layout.
y los widgets permanecerán invisibles. De esta forma siempre se debe generar primero el
layout básico para la clase, después continuar con la siguiente “capa” de layout, y así
sucesivamente.
Para asegurar que los campos de entrada siempre se ubiquen en la parte superior del
DialogoConversor y que el botón salir esté siempre posicionado en la parte de abajo a la
derecha, se utilizan stretches.
Los stretches ocupan el espacio no requerido por los widgets, con esto crea espacios vacíos en
el diálogo. Si se omiten los stretches en el ejemplo, los widgets ocuparían todo el espacio
cuando el usuario agrande el diálogo.
Para anular esto, se agrega un stretch entre el editLayout y el buttonLayout con el método
addStretch().
Para asegurar que el botón salir siempre aparezca abajo a la derecha del diálogo, primero se
llena el layout horizontal buttonLayout con un stretch antes de agregar el botón.
Incrementando la usabilidad
A pesar de los layouts, el diálogo aún no se comporta muy bien en ciertos aspectos:
• El título de la ventana hasta el momento muestra el nombre del programa

byteConverter. Algo más descriptivo sería mejor.
• El botón Salir debería de ser el botón predeterminado del diálogo. El botón

predeterminado es activado al presionar <Enter> aún si no cuenta con el foco actual
del teclado. La mayoría de los estilos de widgets resaltan el botón predeterminado.
• Actualmente se puede ingresar cualquier número (inclusive letras y otros símbolos)

en los widgets line-edit. Se debería restringir a valores válidos, esto es que solo
acepte números decimales entre 0 y 255, números hexadecimales con un máximo
de dos dígitos, y binarios con un máximo de ocho bits.
Se pueden resolver estos tres problemas agregando las siguientes líneas al constructor:
// byteConverter/DialogoConversor.cpp (continuación)
...
102
exitButton->setDefault(true);
// Limitar entrada a valores válidos

QIntValidator* decValidator =
new QIntValidator(0, 255, decEdit);
decEdit->setValidator(decValidator);
QRegExpValidator* hexValidator =
new QRegExpValidator(QRegExp("[0-9A-Fa-f]{1,2}"), hexEdit);
hexEdit->setValidator(hexValidator);
QRegExpValidator* binValidator =
new QRegExpValidator(QRegExp("[01]{1,8}"), binEdit);
binEdit->setValidator(binValidator);
setWindowTitle(tr("Conversor de Bytes"));
...
Estableciendo Título de la ventana
Los primeros dos problemas se resuelven con una simple línea adicional de código (cada uno).
Para resolver el primero, se utiliza la función setWindowTitle(), el cual establece el título de
ventana de un widget si el widget ocupa una ventana de nivel superior. Esta función es un
método de la clase QWidget. Dado que DialogoConversor tiene a QDialog como su clase base,
y esta a su vez a QWidget, DialogoConversor hereda esta función, y se puede simplemente
llamar.
Especificando el botón predeterminado
El botón predeterminado para un cuadro de diálogo se especifica mediante el botón (en vez del
diálogo, como se esperaría) que él es el botón predeterminado. Nótese que la llamada a
setDefault(true) en un objeto QPushButton solo tendrá efecto si el botón es usado dentro de un
diálogo, en una ventana principal no existen botones predeterminados. Si se intenta definir un
botón predeterminado para una ventana principal, Qt lo mostrará como si lo fuera, pero no se
activará cuando el usuario presione la tecla <Enter>.
Validando entradas del usuario
El tercer problema, restringir la entrada en los widgets line-edit a valores válidos, requiere algo
más de trabajo, pero puede resolverse mediante validadores. Estos heredan de QValidator
como su clase base. Un validador se asocia a un objeto padre que recibe entrada e informa si
el objeto debe o no aceptar el valor actual de entrada.
103
Para verificar la validez del número decimal, se utiliza un objeto QIntValidator. Este es creado
invocando al constructor y pasándolo, como el primer y segundo parámetro, los valores de
entrada mínimo y máximo. El tercer parámetro, es un apuntador al objeto line-edit que se desea
que sea el objeto padre del validador. La llamada a stValidator() causa que se mantenga
vigilada la entrada dada al objeto apuntado por decEdit. Ahora el usuario puede teclear solo
valores numéricos entre 0 y 255.
Para validar números hexadecimales, se debe realizar otro tipo de validador:

QRegExpValidator. Este compara la entrada vista como una cadena contra una expresión
regular. En este caso, la expresión regular es [0-9A-Fa-f]{1,2}. La primera sub-expresión entre
corchetes especifica los caracteres permitidos en la cadena de entrada: los dígitos del 0 al 9 y
las letras de la A a la F (escritas en mayúsculas y minúsculas). La siguiente sub-expresión
{1,2}, restringe la longitud de la cadena de entrada a al menos uno, y máximo dos caracteres.
También se utiliza QRegExpValidator con la expresión regular [01]{1,8} como un validador para
el campo de números binarios. Esta expresión permite solo los caracteres 0 y 1 en la cadena
de entrada, pero la cadena puede ser desde uno hasta ocho caracteres de longitud.
Implementando Slots
Finalmente se requiere implementar las conexiones funcionales que harán que el botón salir
trabaje como se espera y sincronizar los tres campos de entrada con cualquiera que se
modifique.
Para asegurar que el clic del botón Salir cierre el diálogo, se extiende el contructor de
DialogoConversor para asociar la señal clicked() del botón con el slot accept() del diálogo. El
slot es provisto por QDialog, de la cual hereda la clase DialogoConversor:
...
connect(exitButton, SIGNAL(clicked()),
this, SLOT(accept()));
...
El método accept(), cuando es llamado, simplemente cierra el diálogo. El uso que se hace de
accept() en este ejemplo sigue una convención general: un gran número de diálogos tienen un
botón Aceptar y Cancelar en la parte inferior; Aceptar corresponde al slot accept(), Cancelar al
slot reject(). Ambos slots cierran el diálogo, el primero sale con un valor de retorno positivo, el
segundo con uno negativo.
Sin embargo, la lógica real de procesamiento de eventos de la aplicación consiste de

incrementar la personalización de señales y slots con algunas conexiones personalizadas,
especifica la funcionalidad de la clase DialogoConversor. Las conexiones de señales/slots
104
deben venir en acciones cuando cualquiera de los objetos QLineEdit envíen la señal
textChanged(), indicando que el texto en esos objetos ha cambiado. Para este propósito, se
expande la definición de la clase como sigue:
// byteConverter/DialogoConversor.h (continuación)
class DialogoConversor : public QDialog
{
...
private slots:
void decChanged(const QString&);
void hexChanged(const QString&);
void binChanged(const QString&);
};
Los slots son declarados de la misma manera que funciones normales, excepto por el control
de acceso que se utilizan los designadores public slots:, protected slots:, y provate slots:, en
vez de los usuales modos de protección public:, protected:, y private:
Cada uno de los tres slots acepta un parámetro del tipo de dato QString&. De esta forma la
señal textChanged() puede pasar el nuevo texto del line edit.
Para el tipo de parámetro para la señal/slot no se seleccionó simplemente un QString, sino una
referencia a un const QString.
A pesar de que la declaración de un slot difiere ligeramente de las otras funciones, este aún
puede ser llamado como una función ordinaria. En seguida se muestra la definición del slot
decChanged() en el archivo DialogoConversor.cpp:
void DialogoConversor::decChanged(const QString& newValue)
{
bool ok;
int num = newValue.toInt(&ok);
if (ok) {
hexEdit->setText(QString::number(num, 16));
binEdit->setText(QString::number(num, 2));
} else {
hexEdit->setText("");
binEdit->setText("");
}
}
La función recibe la nueva cadena mostrada por el line-edit decimal como el valor actual para el
parámetro newValue, y actualiza las cadenas mostradas por los line-edit hexadecimal y binario.
Primero se requiere determinar el valor numérico que corresponde a la cadena de entrada.
Como un objeto de la clase QString, newValue contiene algunas funciones que convierten
105
cadenas a números. Aquí se usará la función toInt(), debido a que la cadena de entrada
representa un valor entero.
Si la conversión es satisfactoria, se actualizará el texto mostrado por los otros dos objetos line-
edit (hexEdit y binEdit) a los equivalentes en hexadecimal y binario del nuevo valor. Para este
propósito la clase QString tiene la función estática number(), la cual retorna la representación
de un número como una cadena. El número por si mismo es un argumento. Como segundo
argumento, number() espera la base para el sistema numérico usado, en este caso 16 para
hexadecimal y 2 para binario. El segundo argumento es opcional, y si no se especifica,
number() asume base 10 (sistema decimal), el cual es el caso más común.
Si la función toInt() no puede convertir la cadena que se introdujo en el line-edit decimal en un

número, se escribirá una cadena vacía a los otros dos widgets line-edit con setText(). Gracias
al validador utilizado para el objeto decEdit, el cual asegura que solo números en el rando de 0
a 255 se pueden introducir, la conversión solo falla en un solo caso: si el usuario elimina la
entrada completamente.
Ahora se implementan los dos slots de la misma forma:
void DialogoConversor::hexChanged(const QString& newValue)
{
...
if (ok) {
decEdit->setText(QString::number(num));
binEdit->setText(QString::number(num, 2));
} else {
...
}
}
void DialogoConversor::binChanged(const QString& newValue)
{
...
if (ok) {
decEdit->setText(QString::number(num));
hexEdit->setText(QString::number(num, 16));
} else {
...
}
}
En estas funciones, cuando se transforma la cadena a un valor entero, se especifica la base en

un segundo argumento opcional a toInt(); como QString::number, toInt() utiliza base 10 por
defecto si el argumento es omitido.
106
Para que estas partes de la aplicación trabajen juntas de acuerdo al diseño, se deben conectar
las señales textChanged() de cada objeto QLineEdit con su slot correspondiente. Para hacer
esto hay que extender el constructor desde la última vez:
...
connect(decEdit, SIGNAL(textChanged(const QString&)),
this, SLOT(decChanged(const QString&)));
connect(hexEdit, SIGNAL(textChanged(const QString&)),
this, SLOT(hexChanged(const QString&)));
connect(binEdit, SIGNAL(textChanged(const QString&)),
this, SLOT(binChanged(const QString&)));
el código del constructor de la clase DialogoConversor está completo ahora, y realiza tres
diferentes tareas:
• Genera todos los widgets de un diálogo, los incorpora al layout apropiado, y

establece la jerarquía de objetos del diálogo.
• Restringe la entrada del usuario a valores sensibles.
• Establece todas las conexiones señal/slot necesarias.
La lógica completa de la aplicación está contenida en el código para slots y sus conexiones a
las señales correspondientes.
107
UNIDAD 6
DESARROLLO PARA MAC OS X
Ing. Juan Carlos Rodríguez Ulloa DESARROLLO PARA MAC OS X
110
UNIDAD 7
DESARROLLO PARA iOS
Ing. Juan Carlos Rodríguez Ulloa DESARROLLO PARA iOS
113

Desarrollo de Aplicaciones en Ambientes Emergentes

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Desarrollo de Aplicaciones en Ambientes Emergentes

Hochgeladen von

Copyright:

Verfügbare Formate

0

HISTORIA DE UNIX ..........................................................................................................................................................3

UNIDAD 2 DISTRIBUCIONES DE SISTEMAS UNIX’ LIKE .......................................................................................... 16

UNIDAD 3 SHELL DE SISTEMAS UNIX’ LIKE ........................................................................................................... 23

UNIDAD 4 ENTORNOS GRÁFICOS ......................................................................................................................... 78

UNIDAD 5 DESARROLLO EN QT ............................................................................................................................ 83

BASES, HERRAMIENTAS Y PRIMER CÓDIGO ........................................................................................................................85

UNIDAD 6 DESARROLLO PARA MAC OS X .......................................................................................................... 108

UNIDAD 7 DESARROLLO PARA IOS ..................................................................................................................... 111

Ken Thompson y Dennis Ritchie, trabajando en el DEC PDP-7.

En 1972, Ken Thompson y Dennis Ritchie crearon el lenguaje de programación C. Si

"Arbol genealógico" de Unix.

Plan 9 (virtualizado), basado en el UNIX versión 7, de 1979.

Los sistemas operativos parecidos a Unix se construyen a partir de un conjunto de bibliotecas,

Filosofía del proyecto GNU

¿Qué es el software libre?

• La libertad de usar el programa, con cualquier propósito (libertad 0).

Más allá del software

Licencias de Software Libre

Ver texto de la licencia

Licencia Pública General Reducida de GNU

Ver texto de la licencia

Licencia Pública General de Affero de GNU

Ver texto de la licencia

Licencia de Documentación Libre de GNU

Ver texto de la licencia

El copyleft también proporciona un incentivo a otros programadores a unirse al software libre.

La licencia apropiada está incluida en muchos manuales y en cada distribución de código

Componentes de una distribución

El kernel es el programa que se encarga de:

• Creación de procesos, asignación de tiempos de atención y sincronización.

Consta de dos partes principales: la sección de control de procesos y la decontrol de

El proceso init es el responsable de establecer la estructura de procesos en Unix.

A partir de ese momento el responsable de atender al usuario en esa terminal es el intérprete

Hay cuatro grandes tipos de núcleos:

Una shell de Unix es un intérprete de comandos y un lenguaje de programación. Como un

La shell provee un pequeño conjunto de comandos incorporados, implementando funcionalidad

Características básicas de la Shell

Sin embargo, en términos generales, la shell lee su entrada y la divide en palabras y

La shell en seguida analiza esos tokens en comandos y otras construcciones, remueve el

1. Lee su entrada de un archivo, de una cadena provista como un argumento a la

Palabras de la forma $’string’ son tratadas especialmente. La palabra expande a la

especifica en el estándar ANSI-C. Las secuencias de escape de diagonal inversa, son

Estructura del sistema de archivos

Estos archivos son administrados mediante el sistema de archivos, que se encuentra

Se tienen tres tipos de particiones:

• Primarias (o físicas). Este tipo de particiones es el básico dentro de los dispositivos

• Extendidas (también físicas). Este tipo de partición realmente es una partición

Las particiones primarias y extendida siempre reciben un número de 1 a 4. Las particiones

En cada partición se puede establecer un sistema de archivos de acuerdo a las necesidades

Filename Type Size Used Priority

Device Boot Start End Blocks Id System

Si la partición no ha sido marcada como swap se requiere modificarla ejecutando fdisk y

¿Qué tan grande debe ser el espacio swap?

Sistema de Archivos Unix’ Like

En contraste, un sistema de archivos consiste de archivos, relaciones a otros archivos, como

• Un tipo de archivo (tipo de dato que esta en el archivo)

Adicionalmente, los sistemas de archivos proveen herramientas que permiten la manipulación

En seguida se muestra un diagrama de un “típico” sistema de archivos Unix’ Like. Como se

de directorios. Note que esto varía entre la variedad de implementaciones y vendedores de

ksh luis/ usb/ win_d/ sbin/ current access.log

• bin/ - contiene los comandos que comúnmente se utilizan

La tercer categoría de archivo mencionada arriba es un archivo de dispositivo. Este es otro

El tipo de archivo de dispositivo típicamente incluye: archivos de dispositivos de caracteres,