De editor a IDE, o lo que es lo mismo: VIM con esteroides.

Normalmente suelo usar un IDE como Eclipse, Netbeans o cualquier otro para tirar código por que son cómodos, estan enfocados al desarrollo y bla, bla, bla... Pero estos IDE's hechos en java, en ruby en lo que sea, algunos pueden ser muy pesados y otros no tantos, pero consumen más recursos de los editores como sublime, atom, note++ (Si, muchos lo siguen usando por... Por que no sé...) es que son editores con algunas ventajas muy cómodas a la hora de escribir código, sacrificando otras, pero que son EDITORES de código (Hacen y no hay punto de comparación con un IDE, así que ni lo intente pensar en sus cabesitas locas.)

Hace unos meses me enfrente a un problema en la oficina, y no es el café, si no los recursos de la maquina que tengo para poder hacer lo que debo. Así que hice lo que debía, pero tener la IDE, el cliente de base de datos (Si, ya sé que aman phmMyAdmin sobre todas las cosas... yo no) docenas de pestañas en el browser y alguna otra cosa en extra... hacían que la maquina fuera por lo suelos en rendimiento. Cambiamos algunas cosas, entorno gráfico, menos pestañas en el browser, ya no mas reproductor de audio en la maquina... usamos en pool data del IDE y dejamos ir al workbrench un rato, pero el IDE seguía consumiendo tantos recursos, hasta el punto de ser molesto.

Así negando a usar un editor de código popular, elegí entre todos los males, el peor, ¿por qué escoger la opción menos malvada? Tomamos vim como el equipo de GEx y lo pusimos bello para editar las necesidades del día al día.

Para lograr esto, usaremos plugins y para hacerlo de la manera mas rápida, usaremos Vundle, un gestor de paquetes para vim que nos permite manejar los paquetes desde el vimrc, lo cual para empezar, debemos clonar el proyecto en nuestra carpeta .vim/bundle/

$ git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim

y crear (en caso de no tenerlo) nuestro .vimrc en el home de nuestro con el siguiente esqueleto, donde poco a poco iremos armando para poder incluir los paquetes (plugins) necesarios o que necesitemos según los gustos de cada quien. Y para ello, les recomiendo la pagina de vimawesome.com donde encontraremos todo lo que necesitemos para convertir a nuestro editor en una pequeña IDE.

set rtp+=~/.vim/bundle/Vundle.vim
" alternatively, pass a path where Vundle should install plugins
" "call vundle#begin('~/some/path/here')
call vundle#begin()
" " let Vundle manage Vundle, required
Plugin 'gmarik/Vundle.vim'
call vundle#end()            " required
filetype plugin indent on    " required
" " Brief help
" " :PluginList       - lists configured plugins
" " :PluginInstall    - installs plugins; append `!` to update or just
" :PluginUpdate
" " :PluginSearch foo - searches for foo; append `!` to refresh local cache
" " :PluginClean      - confirms removal of unused plugins; append `!` to
" auto-approve removal
" " see :h vundle for more details or wiki for FAQ

Vim por si solo nos da muchas ayudas de forma nativa para poder editar código, como resaltado de sintaxis, autoidentado, tamaño del espacio en tabulador, etc, que si bien son una gran ayuda, no son los suficiente para ayudarnos al trabajo del día a día, para ello, les recomiendo Syntastic que nos ayudara a checar errores en la sintaxis y que soporta una gran cantidad de lenguajes.

Otra necesidad, es poder navegar por el proyecto sin tener que salir de vim, para lo cual tenemos la ayuda de NERDTree, un explorador de filesystem desplegado en un árbol, el cual nos permite ver carpetas y abrir los archivos necesarios sin salir del editor.

La necesidad de hoy en día, nos obliga a tener una manera de poder navegar en nuestro código teniendo a la mano las variables y funciones para poder navegar mejor entre tantas lineas de código y evitar la perdida de estar buscando de forma manual, por ello existe Tagbar que requiere que tengamos instalado ctag, el cual podemos compilarlo o descargarlo desde nuestro gestor de dependencias favorito.

Los IDE's modernos nos permiten el autocompletado de código, lo cual es una gran ayuda a la hora de escribir de una forma mas rápida y no cometer errores de sintaxis, en lo personal, uso YouCompleteMe, el cual requiere que clones el proyecto en tu carpeta de Bundles y compiles.

