AT&T

AT&T Inc.

Tipo	Pública
Fundación	1885
Sede	Bedminster, New Jersey
Administración	David Dorman (Principal Oficial Ejecutivo y Director)
Industria	Servicios de Comunicación
Productos	Servicios de banda ancha Telefonía móvil Seguridad por Internet Servicios de tecnología de información Voice over IP VPN
Empleados	61,600
Sitio web	www.att.com

Cabina telefónica de AT&T

La Corporación AT&T (siglas de su antiguo nombre, American Telephone and Telegraph; NYSE: AT&T) es una compañía estadounidense de telecomunicaciones. Provee servicios de voz, video, datos, e internet a negocios, clientes y agencias del gobierno. Durante su larga historia, AT&T ha sido, en ocasiones, la compañía telefónica más grande del mundo, el operador de televisión por cable más grande de los Estados Unidos, y hasta fue clasificado como un monopolio. A principios del 2005 se ven indicios de que pueda ser absorbida por SBC Communications.

Historia

La American Telephone and Telegraph Corporation (Corporación estadounidense de teléfono y telégrafo) comenzó con el propósito de manejar la primera red telefónica a larga distancia de los Estados Unidos (3 de marzo de 1885). Comenzando en Nueva York, la red se extendió a Chicago en 1892, y a San Francisco en 1915. Comenzó a proveer servicios transatlánticos en 1927 utilizando radios, ya que el primer cable telefónico submarino transatlántico no llegó hasta 1956.

La creación de la Bell Telephone Company fue consecuencia de un acuerdo entre Alexander Graham Bell y sus inversores, entre ellos Gardiner G. Hubbard y Thomas Sanders. Su nombre fue cambiado en varias ocasiones, y ya para 1880 se la conocía como la American Bell Telephone Company. Para 1881, la American Bell había comprado de parte de Western Union un interés mayoritario de la compañía Western Electric. Como dato interesante, tres años antes de que esto ocurriera, Western Union había rechazado una oferta de Gardiner Hubbard, en la cual les ofrecía los derechos sobre el teléfono por un coste de $100,000.

La patente de Bell sobre el teléfono expiró en 1894, pero la compañía logró "controlar" a la competencia por medio de demandas y corte de precios. El 30 de diciembre de 1899, la American Telephone and Telegraph Corporation compró los activos de American Bell, creando así un monopolio telefónico en los Estados Unidos. Fue conocido como el Sistema Bell debido a que Bell había adquirido en años anteriores distintas compañías a las que había otorgado licencias para producir equipo telefónico.

El mercado telefónico era bien competitivo en los comienzos del siglo 20. Durante este periodo, los oficiales de AT&T lanzaron varios rumores de que la compañía no se encontraba en buen estado; esto hizo que los inversores de las compañías contratadas por AT&T, por miedo a un colapso, vendieran sus acciones. Tras esto, AT&T compró estas acciones a un precio más barato, y pronto se convertió, a nivel nacional, en el proveedor principal de servicios telefónicos. En el 1907, Theodore Vail, presidente de AT&T, propuso que un monopolio formal sería lo más adecuado y eficiente. El gobierno de los Estados Unidos aceptó en un principio esta propuesta en 1913 por medio del Compromiso Kingsbury.

Durante la mayor parte del siglo 20, la subsidiaria de larga distancia de AT&T, AT&T Long Lines, disfrutó de un monopolio casi total de los servicios telefónicos a larga distancia en los Estados Unidos. AT&T también controlaba 22 Compañías Operativas Bell, las cuales eran proveedoras de servicio telefónico local a gran parte de los Estados Unidos. Aunque había otras "compañías telefónicas independientes", el Sistema Bell era la mayor de todas.

En 1925, AT&T creó una nueva unidad llamada Laboratorios Telefónicos Bell (Bell Labs). Esta unidad de desarrollo e investigación demostró ser exitosa al comenzar proyectos tales como la astronomía radial, el transistor, el sistema operativo Unix, y el lenguaje de programación C. Sin embargo, su compañía matriz no siempre se aprovechó de estos logros.

El monopolio telefónico finalizó el 8 de enero de 1982, cuando se resolvió una demanda de antimonopolio por parte del Departamento de Justicia de los Estados Unidos hacia AT&T (comenzada en 1974). Bajo este acuerdo, AT&T se separaría de sus compañías de servicios operativos locales. A cambio, se le permitió a AT&T entrar en el negocio de los ordenadores. Aunque el Departamento de la Defensa de los Estados Unidos no quería que AT&T fuera dividida, el 1 de enero de 1984, los servicios locales de AT&T fueron separados en siete Compañías Operativas Regionales Bell, independientes unas de otras, conocidas como "Baby Bells". El valor de AT&T se vio reducido por un 70%. La compañía continuó con su servicio de larga distancia, aunque perdió varios clientes en los años subsiguientes debido a la competencia de MCI y Sprint.

Después de que su intento de entrar al mercado informático fallara, en 1991 AT&T absorbió NCR Corporation, esperando generar beneficios en las áreas de redes UNIX y los ordenadores personales, pero no logró conseguir beneficios tecnológicos y financieros sustanciales tras la fusión. En 1996, NCR se separó de AT&T debido a una nueva ley de telecomunicaciones implantada en los Estados Unidos. Al mismo tiempo, los servicios de fabricación de equipos y los Laboratorios Bell de AT&T se convirtieron en Lucent Technologies (una nueva compañía independiente).

En 1997, AT&T contrató a Michael Armstrong, antiguo ejecutivo de IBM como principal oficial ejecutivo. La visión de Armstrong era convertir a AT&T, de un proveedor de larga distancia, a todo un supermercado global de las telecomunicaciones.

