domingo 17 de mayo de 2009

Sistemas Operativos

Una recopilación de todos los sistemas operativos mas usados y su descripción. No se tienen en cuenta las distintas distribuciones del sistema GNU/Linux ni las distintas versiones de Windows ni Mac OS:

ADEOS (siglas de Adaptative Domain Environment Operating Systems), ADEOS proporciona un entorno flexible para compartir los recursos hardware para múltiples sistemas operativos ó múltiples instancias de un mismo sistema operativo. ADEOS activa múltiples núcleos, llamados dominios, que existen simultáneamente sobre el mismo hardware. Ninguno de éstos dominios necesariamente conoce la existencia del resto, pero todos ellos si conocen de la existencia de ADEOS. Un dominio puede ser un Sistema Operativo completo, pero no necesariamente.

AMSDOS es un sistema operativo de disco para los ordenadores de 8 bits Amstrad CPC de Amstrad. Su nombre proviene de la contracción de Amstrad Disc Operating System.

Fue publicado en 1984 con la unidad de disco de 3 pulgadas opcional para el Amstrad CPC 464, e incluido de serie en las ROMs de los Amstrad CPC 664 y Amstrad CPC 6128. En los Amstrad CPC Plus venía en el cartucho incluido de serie junto con un juego. Era más rápido y eficiente que la mayoría de sus equivalentes contemporáneos y podía soportar dos unidades de disco conectadas simultáneamente.

El AMSDOS era proporcionado en la memoria ROM (tanto con la unidad de disco externa o en la ROM de la máquina, dependiendo de modelo) y fue accesible por medio del Locomotive BASIC incorporado en el computador así como también a través de rutinas del firmware. Su función principal era mapear las rutinas de acceso del casete (que estaban incorporadas en cada modelo de CPC) a través a un unidad de disco. Esto permitió a la mayoría de los programas basados en casete trabajar con una unidad de disco sin modificación.

ANDOS es un sistema operativo ruso. Fue usado como sistema operativo para la serie de ordenadores Electronika BK-0010 y Electronika BK-0011M. Fue virtualmente el único sistema en la serie BK que usaba el sistema de archivos de MS-DOS.

ANDOS utilizaba el sistema de archivos FAT12 en disquetes de 800kb.

Amoeba es un sistema operativo distribuido de investigación, basado en una arquitectura de micronúcleo. Fue desarrollado por Andrew S. Tanenbaum y otros en la Universidad Libre de Amsterdam. El objetivo del proyecto Amoeba era construir un sistema de tiempo compartido que hiciera que una red entera de computadores pareciera a los ojos de un usuario como una única máquina.

Android es una plataforma de software y un sistema operativo para dispositivos móviles. Está basado en GNU/Linux e inicialmente fue desarrollado por Google. La presentación de la plataforma Android se realizó el 5 de noviembre de 2007 junto con la fundación Open Handset Alliance, un consorcio de 48 compañías de hardware, software y telecomunicaciones comprometidas a la promoción de estándares abiertos para dispositivos móviles.
Esta plataforma permite el desarrollo de aplicaciones por terceros (personas ajenas a Google), para lo cual, los desarrolladores deben de escribir código gestionado en el lenguaje de programación Java y controlar los dispositivos por medio de bibliotecas desarrolladas o adaptadas por Google. Otras opciones, es decir, escribir programas en C u otros lenguajes, utilizando o no las bibliotecas de Google , también son posibles (compilándolas a código nativo de ARM ); sin embargo, este esquema de desarrollo no es oficialmente soportado por Google.
La mayoría del código fuente de Android ha sido publicada bajo la licencia de software Apache, una licencia de software libre y código fuente abierto.

The Operating System (TOS) es el sistema operativo de la gama de ordenadores Atari ST. Esta gama incluye el 520ST, el 1040ST y las variantes F, FM y E (ej. 1040STE). Posteriormente, las máquinas de 32 bits (TT030 y Falcon) fueron desarrolladas usando una nueva versión de TOS, llamada MultiTOS, la cual permite multitarea. Más recientemente, los usuarios han evolucionado TOS dando lugar a FreeMiNT.

BeFree es una versión libre de BeOS, construida sobre un kernel de Linux. Este sistema operativo pertenece a la rama de los clones como BlueEyedOS, Cosmoe, OpenBeOS/Haiku-OS.

BeOS es un sistema operativo para PC desarrollado por Be Incorporated en 1990, orientado principalmente a proveer alto rendimiento en aplicaciones multimedia. A pesar de la creencia común fomentada por la inclusión de la interfaz de comandos Bash en el sistema operativo, el diseño de BeOS no estaba basado en UNIX.

OSBOS (del inglés Open Standards BeOS-compatible Operating Systems) es el conjunto de sistemas operativos que pretenden recrear las característica del sistema operativo BeOS, comprometiéndose para ello a cumplir unos estándares abiertos, establecidos por BeUnited, de compatibilidad e interoperabilidad.

CP/M (Control Program/Monitor) es un sistema operativo desarrollado por Gary Kildall para el microprocesador 8080/85 de Intel y el Z80 de Zilog. Se trata del sistema operativo más popular entre las computadoras personales en los años 1970. Aunque fue modificado para ejecutarse en un IBM PC, el hecho que IBM eligiera MS-DOS, al fracasar las negociaciones con la desarrolladora del software, hizo que el uso de CP/M disminuyera hasta hacerlo desaparecer.

El acrónimo CP/M significa Control Program for Monitors, es decir, Programa de control para monitores. En la época, la barra inclinada (/) tenía esta acepción de "diseñado para". No obstante, Gary Kildall redefinió el significado del acrónimo poco después.

CP/M se convirtió en un estándar de industria para los primeros micro-ordenadores.

DOS es una familia de sistemas operativos para PC. El nombre son las siglas de Disk Operating System (sistema operativo de disco). Fue creado originalmente para computadoras de la familia IBM PC, que utilizaban los procesadores Intel 8086 y 8088, de 16 bits y 8 bits, respectivamente, siendo el primer sistema operativo popular para esta plataforma. Contaba con una interfaz de línea de comandos en modo texto ó alfanumérico, vía su propio intérprete de órdenes, command.com. Probablemente la más popular de sus variantes sea la perteneciente a la familia MS-DOS, de Microsoft, suministrada con buena parte de los ordenadores compatibles con IBM PC, en especial aquellos de la familia Intel, como sistema operativo independiente o nativo, hasta la versión 6.22 (bien entrados los 90), frecuentemente adjunto a una versión de la interfaz gráfica Ms Windows de 16 bits, como las 3.1x.

E/OS (Emulator Operating System) is a virtual machine emulation system.

E / OS se basa principalmente en el kernel Linux, Qemu, XFree86 y Wine, y está destinada a ser un reemplazo para el funcionamiento de los sistemas de como Microsoft Windows, Mac OS, BeOS, OS/2, DOS y Linux. Su objetivo es hacer posible ejecutar cualquier programa diseñado para cualquier sistema operativo sin necesidad de instalar en realidad ningún otro sistema operativo. Así, sólo un sistema operativo, en este caso, una alternativa libre a los sistemas mencionados, serían necesarios para la ejecución de todos los programas.

eComStation (o eCS) es el sistema operativo para PC, desarrollado por Serenity Systems, que está basado en OS/2 Warp 4.5, incluyendo una nueva interfaz gráfica y varias mejoras, como el Journaling File System, un sistema de archivos que es mucho más tolerante a fallos y que es usado por otros sistemas como AIX.

Este sistema integra la última versión del producto original de IBM (los llamados Convenience Pack) con otros productos que IBM distribuye separadamente por algún motivo (como controladores USB) y diversos desarrollos de software, muchos de ellos open Source, para ofrecer al usuario un sistema actualizado, más completo y sencillo de instalar que el original de IBM.

EXEC II es un sistema operativo de tipo batch o por lotes. En este sentido, EXEC II permite procesar una gran cantidad de trabajo con poca o ninguna interacción entre los usuarios y los programas en ejecución.

GCOS (Sistema Operativo Comprensivo General) es una familia de sistemas operativos orientados hacia computadoras centrales (mainframes). Su primera versión fue desarrollada por General Electric en 1962; originalmente designado GECOS (the General Electric Comprehensive Operating Supervisor) .

Actualmente aún se utiliza sobre grandes sistemas, aunque raras veces, sobre todo debido a problemas de herencia. Los programas empleados sobre este sistema operativo están generalmente escritos en lenguajes tales como COBOL, Fortran  y ahora Java.