cd ~/.vim/bundle/YouCompleteMe
./install.sh --clang-completer

Para poder hacer de YouCompleteMe una experiencia totalmente agradable, usaremos SuperTab que nos ayudara a todos aquellos que estamos muy acostumbrados al autocomplete por medio del tabulador.

Otro paquete que no nos puede faltar para nuestro adorado vim, es el uso de snippets que lo encontramos en IDE's y editores como sublime o atom, y para ello, nada mejor que ultisnips, un paquete que nos ayudara a crearlos de una forma tan simple y que hará las delicias de chicos y grandes.

Y aunque existen muchas otras opciones para diferentes lenguajes como ruby, php, javascript, java o integrarlo con git creo que esto es lo básico para poder hacer de vim algo mas que un simple editor de textos.

Les dejo mi vimrc que esta adaptado para php, es lo que por el momento uso, no sin antes decirles que si gustan de tener estadísticas y datos de su forma de programar, se den una vuelta por wakatime, el cual tiene diferentes plugins para distintas IDE's, editores y si, también para nuestro adorado y amado vim.

Happy hacking.

GnuPG creación de llaves y exportación para su uso en otros clientes

El arte de encriptar es la de meter a una persona en una cripta y no dejarla salir de ahí, pero la de cifrar es mantener nuestra información sensible segura y que nadie mas que nuestro circulo de confianza pueda leer.

La criptografía no es una moda o algo que se invento de un par de años a la fecha, es una serie de técnicas y métodos tan antigua como la propia humanidad Y aunque ahora la tecnología nos permite algo mas confiable, no es algo que muchos de nosotros usemos o que incluso, conozcamos.

GnuPG o simplemente GPG, es un programa de código abierto que remplaza a la suit de criptografía PGP y que utiliza el estándar denominado OpenPGP, así que eso ya es un punto bueno para su uso. Este pequeño cifra mensajes usando un par de llaves asimétricas que deben generar ustedes, pero también se puede añadir una firma para demostrar que ustedes, mis niños, son los autores del mensaje en cuestión y que no es algún mono haciendo de las suyas a su nombre.

Hasta aquí se escucha bien y... ¿Cómo demonios se usa?

GPG se usa por medio de la consola de comandos, aunque existen implementaciones en entorno gráfico que te ayudaran a la creación, exportación y administración de tus llaves, pero hoy no les enseñare a usar alguna de ellas, si no que lo haremos de nuevo de la forma artesanal, así es, por medio de nuestra amiga consola.

lo primero que debemos hacer es tener instalado gpg, que ya casi la mayoría de unix o BSD's ya tienen por defecto, si no es así para su linux favorito, pueden descargarlo de su gestor de paquetes o bien, bajar el código y tener un buen rato de soledad compilandolo.

Una vez instalado, no requieren ser todo poderoso alias, root para su ejecución, tan solo tener ganas de hacer las cosas.

Así que vamos a crear las llaves con el siguiente comando, recuerden que esto es solo una bella receta, pero pueden agregar sus ingredientes preferidos viendo el manual de gpg en su linea de comandos con man.

$gpg --gen-key

Esto les dará una salida, pero que aun así, será interactiva y les pedirá los parámetros necesarios de forma amigable y que les dirá donde pondrá los archivos creados con extención gpg.

Como gpg nace con la insignia de libertad, no usara algoritmos privativos o con patentes como IDEA, que es la piedra angular de pgp, así que usara algoritmos como ELGamal, CASTT5, Triple DES, AES y blowfish.

Siendo DSA y ELGamal sus algoritmos por defecto, los dejará escoger algún otro que ustedes prefieran, así mismo les dirá que usara una llave de 1024 bits, pero que igual, podrán decirle que quieren algo mas de bits, por ejemplo, ya es recomendable usar 2048 o por que no, ponernos serios con 4096 bits para que... no sé, tengan mas tranquilidad en sus almas a la hora de cifrar o firmar sus mensajes.

También les pedira que indiquen si quieren que sus llaves tengan una fecha de caducidad o que sean eternas, esto ya dependerá de sus gustos o paranoia a la hora de pensar en compartir su llave publica.

Otros datos importantes y que no deben de dejar si llenar serán:

• su nombre real
• dirección de correo electrónico
• un comentario (Opcinal)
• Y si, una clave de paso (Recomiendo que lo hagan, por si su llave privada cae en manos nada confiables)