La estrategia más significativa de Armstrong fue comprar una gran cantidad de activos dentro del mercado de la televisión por cable. Después de adquirir TCI y Media One, AT&T se convirtió en el proveedor de televisión por cable más grande en los Estados Unidos.

En 1999 AT&T adquirió el Laboratorio de Investigaciones Olivetti & Oracle Research Lab, de Olivetti y Oracle Corporation. En 2002 finalizaron las labores de investigación en el laboratorio.

Con la reducción de costos de larga distancia y la debilidad del mercado de servicios de telecomunicaciones a finales del siglo pasado, AT&T no pudo aguantar todas las deudas que provocaron sus distintas inversiones en otros mercados. Debido a esto, la compañía se reorganizó en octubre de 2000, moviendo sus unidades de telefonía móvil y banda ancha a secciones independientes, de manera que pudieran levantar por su cuenta el capital necesario para las operaciones diarias.

Durante el año 2001, AT&T se separó por completo de los servicios de telefonía móvil y banda ancha, creando así tres nuevas compañías independientes AT&T Wireless, AT&T Broadband y Liberty Media. En el año 2002, Comcast Communications Corporation adquirió AT&T Broadband, y en 2004 AT&T Wireless se fusionó con Cingular Wireless.

C++

El C++ es un lenguaje de programación, diseñado a mediados de los años 1980, por Bjarne Stroustrup, como extensión del lenguaje de programación C.

Se puede decir que C++ es un lenguaje que abarca tres paradigmas de la programación: la programación estructurada, la programación genérica y la programación orientada a objetos.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los fabricantes de compiladores más modernos. Existen también algunos intérpretes como ROOT (enlace externo). Las principales características del C++ son el soporte para programación orientada a objetos y el soporte de plantillas o programación genérica (templates).

Además posee una serie de propiedades difíciles de encontrar en otros lenguajes de alto nivel:

• Posibilidad de redefinir los operadores (sobrecarga de operadores)
• Identificación de tipos en tiempo de ejecución (RTTI)

C++ está considerado por muchos como el lenguaje más potente, debido a que permite trabajar tanto a alto como a bajo nivel, sin embargo es a su vez uno de los que menos automatismos trae (obliga a hacerlo casi todo manualmente al igual que C) lo que "dificulta" mucho su aprendizaje.

El nombre C++ fue propuesto por Rick Masciatti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

• Clase: Es una plantilla que define la estructura de un conjunto de objetos, que al ser creados se llamarán las instancias de la clase. Esta estructura está compuesta por la definición de los atributos y la implementación de las operaciones ( métodos ).
• Objeto: Es la implementacion de una instancia de clase, es decir, una ocurrencia de esta, que tiene los atributos definidos por la clase, y sobre la que se puede ejecutar las operaciones definidas en ella.
• Identidad: Característica de cada objeto que lo diferencia de los demás, incluyendo de aquellos que pudieran pertenecer a la misma clase y tener los mismos valores en sus atributos.
• Herencia: Es la capacidad que tienen las clases para heredar propiedades y métodos de otras clases.

Paradigma:	multiparadigma: orientado a objetos, imperativo, programación genérica.
Apareció en:	1985
Diseñado por:	Bjarne Stroustrup
Tipo de dato:	fuerte, estático
Implementaciones:	GNU Compiler Collection, Microsoft Visual C++, Borland C++ Builder, Dev-C++, C-Free
Dialectos:	ISO C++, ANSI C++ 1998, ANSI C++ 2003
Influido por:	C, Simula
Ha influido:	Ada, C#, Java, PHP, D

Diagramas sintacticos

Diagramas de Control y Flujo.

En este grupo, los distintos tipos de línea empleados en los diagramas sintácticos tienen el siguiente significado:

• La ausencia de líneas señala la omisión de delimitadores.
• ------- Una línea simple denota la presencia de ninguno, uno o más delimitadores.

Con el fin de no hacer demasiado complicados los diagramas se ha optado por simplemente indicar la ausencia o presencia de delimitadores. La omisión de éstos es aplicable únicamente cuando no hay ambigüedades o problemas de reconocimiento.