GEOS (Graphic Environment Operating System) es un sistema operativo desarrollado por Berkeley Softworks (posteriormente Geoworks). Diseñado originalmente para el Commodore 64 y lanzado en 1986, proporciona una interfaz gráfica de usuario para este popular ordenador de 8 bits.

GEOS recuerda mucho a las primeras versiones de Mac OS e incluye un procesador de textos gráfico (geoWrite) y un programa de dibujo (geoPaint). Durante años, Commodore incluyó GEOS con el C64C, su nueva versión del C64 (rediseñada y de coste más reducido, usaba una caja similar a la del Commodore 128). Debido a ello, GEOS es el tercer más popular sistema operativo del mundo en término de unidades distribuidas, tras MS-DOS y Mac OS.



El GM-NAA I/O (de sistema de entrada/salida de General Motors y North American Aviation) es el primer sistema operativo de la historia de la informática.

Fue creado en 1956 por Bob Patrick de General Motors y Owen Mock de North American Aviation para un ordenador IBM 704. La base de su construcción fue el sistema monitor creado en 1955 por programadores de General Motors para sus IBM 701.

GM-NAA I/O, cuya función principal era ejecutar automáticamente un nuevo programa una vez que el que se estaba ejecutando terminaba, estaba formado por unas rutinas accesibles a los programas que proporcionaban un acceso común a los dispositivos de entrada/salida.



GNU Hurd es un conjunto de programas servidores que simulan un núcleo Unix que establece la base del sistema operativo GNU. El Proyecto GNU lo ha estado desarrollando desde 1990 como software libre, distribuyéndolo bajo la licencia GPL.

Hurd intenta superar los núcleos tipo Unix en cuanto a funcionalidad, seguridad y estabilidad, aun manteniéndose compatible con ellos. Esto se logra gracias a que Hurd implementa la especificación POSIX (entre otras), pero eliminando las restricciones arbitrarias a los usuarios.

GNU/Linux es el término empleado para referirse al sistema operativo similar a Unix que utiliza como base las herramientas de sistema de GNU y el núcleo Linux. Su desarrollo es uno de los ejemplos más prominentes de software libre; todo el código fuente puede ser utilizado, modificado y redistribuido libremente por cualquiera bajo los términos de la GPL de GNU (Licencia Pública General de GNU) y otras licencias libres.

HDOS fue uno de los primeros sistemas operativos para microcomputadoras originalmente escrito para el Heath H-8 y más tarde utilizado en los Heath H89 / Zenith Z89. El autor fue Gordon Letwin, que más tarde fue uno de los primeros empleados de Microsoft y artífice de OS/2.

HDOS originalmente venía con un conjunto muy limitado de herramientas software de sistema, que incluye un ensamblador, pero se añadieron más adelante programas comerciales y gratuitos.

La última versión de HDOS, HDOS 2,0, es notable porque fue uno de los primeros sistemas operativos en utilizar la carga de controladores (drivers) para alcanzar un mayor grado de independencia del dispositivo y extensibilidad.

i5/OS (antes llamado OS/400) es un sistema operativo usado en las minicomputadoras iSeries de IBM (antes llamadas AS/400). La última versión de i5/OS es la V6R1.

El iS-DOS es un sistema operativo usado por algunos clónicos rusos del ZX Spectrum con interface de disco Beta Disk. El iS-DOS fue desarrollado en 1990 o 1991 por Iskra Soft Ltd. (Leningrado, URSS).

Soporta discos flexibles DS y DD, discos duros y CD-ROM.

Una versión moderna para el ordenador ATM es TASiS, desarrollada por NedoPC.

KolibriOS (también conocido como KOS o Kolibri), es un sistema operativo libre con un núcleo monolítico anticipativo (monolithic preemptive kernel) en tiempo real y drivers de video escrito para PC con arquitectura x86 de 32 bits. Es desarrollado y mantenido por The KolibriOS Project Team.

KolibriOS está escrito completamente en FASM (lenguaje Assembler). Sin embargo, permite que lenguajes y compiladores de alto nivel (C--, C, C++, Free Pascal, Forth; entre otros) puedan ser usados para el desarrollo de aplicaciones.

Es importante destacar que no se trata de una distribución de MenuetOS como algunas fuentes mencionan, sino que es una derivación independiente, la cual se separó de MenuetOS en el año 2005 (según aseguran los propios autores); cuando este último dejó de ser distribuido bajo licencia GPL.

LynxOS RTOS es un sistema operativo de tiempo real tipo Unix de LynuxWorks (anteriormente "Lynx Real-Time Systems").

MacOS, abreviatura de Macintosh Operating System (Sistema Operativo de Macintosh), es el nombre del primer sistema operativo de Apple para los ordenadores Macintosh. El Mac OS original fue el primer sistema operativo con una interfaz gráfica de usuario en tener éxito. El equipo de Macintosh incluía a Bill Atkinson, Jef Raskin y Andy Hertzfeld.

Hay una gran variedad de puntos de vista sobre cómo fue desarrollado Macintosh y dónde se originaron las ideas subyacentes. Mientras la conexión entre el proyecto Macintosh y el proyecto Alto en Xerox PARC ha sido establecido en los documentos históricos, las contribuciones iniciales del Sketchpad de Ivan Sutherland y el On-Line System de Doug Engelbart no son menos significantes. Véase Historia de la interfaz gráfica de usuario y Apple vs Microsoft.

Apple quitó importancia de forma deliberada a la existencia del sistema operativo en los primeros años de Macintosh para ayudar a hacer que la máquina pareciera más agradable al usuario y a distanciarla de otros sistemas como MS-DOS, que eran un desafío técnico. Apple quería que Macintosh fuera visto como un sistema que trabajara nada más con encenderlo.



MenuetOS, también conocido como MeOS, es un sistema operativo creado por Ville Mikael Turjanmaa para PC x86, escrito enteramente en lenguaje ensamblador (FASM) para 32 y 64 bits.

Soporta programación en 32 y 64 bits en lenguaje de ensamblador.

Su núcleo es de tiempo real, monolítico, con multitarea preferente, el cual incluye controladores de vídeo.

También tiene una distribución en CD, la que viene con muchas aplicaciones ya preinstaladas.

Su desarrollo se ha enfocado en una realización eficiente, sencilla y rápida. Tiene un escritorio gráfico, juegos y conectividad, mediante una pila TCP/IP. Aun así, cabe en un disco flexible de 1'44MB. También facilita la programación fácil y completa en lenguaje ensamblador. Esto se opone a la visión habitual según la cual el lenguaje ensamblador sólo es útil en sistemas viejos o empotrados.

Originalmente fue escrito para la arquitectura x86 y licenciado bajo la licencia GPL, por lo que muchas de sus aplicaciones son distribuidas bajo la misma licencia. La versión de 64 bits, habitualmente llamada "Menuet 64", sigue siendo una plataforma de aprendizaje para la programación en ensamblador de 64 bits; pero a diferencia de la versión de 32 bits, se distribuye como freeware sin el código fuente de los componentes centrales. Menuet 64 funciona tanto en Hardware real, como virtualizado.

MorphOS es un sistema operativo, en parte propietario y en parte de código abierto, producido para ordenadores basados en los procesadores PowerPC (PPC), entre los que se encuentran la mayoría de los modelos clásicos de ordenadores Commodore Amiga con aceleradoras PPC, y los equipos con placa madre Pegasos y EFIKA PPC. El sistema operativo en si es propietario, pero muchas librerías y otros componentes del mismo son de código abierto, tales como Ambient (la interface del escritorio). La mariposa azul es el logo característico de este sistema operativo.

NEXTSTEP es el sistema operativo orientado a objetos, multitarea que NeXT Computer, Inc. diseñó para correr en los ordenadores NeXT (informalmente conocidos como "black boxes").

Not Another Completely Heuristic Operating System o NachOS es un Sistema Operativo educativo para los estudiantes de cursos de Sistemas Operativos, sin graduación o aspirantes a graduados. Fue desarrollado en la University of California, Berkeley, diseñado por Thomas Anderson, y es usado por numerosas escuelas.

Escrito originalmente en C++ para MIPS, la versión actual (5.0j) ha sido escrita en el lenguaje de programación Java.

Ha sido portado a MIPS, Sparc (SunOS y Solaris), Alpha, Linux, NetBSD y FreeBSD, RS/6000, Mac 68000 (no soportada), y HP.

La Stanford University utilizó NACHOS hasta 2004, en que introdujo Pintos, un sistema operativo derivado de NACHOS escrito en C y diseñado para correr en el actual hardware x86 (como Java, NachOS no corre sobre un hardware real, sino sobre una máquina virtual, por lo que requiere un sistema operativo anfitrión).