Ya tengo mis llaves, y ahora como demonios las administro o veo...

Administrar tus llaves es tu responsabilidad, ya que puedes crear tantas como requieras, una para los amigotes, para la novia, para tu trabajo, etc, etc, etc, por lo cual uno siempre debe saber cual es cual y tener una idea para poder hacer el buen uso de ellas, así que gpg nos da la opción de listarlas mediante dos argumentos al comando gpg

$ gpg -k

o bien

$ gpg --list-keys

Esto nos desplegara la longitud de las llaves publicas y privadas, así como en usuario (Tu nombre) y un hash que las identificará, algo así como:

/home/uetiko/.gnupg/pubricng.gpg
--------------------------------------
pud 2048D/CA5B3485 2014-07-05
uid                                         Uetiko
sub  2048C/EF7A4E93 2014-07-05

Pero eso ¿qué carajos quiere decir?, digo, se ve padre y esta bien chido, pero en que idioma esta... Bien, con calma chamacos.

• pud: Es la llave publica.
• sud: es la llave privada
•  2048D: Es la longitud de bits que escogieron.
• CA5B3485: Es el ID de la llave.
• Uetiko: Es el nombre real de ustedes (Bueno... debe ser su nombre real por convención y buenas practicas)

pueden exportar sus llaves en gpg para su uso otros lugares como correo, desgraciadamente su llave esta en ansii, por lo que no todos los programas lo podrán entender y requerirán algo mas legible, por ejemplo algún cliente en web, donde un cat a la llave no podrá ser de utilidad y les dirá que la armadura ansii no es correcta o algún otro error a la hora de verificar o leer la codificación, lo que hará imposible su uso, pero si esto fuera así y ya, sería inútil, aburrido y nada benéfico su uso real en el mundo.

Para ello podemos exportarlas en formatos amigables y así seguir manteniendo una comunicación segura usando los clientes que queramos usar. Y para ello exportaremos las claves por partes, primero la publica para pasarla a nuestros amigotes y luego la privada, para que la usemos en nuestros clientes de confianza.

Exportando la llave publica

Como gpg tiene muchas opciones para nuestros gustos mas exquisitos, podemos usar una forma simple, pero muy buena para cocinar nuestra llave publica en ese formato amigable que deseamos.

$ gpg --armor --export > miLlavePublica.asc

Esto nos dará como salida algo asi como:

 -----BEGIN PGP PUBLIC KEY BLOCK-----Version: GnuPG v1.0.1 (GNU/Linux)Comment: For info see http://www.gnupg.orgmQGiBDkHP3URBACkWGsYh43pkXU9wj/X1G67K8/DSrl85r7dNtHNfLL/ewil10k2q8saWJn26QZPsDVqdUJMOdHfJ6kQTAt9NzQbgcVrxLYNfgeBsvkHF/POtnYcZRgLtZ6syBBWs8JB4xt5V09iJSGAMPUQE8Jpdn2aRXPApdoDw179LM8Rq6r+gwCg5ZZapGNlkgFu24WM5wC1zg4QTbMD/3MJCSxfL99Ek5HXcB3yhj+o0LmIrGAVBgoWdrRdBIGjQQFhV1NSwC8YhN/4nGHWpaTxgEtnb4CI1wI/G3DK9olYMyRJinkGJ6XYfP3bcCQmqATDF5ugIAmdditnw7deXqn/eavaMxRXJM/RQSgJJyVpbAO2OqKe6L6Inb5HkjcZA/9obTm499dDMRQ/CNR92fA5pr0zriy/ziLUow+cqI59nt+bEb9nY1mfmUN6SW0jCH+pIQH5lerV+EookyOyq3ocUdjeRYF/d2jl9xmeSyL2H3tDvnuE6vgqFU/Nsdvby4B2Iku7S/h06W6GPQAe+pzdyX9vS+Pnf8osu7W3j60WprQkUGF1bCBHYWxsYWdoZXIgPHBhdWxnYWxsQHJlZGhhdC5jb20+iFYEExECABYFAjkHP3UECwoEAwMVAwIDFgIBAheAAAoJEJECmvGCPSWpMjQAoNF2zvRgdR/8or9pBhu95zeSnkb7AKCm/uXVS0a5KoN7J61/1vEwx11poLkBDQQ5Bz+MEAQA8ztcWRJjW8cHCgLaE402jyqQ37gDT/n4VS66nU+YItzDFScVmgMuFRzhibLblfO9TpZzxEbSF3T6p9hLLnHCQ1bDHRsKfh0eJYMMqB3+HyUpNeqCMEEd9AnWD9P4rQtO7Pes38sV0lX0OSvsTyMG9wEBvSNZk+Rl+phA55r1s8cAAwUEAJjqazvk0bgFrw1OPG9m7fEeDlvPSV6HSA0fvz4wc7ckfpuxg/URQNf3TJA00Acprk8Gg8J2CtebAyR/sP5IsrK5l1luGdk+l0M85FpT/cen2OdJtToAF/6fGnIkeCeP1O5aWTbDgdAUHBRykpdWU3GJ7NS6923fVg5khQWguwrAiEYEGBECAAYFAjkHP4wACgkQkQKa8YI9JamliwCfXox/HjlorMKnQRJkeBcZiLyPH1QAoI33Ft/0HBqLtqdtP4vWYQRbibjW=BMEc-----END PGP PUBLIC KEY BLOCK-----

