leer wikipedia con nuevo diseño

Modula-3

Modula-3 es un lenguaje de programación concebido como sucesor de una versión mejorada de Modula-2 conocida como Modula-2 + . Si bien ha sido influyente en los círculos de investigación (influyendo en los diseños de lenguajes como Java , C # y Python [7] ), no se ha adoptado ampliamente en la industria. Fue diseñado por Luca Cardelli , James Donahue, Lucille Glassman, Mick Jordan (antes en el Laboratorio de Tecnología de Software Olivetti ), Bill Kalsow y Greg Nelson en el Centro de Investigación de Sistemas (SRC) de Digital Equipment Corporation (DEC ) y elOlivetti Research Center (ORC) a fines de la década de 1980.

Modula-3
Modula-3.svg
Paradigmasimperativo , estructurado , procedimental , modular , concurrente
FamiliaWirth Modula
Diseñada porLuca Cardelli , James Donahue, Lucille Glassman, Mick Jordan; Bill Kalsow, Greg Nelson
DesarrolladoresDEC
Olivetti
elego Software Solutions GmbH
Apareció por primera vez1988 ; Hace 33 años ( 1988 )
Lanzamiento estable
5.8.6 / 14 de julio de 2010 ; Hace 10 años ( 14 de julio de 2010 )
Versión de vista previa
5.8.6 / 14 de julio de 2010 ; Hace 10 años ( 14 de julio de 2010 )
Disciplina de mecanografíafuerte , estático , seguro o si no es seguro explícitamente seguro aislado
AlcanceLéxico
PlataformaIA-32 , x86-64 , PowerPC , SPARC
SOMultiplataforma : FreeBSD , Linux , Darwin , SunOS
Sitio webwww .modula3 .org
Implementaciones importantes
SRC Modula-3, CM3, [1] PM3, [2] EZM3, [3] M3 / PC Klagenfurt [4]
Influenciado por
ALGOL , Euclid , Mesa , Modula-2 , Modula-2 + , Oberon , Pascal
Influenciado
C # , Java , Nim , [5] OCaml , Python [6]

Las características principales de Modula-3 son la simplicidad y la seguridad al tiempo que preservan el poder de un lenguaje de programación de sistemas. Modula-3 tenía como objetivo continuar la tradición de Pascal de seguridad de tipos, al tiempo que introducía nuevas construcciones para la programación práctica del mundo real. En particular, Modula-3 agregó soporte para programación genérica (similar a plantillas ), multiproceso , manejo de excepciones , recolección de basura , programación orientada a objetos , revelación parcial y marcado explícito de código inseguro. El objetivo de diseño de Modula-3 era un lenguaje que implementa las características más importantes de los lenguajes de programación imperativos modernos en formas bastante básicas. Por lo tanto, se omitieron características supuestamente peligrosas y complicadas, como la herencia múltiple y la sobrecarga de operadores .

Desarrollo historico

El proyecto Modula-3 comenzó en noviembre de 1986 cuando Maurice Wilkes escribió a Niklaus Wirth con algunas ideas para una nueva versión de Modula. Wilkes había estado trabajando en DEC justo antes de este punto, y había regresado a Inglaterra y se había unido a la Junta de Estrategia de Investigación de Olivetti. Wirth ya se había trasladado a Oberon , pero no tuvo problemas con el desarrollo continuo del equipo de Wilkes bajo el nombre de Modula. La definición del lenguaje se completó en agosto de 1988, y una versión actualizada en enero de 1989. Pronto siguieron los compiladores de DEC y Olivetti, y luego las implementaciones de terceros.

Su diseño estuvo fuertemente influenciado por el trabajo en el lenguaje Modula-2 + en uso en SRC y en el Acorn Computers Research Center (ARC, más tarde ORC cuando Olivetti adquirió Acorn) en ese momento, que era el idioma en el que se usaba el sistema operativo para el Se escribió la estación de trabajo VAX multiprocesador DEC Firefly y en la que se escribió el Compilador Acorn para Acorn C y la Biblioteca de Ejecución Modula (CAMEL) en ARC para el proyecto del sistema operativo ARX ​​de la gama de computadoras Acorn Archimedes basadas en ARM . Como indica el Informe Modula-3 revisado, el lenguaje fue influenciado por otros lenguajes como Mesa , Cedar , Object Pascal , Oberon y Euclid . [8]

Durante la década de 1990, Modula-3 ganó una popularidad considerable como idioma de enseñanza, pero nunca se adoptó ampliamente para uso industrial. A esto puede haber contribuido la desaparición de DEC, un partidario clave de Modula-3 (especialmente cuando dejó de mantenerlo eficazmente antes de que DEC se vendiera a Compaq en 1998). En cualquier caso, a pesar de la simplicidad y el poder de Modula-3, parece que había poca demanda de un lenguaje compilado de procedimientos con implementación restringida de programación orientada a objetos . Durante un tiempo, un compilador comercial llamado CM3 mantenido por uno de los principales implementadores antes de DEC SRC que fue contratado antes de que DEC se vendiera a Compaq , un entorno de desarrollo integrado (IDE) llamado Reactor y una máquina virtual Java extensible (con licencia en código binario y formatos de código fuente y compilables con Reactor) fueron ofrecidos por Critical Mass, Inc., pero esa compañía cesó sus operaciones activas en 2000 y entregó parte del código fuente de sus productos a elego Software Solutions GmbH. Modula-3 ahora se enseña en las universidades principalmente en cursos de lenguajes de programación comparativos, y sus libros de texto están agotados. Esencialmente, el único patrocinador corporativo de Modula-3 es elego, que heredó las fuentes de Critical Mass y desde entonces ha realizado varias versiones del sistema CM3 en código fuente y binario. El IDE de Reactor ha sido lanzado en código abierto después de varios años sin hacerlo, con el nuevo nombre CM3-IDE. En marzo de 2002, elego también se hizo cargo del repositorio de otra distribución activa de Modula-3, PM3, hasta entonces mantenida en la École Polytechnique de Montréal pero que luego continuó con el trabajo en HM3 mejorado a lo largo de los años hasta que quedó obsoleto.

Sintaxis

Un ejemplo común de la sintaxis de un idioma es "¡Hola, mundo!" programa .

 MÓDULO  Principal ;  IMPORT  IO ;  COMIENZO  IO . Ponga ( "Hola mundo \ n" )  END  Main .

Todos los programas en Modula-3 tienen al menos un archivo de módulo, mientras que la mayoría también incluye un archivo de interfaz que los clientes utilizan para acceder a los datos del módulo. Como en otros lenguajes, un programa Modula-3 debe exportar un módulo Main, que puede ser un archivo llamado Main.m3, o un archivo puede llamar EXPORTpara exportar el módulo Main.

MÓDULO  Foo  EXPORTS  Principal

Se recomienda que los nombres de los archivos del módulo sean los mismos que los del código fuente. Si difieren, el compilador solo emite una advertencia.

Otras convenciones en la sintaxis incluyen nombrar el tipo exportado de una interfaz T, ya que los tipos generalmente están calificados por sus nombres completos, por Tlo que se nombrará un tipo dentro de un módulo llamado Foo Foo.T. Esto ayuda a la legibilidad. Otra convención similar es nombrar un objeto público Publiccomo en los ejemplos de programación orientada a objetos anteriores.

Características del idioma

Modularidad

En primer lugar, todas las unidades compiladas son INTERFACEo implementaciones MODULE, de un tipo u otro. Una unidad compilada de interfaz, que comienza con la palabra clave INTERFACE, define constantes, tipos, variables, excepciones y procedimientos. El módulo de implementación, que comienza con la palabra clave MODULE, proporciona el código y cualquier otra constante, tipo o variable necesaria para implementar la interfaz. De forma predeterminada, un módulo de implementación implementará la interfaz del mismo nombre, pero un módulo puede EXPORThacerlo explícitamente en un módulo que no tenga el mismo nombre. Por ejemplo, el programa principal exporta un módulo de implementación para la interfaz principal.

 MÓDULO  HelloWorld  EXPORTS  Principal ;  IMPORT  IO ;  COMIENZO  IO . Ponga ( "Hello World \ n" )  END  HelloWorld .

Cualquier unidad compilada puede tener IMPORTotras interfaces, aunque las importaciones circulares están prohibidas. Esto se puede resolver haciendo la importación desde el MÓDULO de implementación. Las entidades dentro del módulo importado se pueden importar, en lugar de solo el nombre del módulo, usando la FROM Module IMPORT Item [, Item]*sintaxis:

 MÓDULO  HelloWorld  EXPORTS  Principal ;  DESDE  IO  IMPORT  Put ;  BEGIN  Put ( "Hello World \ n" )  END  HelloWorld .

Por lo general, uno solo importa la interfaz y usa la notación 'punto' para acceder a los elementos dentro de la interfaz (similar a acceder a los campos dentro de un registro). Un uso típico es definir una estructura de datos (registro u objeto) por interfaz junto con cualquier procedimiento de soporte. Aquí, el tipo principal obtendrá el nombre 'T', y se usará como en MyModule.T.

En el caso de una colisión de nombres entre un módulo importado y otra entidad dentro del módulo, la palabra reservada ASse puede utilizar como enIMPORT CollidingModule AS X;

Seguro vs inseguro

Alguna habilidad se considera insegura, donde el compilador ya no puede garantizar que los resultados sean consistentes; por ejemplo, al interactuar con el lenguaje C. La palabra clave con el UNSAFEprefijo INTERFACEo MODULE, puede usarse para decirle al compilador que habilite ciertas características de bajo nivel del lenguaje. Por ejemplo, una operación insegura pasa por alto el sistema de tipos que usa LOOPHOLEpara copiar los bits de un entero en un REALnúmero de coma flotante .

Una interfaz que importa un módulo inseguro también debe ser insegura. Un módulo de implementación inseguro puede exportar una interfaz segura. Este es el uso típico cuando se interactúa con bibliotecas externas , donde se construyen dos interfaces: una insegura y la otra segura.

Genéricos

Una interfaz genérica y su módulo genérico correspondiente, prefijo la palabra clave INTERFACEo MODULEcon GENERIC, y toma como argumentos formales otras interfaces. Por lo tanto (como las plantillas de C ++ ), uno puede definir y usar fácilmente tipos de datos abstractos, pero a diferencia de C ++ , la granularidad está en el nivel de módulo. Se pasa una interfaz a la interfaz genérica y a los módulos de implementación como argumentos, y el compilador generará módulos concretos.

Por ejemplo, uno podría definir un GenericStack, luego instanciarlo con interfaces como IntegerElem, o RealElem, o incluso interfaces a Objetos, siempre que cada una de esas interfaces defina las propiedades que necesitan los módulos genéricos.

Los tipos simples INTEGER, o REALno se pueden usar, porque no son módulos, y el sistema de genéricos se basa en el uso de módulos como argumentos. En comparación, en una plantilla de C ++, se usaría un tipo simple.

ARCHIVO: IntegerElem.i3 

 INTERFACE  IntegerElem ;  CONST  Name  =  "Entero" ;  TIPO  T  =  INTEGER ;  PROCEDIMIENTO  Formato ( x :  T ):  TEXTO ;  PROCEDIMIENTO  Escaneo ( txt :  TEXT ;  VAR  x :  T ):  BOOLEAN ;  END  IntegerElem .

ARCHIVO: GenericStack.ig 

  INTERFAZ  GENÉRICA GenericStack ( Elemento );  (* Aquí Element.T es el tipo que se almacenará en la pila genérica. *)  TYPE  T  =  Public  OBJECT ;  Público  =  MÉTODOS DE OBJETO  init (): TStack ; formato (): TEXTO ; isEmpty (): BOOLEANO ; count (): INTEGER ; empujar ( olmo : Elemento . T ); pop ( VAR elem : Element . T ): BOOLEAN ; FIN ; END GenericStack .

ARCHIVO: GenericStack.mg 

  MÓDULO  GENÉRICO GenericStack ( Elemento );  <  ...  detalles de implementación genérica  ... > PROCEDIMIENTO Formato ( self : T ): TEXT = VAR str : TEXT ; BEGIN str : = Elemento . Nombre & "Pila {" ; PARA k : = 0 A uno mismo . n - 1 HACER SI k > 0 ENTONCES str : = str & "," ; FIN ; str : = str & Element . Formato ( auto . Arr [ k ]); FIN ; str : = str & "};" ; RETURN str ; Formato END ; < ... detalles de implementación más genéricos ... > END GenericStack .

ARCHIVO: IntegerStack.i3 

INTERFACE  IntegerStack  =  GenericStack ( IntegerElem )  END  IntegerStack .

ARCHIVO: IntegerStack.m3 

MÓDULO  IntegerStack  =  GenericStack ( IntegerElem )  END  IntegerStack .

Trazabilidad

Cualquier identificador puede rastrearse hasta donde se originó, a diferencia de la característica 'incluir' de otros idiomas. Una unidad compilada debe importar identificadores de otras unidades compiladas, utilizando una IMPORTdeclaración. Incluso las enumeraciones utilizan la misma notación de "punto" que se utiliza al acceder a un campo de un registro.

INTERFAZ  A ;TIPO  Color  =  { Negro ,  Marrón ,  Rojo ,  Naranja ,  Amarillo ,  Verde ,  Azul ,  Violeta ,  Gris ,  Blanco };END  A ;
MÓDULO  B ;IMPORT  A ; DE  UNA  IMPORTACIÓN  Color ;VAR  aColor :  Una . Color ;  (* Utiliza el nombre del módulo como prefijo *)  theColor :  Color ;  (* No tiene el nombre del módulo como un prefijo *)  anotherColor :  Una . Color ;COMENZAR  aColor  : =  A . Color . Marrón ;  theColor  : =  Color . Rojo ;  otroColor  : =  Color . naranja ;  (* No se puede simplemente usar naranja *) FIN  B .

Asignación dinámica

Modula-3 admite la asignación de datos en tiempo de ejecución . Hay dos tipos de memoria que se pueden asignar, TRACEDy UNTRACEDla diferencia es si el recolector de basura puede verla o no. NEW()se utiliza para asignar datos de cualquiera de estas clases de memoria. En un UNSAFEmódulo, DISPOSEestá disponible para liberar memoria no rastreada.

Orientado a objetos

Las técnicas de programación orientada a objetos se pueden utilizar en Modula-3, pero su uso no es necesario. Muchas de las otras características proporcionadas en Modula-3 (módulos, genéricos) generalmente pueden reemplazar la orientación a objetos.

El soporte de objetos se mantiene intencionalmente en sus términos más simples. Un tipo de objeto (denominado "clase" en otros lenguajes orientados a objetos) se introduce con la OBJECTdeclaración, que tiene esencialmente la misma sintaxis que una RECORDdeclaración, aunque un tipo de objeto es un tipo de referencia, mientras que los RECORD en Modula-3 no lo son ( similar a las estructuras en C). Los tipos exportados generalmente se denominan T por convención y crean un tipo "Público" separado para exponer los métodos y los datos. Por ejemplo:

INTERFAZ  Persona ;TIPO  T  < :  Público ;  Público  =  MÉTODOS DE OBJETO  getAge (): INTEGER ; init ( nombre : TEXT ; edad : INTEGER ): T ; FIN ;         Persona FINAL .

Esto define una interfaz Personcon dos tipos, Ty Public, que se define como un objeto con dos métodos, getAge()y init(). Tse define como un subtipo de Publicpor el uso del <:operador.

Para crear un nuevo Person.Tobjeto, utilice el procedimiento integrado NEWcon el método init()como

VAR  jim  : =  NUEVO ( Persona . T ). init ( "Jim" ,  25 );

La REVEALconstrucción de Modula-3 proporciona un mecanismo conceptualmente simple y limpio pero muy poderoso para ocultar los detalles de implementación a los clientes, con arbitrariamente muchos niveles de amabilidad . Úselo REVEALpara mostrar la implementación completa de la Personinterfaz desde arriba.

MÓDULO  Persona ;REVEAL  T  =  Nombre de OBJETO DE MARCA público  : TEXTO ; (* Estas dos variables *) edad : INTEGER ; (* Son privados *.) EXCEPCIONES getAge : = Edad ; init : = Init ; FIN ;             PROCEDIMIENTO  Edad ( yo :  T ):  INTEGER  =  EMPEZAR  REGRESAR  yo . edad ;  END  Age ;PROCEDIMIENTO  Init ( self :  T ;  name :  TEXT ;  age :  INTEGER ):  T  =  BEGIN  self . nombre  : =  nombre ;  yo . edad  : =  edad ;  REGRESAR a  uno mismo ;  END  Init ;BEGIN END  Persona .

Tenga en cuenta el uso de la BRANDEDpalabra clave, que "marca" los objetos para hacerlos únicos y evitar la equivalencia estructural. BRANDEDtambién puede tomar una cadena como argumento, pero cuando se omite, se genera una cadena única para usted.

Modula-3 es uno de los pocos lenguajes de programación que requiere referencias externas de un módulo para estar estrictamente calificado. Es decir, una referencia en módulo Aal objeto xexportado desde módulo Bdebe tomar la forma B.x. En Modula-3, es imposible importar todos los nombres exportados desde un módulo.

Debido a los requisitos del idioma sobre la calificación del nombre y la anulación de métodos , es imposible romper un programa en funcionamiento simplemente agregando nuevas declaraciones a una interfaz (cualquier interfaz). Esto hace posible que muchos programadores editen programas grandes al mismo tiempo sin preocuparse por los conflictos de nombres; y también permite editar bibliotecas de idiomas centrales con el firme conocimiento de que ningún programa existente se romperá en el proceso.

Excepciones

El manejo de excepciones se basa en un TRY... EXCEPTsistema de bloques, que desde entonces [ cita requerida ] se ha vuelto común. Una característica que no ha sido adoptada en otros lenguajes [ cita requerida ] , con las notables excepciones de Delphi , Python [1] , Scala [2] y Visual Basic.NET , es que la EXCEPTconstrucción define una forma de declaración de cambio con cada posible excepción como caso en su propia cláusula EXCEPT. Modula-3 también admite una LOOP... EXIT... ENDconstrucción que se repite hasta que se EXITproduce una, una estructura equivalente a un bucle simple dentro de una TRY... EXCEPTcláusula.

Multiproceso

El lenguaje admite el uso de subprocesos múltiples y la sincronización entre subprocesos. Hay un módulo estándar dentro de la biblioteca en tiempo de ejecución ( m3core ) llamado Thread, que admite el uso de aplicaciones multiproceso. El tiempo de ejecución de Modula-3 puede hacer uso de un hilo separado para tareas internas como la recolección de basura.

Se MUTEXutiliza una estructura de datos incorporada para sincronizar varios subprocesos y proteger las estructuras de datos del acceso simultáneo con posibles daños o condiciones de carrera. La LOCKdeclaración introduce un bloque en el que se bloquea el mutex. El desbloqueo de a MUTEXestá implícito en el lugar de ejecución del código que sale del bloque. El MUTEXes un objeto y, como tal, otros objetos pueden derivarse de él.

Por ejemplo, en la sección de entrada / salida (E / S) de la biblioteca libm3 , los lectores y escritores (Rd.T y Wr.T) se derivan de MUTEX y se bloquean antes de acceder o modificar cualquier dato interno como tampones.

Resumen

En resumen, las características del idioma:

  • Módulos e interfaces
  • Marcado explícito de código inseguro
  • Genéricos
  • Recolección automática de basura
  • Fuerte tipificación , equivalencia estructural de tipos
  • Objetos
  • Excepciones
  • Hilos

Modula-3 es uno de los raros lenguajes cuya evolución de características está documentada.

En Programación de sistemas con Modula-3 , se discuten intensamente cuatro puntos esenciales del diseño del lenguaje. Estos temas son: equivalencia estructural versus equivalencia de nombre, reglas de subtipo, módulos genéricos y modos de parámetros como READONLY.

Características de la biblioteca estándar

Continuando con una tendencia iniciada con el lenguaje C , muchas de las características necesarias para escribir programas reales se dejaron fuera de la definición del lenguaje y en su lugar se proporcionaron a través de un conjunto de bibliotecas estándar . La mayoría de las interfaces siguientes se describen en detalle en [9].

Bibliotecas estándar que ofrecen las siguientes características. Estos se denominan interfaces estándar y son obligatorios (deben proporcionarse) en el idioma.

  • Texto: operaciones en referencias de cadena inmutables, llamadas TEXTs
  • Subproceso: operaciones relacionadas con el subproceso, incluida la MUTEXvariable de condición y la pausa del subproceso. La biblioteca de subprocesos proporciona conmutación de subprocesos preventiva
  • Word: operaciones bit a bit en enteros sin signo (o palabras de máquina). Normalmente implementado directamente por el compilador
  • Interfaces de punto flotante

Algunas interfaces recomendadas implementadas en las implementaciones disponibles pero no son obligatorias

  • Lex: para analizar números y otros datos
  • Fmt: formateo de varios tipos de datos para imprimir
  • Pkl (o Pickle): serialización de objetos de cualquier tipo de referencia accesible por el recolector de basura
  • Tabla: Módulos genéricos para mapas

Como en C, la E / S también se proporciona a través de bibliotecas, en Modula-3 se llama Rdy Wr. El diseño orientado a objetos de las bibliotecas Rd (lectores) y Wr (escritores) se trata en detalle en el libro de Greg Nelson. Un aspecto interesante de Modula-3 es que es uno de los pocos lenguajes de programación cuyas bibliotecas estándar se han verificado formalmente para no contener varios tipos de errores, incluidos los errores de bloqueo. Esto se hizo bajo los auspicios de los proyectos Alerce / Modula-3 (ver familia Alerce ) [10] y Comprobación estática extendida [11] en el Centro de Investigación de Sistemas DEC .

Implementaciones

Hay varios compiladores disponibles, la mayoría de ellos de código abierto .

  • DEC-SRC M3, el original. [12]
  • El kit de herramientas Modula-3 del Centro de Investigación Olivetti (ORC), originalmente un compilador, ahora está disponible como una biblioteca para el análisis sintáctico, léxico y semántico de los programas Modula-3. [13]
  • Critical Mass CM3, un sucesor diferente de DEC-SRC M3
  • Polytechnique Montreal Modula-3 PM3, sucesor de DEC-SRC M3, actualmente se fusiona con CM3
  • EzM3, una implementación independiente, ligera y fácilmente portátil, desarrollada en conexión con CVSup
  • HM3, sucesor de la versión pm3-1.1.15 de PM3, con soporte de subprocesos nativos usando NPTL
  • CM3, el sucesor de Critical Mass CM3. Esta es la única implementación actualizada, mantenida y desarrollada. Las versiones están disponibles en http://www.opencm3.net/releng/ .

Dado que el único aspecto de las estructuras de datos C que falta en Modula-3 es el tipo de unión, todas las implementaciones existentes de Modula-3 pueden proporcionar una buena compatibilidad de código binario con declaraciones de tipo de lenguaje C de matrices y estructuras .

Libros

Ninguno de estos libros está todavía impreso, aunque se pueden obtener copias usadas y algunos están digitalizados, parcial o totalmente, y algunos capítulos de uno de ellos tienen versiones anteriores o posteriores que se pueden obtener como informes de investigación en la web.

  • Greg Nelson, ed., Programación de sistemas con Modula-3 La referencia definitiva sobre el lenguaje Modula-3 con artículos interesantes sobre la construcción de software de sistemas orientados a objetos y una documentación de la discusión que conduce a las características finales del lenguaje. Hay algunos anteriormente (ver [8] para el capítulo dos, [14] para el capítulo cuatro, [15] para el capítulo cinco, [16] para el capítulo seis) y algunos posteriormente (ver [17] para el capítulo uno y más actualizado dos, por lo tanto, de las dos versiones anteriores de la definición del lenguaje [8] y, [9] para el capítulo tres y [18] para el capítulo siete) de las versiones de publicación de la mayoría de sus ocho capítulos disponibles individualmente en el Centro de Investigación de Sistemas DEC (SRC) anterior informes para descargar.
  • Samuel P. Harbison, Modula-3 Libro de texto de clase fácil de usar.
  • Robert Sedgewick , algoritmos en Modula-3
  • Laszlo Boszormenyi & Carsten Weich, Programación en Modula-3: Introducción a la programación con estilo
  • Renzo Orsini, Agostino Cortesi Programmare in Modula-3: introduzione alla programmazione imperativa ea oggetti un libro italiano del idioma que explica sus principales características.

Proyectos que utilizan Modula-3

El software que se programa Modula-3 incluye:

  • El sistema operativo SPIN
  • El programa de sincronización del repositorio de software CVSup
  • El lenguaje Obliq , que utiliza la capacidad de objetos de red Modula-3 para migrar objetos a través de redes locales de forma transparente, permite una capacidad distribuida al paradigma de programación orientada a objetos Modula-3. Se ha utilizado para crear aplicaciones distribuidas, animaciones informáticas y aplicaciones de programación web en forma de extensión de secuencias de comandos para Modula-3.

Influencias en otros lenguajes de programación

Aunque Modula-3 no ganó el estatus de corriente principal, varias partes de la distribución DEC-SRC M3 sí lo hicieron. Probablemente la parte más influyente fue la biblioteca de objetos de red, que formó la base para la primera implementación de invocación de método remoto (RMI) de Java, incluido el protocolo de red. Solo cuando Sun pasó del estándar Common Object Request Broker Architecture (CORBA) al protocolo basado en IIOP, se eliminó. La documentación de Java sobre la recolección de basura de objetos remotos todavía se refiere al trabajo pionero realizado para Modula-3 Network Objects. [19] La implementación de clases de Python también se inspiró en el mecanismo de clases que se encuentra en C ++ y Modula-3. [20] Además, el lenguaje Nim hace uso de algunos aspectos de Modula-3, como los punteros trazados frente a los no trazados .

Referencias

  1. ^ "Módulo de masa crítica-3 (CM3)" . Módulo de masa crítica-3 . elego Software Solutions GmbH . Consultado el 21 de marzo de 2020 .
  2. ^ "Polytechnique Montréal Modula-3 (PM3): ¿Qué es" . Polytechnique Montréal Modula-3 . elego Software Solutions GmbH . Consultado el 21 de marzo de 2020 .
  3. ^ Polstra, John D. (9 de noviembre de 2006). "Ezm3: una distribución más fácil de Modula-3" . CVSup.org . Archivado desde el original el 10 de abril de 2013 . Consultado el 21 de marzo de 2020 .
  4. ^ Weich, Carsten. "M3 / PC Klagenfurt 96: un entorno Modula-3 para MS-DOS" . Departamento de Informática . Universidad de Klagenfurt. Archivado desde el original el 20 de mayo de 2000 . Consultado el 21 de marzo de 2020 .
  5. ^ Picheta, Dominik; Locurcio, Hugo. "Preguntas frecuentes" . Consultado el 21 de marzo de 2020 .
  6. ^ van Rossum, Guido (mayo de 1996). "Programación de Python: Prólogo (1ª ed.)" . Python.org . Consultado el 21 de marzo de 2020 .
  7. ^ "Preguntas frecuentes sobre diseño e historia: ¿Por qué debe usarse 'self' explícitamente en las definiciones y llamadas de métodos?" . Python.org . 21 de marzo de 2020 . Consultado el 21 de marzo de 2020 .
  8. ^ a b c Informe Modula-3 (revisado) Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan, Bill Kalsow, Greg Nelson. Informe de investigación 52 del Centro de Investigación de Sistemas DEC (SRC) (noviembre de 1989)
  9. ^ a b Algunas interfaces útiles de Modula-3 Jim Horning, Bill Kalsow, Paul McJones, Greg Nelson. Informe de investigación 113 del Centro de Investigación de Sistemas DEC (SRC) (diciembre de 1993)
  10. ^ LM3 Kevin D. Jones. Informe de investigación 72 del Centro de Investigación de Sistemas DEC (SRC) (junio de 1991)
  11. ^ Comprobación estática extendida David L. Detlefs, K. Rustan M. Leino, Greg Nelson, James B. Saxe . Informe de investigación 159 de Compaq SRC (diciembre de 1998)
  12. ^ SRC Modula-3 3.3 [ enlace muerto permanente ] Bill Kalsow y Eric Muller. Digital Equipment Corporation (enero de 1995)
  13. ^ Jordan, Mick (1990). "Un entorno de programación extensible para Modula-3" . SIGSOFT Softw. Ing. Notas . 15 (6): 66–76. doi : 10.1145 / 99278.99285 . Consultado el 8 de septiembre de 2009 .
  14. ^ Una introducción a la programación con subprocesos Andrew D. Birrell. Informe de investigación 35 del Centro de Investigación de Sistemas DEC (SRC) (enero de 1989)
  15. ^ Primitivas de sincronización para un multiprocesador: una especificación formal AD Birrell, JV Guttag, JJ Horning, R. Levin. Informe de investigación 20 del Centro de Investigación de Sistemas DEC (SRC) (agosto de 1987)
  16. ^ IO Streams: tipos abstractos, programas reales Mark R. Brown y Greg Nelson. Informe de investigación 53 del Centro de investigación de sistemas DEC (SRC) (noviembre de 1989)
  17. ^ Manual de referencia de Modula-3 Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan, Bill Kalsow, Greg Nelson. DEC Systems Research Center (SRC) (febrero de 1995)
  18. ^ Tutorial de caballete Mark S. Manasse y Greg Nelson. Informe de investigación 69 del Centro de Investigación de Sistemas DEC (SRC) (mayo de 1992)
  19. ^ Recolección de basura de objetos remotos , documentación de invocación de método remoto de Java para Java SE 8.
  20. ^ Clases , documentación oficial de Python.

enlaces externos

  • Página web oficial
  • Modula3 en GitHub
  • Sitio web de implementación de CM3
  • Página de inicio de Modula-3 (ahora muerta hace mucho tiempo, espejo )
  • Modula-3: Definición del lenguaje
  • Soluciones de software elego
  • Grupo de noticias Modula-3 , en su mayoría desierto
  • Lista de correo de desarrollo Modula-3 , activa
  • Notas de la clase CS2 de Caltech, enseñada en Modula-3 en 2002 y 2003
  • Caltech's CS3 class 2009 en Wayback Machine (archivado el 23 de mayo de 2013)
  • Programación espejo en Modula-3 : ejemplos de programas
  • Creación de aplicaciones OO distribuidas: objetos Modula-3 en funcionamiento . Michel R. Dagenais. Versión preliminar (enero de 1997)
  • Modula-3: Lenguaje, Bibliotecas y Herramientas . Presentación sobre Modula-3 en 120 diapositivas. Michael R. Dagenais [ enlace muerto permanente ] , muerto
  • Abstracción de datos orientada a objetos en Modula-3 . Joseph Bergin (1997)
  • Entrevista Computerworld con Luca Cardelli sobre Modula-3

This page is based on a Wikipedia article Text is available under the CC BY-SA 4.0 license; additional terms may apply. Images, videos and audio are available under their respective licenses.

  • Terms of Use
  • Privacy Policy