El sistema operativo OpenVMS (Sistema de Memoria Virtual) es un sistema multiusuario y multiproceso diseñado por Digital, ahora parte de Hewlett-Packard, para su utilización en entornos de tiempo compartido, tiempo real, procesamiento por lotes y procesamiento de transacciones. Conocido inicialmente como VMS, se ejecutaba sobre sistemas VAX,el nombre cambió a OpenVMS en 1990. Fue posteriormente portado a DEC Alpha(1992) e Intel Itanium.

Palm webOS es un sistema operativo empotrado desarrollado por Palm, Inc. para smartphones, el cual fue presentado al público en el Consumer Electronics Show de Las Vegas el 8 de enero de 2009.
Palm webOS está diseñado para ser usado a través de una interfaz de usuario basada en pantalla táctil. Incluye una suite de aplicaciones para gestión de datos personales y hace uso de una serie de tecnologías web como XHTML, JavaScript y CSS. Palm asegura que el diseño alrededor de estas tecnologías fue intencionado, para evitar así el aprendizaje de un nuevo lenguaje de programación por parte de los desarrolladores.[3] [4] El Palm Pre, cuya comercialización está prevista para la primera mitad de 2009, es el primer dispositivo que incorpora este sistema operativo.

Pintos es un sistema operativo educativo creado en la Stanford University en 2004 y usado en los cursos de pregrado para introducir conceptos de diseño e implementación de un sistema operativo, requiriendo la implementación de partes bastante significativas de un sistema operativo real, como son el manejo de threads y memoria y el acceso al sistema de archivos. Pintos deriva de NachOS un sistema similar creado por la University of California, Berkeley. A diferencia de NachOS, Pintos puede ejecutarse en el hardware x86 actual, en lugar de correr como una máquina virtual sobre un sistema anfitrión. Pintos está escrito en el Lenguaje de programación C en lugar de en C++.

Plan 9 from Bell Labs (o simplemente Plan 9) es un sistema operativo distribuido, usado principalmente como vehículo de investigación.

Fue desarrollado como el sucesor en investigación del sistema UNIX por el Computing Sciences Research Center de los Laboratorios Bell entre mitad de los años 80 y 2002.

Plan 9 es conocido especialmente por representar todos los interfaces del sistema, incluyendo aquellos utilizados para redes y comunicación con el usuario, a través del sistema de archivos en lugar de sistemas especializados.

El nombre proviene de la película de ciencia ficción llamada Plan 9 del espacio exterior.

El sistema operativo SHARE Operating System, también conocido como SOS, fue creado en 1959 como una mejora del sistema operativo GM-NAA I/O, el primer sistema operativo, por el grupo de usuarios SHARE. El objetivo fundamental era mejorar la compartición de programas respecto a GM-NAA I/O.

SHARE Operating System proporcionaba nuevos métodos para gestionar los buffers y los dispositivos de entrada/salida, y, al igual que GM-NAA I/O, permitía la ejecución de programas realizados en lenguaje ensamblador.

Inicialmente funcionaba en ordenadores IBM 704, pero posteriormente fue portado a los IBM 709.

Más tarde IBM dio soporte al mismo bajo el nombre de IBSYS, portándolo a sus nuevos ordenadores basados en transistores, los IBM 7090 y 7094.

SO3 es un sistema operativo para PC de origen Dominicano desarrollado por SHD Dominicana en 1999, orientado a pcs de escritorio y servidores. compatible con el estandard posix. Su principal característica es su modularidad y su adaptabilidad lo que lo hacen uno de los sistemas más flexibles de todos los tiempos. Sus desarrollos llaman a esto "evolución acelerada". Cada usuario que posee este sistema es capaz de hacerle cambios y poder distribuirlo libremente con dichos cambios.

SABRE es un sistema operativo de procesamiento en tiempo real (RT TPOS) centralizado, desarrollado por American Airlines e IBM. Este sistema operativo corre en un servidor central y es accedido desde terminales de usuario que no cuentan más que con un bios primitivo, un monitor monocromático, un teclado y un par de puertos serie para comunicarse con una impresora y un MODEM; el sistema no cuenta con medios de acceso extraíbles ya que en el momento de ser diseñadas no había medios extraíbles que pudieran integrarse en una terminal personal por su tamaño y costo.

Sequel es un sistema operativo desarrollado según la filosofía del sistema BeOS, basado en un micronúcleo de licencia BSD.

El Sinclair QDOS (a veces escrito Qdos en la literatura oficial) es el sistema operativo multitarea presente en el ordenador personal Sinclair QL y sus clones. Fue diseñado por Tony Tebby mientras trabajaba en Sinclair Research, como una alternativa interna a otro sistema operativo, posteriormente cancelado, encargado a GST Computer Systems.

El Sinclair QDOS se implementó en Lenguaje ensamblador Motorola 68000, y en el QL, reside en 48 KB de ROM, consistente en tres ROM chips de 16 KB o en un chip de 32 KB y otro de 16 KB. En esas ROMs también se almacena el intérprete de SuperBASIC, una variante avanzada del BASIC con adiciones de programación estructurada. También actúa como el intérprete de comandos QDOS.

Las prestaciones proporcionadas por QDOS incluyen manejo de procesos (o "trabajos" en la terminología del QDOS), asignación de memoria, y un "sistema de redirección de entrada/salida" extensible, proporcionando un marco genérico para los sistemas de archivos y controladores de dispositivos. También se proporcionaba una muy básica funcionalidad de ventanas en pantalla. Esto, y varias otras prestaciones, nunca fueron completamente implementadas en las versiones liberadas de QDOS, pero fueron implementadas en posteriores extensiones al sistema operativo producidos por la compañía fundada por Tebby, QJUMP.

También se desarrollaron versiones mejoradas reescritas del QDOS, como el Minerva de Laurence Reeves, y SMS2 y SMSQ/E de Tebby. El último es la variante más moderna y todavía se está mejorando.

Solaris es un sistema operativo de tipo Unix desarrollado por Sun Microsystems desde 1992 como sucesor de SunOS. Es un sistema certificado oficialmente como versión de Unix. Funciona en arquitecturas SPARC y x86 para servidores y estaciones de trabajo.

Aunque Solaris fue desarrollado como software privativo, la mayor parte de su código se ha liberado como proyecto de software libre denominado OpenSolaris. Solaris es conocido por su escalabilidad, especialmente en sistemas SPARC, y por ser origen de innovadoras tecnologías, como DTrace y ZFS.



Sprite es el nombre de un sistema operativo distribuido con un núcleo monolítico desarrollado por la University of California, Berkeley, más concretamente por el grupo de investigación de John Ousterhout.

Este sistema operativo tiene la apariencia para los programadores de un sistema único, ya que la distribución se produce dentro del propio núcleo y de este modo, Sprite nos da la impresión de estar trabajando sobre un típico sistema UNIX.

SymbOS es un sistema operativo multitarea para ordenadores de 8 bits basados en el Zilog Z80. En el momento actual está disponible para las gamas de ordenadores Amstrad CPC, PCW, y MSX 2. Contrariamente a anteriores sistemas operativos de 8 bits, se basa en un Micronúcleo, que realiza multitarea preferente (preemptiva), orientada a prioridades y administra una memoria RAM de hasta 576 Kilobytes. SymbOS contiene un GUI similar al de MS-Windows, soporta unidades de disco no removibles de hasta 128 Gb y puede funcionar en un CPC 6128 o un MSX2 de 128 Kilobytes una vez arrancados.

Symbian es un sistema operativo que fue producto de la alianza de varias empresas de telefonía móvil, entre las que se encuentran Nokia, Sony Ericsson, PSION, Samsung, Siemens, Arima, Benq, Fujitsu, Lenovo, LG, Motorola, Mitsubishi Electric, Panasonic, Sharp, etc. Sus orígenes provienen de su antepasado EPOC32, utilizado en PDA's y Handhelds de PSION.

El objetivo de Symbian fue crear un sistema operativo para terminales móviles que pudiera competir con el de Palm o el Windows Mobile de Microsoft.

THEOS es un Sistema Operativo que comenzó como OASIS, un sistema operativo para microordenadores basados en el procesador Z80. Originalmente desarrollado a finales de 1970 por Timothy S. Williams como una alternativa de bajo costo a los muchos más caros mini y super ordenadores Miniframe y Mainframe que eran populares en la época, Oasis disponía de facilidades multiusuario que permitían compartir los mismos recursos entre varios usuarios. Recordar que en aquella época, el ordenador más básico costaba unos cuantos miles de dólares. THEOS se enfocó por entonces a la pequeña empresa.