Bien, ya podemos descansar un poco, pero el problema es que esto es la publica... Y la privada? Por que la necesitamos nosotros para cifrar o firmar nuestros preciados mensajes... Bien, usando el siguiente comando podremos exportar esa preciada llave que debemos guardar lo mejor posible.

$ gpg --export-secret-key -a > miLlaveSecreta.asc

Esto nos generara una salida parecida a la anterior, pero nos dirá que es private y no public, por lo que ya podremos hacer uso de esta llave en nuestros clientes que no soportan la extensión de gpg.

La privacidad es un derecho que debemos tener, pero es su responsabilidad crearla y mantenerla de esta forma.

Con amor: Uetiko.

Un primer vistazo a Git

De la teoría y esas cosas

Git es un administrador de versiones simple, elegante, y extremadamente flexible, lo que puede resultar difícil de manejar o de aprender (Mejor dicho, de dominar). Pero quien en estos tiempos tiene tiempo para querer una vida fácil.

Git es un control de versiones distribuido, lo que significa en palabras simples: Ya no es necesario tener un servidor como en el caso de CVS o SVN, si no que ahora puedes tener tu control de versiones en tu maquina y posterior mente pasar todo esos cambios a un servidor central. Pero como diablos hacemos eso? como es que ahora puedo tener mi repositorio en mi maquina y así?

De los install y otras maravillas

Si usas windows, te recomiendo que bajes el ejecutable desde la pagina de git: dale aquí, si usas linux, existen paquetes precompilados para la mayoría de las distribuciones, por lo que ya no tendras que bajarte las fuentes y pasarte toda la noche peleándote con el make y gcc, así que abran sus consolas, sean todos poderosos (o sea, sean root) y dejen que su gestor de paquetes haga magia.

Fedora: # yum install git
ubuntu: apt-get install git-core

ArchLinux: # pagman -s git

Solais:# pkg install developer/versioning/git

En dado caso que no exista un precompilado para su linux o unix, descargen en source y hagan lo siguiente: 

# tar -zxf git-.tar.gz

# cd git-

# make prefix=/usr/local all

# make prefix=/usr/local install

Opcional: 

# make prefix=/usr/local clear

si quieren un cliente grafico, les recomiendo darle click aquí y bajar el que mas les acomode según su OS y perversiones personales.

Git es divertido

Para su desgracia, crear un repositorio es cosa fácil, por lo que las excusas quedan para CVS, mercury y otros. Pueden hacerlo con la GUI de su preferencia, por lo mientras, lo haremos de la forma artesanal (O sea, a manita desde la terminal.)

No es necesario que sean root para esto, git puede ser usado para todo usuario mortal del sistema.

Antes que nada, es importante que configuren git, eso es bueno para no ser el developer anónimo y sepamos a quien torturar en caso de subir bugs y demas cosas raras. Para ello hagan lo siguiente:

Díganle a git quien eres y dale un correo para futuros reclamos:

$ git config --global user.name "Sugizo"

$ git config --global user.email "sugi.sugi@sugimail.com"

Git también te permite indicarle cual es tu editor de confianza, como nano, vi, emacs etc, esto es opcional, pero si quieres hacerlo, estaría genial: 

$ git config --global core.editor vim

Si quieres ver tu configuración global, sólo teclea el siguiente comando:

$ git config --list

ó

$ vim ~/.gitconfig