Clase Sintáctica	Descripción
Instrucciones	+<-------------------------------+ | | >---->+-->+----------------------->+-->+---->> | | +---> Operaciones ---->+ | | +---> Estructuras ---->+
Estructuras	>-------+---> Estructuras de Decisión ---->+-------->> | | +---> Estructuras Cíclicas ---->+
Estructuras de Decisión	>-------+---> Sencilla ---->+-------->> | | +---> Múltiple ---->+
Sencilla	>-> IF -> Operaciones -> THEN -> Instrucciones -->+ | +<---------------------------+ | +-> ELSE -> Instrucciones -+ | | +------------------------->+> END ->>
Múltiple	>-> CHOOSE ->+-> ONE ->+ | | +-> ALL ->+<-----------------------------+ | | +-> OPTION -> Operaciones -+ | | | +<---------------------------+ | | | +-> THEN -> Instrucciones -->+-->+ | +<---------------------------+ | +-> ELSE -> Instrucciones -+ | | +------------------------->+> END ->>
Estructuras Cíclicas	>-------->+--------> Prestablecida ------->+------>> | | +--------> Precondicional ------->+ | | +--------> Postcondicional ------->+
Prestablecida	>--> FOR --> Inhibidor Nombre --> DO --+ | +------------+ | +--> Instrucciones --> END -->>
Precondicional	>---> WHILE ---> Operaciones ---> DO --+ | +------------+ | +--> Instrucciones --> END -->>
Postcondicional	>--> REPEAT --> Instrucciones --> UNTIL --+ | +---------------+ | +--> Operaciones --> END -->>
Operaciones	+<------------------------------------------+ | | >-+--+--> Operador ---->+--+----->> | | +--> Operación de Pila ---->+ | | +--> Función de Pila ---->+ | | +--> Función Matemática ---->+ | | +--> Objeto de Pila ---->+ | | +--> Operación de E/S ---->+ | | +--> Procedimiento ---->+ | | +--> Arreglo ---->+ | | +--> Variable ---->+ | | +--> Operación de Evaluación ---->+ | | +--> Operación de Transformación ---->+ | | +--> Operación de Asignación ---->+
Operador Ternario	>-------------> ? -------------->>
Operación de Pila	>-----------+--> Operación ---->+-------->> | Básica de Pila | | | | Operación | +--> Generalizada ---->+ | de Pila | | | | Operación | +--> Indirecta ---->+ en Pila
Operación Básica de Pila	>--------+---> PUSH ---->+-------->> | | +---> DROP ---->+ | | +---> ROTATE ---->+ | | +---> REVOLVE ---->+ | | +---> SWAP ---->+ | | +---> OVER ---->+ | | +---> BELOW ---->+
Operación Generalizada de Pila	>--------+---> DUPLICATE ----->+---------->> | | | +--> UP -->+ +---> ROLL ->+ | | +-> DOWN ->+ | | +---> PICK ----->+ | | +---> INSERT ----->+ | | +---> CLEAR ----->+ | | +---> INTERCHANGE ----->+
Operación Indirecta de Pila	Operación >-------> INDIRECT -------> Generalizada ---->> de Pila
Función de Pila	>---------+---> SIZE ---->+-------->> | | +---> TOP ---->+ | | +---> TYPE ---->+
Objeto de Pila	>---------+---> Escalar ---->+-------->> | | +---> Objeto ---->+ Inhibido
Operador	>---------+---> Operador Aritmético ---->+-------->> | | +---> Operador Lógico ---->+ | | +---> Operador Relacional ---->+ | | +---> Operador Ternario ---->+
Operador Aritmético	>---------+---> + ---->+-------->> | | +---> - ---->+ | | +---> * ---->+ | | +---> / ---->+ | | +---> \ ---->+ | | +---> ^ ---->+ | | +---> % ---->+ | | +---> ! ---->+
Operador Lógico	>---------+---> & ---->+-------->> | | +---> | ---->+ | | +---> ~ ---->+
Operador Relacional	>---------+---> < ---->+-------->> | | +---> = ---->+ | | +---> > ---->+ | | +---> <= ---->+ | | +---> => ---->+ | | +---> >< ---->+
Función Matemática	>---------+---> CHS ---->+-------->> | | +---> SGN ---->+ | | +---> LN ---->+ | | +---> EXP ---->+ | | +---> SIN ---->+ | | +---> COS ---->+ | | +---> TAN ---->+ | | +---> SQRT ---->+ | | +---> RAND ---->+
Operación de E/S	>--------+---> ENTER ---->+-------->> | | +---> ENTRY ---->+ | | +---> POP ---->+ | | +---> OPEN ---->+ | | +---> CLOSE ---->+ | | +---> RECOVER ---->+ | | +---> ARCHIVE ---->+
Operación de Evaluación	>-----------> EVALUATE ------------>>
Operación de Transformación	>-----------> TRANSFORM ------------>>
Operación de Asignación	>-------------> STORE -------------->>
Escalar	>---------+---> ENTERO ---->+-------->> | | +---> REAL ---->+ | | +---> BINARIO ---->+ | | +---> CADENA ---->+
Arreglo	>---> Nombre ( ---+----------------------------+-> ) --->> | | +-+-> Expresión Postfija -+->+ | | +<--------- , ----------+
Procedimiento	>-+-> Nombre --------------------------------------->+--->> | | +-> Nombre { ->+--------------------------->+-> }->+ | | +-+-> Expresión Postfija -+->+ | | +<--------- , ----------+
Variable	>---------> Nombre ------------>>
Expresión Postfija	>---------> Operaciones ------------>>
Operador de Inhibición	>-------------> ' -------------->>
Objeto Inhibido	>--> Inhibidor -+--> Escalar -->+-------->> | | +--> Operador -->+ | | +--> Función de -->+ | Pila | | | +--> Función -->+ | Matemática | | | +--> Operación de -->+ | Asignación | | | +--> Procedimiento -->+ | | +--> Arreglo -->+ | | +--> Variable -->+ | | +--> Operación -->+ | de E/S | | | +--> Operación -->+ | de Pila | | | +--> Operación de -->+ | Evaluación | | | +--> Operación de -->+ Transformación
Comentario de Línea	>-----> ; -----> Texto -----> Fin de Línea ---->>
Comentario de Bloque	>-----> Marca -----> Texto -----> Marca ---->>
Marca	>-------------------> ## ---------------->>

palbras reservadas

Este es el listado de algunas de las palabras reservadas, es decir aquellas que no puedes usar para darle el nombre a las variables o constantes que vayas a definir:

AND, ARRAY, BEGIN, CASE, CONST, DIV, DO, DOWNTO, ELSE, END, FILE, FOR, FORWARD, FUNCTION, GOTO, IF, IN, LABEL, MOD, NIL, NOT, OF, OR, PACKED, PROCEDURE, PROGRAM, RECORD, REPEAT, SET, THEN, TO, TYPE, UNTIL, VAR, WHILE, WITH, ABSOLUTE, ASM, DESTRUCTOR, IMPLEMENTATION, INTERFACE, OBJECT, PRIVATE, SHR, UNIT, VIRTUAL, CONSTRUCTOR, EXTERNAL, INLINE, INTERRUPT, SHL, STRING, USES, XOR.