Cuando el sistema operativo fue lanzado para la plataforma IBM PC'AT en 1982, se le cambió el nombre a THEOS, abreviatura de THE Operating System (El Sistema Operativo). THEOS está en continuo desarrollo, y la compañía sigue liderada por su fundador Tim Williams, que participa muy activamente en los desarrollos actuales del producto.

THEOS sigue siendo usado hoy y es muy popular en Europa, especialmente en España, donde fue introducido por Fujitsu hace 30 años, junto con otros fabricantes de hardware, con más de 3 millones de usuarios en todo el mundo.

Su última version se llama THEOS Corona. Corona es un sistema operativo de 32-64 bits, para las plataformas x86 compatibles y el hardware actual popular del mercado (por ejemplo SCSI 320, SATA, SAS, RED 10/100/1000, PCMCIA, USB, PCI/X/64 etc.) y servidores de gama alta.

El TOS es un sistema operativo monotarea, en esencia limitando al usuario a ejecutar una única aplicación en el sistema. Una pequeña excepción a esta regla son los accesorios de escritorio,programas pequeños que son codificados para ser accedidos a través de la barra de menú del GEM. Mientras se trabaja en una aplicación GEM se pueden tener hasta 6 accesorios abiertos de manera concurrente. Esto permite un tipo primitivo de multitarea cooperativa.

El TR-DOS es un sistema operativo de disco para ordenadores ZX Spectrum (y compatibles) incluido como firmware en el interface de disco Beta Disk. El sistema operativo TR-DOS y el interface Beta Disk fueron desarrollados por Technology Research Ltd (Reino Unido), en 1985.

En sus primeras versiones podía crear hasta 128 directorios por disco. La última versión estable conocida es el TR-DOS 5.03. Posteriormente, han aparecido versiones hackeadas, como la 6.10E (en Mr Gluk Reset Service) y vTR-DOS (para ATM). Existen versiones actualizadas en 2006.

El TR-DOS soporta discos flexibles SS/DS, SS/DD. Todas las versiones modernas soportan disco RAM. Algunas versiones soportan disco duro.

Algunos sistemas operativos para ZX Spectrum derivados del TR-DOS son el HR-DOS y el SP-DOS.

Tabos es un sistema operativo (aun en desarrollo) libre para Intel x86 y procesadores compatibles. Se puede usar como sistema de rescate, y como un sistema de escritorio para usuarios domésticos o usuarios de oficina.

Unununium es un sistema operativo sin núcleo, hecho a través de VOiD por el hacker Dave Poirier en lenguaje ensamblador. Está enfocado en la velocidad y, sin duda, el gran mérito de este sistema reside en la dificultad de documentar las miles de líneas de un sistema operativo sin núcleo en ensamblador.

El VM/CMS es un sistema operativo de máquina virtual que se anunció para el público en 1972 por IBM para computadores centrales o mainframes, plataformas como System/370, System/390, zSeries, System Z9 además de otros sistemas compatibles como el emulador Hércules.

Está basado en máquina virtual de sistema cuyo núcleo es un programa de control llamado CP (Control Program) o también denominado VMCP (Virtual Machine Control Program) cuya principal característica es que permite la ejecución de una máquina virtual dentro de otra máquina virtual, también es la encargada de controlar los dispositivos hardware del ordenador: CPU, discos cintas, etc. Además CP es quién controla el proceso de LOGON de un usuario y activa la máquina virtual. Junto a este componente existe el CMS (Conversacional Monitor System) su entorno permite la ejecución, creación y depuración de aplicaciones, gestión de archivos de datos, trabajo por lotes además de comunicarse con otros usuarios y sistemas, en general es el encargado de aceptar las órdenes del usuario y convertirlas en instrucciones que el CP es capaz de ejecutar.

Windows es una familia de sistemas operativos desarrollados y comercializados por Microsoft. Existen versiones para hogares, empresas, servidores y dispositivos móviles, como computadores de bolsillo y teléfonos inteligentes. Hay variantes para procesadores de 16, 32 y 64 bits.

Incorpora diversas aplicaciones como Internet Explorer, el Reproductor de Windows Media, Windows Movie Maker, Windows Mail, Windows Messenger, Windows Defender, entre otros.

Desde hace muchos años es el sistema operativo más difundido y usado del mundo; de hecho la mayoría de los programas (tanto comerciales como gratuitos y libres) se desarrolla originalmente para este sistema.

Windows Vista es la versión más reciente para computadoras personales, Windows Server 2008 para servidores y Windows Mobile 6.0 en los dispositivos móviles.



WOW64 (Windows-on-Windows 64-bit) es un subsistema de Microsoft Windows capaz de ejecutar aplicaciones de 32 bit y que se incluye en todas las versiones de 64 bit de Windows (Windows XP 64 bit Edition, Windows Server 2003 x64 y Windows Vista 64 bit Edition). WOW64 se encarga de todas las diferencias en las versiones 32 y 64 bit de Windows, especialmente las que implican cambios estructurales en el propio Windows.

XINU "Xinu Is Not Unix" (Es un acrónimo recursivo: Xinu No es Unix) es un Sistema operativo Tipo UNIX, desarrollado Originalmente por Douglas Comer con fines de instrucción, en la Universidad de Purdue en la década de los ochentas. Ha sido portado a varias plataformas, como son: DEC LSI-11, Sun-2 y Sun-3,Intel x86, y PowerPC G3.

Xinu ha sido usado como base en el desarrollo de varios productos comerciales, y sigue siendo utilizado en algunas universidades del mundo en cursos de Sistemas Operativos y redes.

XtreemOS es un sistema operativo basado en Linux, que soporta organizaciones virtuales en Grid de nueva generación. El principal objetivo del proyecto XtreemOS (perteneciente al 6º Programa Marco de la CE, sección de Tecnologías de la Sociedad de la Información) es el diseño, implementación, evaluación y distribución de un sistema operativo Grid de código abierto (denominado XtreemOS) con soporte nativo para organizaciones virtuales y capaz de correr en una amplia gama de plataformas, desde clusters a dispositivos móviles.

Este texto fue realizado con los datos obtenidos de Wikipedia.org.

sábado 9 de mayo de 2009

Linux y comandos para manejo de archivos

Resumen para rendir el primer practico de Sistemas Operativos:
Distribuciones de Linux:
Red Hat, Caldera, Debian, Slackware, Correctiva, Ubuntu, Ututo, Suse, etc.

Arquitectura Básica de un SO:
4)Aplicaciones
3)Shell o Caparazón
2)Kernell o núcleo
1)Hardware
Las dos capas que corresponden al SO son Shell(Interprete de Comandos, utilizado por usuarios y aplicaciones) y Kernell(núcleo que se comunica con el Hardware).
Trabajaremos en modo consola aunque existen entornos gráficos.
Se puede trabajar con 6 consolas virtuales, estas se intercambian con Ctrl+Alt+F1 para pasar a texto y Ctrl+Alt+F9 para pasar a modo grafico.
Existen varios tipos de Shell, variando a veces los prompts:
_ash: Ashell
_csh: Cshell %
_tcsh: Extension de Cshell
_ksh: Kornshell $
_bsh: Bourne Shell $
_bash: Bourne Again Shell $ //mas usada

Los comandos se tipean en bash de esta manera:
$ ________ ________ __________
el signo $ es el prompt, el primer campo es para el nombre de comando, el segundo para el argumento y el tercero que puede ser ninguno o muchos es para pasarle opciones.
Esto no es así siempre pero es la estructura habitual.
El prompt # es exclusivo del administrados del sistema.

Sistema de Archivos

Root(padre o admin, Raiz nomas)
/usr
Software para ejecutar aplicaciones de usuario.
/lib
Librerías de lenguajes de programación.

/bin Comandos del SO.

/dev Device, dispositivos periféricos, drivers.
/etc
Configuración de arranque del sistema.

/tmp Archivos Temporales.
/home
Contiene a los usuario o sus subdirectorios.
          

/alumno214
           /invitado

/mnt montaje(mount) archivos de montaje.

/proc Proceso – archivos de proceso activos

/boot Archivos de arranque



i-nodo: numero de identificación del archivo(todos los directorios son archivos para Linux)

Todos los directorios y archivos tienen un dueño(quien lo crea) y tienen 3 tipos de permiso.



Permisos de Archivo:

Terna rwx, donde:
r = permiso de lectura (read)

w = permiso de escritura (write)

x = permiso de ejecución (execution)

Esta terna de permisos debe ser aplicada a cada usuario o grupo de usuarios:
rwx rwx rwx