Recuerda algo importante, si tienes duda de algún comando, git tiene un help y un man para esos casos.

$ git help

usage: git [--version] [--exec-path[=]] [--html-path] [--man-path] [--info-path]

           [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]

           [--git-dir=] [--work-tree=] [--namespace=]

           [-c name=value] [--help]

            []

The most commonly used git commands are:

   add        Add file contents to the index

   bisect     Find by binary search the change that introduced a bug

   branch     List, create, or delete branches

   checkout   Checkout a branch or paths to the working tree

   clone      Clone a repository into a new directory

   commit     Record changes to the repository

   diff       Show changes between commits, commit and working tree, etc

   fetch      Download objects and refs from another repository

   grep       Print lines matching a pattern

   init       Create an empty git repository or reinitialize an existing one

   log        Show commit logs

   merge      Join two or more development histories together

   mv         Move or rename a file, a directory, or a symlink

   pull       Fetch from and merge with another repository or a local branch

   push       Update remote refs along with associated objects

   rebase     Forward-port local commits to the updated upstream head

   reset      Reset current HEAD to the specified state

   rm         Remove files from the working tree and from the index

   show       Show various types of objects

   status     Show the working tree status

   tag        Create, list, delete or verify a tag object signed with GPG

See 'git help ' for more information on a specific command.

Del init, add y otras maravillas

Antes, para crear un repositorio tenias que sacrificar una cabra a media noche y con luna llena. Pero ahora, invocar al demonio es cosa de un par de comandos simples: 

$ cd miProyecto

$ git init

Esto te va a crear una carpeta oculta .git donde tendrás una estructura parecida a esta