Tampoco se pueden usar nombres de procedimientos o funciones incluidas en Turbo Pascal, por ejemplo : circle, random, settime, entre otros.

Case sensitive

Case sensitive es una expresión informática que hace referencia a la propiedad de un texto para presentarse en mayúsculas o en minúsculas.

Se dice que un texto es 'case sensitive' si distingue mayúsculas de minúsculas, por ejemplo los Sistemas Operativos basados en UNIX en los que un texto escrito en mayúsculas es totalmente diferente a uno escrito en minúsculas. Contrariamente, se dice que el texto es 'Case insensitive' si no distingue mayúsculas de minúsculas.

A nivel máquina, cada letra del alfabeto está representada por un conjunto de dígitos binarios que corresponden al Código ASCII de dicha letra, de modo que una cadena de texto no es otra cosa que un vector de datos numéricos conteniendo cada ASCII de cada caracter.

Mientras que A=65 y D=68, a=97 y d=100.

Para procesar un texto en modo case sensitive basta con hacer una comparación bit a bit del texto en cuestión, haciendo esto, la comparación de "A" y "a" será comparar 65 y 97, regresando un resultado negativo.

El procesamiento de un case insensitive consiste en una sencilla operación con los bits del entero que representa el código de cada caracter. Tenemos que:

char	int	bin
A	65	1000001
a	97	1100001
---	---	-------------
D	68	1000100
d	100	1100100

Como puede observarse, la diferencia entre el código binario de una letra mayúscula y una minúscula es el segundo valor de izquierda a derecha y el sexto de derecha a izquierda, esto se debe a que la diferencia entre los valores mayúscula/minúscula es de 32 y el rango de caracteres ASCII termina en 127 (1111111 en binario) que es =(2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^1 + 2^0). Aquel 1 que hace la diferencia está en la sexta posición, es por ello que equivale a 2^5 (se cuenta partiendo de 2^0) equivaliendo a 32. Para mostrar más claramente esto, mostraremos que un byte relleno con los bits 0000000 pasaría a ser 0100000 si se le SUMARA un 32 desde el procesador.

Dejando despejado esto, terminaremos con que el proceso para comparar si dos caracteres de una cadena son iguales usando case insensitive se basa en ese principio. Las técnicas que se pueden usar son varias (la que se le ocurra y la que más le parezca al programador) como añadir ese 1 o 0 en la sexta posición y hacer la comparación bit a bit, o bien hacer la comparación con previa suma/resta de 32, o ajustar todos los caracteres de manera que el "bit del poder" quede en cero o en uno y después hacer la comparación, o hacer una función de comparación que descarte el valor de ese bit, etc.

En la disciplina de la programación el case sensitive lleva un fuerte impacto que crece en importancia cuanto más bajo es el nivel en que se trabaja. Hay lenguajes tales como C, C++, y Java donde nunca es lo mismo escribir un texto en mayúsculas que en minúsculas, al tanto que lenguajes como BASIC, Visual Basic y Pascal no ven diferencia alguna en la tipografía con que se escriba.

Solaris

olaris es un sistema operativo desarrollado por Sun Microsystems. Es un sistema certificado como una versión de UNIX. Aunque Solaris en sí mismo aún es software propietario, la parte principal del sistema operativo se ha liberado como un proyecto de software libre denominado Opensolaris. Solaris puede considerarse uno de los sistemas operativos más avanzados. Sun denomina así a su sistema operativo.

Solaris usa una base de código común para las arquitecturas que soporta: SPARC y x86 (incluyendo AMD64/EM64T). También fue portado a la arquitectura PowerPC (en plataforma PReP) en la versión 2.5.1, pero el porte fue cancelado casi tan pronto como fue liberado. En un tiempo se planeó soporte para el Itanium pero nunca se llevó al mercado. ^[1] Sun también tiene planes de implementar ABIs de Linux en Solaris 10, permitiendo la ejecución de código objeto Linux de forma nativa en la plataforma x86.

Solaris tiene una reputación de ser muy adecuado para el multiprocesamiento simétrico (SMP), soportando un gran número de CPUs. También ha incluido soporte para aplicaciones de 64 bits SPARC desde Solaris 7. Históricamente Solaris ha estado firmemente integrado con la plataforma hardware de Sun, SPARC, con la cual fue diseñado y promocionado como un paquete combinado. Esto proporcionaba frecuentemente unos sistemas más fiables pero con un coste más elevado que el del hardware de PC. De todas formas, también ha soportado sistemas x86 desde la versión Solaris 2.1 y la última versión, Solaris 10, ha sido diseñada con AMD64 en mente, permitiendo a Sun capitalizar en la disponibilidad de CPUs de 64 bits commodities basadas en la arquitectura AMD64. Sun ha promocionado intensamente Solaris con sus estaciones de trabajo de nivel de entrada basadas en AMD64, así como con servidores que en 2006 varían desde modelos dual-core hasta modelos a 16 cores.

En orden descendente, las siguientes versiones de Solaris han sido liberadas a 2006:

Versión de Solaris	Versión de SunOS	Fecha de publicación	Descripción
Solaris 10	SunOS 5.10	31 de enero, 2005	Incluye soporte AMD64/EM64T, DTrace, Solaris Containers, Service Management Facility (SMF) para reemplazar al sistema init.d, NFSv4. Modelo de seguridad basado en el menor privilegio. Se ha eliminado soporte para procesadores sun4m y UltraSPARC I a frecuencia menor que 200 Mhz. Se ha añadido Java Desktop System como escritorio por defecto. Se ha añadido GRUB como cargador de arranque para plataformas x86. Se ha añadido soporte iSCSI. Se ha añadido soporte para el nuevo sistema de archivos, ZFS (versión 1/06).
Solaris 9	SunOS 5.9	28 de mayo, 2002 (SPARC) 10 de enero, 2003 (x86)	iPlanet Directory Server, Resource Manager, Solaris Volume Manager. Añadida compatibilidad con Linux. Eliminado OpenWindows. Eliminado soporte para sun4d. La actualización más reciente es Solaris 9 9/05.
Solaris 8	SunOS 5.8	Febrero de 2000	Incluye Multipath I/O, IPv6 y IPsec. Introduce RBAC (control de acceso basado en roles). Soporte para sun4c eliminado. La actualización más reciente es Solaris 8 2/04.[5]
Solaris 7	SunOS 5.7	Noviembre de 1998	La primera versión de 64 bits para plataforma UltraSPARC. Añadido soporte nativo para registro de metadatos en el sistema de archivos (UFS logging).[6]
Solaris 2.6	SunOS 5.6	Julio de 1997	Incluye protocolo Kerberos, PAM, TrueType, WebNFS, y soporte de archivos grandes. [7]
Solaris 2.5.1	SunOS 5.5.1	Mayo de 1996	Ésta fue la primera y única versión que soportó la plataforma PowerPC. También se añadió soporte Ultra Enterprise, y los identificadores de usuario (uid_t) se expandieron a 32 bits. [8]
Solaris 2.5	SunOS 5.5	Noviembre de 1995	Primera versión en soportar UltraSPARC e incluir CDE, NFSv3 y NFS/TCP.[9]
Solaris 2.4	SunOS 5.4	Noviembre de 1994	Primera versión unificada SPARC/x86. Incluye soporte de ejecución OSF/Motif.
Solaris 2.3	SunOS 5.3	Noviembre de 1993	OpenWindows 3.3 cambia de NeWS a Display PostScript y elimina soporte de SunView. Esta versión fue sólo para SPARC.
Solaris 2.2	SunOS 5.2	Mayo de 1993	Primera en soportar la arquitectura sun4d. Esta versión fue sólo para SPARC.
Solaris 2.1	SunOS 5.1	Diciembre de 1992 (SPARC), Mayo de 1993 (x86)	Soporte para arquitectura Sun-4 y sun4m. Primera versión para Solaris x86.
Solaris 2.0	SunOS 5.0	Junio de 1992	Primera versión preliminar, soporte solamente para la arquitectura sun4c. [10

Sistema operatino Linux

Linux (pronunciación IPA: /ˈlɪnʊks/) es la denominación de un sistema operativo tipo-Unix y el nombre de un núcleo. Es uno de los paradigmas más prominentes del software libre y del desarrollo del código abierto, cuyo código fuente está disponible públicamente, para que cualquier persona puede libremente usarlo, estudiarlo, redistribuirlo y, con los conocimientos informáticos adecuados, modificarlo^[1].

Los primeros sistemas Linux se originaron en 1992, al combinar utilidades de sistema y librerías del proyecto GNU con el núcleo Linux, completando un sistema también conocido como GNU/Linux^[2]. Desde fines de 1990 Linux ha obtenido el apoyo de diversas empresas multinacionales del mundo de la informática, tales como IBM^[3], Sun Microsystems^[4], Hewlett-Packard^[5] y Novell^[6]. Actualmente Linux es comercializado en computadores de escritorio y portátiles por Dell^[7] y Lenovo^[8], además hay un grupo numeroso de compañías establecidas en Taiwan que planean hacer lo propio^[9].

Si bien Linux es usado como sistema operativo en computadores de escritorio (PCs x86 y x86-64 así como Macintosh y PowerPC), computadores de bolsillo, teléfonos celulares, dispositivos empotrados y otros, su mayor desarrollo se ha llevado a cabo en el mundo de los servidores y supercomputadores^[10].

La marca Linux (Número de serie: 1916230) pertenece a Linus Torvalds y se define como "un sistema operativo para computadoras que facilita su uso y operación".

Existen grupos de usuarios del sistema Linux en casi todas las áreas del planeta.

La colección de utilidades para la programación de GNU es con diferencia la familia de compiladores más utilizada en Linux. Tiene capacidad para compilar C, C++, Java, Ada, entre otros muchos lenguajes. Además soporta diversas arquitecturas mediante la compilación cruzada, lo que hace que sea un entorno adecuado para desarrollos heterogéneos.

Hay varios IDEs disponibles para Linux incluyendo, Anjuta, KDevelop, NetBeans IDE y Eclipse. Además existen editores extensibles como pueda ser Emacs que hoy en día siguen siendo ampliamente utilizados. GNU/Linux también dispone de capacidades para lenguajes de guión (script), aparte de los clásicos lenguajes de programación de shell, la mayoría de las distribuciones tienen instalado Python, Perl, PHP y Ruby.

Desarrollador:	Varios
Modelo de desarrollo:	Open source
Núcleo:	Linux
Tipo de núcleo:	Monolítico
Licencia:	GPL/LGPL/BSD/Otras
Estado actual:	En desarrollo

Sistema operativo MS-DOS

MS-DOS son las siglas de MicroSoft Disk Operating System, Sistema operativo de disco de Microsoft. es un sistema operativo comercializado por Microsoft perteneciente a la familia DOS. Fue un sistema operativo para el IBM PC que alcanzó gran difusión.

Desarrollador:	Microsoft
Modelo de desarrollo:	Software Privativo
Tipo de núcleo:	Núcleo monolítico
Licencia:	Propietaria
Última versión estable:	8.0 / 14 de septiembre de 2000
Estado actual:	Abandonado

El Sistema Operativo MS-DOS (MicroSoft Disk Operating System), tiene el origen en el QDOS (Quick and Dirty Operating System) sistema operativo escrito por Tim Paterson para la Seattle Computer Products y comercializado bajo la denominación 86-DOS.

Se desarrolló para micro-ordenadores personales de 16 bits. Se diseñó como un clon a corto plazo del sistema operativo CP/M, que estaba operativo en los ordenadores con microprocesador de 8 bits, para dar compatibilidad con la base instalada existente de programas comerciales como WordStar y dBase. Cuando IBM encargó a Microsoft un sistema operativo para su entonces novedoso IBM PC, Microsoft se vio incapaz de cumplir los plazos y compró el QDOS a sus propietarios, saliendo al mercado en dos versiones: PC-DOS (versión de IBM) y MS-DOS (versión de Microsoft).

El MS-DOS fue el producto clave, a finales de los años ochenta del siglo XX, en la transformación de Microsoft desde sus orígenes en los años 70 como proveedor especializado en lenguajes de programación a su actual estado como gigante en la industria informática. Precisamente los ingresos por las ventas de MS-DOS (particularmente mediante contratos exclusivos con marcas, probados como ilegales en Estados Unidos más tarde) ^{[cita requerida]} hicieron posible un espectacular crecimiento de la compañía. De hecho, hasta la salida de Windows 95, los ingresos por MS-DOS eran superiores a los de Windows.

Con el tiempo MS-DOS imitó otros sistemas operativos; MS-DOS 2.0 introdujo características de Unix tales como subdirectorios, es decir, estructura jerárquica y redirección de entrada/salida de órdenes (>,<) y tuberías (en inglés pipe (|)).

MS-DOS no es multiusuario o multitarea, pero se hicieron muchos intentos para agregarle estas capacidades en un futuro. Muchos programas utilizaron la técnica terminar y permanecer residente o TSR (Terminate and Stay Resident) y otras funciones normalmente indocumentadas para proporcionar aplicaciones pop up incluyendo el popular Sidekick de Borland. Es en modo texto, sin ninguna apariencia gráfica, a través de comandos. Gestiona periféricos y memoria. Entornos añadidos como DesqView intentaron proporcionar características multitarea, logrando cierto grado de éxito al combinarse con la administración de memoria del hardware del procesador Intel 80386.

Tras la aparición del Apple Macintosh en 1984, el público se interesó por la interfaz de usuario gráfica o GUI (Graphical User Interface), aunque el primer entorno gráfico fue el Alto de Xerox en 1973, basado en un sistema operativo propio. Muchos programas crearon sus propias interfaces gráficas, como Microsoft Word para DOS, XTree y el Norton Shell. Sin embargo, esto exigía duplicar esfuerzos y no proporcionaba mucha consistencia, lo que hizo crear entornos GUI completos.

Así, IBM y Microsoft se aliaron en un proyecto llamado OS/2, originalmente una versión en modo protegido de MS-DOS con una GUI, pero Microsoft pronto abandonó el proyecto para concentrar sus recursos en Windows. Por su parte, Digital Research creó el entorno GEM sin alcanzar mucha popularidad. Finalmente, tanto el OS/2 como el GEM se abandonaron, al parecer por contratos de exclusividad de Microsoft con vendedores de hardware de ordenadores. En teoría, hasta Windows 95, Windows no era un sistema operativo, sino una shell o capa que se interponía entre el usuario y el MS-DOS para facilitar su utilización. No obstante, hay expertos que alargan esta transformación hasta el Windows NT - Windows XP.

Actualmente, MS-DOS ha sido sustituido por la familia de sistemas Windows de Microsoft, sin embargo la consola de comando del sistema permite acceder a un entorno de texto con casi los mismos comandos de MS-DOS.

Las primeras versiones de Windows podían ejecutar programas para MS-DOS. Las últimas versiones de DOS "extendidas" usaban el modo protegido. Las últimas versiones de Windows se ejecutan independientemente de DOS pero incluyen una parte importante de viejo código que puede ejecutarse en máquinas virtuales (virtual machines).

• PC DOS 1.0 Liberado en 1981 como complemento al IBM-PC. Primera versión de DOS. Soporta 16 Kb de memoria RAM, disquetes de 5,25 pulgadas de una sola cara de 160 Kb.
  • PC DOS 1.1 Corregidos muchos errores, soporta disquetes de doble densidad de 320 Kb.
  • MS-DOS 1.25 Primera versión liberada con el nombre MS-DOS.
• MS-DOS 2.0 Complemento del IBM XT liberado en 1983. Más del doble de nuevas órdenes, soporte de disco duro (muy pequeño, alrededor de 5 MB).
  • PC DOS 2.1 Complemento del IBM PCjr. Añadidas algunas mejoras.
  • MS-DOS 2.11 Añadido el soporte para otros idiomas (aparte del inglés).
  • MS-DOS 2.25 Versión con un mejor soporte de los juegos de caracteres de los idiomas japonés y coreano.
• MS-DOS 3.0 Diseñado para soportar el nuevo hardware del IBM-AT. Añadidas unas pocas características de LAN.
  • MS-DOS 3.1 Añadidas más características y soporte LAN.
  • MS-DOS 3.2 Añadida capacidad para disquetes de 3,5 pulgadas y 720 Kb.
  • PC DOS 3.3 Añadido soporte para el ordenador PS/2 de IBM y los nuevos disquetes de 3,5 pulgadas de alta capacidad (1,44 MB). Nuevas páginas de código de caracteres internacionales añadidas, con soporte para 17 países.
  • MS-DOS 3.3 Capacidad para crear particiones de disco superiores a 32 MB. Soporte de 4 puertos serie (antes sólo 2). Incorporación de la orden "Files" para poder abrir hasta 255 archivos simultáneamente.
• MS-DOS 4.0 Generado con el código fuente de IBM, no con el de Microsoft.
• PC DOS 4.0 Agregado shell DOS, algunas mejoras y arreglos.
  • MS-DOS 4.01 Versión para 'corregir' algún error.
• MS-DOS 5.0 Implementado en 1991, incluyendo más características de administración de memoria y herramientas para soporte de macros, mejora del intérprete de órdenes o shell.
• MS-DOS 6.0 Liberado en 1993, incluye soporte para Microsoft Windows, desfragmentación del disco, compresión de archivos, copias de seguridad, anti-virus, Memmaker, etc.
  • MS-DOS 6.2 Versión para corregir errores.
  • MS-DOS 6.21 Eliminado el soporte de compresión de disco DoubleSpace.
  • PC DOS 6.3 Liberado en abril de 1994.
  • MS-DOS 6.22 Última versión distribiuda por separado. Incluido DriveSpace para sustituir a DoubleSpace.
• PC DOS 7.0 Añade Stacker para reemplazar a DoubleSpace.
• MS-DOS 7.0 Distribuido junto con Windows 95. Incluye soporte para nombres de archivo largos (hasta ahora habían tenido la restricción del 8+3).
  • MS-DOS 7.1 Integrado en Windows 95 OSR2 y posteriormente en Windows 98 y 98 SE. Soporta sistemas de archivos FAT32.
• MS-DOS 8.0 Incluido en Windows Me. Es la última versión de MS-DOS.
• PC DOS 2000 Versión que soluciona el problema del año 2000.

Dennis Ritchie

Dennis MacAlistair Ritchie (n. en 1941) es un físico estadounidense que colaboró en el desarrollo del sistema operativo Unix y creó el lenguaje de programación C, tema sobre el cual escribió un célebre clásico de las ciencias de la computación junto a Brian Wilson Kernighan: El Lenguaje de Programación C.

Nació en Bronxville (Nueva York) el 9 de septiembre de 1941. En 1967 ingresó a Laboratorios Bell en donde trabajó en Multics, BCPL, ALTRAN y el lenguaje de programación B. En Lucent encabezó los esfuerzos para la creación de Plan 9 e Inferno. Sus aportaciones junto a Ken Thompson al campo de los sistemas operativos han sido reconocidas con el Premio NEC C&C en 1979, con el Premio Turing de la ACM en 1983 y con la Medalla Nacional de Tecnología de los Estados Unidos en 1998.

El C de Kernighan y Ritchie [editar]

En 1978, Ritchie y Brian Kernighan publicaron la primera edición de El lenguaje de programación C. Este libro fue durante años la especificación informal del lenguaje. El lenguaje descrito en este libro recibe habitualmente el nombre de "el C de Kernighan y Ritchie" o simplemente "K&R C" (La segunda edición del libro cubre el estándar ANSI C, descrito más abajo.)

Kernighan y Ritchie introdujeron las siguientes características al lenguaje:

• El tipo de datos struct.
• El tipo de datos long int.
• El tipo de datos unsigned int.
• Los operadores =+ y =- fueron sustituidos por += y -= para eliminar la ambigüedad semántica de expresiones como i=-10, que se podría interpretar bien como i =- 10 o bien como i = -10.

El C de Kernighan y Ritchie es el subconjunto más básico del lenguaje que un compilador debe de soportar. Durante muchos años, incluso tras la introducción del ANSI C, fue considerado "el mínimo común denominador" en el que los programadores debían programar cuando deseaban que sus programas fueran transportables, pues no todos los compiladores soportaban completamente ANSI, y el código razonablemente bien escrito en K&R C es también código ANSI C válido.

En estas primeras versiones de C, las únicas funciones que necesitaban ser declaradas si se usaban antes de la definición de la función eran las que retornaban valores no enteros. Es decir, se presuponía que una función que se usaba sin declaración previa devolvería un entero.

Ejemplo de llamada que requiere declaración previa:

long int cierta_funcion();

int llamando_funcion()
{
 long int ret;
 ret = cierta_funcion();
} 

Ejemplo de llamada que no requiere declaración previa:

int llamando_funcion()
{
 int ret;
 ret = alguna_otra_funcion();
}

int alguna_otra_funcion()
{
 return 0;
} 

Dado que el lenguaje C de K&R no incluía ninguna información sobre los argumentos de las funciones, no se realizaba comprobación de tipos en los parámetros de las funciones, aunque algunos compiladores lanzan mensajes de advertencia si se llamaba a una función con un número incorrecto de argumentos.

En los años siguientes a la publicación del C de Kernighan y Ritchie, se añadieron al lenguaje muchas características no oficiales, que estaba soportadas por los compiladores de AT&T, entre otros. Algunas de estas características eran:

• Funciones void y el tipo de datos void *.
• Funciones que retornaban tipos de datos struct o union (en lugar de punteros).
• Asignación de tipos de datos struct.
• Calificador const, que hace que un objeto sea de sólo lectura.
• Una biblioteca estándar, que incorporaba la mayoría de las funcionalidades implementadas por varios desarrolladores de compiladores.
• Enumeraciones.

ANSI C e ISO C [editar]

A finales de la década de 1970, C empezó a sustituir a BASIC como lenguaje de programación de microcomputadores predominante. Durante la década de 1980 se empezó a usar en los IBM PC, lo que incrementó su popularidad significativamente. Al mismo tiempo, Bjarne Stroustrup empezó a trabajar con algunos compañeros de Bell Labs para añadir funcionalidades de programación orientada a objetos a C. El lenguaje que crearon, llamado C++, es hoy en día el lenguaje de programación de aplicaciones más común en el sistema operativo Microsoft Windows; mientras que C sigue siendo más popular en el entorno Unix. Otro lenguaje que se desarrolló en esa época, Objective C, también añadió características de programación orientada a objetos a C. Aunque hoy en día no es tan popular como C++, se usa para desarrollar aplicaciones Cocoa para Mac OS X.

En 1983, el Instituto Nacional Estadounidense de Estándares organizó un comité, X3j11, para establecer una especificación estándar de C. Tras un proceso largo y arduo, se completó el estándar en 1989 y se ratificó como el "Lenguaje de Programación C" ANSI X3.159-1989. Esta versión del lenguaje se conoce a menudo como ANSI C, o a veces como C89 (para distinguirla de C99).

En 1990, el estándar ANSI (con algunas modificaciones menores) fue adoptado por la Organización Internacional para la Estandarización (ISO) en el estándar ISO/IEC 9899:1990. Esta versión se conoce a veces como C90. No obstante, "C89" y "C90" se refieren en esencia al mismo lenguaje.

Uno de los objetivos del proceso de estandarización del ANSI C fue producir una extensión al C de Kernighan y Ritchie, incorporando muchas funcionalidades no oficiales. Sin embargo, el comité de estandarización incluyó también muchas funcionalidades nuevas, como prototipos de función, y un preprocesador mejorado. También se cambió la sintaxis de la declaración de parámetros para hacerla semejante a la empleada habitualmente en C++:

main(argc, argv)
 char **argv;
{
...
} 

pasó a ser

int main(int argc, char *argv[])
{
...
} 

ANSI C está soportado hoy en día por casi la totalidad de los compiladores. La mayoría del código C que se escribe actualmente está basado en ANSI C. Cualquier programa escrito sólo en C estándar sin código que dependa de un hardware determinado funciona correctamente en cualquier plataforma que disponga de una implementación de C compatible. Sin embargo, muchos programas han sido escritos de forma que sólo pueden compilarse en una cierta plataforma, o con un compilador concreto, debido a (i) la utilización de bibliotecas no estándar, como interfaces gráficos de usuario, (ii) algunos compiladores no cumplen, en el modo por defecto, las especificaciones del estándar ANSI C o su sucesor, o (iii) el código está escrito con dependencia de un tamaño determinado de ciertos tipos de datos, o de un determinado orden de los bits de la plataforma.

La macro __STDC__ puede usarse para dividir el código en secciones ANSI y K&R.

#if __STDC__
extern int getopt(int,char * const *,const char *);
#else
extern int getopt();
#endif 

Algunos programadores recomiendan usar "#if __STDC__", como en el ejemplo, en lugar de "#ifdef __STDC__" porque algunos compiladores le asignan el valor cero a __STDC__ para indicar que no son compatibles con ANSI.

C99 [editar]

Tras el proceso de estandarización de ANSI, la especificación del lenguaje C permaneció relativamente estable durante algún tiempo, mientras que C++ siguió evolucionando. Sin embargo, el estándar continuó bajo revisión a finales de la década de 1990, lo que llevó a la publicación del estándar ISO 9899:1999 en 1999. Este estándar se denomina habitualmente "C99". Se adoptó como estándar ANSI en marzo de 2000.

Las nuevas características de C99 incluyen:

• Funciones inline.
• Las variables pueden declararse en cualquier sitio (como en C++), en lugar de poder declararse sólo tras otra declaración o al comienzo de una declaración compuesta.
• Muchos tipos de datos, incluyendo long long int (para reducir el engorro de la transición de 32 bits a 64 bits), un tipo de datos booleano, y un tipo complex que representa números complejos.
• Arrays de longitud variable.
• Soporte para comentarios de una línea que empiecen con //, como en BCPL o en C++, característica para la que muchos compiladores habían dado soporte por su cuenta.
• muchas funciones nuevas, como snprintf()
• muchos headers nuevos, como stdint.h.

Una consideración importante es que hasta la publicación de este estándar, C había sido mayormente un subconjunto estricto del C++. Era muy sencillo "actualizar" un programa de C hacia C++ y mantener ese código compilable en ambos lenguajes. Sin embargo, el nuevo estándar agrega algunas características que C++ no admite, como por ejemplo los inicializadores estáticos de estructuras. También define al tipo "bool" de una manera que no es exactamente la del C++.

El compilador GCC, entre muchos otros, soportan hoy en día la mayoría de las nuevas características de C99. Sin embargo, este nuevo estándar ha tenido peor acogida entre algunos desarrolladores de compiladores, como Microsoft y Borland, que se han centrado en C++. Brandon Bray, de Microsoft, dijo a este respecto: "En general, hemos visto poca demanda de muchas características de C99. Algunas características tienen más demanda que otras, y consideraremos incluirlas en versiones futuras siempre que sean compatibles con C++."