Dueño user, Grupo, Otros

Las combinaciones de estos tres valores entre prendidos y apagados son 7, donde 7 es el de mayor valor o sea que tiene permisos de escritura, lectura y ejecución, esta terna se modifica con el comando chmod seguido de la secuencia de numero que representan cada estado de la terna y luego el nombre del archivo, por eje: chmod 777 archivo o chmod 000 archivo.

Eje: 704 111 000 100

rwx --- r--

Los archivos están ordenados en una tabla de archivos donde se guarda su inodo, sus permisos, nombre, dueño, fecha de creación, etc, etc.

Tipos de rutas para moverse en el file system
La ruta absoluta comienza con / el cual ubica la raíz y desde allí se debe especificar la dirección.
La ruta relativa es relativa a la carpeta actual:
por ejemplo dada esta estructura(ruta absoluta): /home/joaquin/jojojo, y nos ubicamos en home.
Para acceder a jojojo seria: ../home/joaquin/../joaquin/jojojo o simplemente joaquin/jojojo.

Comandos:
orden o acción(verbo infinitivo) copiar, pegar, zipear, mover, enlazar, crear, borrar, etc.
Ejecución de un comando:
$(prompt) [comando] [opciones] [argumentos]

Comando ls (list -listado, lista de archivos y directorios)
ls -l / (listar los archivos y directorios de raíz (/))
drwxrwxrwx 15 root grupo tamaño date nombre
el primer carácter es da el tipo: d(directory) -(archivo) b(archivo de bloque) l(linkeado enlazado) p(tubería pipe) f(buffer).
El segundo campo es de los permisos Dueño Grupo Otros.
Tercer campo contador de enlaces.
Cuarto campo dueño.
Quinto campo tamaño.
Sexto fecha de creación.
Séptimo nombre de archivo.
(Esto varia en la consola donde los campos están divididos por espacios en blanco)
$ ls -l (Listado extendido, todos los atributos menos el i-nodo)
$ ls -i (Listado de archivos con nombre y numero de i-nodo)
$ls -li (combinación de ambos)
$ls (solo nombres de archivo)

Archivo:Conjunto de registros que pertenecen a la misma aplicación, Registro: Conjunto de campos el campo es indivisible.
Los archivos en Linux se identifican con numero de i-nodo, es único y es el medio por el que el SO lo accede, el nombre es simbólico y sirve para resolver la interacción con el usuario a quien le resulta mas fácil trabajar con una estructura de directorios y archivos con nombre que con miles de números de i-nodo.
Cada archivo tiene una tabla con las características del archivo, es accedido por el numero de i-nodo.

Operación con archivos:
Crear archivos de datos:
Se realiza con el comando cat que es una llamada a ingreso por teclado mas le operador de asignación > que es quien crea el archivo.
Ejemplo:
$cat > nombredearchivo
Esto da una apertura para el ingreso por teclado que se guardara en nombedearchivo.
Pero el que crea el archivo es mas bien > por ejemplo esta orden:
$ls -l /bin > nombre
Guarda lo devuelto por ls -l /bin en nombre.

Crear directorios:
Se realiza con el comando mkdir(make directory)
$mkdir pruebas
crea el directorio pruebas en el directorio actual.
$mkdir /borrar
crea el directorio borrar en la raíz del SO.

Borrar archivos:
Se borran con el comando rm seguido por el/los nombres de archivo.
Ejemplo:
$rm jojojo

Borrar Directorios:
Se borran con el comando rmdir seguido por el/los nombre de comando.
Ejemplo:
$rmdir /borrar
Borramos el directorio creado en el ejemplo de creación de directorios.


Concatenar archivos:
Se hace un cat concatenando dos archivos hacia uno nuevo.
Los operadores de asignación > borran el contenido anterior del archivo mientras que el >> agrega.
$cat [archivo1] [archivo2] > [nuevoarchivooviejo]

Copiar archivos:
El comando es cp(copy) archivo de origen y archivo de destino.
Se crean dos archivos físicos con distinto i-nodo.
$cp jojojo jajaja

Mover o renombrar archivos:
El comando es mv [archivodeorigen] [archivodestino]
Lo hace es cambiar el nombre del archivodeorigen por otro pero sigue manteniendo el nuero de i-nodo y archivo físico, en la tabla de archivos solamente modifica ubicación y nombre.
$mv jojojo jijiji

Redireccionar:
Es el caso de > y >>, todos los comandos salen por pantalla salvo que se le indique una asignación con > o >>, por ejemplo
$ls -l bin > comandosdelsistema
Enlazar Linkear:
Enlazar o linkear un archivo es una manera de compartirlo con varios usuarios y directorios, los enlaces son “punteros”.
Los comandos que se usan son:
$ln -d enlace duro
$ln -s enlace simbólico
$ln -f hacia archivo existente//no estoy seguro

$ln [opcion] [archivoorigen] [archivodestino]

Tipos de enlaces:
Duro o Hard Link:
- Se usa para trabajar en el mismo File System y el mismo volumen de disco.
- Existe un solo archivo físico, un único numero de i-nodo.

- Este enlace permite que el archivo enlazado figure en varios directorios y con distintos nombres y el mismo i-nodo.

- El contador de enlaces se incrementa en 1 cada vez que el archivo se enlaza.
- Si uno de los enlaces es modificado, todos son modificados por que es un único archivo físico.
- El archivo físico no se borrara hasta que el contador de enlaces sea igual a 1.
Simbólico o Simbolic Link(Accesos Directos):
- Se usa para trabajar en distintos File Systems y en distintos volúmenes de disco, remotos inclusive.
- Los enlaces tienen distintos i-nodos y nombre.
- Existen varios archivos físicos pero solo contienen la ruta física al principal.
- El archivo enlazado puede borrarse aunque el contador de enlaces sea distinto de 1 y los enlaces quedan apuntando a una dirección inexistente.

Respaldar Archivos:
Respaldar o generar una copia de seguridad, backup.
El comando que se utiliza es tar(tape archive, viene de las cintas “tape” que se usaban antes).
$tar [opcion1] [opcion2] [opcion3] [archi.tar] [archivo1] ... [archivon]
La primera opcion indica que se desea hacer [c] crea los archivos, [x] extrae archivos guardados en un .tar, [t] muestra los archivos incluidos en un .tar.
La segunda opcion es [v] imprime por pantalla los archivos respaldados.
La tercera opcion [f] indica que el primer argumento será el nombre del archivo respaldado.
Ejemplos:
$ls -l /bin > comandos
$ls -l /dev > drivers
$ls -l /proc > procesos
$ls-l
$tar cvf backup.tar comandos drivers procesos

//Allí se crea un respaldo backup.tar de los archivos.

$ls -l

$tar tvf backup.tar
//Se ven los archivos respaldados
$tar xvf backup.tar
//Se extraen los archivos respaldados


Compresión de Archivos:
Comprimir un archivo es codificar de manera que el archivo ocupe menos espacio en el disco y tambien para que sea mas fácil de transmitir por la red, juntando varios archivos en 1.
Hay dos comandos compress y gzip. Gzip destruye los archivos comprimidos.
Con compress:
$compress -3 [archivo]
Cuando se comprime un archivo de establece un grado de compresion que va desde -1 hasta -9 siendo -9 el mas comprimido y mas lento(no me acuerdo si es así) por defecto sin opcion bash asume que es -6.
$uncompress [archivo.z]
Descomprime un archivo comprimido con compress. Descomprime .z.
Con gzip:
$gzip -1 [archivo]
Se comprime un archivo y se elimina el original.
$gunzip [archivo.gz]
Descomprime un archivo.gz comprimido con gzip, eliminando el archivo .gz.
Ambas compresiones se pueden ver con $zcat [nombrearchivo]

División de Archivos:
Se trata de dividir un archivo en n cantidad de partes que son iguales menos el ultimo archivo que contiene el resto de la división, juaz.
$split [-lineas] [archivoadividir] [nombredearchivos]
Si no se selecciona un nombre de archivo de salida se va desde aa hasta zz, de lo contrario seria desde nombrearchivosaa hasta nombrearchivoszz.
Se concatenan con cat, el mismo de concatenación obv.
$cat [nombrearchivos*] > [archivoconcatenado]

Comparacion de archivos:
La comparacion sirve para mostrar las lineas o registros diferentes, si no hay salida es por que los archivos son iguales, los comandos son diff y cmp, si hay diferencia muestra la línea y el archivo donde la encontró.
$diff archivo1 archivo2 (compara archivos de texto)
$cmp archivo1 archivo2 (compara cualquier tipo de archivo y es mas lento)
la opcion -b ignora los espacios en blanco y los márgenes en la comparacion diff