.git/
|-- branches
|-- COMMIT_EDITMSG
|-- config
|-- description
|-- HEAD
|-- hooks
|   |-- applypatch-msg.sample
|   |-- commit-msg.sample
|   |-- post-update.sample
|   |-- pre-applypatch.sample
|   |-- pre-commit.sample
|   |-- prepare-commit-msg.sample
|   |-- pre-rebase.sample
|   `-- update.sample
|-- index
|-- info
|   `-- exclude
|-- logs
|   |-- HEAD
|   `-- refs
|       |-- heads
|       |   `-- master
|       `-- remotes
|           `-- origin
|               `-- master

Es recomendable que hagas un primer commit a tu repo, ya sea que tengas código o puedes agregar un simple README, da igual, la cosa es que sepas como se hace.

$ git add *.java

$ git commit -m "agregado algo al repo feliz"

El -m indica que es necesario un mensaje para identificar al commit que estas subiendo, es recomendable que ese mensaje sea la descripción de lo que subes, ya sea una nueva funcion, una modificación o una buena excusa para decir que corre con problemas y tiene muchos bugs y que es mejor no ejecutar para no borrar toda la base de datos, digo, por si las dudas, mejor que este bien claro. XD

Vieron, no fue cosa del otro mundo.

De los ejércitos imperiales y las guerras clon.

Pero que pasa si ya hay un repositorio en un server o en github y yo quiero descargarlo en mi maquina para poder modificarlo a cuchillo cincel y martillo??

Bueno, para estos casos, git es igual de amable y flexible, y no es necesario mas que el comando clon para poder clonar el repositorio a nuestra compu para poder trabajar.

git clone https://github.com/sugisugi/unProyecto.git []

En dado caso de que ustedes no especifiquen una carpeta, git creara una carpeta con el nombre del proyecto.

Por último y no menos importante. Supongamos que ya hicimos muchos commits en nuestro git local y todo bien padre, pero tenemos un github al cual quieremos subir todo el desmadre que hicimos en nuestra computadora, pero como demonios invoco a la fuerza para que haga tan noble labor sin necesidad de llamar al lado obscuro?

No necesitas mas que decirle al git de tu proyecto cual es el repositorio remoto al cual conectaras tu master:

$ git remote add origin https://github.com/sugisugi/unProyecto.git

Y para subir tus cambios del local al github, usa el parámetro push

$ git push -u origin master

te pedirá el usuario y el password.

Y con esto, ustedes ya pueden jugar con git felizmente toda la noche. En un post posterior explicare como hacer algunas funciones un poco mas avanzadas. Es recomendable que se den un tiempo para leer la documentación oficial para que sepan mas sobre como funciona un control de versiones y como git hace todo su trabajo como las ramas, los tags y otras maravillas que esta herramienta les puede ofrecer. 

Puedes hacer todo esto con la GUI o con el plugin para ti IDE de confianza. Si eres usuario de windows, no tienes excusa, git te instala un emulador de bash con los comando básicos de linux y los comandos de git para que puedas replicar los vistos aquí sin ningún problema.

Con amor, Sugizo.

Como recuperar sectores dañandos del disco duro dese la linea de comados de linux

Los discos duros no son eternos y a menos de que sean de estado sólido, están sujetos a errores de escritura por una mala imantación o por otras causas que son ajenas a uno como usuario. Así que siempre es bueno hacer un backup de nuestros datos en una unidad externa, ya sea en un storage en la red o en una usb que este bien oculta bajo la almohada.

Una buena práctica es hacerlo cuando el sistema operativo empiece a decirnos este tipo de cosas, que si no lo hacemos, a la larga nos sea más difícil o tardado este tipo de cosas. Así que hagan caso, hagan un back up y denle a esos sectores.

¿Cómo lo hacemos?

Abrimos nuestra tan amada consola para los que somos "consoleros" de corazón, para los que no, igual, abran la consola y cambien a super usuario.

Lo más recomendable es que si como yo, tienen más de una partición o de plano no se acuerdan del nombre de la partición, ejecuten fdisk

[root@uetiko]# fdisk -l
Disposit. Inicio Comienzo Fin Bloques Id Sistema
/dev/sda1 * 1 10947 87931746 5 Extendida
/dev/sda2 10948 19092 65424712+ 83 Linux
/dev/sda3 19093 19457 2931862+ 82 Linux swap / Solaris
/dev/sda5 1 10947 87931714+ 83 Linux

Y es así como ya teniendo nuestro listado de particiones, podremos reparar los sectores. Es importante que la partición ese desmontada o nos dará dolores de cabeza cuando nos salga que el dispositivo está siendo ocupado.

Para esto, basta un unmount podremos resolver el problema

[root@uetiko]# unmount /deb/sda1

Y ahora si, viene el momento de la verdad, y es aquí donde radica la magia para poder un disco duro guapo y en forma. Para ello usamos un comando que se llama badblocks, el cual tiene muchas chunchitas para que podamos analizar y reparar sectores y demás, pero por ahora nos limitaremos a jalar del gatillo y esperar que el disparo de en el blanco. Si no lo tienen, solo bájenlo de los repositorios con su gestos de paquetes preferido según su diestro.

[root@uetiko]# badblocks -s -v -f /dev/sda1

Y esperen a que el programa haga su trabajo. Claro, esto les causara un infarto cuando termine y vean que algunos de sus datos han... como decirlo, desaparecido extrañamente, para evitar esto y que en lo personal, no recomiendo, es agregar la opción -n para que así, no borre ningún dato cuando repare los sectores dañados, claro, esto les llevara mucho, pero mucho tiempo, así que si lo hacen, recomiendo que salgan al cine con la novia/amiga, la lleven a cenar y después regresen haciendo paradas en cualquier bar/cafetería que encuentren.

Notas sobre Java (Más teoría)

Java es un lenguaje Orientado a Objetos (POO), es decir que define a los programas en términos de 'clases de objetos' que son entidades que cambian de estado o es mejor decir, de datos. La programación orientada a objetos establece que un programa como un conjunto de estos objetos que se comunican entre ellos por medio de métodos. Esto métodos están pensados para hacer los módulos más fáciles de escribir, mantener y reutilizar.

La programación orientada a objetos establece ciertas características:

• Abstracción.
• Encapsulación.
• Polimorfismo.
• Herencia.

así que entremos al tema con mucha materia y poca saliva.

Abstracción: Cada objeto en el sistema sirve como un agente que puede realizar un trabajo, informar y cambiar su estado, y así mismo comunicarse con otros objetos sin revelar como se implementa.

Encapsulación: A esto también se le conoce como "ocultamiento de información", esto asegura que los objetos no pueden cambiar el estado interno de otros objetos.

Polimorfismo: La capacidad de una clase de comportarse como otra, asi de fácil, así de simple.

Herencia: Esta es la parte linda, es la que organiza y facilita el polimorfismo y la encapsulación, así permite la creación de objetos especializados que pueden compartir su comportamiento sin necesidad de reimplementarlo.
Estructura de una clase en Java

1. package: Declaración del paquete.
2. import: Uso de clases de un paquete externo.
3. class: Definición de la clase.

Sintaxis:

package < 'ruta del paquete' >
< 'Modificador de acceso' > class < 'nombre' > {
< 'Delcaración de atributos' >
< 'Declaración de Construcctor' >
< 'Declaración de métodos' >
}
Modificador de acceso

• Friendly: Es el acceso por default. No tiene una palabra clave asociada, por lo que se le denomina como acceso amistoso y pueden ser accesadas por clases del mismo paquete.
• Public: Puede ser accesada por cualquier miembro del paquete o de otros paquetes.
• Private: No puede ser accesada por otra clase, únicamente por medio de métodos publicos.

Declaración de atributos y datos primitivos

< 'Modificado de acceso' >< 'tipo' >< 'nombre' >[=< 'valor' >]

Tipo de datos primitivos

Typo Valor

• bolean = false
• byte = 0
  
• char = '\u0000'
  
• short = 0
  
• int = 0
  
• long = 0L
  
• float = 0.0f
  
• double = 0.0d

Este tipo de datos tiene una contraparte o una clase especializada llamada Wrapper.

Pero ya hablaremos de eso en otra ocasión, por ahora es momento de decir adios y nos veremos la próxima.

Notas sobre Java (Teoría)

Java es uno de los lenguajes más populares para aplicaciones basadas en web y dispositivos que se comunican por red.

Historia.

En 1991 se creo un proyecto interno en Sun Microsystem denominado Green. El plan era desarrollar un lenguaje basado en C++ que en un inicio se llamo Oak, culpa de un roble que se podía ver desde la oficina de James Gosling, su creador. Pero ya existia un lenguaje con ese nombre, por lo que mas adelante se le llamo Java, cuando un grupo de generentes visitaron una cafetería local.

Java fue creado para el mercado de dispositivos electrónicos inteligentes. Por desgracia, la proyección de Sun fue errónea y este tipo de dispositivos no se desarrollaban tan rápido. Así que el proyecto corrió con la suerte de ser cancelado. En 1993 exploto la popularidad de Internet y los chicos de Sun se dieron cuenta de que Java podía agregarle Dinamismo a las estaticas paginas creadas en html vil y villano.

En 1995, Sun Microsystem dio a conocer Java dentro de una conferencia y su fuerte fue los actuales y extintos Apples dentro de las paginas de Internet y se gano el corazón del mundo de los negocios, así como aplicaciones para dispositivos móviles como los celulares y radiolocalizadores.

Java se divide en tres ediciones que son:

• Java Standar Edition (Java SE).
• Java Enterprise Edition (Java EE) Orientada a las aplicaciones de redes a gran escala y aplicaciones basadas en web.
• Java Micro Edition (Java ME) Orientada al desarrollo de aplicaciones para dispositivos moviles con memoria limitada.

Entorno de desarrollo en Java

La programación en Java pasa por 5 etapas:

• Edición
• Compilación
• Carga
• Verificación
• Ejecución

Etapa 1

En esta primer etapa, es la parte donde escribiremos el programa ayudados por un editor. Posterior mente guardaremos el archivo bajo la extención '.java'.


Por ejemplo, suelo usar los editores vi o emacs para entornos Linux, pero para el campo de guerra necesitamos poder. Para ello existen los Entornos de desarrollo integrado (IDE's).


Entre los mas populares tenemos:

• Eclipse
• NetBeans
• JBuilder
• JCreator (Sólo si te gusta la austeridad)

Etapa 2

Para compilar un archivo .java, es necesario hacerlo con el archivo javac, que es el compilador.

Por ejemplo, supongamos que trabajamos con vi para hacer un pequeño programa y es hora de saber si podemos seguir o nos detenemos a ver errores. Desde una shell podemos hacer lo siguiente:

[Sugizo@old ~]$javac HolaMundo.java

si no detecta ningun error, nos generara un archivo '.class' a la cual llamamos 'Byte Code' que será lo que la Maquina Virtual de Java (JVM) usara para hacer las tareas que hemos escrito.

Para ejecutar este programa es tan fácil como escribirn en nuestra terminal lo siguiente:

[Sugizo@old ~]$java HolaMundo

Y veremos en terminal o por Interface grafica de usuario (GUI) el resultado.

Etapa 3

Para poder ejecutar el programa, este debe cargarse primero a memoria, de lo que se encarga el cargador de clases. el cargador también carga cualquiera de los .class de las librerías que el programa use.

Etapa 4

A medida en que se cargan las clases, existe un componente interno conocido como el verificador de Byte Code que examina las clases para asegurar que sean correctos y no violen las restricciones de seguridad.

Etapa 5

En este punto, la JVM ejecuta los Byte Code. Antes esta parte era la mas pesada ya que la Maquina virtual interpretaba bytecode por bytecode, ahora es mas eficiente gracias a algo llamado Just in time (JIT), esto hace que se interpreten a medida de que busca puntos activos del programa. Es decir, partes del codigo que se ejecutan con frecuencia.

Ahora bien, instalar Java en Windows es tan fácil como dar doble click. Pero para hacerlo desde linux, basta seguir estas instrucciones.

Besitos.

Programando pic's desde linux. (config.inc)

Creo que la chamba mas fácil siempre es la de configurar el pic, ponerle las entradas, salidas y activar una que otra bandera de interrupción.

Básicamente diremos lo siguiente.

• Puerto A fue usado para el convertidor analógico digital RA0, RA1, RA2 (Valores de referencia), RA3 (Valores de referencia), RA4 y RA5.
• Puerto B para uso de teclado por su patita RB0/INT Que genera interrupción, y por que se puede programar las patitas RB4-RB7 como interrupción por cambio de estado.
• Puerto C, uso de Led's o cualquier otra cosa que le quieran colgar.
• Puerto D, bus de datos para la pantalla LCD.
• Puerto E, lineas de control para LCD.
  

;************************************************
;Libreria de configuración general del pic.

;***************************************************
;Configura la direccionalidad de los puertos del PIC

Init_Config
bcf STATUS,RP0
bcf STATUS,RP0
clrf PORTA

movlw b'11110000' ;Configiración del puerto B para el teclado
movwf PORTB
call Init_interrup

bsf STATUS,RP0
bcf STATUS,RP1
clrf TRISC

clrf TRISD
clrf TRISE
call Init_ADC
bcf STATUS,RP0

return

;******************************************
;Habilitando interrupciones
Init_interrup
movlw b'11111000'
movwf INTCON

return

;******************************************
;Rutina de configuración del ADC
Init_ADC
;bsf STATUS,RP0
;bcf STATUS,RP1
movlw b'10001100' ;configuramos las entradas del ADC para abrir 3 canales

movwf ADCON1 ;y tener dos valores de referencia.
bcf STATUS,RP0
movlw b'01000000'

movwf ADCON0
return

;******************************************
;Rutina de configuración del Timer1
TMR1_Config
clrf T1CON

bsf STATUS,RP0
bcf STATUS,RP1
bcf PIE1,TMR1IE ;Inhabilitando el desbodamiento del TMR1

bcf STATUS,RP0
clrf TMR1L
clrf TMR1H
bsf PIE1,TMR1IE

movlw 0x36
movwf T1CON
return

Lo basico e indispensable.

Me das la hora?

La verdad es que eso lo hice de rápido y pero la idea es mostrar un while en ensamblador de una forma básica. Espero les pueda servir y bueno, ya luego les pongo el método principal.


__CONFIG _LVP_OFF & _CP_OFF & _PWRTE_ON & _XT_OSC & _BODEN_OFF & _WDT_OFF

list p=pic16f877
include <p16f877.inc>

;Variables
Cont equ 0x20

Hrs equ 0x21
Min equ 0x22
Seg equ 0x23
ContadorC equ 0x24

Temp0 equ 0x25
Temp1 equ 0x26
ContadorB equ 0x27
ContadorA equ 0x28

org 0
goto Principal
org 4
retfie

org 5

Un_Min
movlw d'60'
movwf Temp0

decfsz Temp0,1 ;Este es mi while. Temp0 == 0?
goto retraso_1_seg ;No...
return ;Si!

retraso_1_seg
movlw D'6'
movwf ContadorC

retraso_1_seg_bucle
call sub_delay_1_seg

decfsz ContadorC,1 ; Aquí otro; ContadorC == 0?
goto retraso_1_seg_bucle ;No...
return ;Si!!1

sub_delay_1_seg
movlw D'217'
movwf ContadorB
movlw D'111'

movwf ContadorA

sub_delay_1_seg_bucle
decfsz ContadorA,1
goto sub_delay_1_seg_bucle

decfsz ContadorB,1
goto sub_delay_1_seg_bucle
return