Filtrado de archivos:
grep sirve para buscar cadenas de caracteres en un archivo, se usa poniendo el patrón primero y el archivo después:
$grep hola jojojo
//busca la palabra hola en el archivo jojojo
Las salida muestra todas las lineas donde se encontró la cadena, además se pueden especificar las siguientes opciones de comando:
-n además de las lineas muestra el numero de línea.
-v invierte la búsqueda, es decir muestra todas las lineas donde no se encuentra el patrón.
-y no discrimina mayúsculas y minúsculas, quita el case sensitive.
El operador * en la cadena sirve para prolongar la aparición de un carácter en vez de poner aaa se pone a*, el operador .* es para encontrar cualquier cadena que contenga a la primera.

Búsqueda de archivos:
Sirve para buscar archivos adentro de los directorios o del File System en conjunto:
la sintaxis es $find pathname -opciones argumentos
Se pueden especificar varios directorios ejemplo:
$find /bin /dev /proc -name 'ls'
Se busca en los tres directorios archivos que se llamen ls, esta orden devuelve un listado con las rutas absolutas de los archivos encontrados. Se puede usar el operador * para buscar todos los archivos que contengan ls.
Ademas se pueden especificar varias opciones al mismo tiempo -name '*ls*' -name '*.z', esto buscaria archivos que contengan 'ls' y terminen en '.z'
Otra opcion además del nombre es buscar por fechas en donde se indica la cantidad de días desde la creación o modificación del archivo -atime 5, se piden los archivos modificados o creados en los últimos 5 días.
Otras opciones: -type (f, d, b, c, l, p) busca distintos tipos de archivos por ejemplo
$find /bin -type d busca directorios adentro de /bin.
-inum 236523, busca todos los archivos con i-nod igual a 236523 o sea el original y todos los que lo enlazan.
-newer busca archivos modificados después de la fecha de modificación de otro:
$find /bin -newer /home/joaquin/jojojo.tar, lista todos los archivos modificados después de la creación de jojojo.tar.
-level sirve para especificar hasta donde va la búsqueda, nivel en la jerarquía, por ejemplo -level o busca solamente en el directorio indicado pero -level 1 busca en los siguientes subdirectorios.
-size +3000 -size -2000 archivos que tengan mas de 3000 y menos de 2000 bloques.
-mtime +10 busca archivos modificados hace mas de 10 días.

Ordenar Archivos:
Sirve para ordenar los registros de un archivo y no destruye el archivo original, de esta manera podemos tener una salida por pantalla redireccionable a otro archivo.
El comando es sort, las opciones son:
-r ordena los registros en forma descendente.
-n ordena numéricamente

-u ordena y elimina registros idénticos

-nr orden numérico descendente(combinación)
La forma es:
$sort -k2n archivo > archivoordenado
En ese caso se ordena numéricamente el campo numero 2(la división de campos es por espacios) y se envía la salida al archivoordenado.
$sort -k9nru archivo > archivoordenado

Lo mismo pero en el orden contrario.
Un ejemplo con tuberías:
$ls -l /dev | sort -k9r > devordenado
Lista /dev lo ordena y lo guarda.

Contar Registros, Palabra o Caracteres:
El comando es wc, sintaxis $wc [-opcion] [archivo]
-l lineas del archivo

-w palabras(cadenas separadas por espacios en blanco)
-c caracteres.
$who | wc -l
Esto cuenta los usuario conectados al sistema, ya que who devuelve en lineas los usuarios y wc -l cuenta la cantidad de lineas.

Mostrar Contenido de Archivos:
Son varios comandos:
cat = muestra el contenido del archivo.

more = muestra el archivo en forma paginada
con la opcion more -15 se especifica la cantidad de lineas por pagina

less = muestra el archivo igual que more.

more y less muestran el archivo pero less lo hace de una manera mas practica, en ambos las opciones para ver son:
barra espaciadora: avanza pagina

tecla q: cierra el programa more y less.
Tecla s o Enter: avanza una línea, less lo hace con las flechas.

/patrón: búsqueda de una palabra en el archivo.
Tecla b: retrocede una pagina.
-?patrón: búsqueda hacia atrás solamente en less.
Tecla f: avanza una pagina entera en more.


head muestra las lineas altas de un archivo, la cantidad de lineas se especifican con -numero igual que en more.
tail hace lo mismo que head pero con las lineas de cola o inferiores.

Tuberías Pipe |:
El operador | sirve para concatenar varias ordenes o comandos como por ejemplo: $who | wc -l o tambien $ls -l /dev | sort -k9r > devordenado
En esos casos las salidas de comandos como who o ls son conectadas con las entradas que deberían recibir los comandos wc y sort respectivamente, Linux permite todas las redirecciones que se deseen.
Ademas con el operador tee se puede hacer una bifurcación enviando el resultado por ejemplo hacia un archivo y hacia la consola.

viernes 8 de mayo de 2009

No a la minería Cangrejillos Jujuy Argentina

Hace un año desde otro blog me ponía en campaña, junto con varios cientos de personas que lo hacían desde otros medios, para parar una explotación minera a cielo abierto en el Valle de Traslasierra, Traslasierra es de donde vengo y puse todas mis conocimientos a favor de esta causa, pero no fui el único al mismo tiempo y antes que yo se ponían en acción distintas organizaciones como escuelas, municipios, asociaciones de vecinos, cámaras de empresarios y habitantes Traslasierra.. El movimiento llego finalmente a la capital de la provincia en una caravana a presentar un proyecto de ley que prohibiera este tipo de explotaciones mineras tan destructivas.
La provincia accedió y se dio marcha atrás en un emprendimiento que casi le cuesta el principal recurso turístico de Córdoba, Las Sierras Grandes.
Para mas informacion sobre este acontecimiento podes visitar el blog en cuestión: http://trasla.blogspot.com/ y quizas hallas leído la cadena que de allí salió y aun sigue dando la vuelta al mundo vía correo electrónico.
Movilizar estos recursos en pos de una causa justo tiene su total recompensa.
En este momento la Comunidad del pueblo de Cangrejillos necesita la ayuda de todos para detener un proyecto minero que amenaza la ecología y los recursos del pueblo.
La provincia pretende un proyecto minero que abarcara entre muchas cosas la explotación de zonas de valor histórico y arqueológico y la destrucción del poblado en su emplazamiento actual. Siendo que la constitucion nacional prohíbe este tipo de intrusiones en comunidades.

Extracto de http://www.biodiversidadla.org/content/view/full/49048

La Comisión Directiva de la Comunidad Aborigen de Cangrejillos, el 25 de julio de 2008, por mandato de asamblea, cumplió en expresar e informar a la autoridades provinciales, mediante una Ordenanza Municipal, su rechazo de manera categórica y en todos sus términos los informes de impacto ambiental para la etapa de exploración y cateo dentro de su territorio comunitario. La Comunidad de Cangrejillos se vio directamente amenazada, debido a que la futura explotación abarcaría casi la totalidad del área urbana de dicha comunidad. Además en el informe de impacto ambiental no se reconocían los sitios arqueológicos prehispánicos existentes en ese territorio.

Mediante asamblea concluyeron que las actividades mineras están en oposición con la forma ancestral del trabajo de la tierra y el cuidado de los recursos naturales, que se llevan en a cabo en Cangrejillos. La empresa llegó a realizar algunos cateos, sin siquiera disponer de los permiso legales, produciendo enormes pozos que pusieron en riesgo a la ganadería del lugar, con reiterados accidentes.

A pesar de la Ordenanza emitida, las denuncias realizadas y al rechazo de los informes de impacto ambiental, la justicia no les ha dado ninguna respuesta formal hasta el momento.

Como ayudamos a esta comunidad a solucionar el problema:
Lo primero es difundir la noticia entre tus conocidos y no conocidos para que llegue a todas las personas posibles.
Lo segundo seria dirigirte al medio de comunicación que habitualmente utilices, por ejemplo si escuchas la Radio Cadena 3, podes enviar un mensaje con la problemática al 44443. La idea es movilizar el cuarto poder que es el que de verdad hace temblar a los poderosos.
Finalmente tambien podemos comunicarnos con la Comunidad Aborigen de Cangrejillos quienes deben coordinar de alguna manera los esfuerzos de todos para que esto se solucione:

Nélida Tolay 0388 154-771-188
(Delegada de la Comunidad de Cangrejillos- Movim. Tupaj Katari; area pueblos originarios)

Marcela Chambi 0388 154-861-125
(Movim. Tupaj Katari, comisión ecología y medio ambiente)

Elbio Cabrera 0388 154339204 (Movim. Tupaj Katari; area pueblos originarios)
elbiocabrera(arroba)hotmail.com

Silvana Morel 0388 154045044 (Movim. Tupaj Katari, abogada de la comunidad de Cangrejillos)- silvanamorel(arroba)hotmail.com

Programa de Practica en Java - Juegos


Así quedo terminado este programa de practica en java, les dejo el código fuente, para seguir modificándolo pueden usar el Easy Eclipse
package modelo
Class Pelota.java

package modelo;
import javax.swing.JButton;
public class Pelota extends Thread {
    private JButton pelota;
    private int x;
    private int y;
    private Control activo;
    private boolean arriba, derecha;
    private int aceleracion;
    private Tiempo time;
    public Pelota(int x, int y,JButton pelota ,Control activo, int acele, Tiempo time)
    {
        this.x=x;
        this.y=y;
        this.pelota=pelota;
        this.activo=activo;
        arriba=false;
        derecha=true;
        this.aceleracion=acele;
        this.time=time;
    }
    public void run()
    {
        while(activo.getControl()&&time.getOk())
        {
            pelota.setLocation(x, y);
            if(arriba)
            {
                y=y-aceleracion;
            }
            else
            {
                y=y+aceleracion;
            }
            if(derecha)
            {
                x=x+aceleracion;
            }
            else
            {
                x=x-aceleracion;
            }
            if(x<3)
            {
                derecha=true;
            }
            if(x>700)
            {
                derecha=false;
            }
            if(y>300)
            {
                arriba=true;
            }
            if(y<3)
            {
                arriba=false;
            }
            try{
                sleep(10);
            }
            catch(Exception e)
            {
            }
            time.disminuye();
        }
    }
}

Class ControlTiempo.java

package modelo;
import javax.swing.JLabel;
public class ControlTiempo extends Thread {
    private Tiempo t;
    private JLabel l;
    public ControlTiempo(Tiempo t, JLabel l)
    {
        this.t=t;
        this.l=l;
    }
    public void run()
    {
        while(t.getTiempo()>0)
        {
            l.setText(String.valueOf(t.getTiempo()));
            try{
                sleep(200);
            }
            catch(Exception error)
            {
            }
        }
    }
}

Class Tiempo.java

package modelo;
public class Tiempo {
    private boolean ok;
    private int tiempo;
    public Tiempo()
    {
        ok=true;
        tiempo=10000;
    }
    public void setOk(boolean x)
    {
        ok=x;
    }
    public boolean getOk()
    {
        return ok;
    }
    public int getTiempo()
    {
        return tiempo;
    }
    public void setTiempo(int t)
    {
        this.tiempo=t;
    }
    public void disminuye()
    {
        tiempo--;
        if(tiempo==0)
        ok=false;
    }
    public void rotate()
    {
        if(ok)
        ok=false;
        else
        ok=true;
    }
}

Class Control.java

package modelo;
public class Control {
    boolean control;
    public Control()
    {
        control=true;
    }
    public void setControl(boolean x)
    {
        control=x;
    }
    public boolean getControl()
    {
        return control;
    }
    public void rotate()
    {
        if(control)
        control=false;
        else
        control=true;
    }
}

package visual
Class Pong.java

package visual;
import javax.swing.SwingUtilities;
import java.awt.BorderLayout;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.Dimension;
import javax.swing.JLabel;
import java.awt.Rectangle;
import java.awt.Color;
import javax.swing.JButton;
import modelo.Control;
import modelo.Pelota;
import modelo.Tiempo;
import modelo.ControlTiempo;
public class Pong extends JFrame {
    private static final long serialVersionUID = 1L;
    private JPanel jContentPane = null;
    private JButton JbPlay = null;
    private Control z1;
    private Control z2;
    private Control z3;
    private Control z4;
    private Control z5;
    private Pelota j1;
    private Pelota j2;
    private Pelota j3;
    private Pelota j4;
    private Pelota j5;
    private JButton JB1 = null;
    private JButton JB2 = null;
    private JButton JB3 = null;
    private JButton JB4 = null;
    private JButton JB5 = null;
    private JLabel jLabel = null;
    private JLabel Nivel = null;
    private JLabel JLnivel = null;
    private int nivel;
    private Tiempo time;
    private JLabel jltiempo = null;
    private JLabel Tiempo = null;
    private JLabel jlpuntaje = null;
    private JLabel Puntaje = null;
    private ControlTiempo t;
    private int puntaje;
    private JButton getJbPlay() {
        if (JbPlay == null) {
            JbPlay = new JButton();
            JbPlay.setBounds(new Rectangle(10, 466, 98, 19));
            JbPlay.setText("Play");
            JbPlay.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    nivel++;
                    time = new Tiempo();
                    t= new ControlTiempo(time, Tiempo);
                    z1=new Control();
                    z2=new Control();
                    z3=new Control();
                    z4=new Control();
                    z5=new Control();
                    j1 = new Pelota(JB1.getX(),JB1.getY(),JB1, z1,nivel, time);
                    j2 = new Pelota(JB2.getX(),JB2.getY(),JB2, z2,nivel+1, time);
                    j3 = new Pelota(JB3.getX(),JB3.getY(),JB3, z3,nivel+2, time);
                    j4 = new Pelota(JB4.getX(),JB4.getY(),JB4, z4,nivel+3, time);
                    j5 = new Pelota(JB5.getX(),JB5.getY(),JB5, z5,nivel+4, time);
                    t.start();
                    j1.start();
                    j2.start();
                    j3.start();
                    j4.start();
                    j5.start();
                    Nivel.setText(String.valueOf(nivel));
                }
            });
        }
        return JbPlay;
    }
    private JButton getJB1() {
        if (JB1 == null) {
            JB1 = new JButton();
            JB1.setBounds(new Rectangle(268, 28, 67, 57));
            JB1.setText("1");
            JB1.setBackground(new Color(0, 51, 204));
            JB1.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    z1.setControl(false);
                    Puntaje();
                }
            });
        }
        return JB1;
    }
    private JButton getJB2() {
        if (JB2 == null) {
            JB2 = new JButton();
            JB2.setBounds(new Rectangle(112, 154, 82, 91));
            JB2.setText("2");
            JB2.setBackground(Color.yellow);
            JB2.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    z2.setControl(false);
                    Puntaje();
                }
            });
        }
        return JB2;
    }
    private JButton getJB3() {
        if (JB3 == null) {
            JB3 = new JButton();
            JB3.setBounds(new Rectangle(247, 139, 95, 93));
            JB3.setText("3");
            JB3.setBackground(new Color(0, 204, 255));
            JB3.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    z3.setControl(false);
                    Puntaje();
                }
            });
        }
        return JB3;
    }
    private JButton getJB4() {
        if (JB4 == null) {
            JB4 = new JButton();
            JB4.setBounds(new Rectangle(465, 137, 96, 127));
            JB4.setText("4");
            JB4.setBackground(new Color(51, 255, 0));
            JB4.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    z4.setControl(false);
                    Puntaje();
                }
            });
        }
        return JB4;
    }
    private JButton getJB5() {
        if (JB5 == null) {
            JB5 = new JButton();
            JB5.setBounds(new Rectangle(457, 34, 137, 163));
            JB5.setText("5");
            JB5.setBackground(new Color(255, 51, 51));
            JB5.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    z5.setControl(false);
                    Puntaje();
                }
            });
        }
        return JB5;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                Pong thisClass = new Pong();
                thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                thisClass.setVisible(true);
            }
        });
    }
    public Pong() {
        super();
        initialize();
    }
    private void initialize() {
        this.setSize(837, 539);
        this.setResizable(false);
        this.setContentPane(getJContentPane());
        this.setTitle("Pong");
        nivel = 0;
        puntaje = 0;
    }
    private JPanel getJContentPane() {
        if (jContentPane == null) {
            Puntaje = new JLabel();
            Puntaje.setBounds(new Rectangle(401, 466, 74, 19));
            Puntaje.setText("0");
            jlpuntaje = new JLabel();
            jlpuntaje.setBounds(new Rectangle(344, 466, 51, 19));
            jlpuntaje.setText("Puntaje:");
            Tiempo = new JLabel();
            Tiempo.setBounds(new Rectangle(279, 466, 62, 19));
            Tiempo.setText("10000");
            jltiempo = new JLabel();
            jltiempo.setBounds(new Rectangle(218, 466, 56, 19));
            jltiempo.setText("Tiempo:");
            jLabel = new JLabel();
            jLabel.setBounds(new Rectangle(10, 491, 329, 20));
            jLabel.setText("Hay que hacer clic sobre los cuadrados para pararlos");
            JLnivel = new JLabel();
            JLnivel.setBounds(new Rectangle(118, 466, 35, 19));
            JLnivel.setText("Nivel:");
            Nivel = new JLabel();
            Nivel.setBounds(new Rectangle(157, 466, 55, 19));
            Nivel.setText("1");
            jContentPane = new JPanel();
            jContentPane.setLayout(null);
            jContentPane.add(getJbPlay(), null);
            jContentPane.add(getJB1(), null);
            jContentPane.add(getJB2(), null);
            jContentPane.add(getJB3(), null);
            jContentPane.add(getJB4(), null);
            jContentPane.add(getJB5(), null);
            jContentPane.add(Nivel, null);
            jContentPane.add(JLnivel, null);
            jContentPane.add(jLabel, null);
            jContentPane.add(jltiempo, null);
            jContentPane.add(Tiempo, null);
            jContentPane.add(jlpuntaje, null);
            jContentPane.add(Puntaje, null);
        }
        return jContentPane;
    }
    public void Puntaje()
    {
        if(!z1.getControl()&&!z2.getControl()&&!z3.getControl()&&!z4.getControl()&&!z5.getControl())
        {
            puntaje+=time.getTiempo();
            time.setTiempo(0);
        }
        Puntaje.setText(String.valueOf(puntaje));
    }
}

Bueno, quería mostrarlo…

jueves 7 de mayo de 2009

Concurrencia en Java primer acercamiento a Swing

En la clase de ayer nos incentivaron a diseñar un programa que funcionara de la misma manera que el Pong, yo cuando me senté en mi PC, empecé a escribirlo pero a medida que lo hacia fui cambiando el objetivo, el resultado fue un programita sencillo con JButton de colores que se mueven rebotando por la pantalla y hay que hacerles clic para que se paren, se mueven a X pixeles cada 10 milésimas de segundo.
pongFue solamente para practicar un poco el tema de concurrencia así que no esperen que solucione todos los problemas que tiene. Tarde 1 hora.
Esencialmente el programa son tres clases una es un Boolean para control, hay clases que cumplen los requisitos actuales, no uso otra clase por la idea es que mas adelante esa clase cumpla con otros tipos de controles como el tiempo o las coordenadas.
La segunda clase es el Thread que mueve a los botones por la pantalla, para ello recibe en el constructor varias cosas: La referencia al JButton, un objeto Control, un par de coordenadas y la velocidad de movimiento del botón.
La ultima es una clase visual donde están instanciados los botones, los elementos Control y los Threads.
Lo que ocurre si presionamos varias veces el botón Play es que varios manejadores de botones toman el control del mismo entonces el botón empieza a saltar por la pantalla.
Probé lanzar hasta 500 Threads y no se colgó nada, además los últimos ya funcionaban a 100 pixeles cada 10 milésimas de segundo.
Este .jar esta desarrollado en Easy Eclipse y con sus plugins visuales, además las dos primeras clases se ubicaran en el paquete modelo y la visual en visual.
La primera Clase es Control y de ella creo que no hace falta explicar mucho:

package modelo;
public class Control {    
boolean control;    
public Control()
    {
        control=true;
    }    
public void setControl(boolean x)
    {
        control=x;
    }    
public boolean getControl()
    {
        return control;
    }    
public void rotate()
    {
        if(control)
        control=false;
        else
        control=true;
    }
}

La funcion rotate() por ahora no la utilizo para nada, La segunda clase es Pelota, la idea era desarrollar un Pong no?, eta es la que extiende de Thread así que será la mas importante me parece a mi:

package modelo;
import javax.swing.JButton;
public class Pelota extends Thread {
    JButton pelota;
    int x;
    int y;
    Control activo;
    boolean arriba, derecha;
    int aceleracion;
    public Pelota(int x, int y,JButton pelota ,Control activo, int acele)
    {
        this.x=x;
        this.y=y;
        this.pelota=pelota;
        this.activo=activo;
        arriba=false;
        derecha=true;
        this.aceleracion=acele;
    }
    public void run()
    {
        while(activo.getControl())
        {
            pelota.setLocation(x, y);
            if(arriba)
            {
                y=y-aceleracion;
            }
            else
            {
                y=y+aceleracion;
            }
            if(derecha)
            {
                x=x+aceleracion;
            }
            else
            {
                x=x-aceleracion;
            }
            if(x<3)
            {
                derecha=true;
            }
            if(x>700)
            {
                derecha=false;
            }
            if(y>300)
            {
                arriba=true;
            }
            if(y<3)
            {
                arriba=false;
            }
            try{
                sleep(10);
            }
            catch(Exception e)
            {
            }
        }
    }
}

Las claves de esta clase son solamente mover el objeto JButton que nos viene por parámetro mientras el otro objeto Control sea verdadero, este se cambiara desde otra clase así que no nos importa, ponemos un while que realice el movimiento.
Para ello definimos una velocidad-> aceleración(interpretando muy mal un concepto de física le he puesto aceleración como nombre cuando debería ser velocidad) que será el ++ o – – correspondiente para cada movimiento, las otras variables son derecha y arriba, ellas son booleanas y se cambian cuando el tercer grupo de variable las coordenadas sobrepasan ciertos limites.
Los objetos JButton se moverán en un rectángulo aproximado de 700 X 300 pixeles de la ventana, luego en la siguiente clase es donde diseñamos la parte visual.
Alli hay que crear una clase visual a partir de JFrame, deshabilitar el Layout y poner 5 botones de distintos tamaños y colores recordando colocar un nombre comprensible  a cada uno.
Por otro lado y llendo hacia el código debemos importar lo siguiente para no tener problemas, recordemos que esta clase estará en el paquete visual mientras que las dos primeras están en modelo.

import modelo.Control;
import modelo.Pelota;

Luego las variables que debemos crear en esta clase, además de las que el editor visual nos genera son:

private Control z1;
private Control z2;
private Control z3;
private Control z4;
private Control z5;
private Pelota j1;
private Pelota j2;
private Pelota j3;
private Pelota j4;
private Pelota j5;
private JButton JB1 = null;
private JButton JB2 = null;
private JButton JB3 = null;
private JButton JB4 = null;
private JButton JB5 = null;
private JLabel jLabel = null;
private JLabel Nivel = null;
private JLabel JLnivel = null;
private int nivel;

La variable nivel será la que nos proveerá la velocidad de cada botón en los distintos niveles, además hacemos un JLabel para indicar al jugador cual es el actual.
JB1, JB2, JB3, JB4, JB5 son lo botones creados por el editor visual, los objetos Control y Pelota son las banderas de movimiento y los manejadores de cada botón, además hay un botón Play que desencadenara todo el movimiento.
En el initialize de la ventana hay que agregar:

nivel = 0;
El botón Play: en ese botón debemos seleccionar un ActionPerformed que hará lo siguiente:
nivel++;
z1=new Control();
z2=new Control();
z3=new Control();
z4=new Control();
z5=new Control();
j1 = new Pelota(JB1.getX(),JB1.getY(),JB1, z1,nivel);
j2 = new Pelota(JB2.getX(),JB2.getY(),JB2, z2,nivel);
j3 = new Pelota(JB3.getX(),JB3.getY(),JB3, z3,nivel);
j4 = new Pelota(JB4.getX(),JB4.getY(),JB4, z4,nivel);
j5 = new Pelota(JB5.getX(),JB5.getY(),JB5, z5,nivel);
j1.start();
j2.start();
j3.start();
j4.start();
j5.start();
Nivel.setText(String.valueOf(nivel));

Al inicializar los objetos zX del tipo Control se inicializan todos en true Luego construimos los “Pelota” pasándole como parámetro las posiciones actuales de los botones, los botones, el objeto de Control correspondiente y el nivel que es compartido por todos.
Luego se da start a cada Thread(nunca run()) y todos los botones comienzan a moverse por la pantalla, por ultimo seteamos nuestra label de nivel que informara que llegamos al nivel 1 la primera vez.
Como para los botones?
Fácil, lo que hacemos es establece un ActionPerfomed para cada uno de los 5 botones BJ1, JB2 JBN y adentro la clase de escucha paramos el objeto de Control, o sea el zX correspondiente: para JB1 seria así:

z1.setControl(false);

Con ello ya tenemos el juego funcionando discretamente, como les comente arriba se pueden iniciar muchos manejadores del mismo botón y crea una especie de lluvia de colores en pantalla.
Si están empezando a programar en Java como yo les va a gustar jugar con esto.