What Runs Where on Athena - Languages

C

cc

Description: Developer Studio C compiler
TO RUN:
athena% add -f sunsoft_v12.6
athena% cc options file.c _(or use {}makefile)_
athena% cc -flags gives a concise summary of command-line options
There is online documentation; also Information on C programming in the Knowledge Base
See also: gcc, lint
Note: *On Linux machines, */usr/bin/cc is usually a link to gcc
On Ubuntu machines, you may need to add the following command-line option to your compile command if you get errors about missing standard libraries (like -lm):
-YP,/usr/lib/x86_64-linux-gnu
Additionally, if you get errors about undefined symbols when compiling system header files, add the following command-line option:
-I/usr/include/x86_64-linux-gnu

gcc

Description: GNU C compiler
TO RUN:
athena% add -f gcc-6plus
athena% *info gcc *(for online help)
athena% gcc options file.c
Please see file /mit/gcc-6plus/README for notes on linking to libraries in the gcc-6pluslocker. A default link will link to older libraries in the debathena release which may be incompatible.
There is a gcc Web page
See also: cc, gdc, Go, Nim
Note: There is an older version of gcc in the debathena release.

lint

Description: checks C programs for compliance with syntax and style rules
TO RUN:
athena% add sunsoft_v12.6
athena% *lint *_file.c _
athena% lint -flags gives a concise summary of command-line switches
See also: cc, Cscope, dbx, ftnchek, TotalView
Note: *This version of {}lint* is supplied with the Developer Studio compiler set and is designed to work with features supported by those compilers.

C++

CC

Description: Developer Studio C++ compiler
TO RUN:
athena% add sunsoft_v12.6
athena% CC options file.C
athena% CC -flags gives a concise summary of command-line options
There is online documentation
See also: g++
*Note: *Please read file /mit/sunsoft_v12.6/README.dynamic_linking for information on dynamic linking
On Ubuntu machines, you may need to add the following command-line option to your compile command if you get errors about missing standard libraries (like -lm):
-YP,/usr/lib/x86_64-linux-gnu
Additionally, if you get errors about undefined symbols when compiling system header files, add the following command-line option:
-I/usr/include/x86_64-linux-gnu

g++

Description: GNU C++ compiler
TO RUN:
athena% add -f gcc-6plus
athena% info g++ (for online help)
athena% g++ options file.cpp
Please see file /mit/gcc-6plus/README for notes on linking to libraries in the gcc-6pluslocker. A default link will link to older libraries in the debathena release which may be incompatible.
There is a gcc/g++ Web page
See also: boost, CC, EiffelStudio, Erlang, gdc, Go, Nim, Rust
Note: There is an older version of g++ in the debathena release.

FORTRAN

f77

Description: Developer Studio FORTRAN 77 compiler
TO RUN:
athena% add sunsoft_v12.6
athena% f77 options file.f
athena% f77 -flags gives a concise summary of command-line options
There is online documentation; also local FORTRAN Answers
See also:[ f90|What Runs Where on Athena - Languages#f90],[ gfortran|What Runs Where on Athena - Languages#g77], g95, ftnchek
Note: *Please read file /mit/sunsoft_v12.6/README.dynamic_linking for information on dynamic linking; this is really the {}f95* compiler running in f77 compatibility mode
On Ubuntu machines, you may need to add the following command-line option to your compile command if you get errors about missing standard libraries (like -lm):
-YP,/usr/lib/x86_64-linux-gnu
Additionally, if you get errors about undefined symbols when compiling system header files, add the following command-line option:
-I/usr/include/x86_64-linux-gnu

f90/f95

Description: Developer Studio FORTRAN 90/95 compiler
TO RUN:
athena% add -f sunsoft_v12.6
athena% f90 options file.f90
athena% f95 options file.f95
athena% f90 -flags gives a concise summary of command-line options
There is online documentation; also local FORTRAN Answers
See also: f77, gfortran, g95, ftnchek
*Note: *Please read file /mit/sunsoft_v12.6/README.dynamic_linking for information on dynamic linking
On Ubuntu machines, you may need to add the following command-line options to your compile command if you get errors about missing standard libraries (like -lm):
-YP,/usr/lib/x86_64-linux-gnu
Additionally, if you get errors about undefined symbols when compiling system header files, add the following command-line option:
-I/usr/include/x86_64-linux-gnu

gfortran

Description: GNU FORTRAN 90 compiler
TO RUN:
athena% add -f gcc-6plus
athena% gfortran options file.f
Please see file /mit/gcc-6plus/README for notes on linking to libraries in the gcc-6pluslocker. A default link will link to older libraries in the debathena release which may be incompatible.
See also: f77, f90, g95, ftnchek
There is gnu documentation
Note: *The {}gfortran* compiler is a front-end to the* gcc compiler; g77* has been replaced by gfortran as of the 4.0 release. gfortran is mostly compliant with the FORTRAN 90 specification. There is an older version of gfortran in the debathena release.

g95

Description: Open Source FORTRAN 95 compiler incorporating some features of the FORTRAN 2003 and FORTRAN 2008 specifications
TO RUN:
athena% add g95
athena% g95 options file.f95
See also:[ f77|What Runs Where on Athena - Languages#f77], f90, gfortran, ftnchek
There is local documentation and a home page
Note: *The {}g95* compiler is a front-end to the gcc compiler but is distinct from gfortran

ftnchek

Description: checks FORTRAN programs for compliance with syntax; similar to lint for C programs
TO RUN:
athena% *ftnchek *file.f
There is a developer Web page and online documentation
See also: f77, f90, gfortran, g95, lint, TotalView

Other Languages

mlisp (Allegro Common Lisp)

Description: Common Lisp programming language
TO RUN:
athena% add acl
athena% mlisp [istdraft:-I <image path and name>.dxl] options (to run Lisp only, command-line interface; type :exit at Lisp prompt to exit)
athena% mlisp-xemacs & (to run Lisp only, xemacs interface)
athena% mlisp-composer & (to run Lisp with Composer, xemacs interface; then ACL *-> {}Composer -> {}Start Composer*)
athena% mlisp-composer-emacs & (to run Lisp with Composer, emacs interface)
athena% mlisp-clim & (to run Lisp with CLIM, xemacs interface)
athena% mlisp-clim-emacs & (to run Lisp with CLIM, emacs interface)
To run CLIM demos, after loading mlisp-clim, type:
(require :climdemo)
followed by:
*(clim-demo:start-demo) *
There is 8.1 documentation, release notes and CLIM manual
There is an online Lisp language reference manual. For a detailed hypertext Common Lisp guide see the Lisp HyperSpec from LispWorks; see also the FAQ. There are free online books: On Lisp, Practical Common Lisp
See also: clisp, Clojure, racket, scheme, SCM
Note: This application is out of maintenance and the latest version on Athena will remain 8.1. Users can download a current Linux release ("Free Express Edition") subject to some limitations and license conditions; see vendor site for details.

AMPL

Description: modeling language for mathematical optimization programming
Licenses: We have 5 floating licenses.
TO RUN:
athena% *add ampl *
athena% *ampl *(starts the interactive development environment)
AMPL can be run with a built-in CPLEX solver (the default) or using one of three optional solvers, LOQO, SNOPT *or ipopt*
To select LOQO as solver, type option solver loqo; *at the {}ampl:* prompt.
To select SNOPT as solver, type option solver snopt; *at the {}ampl:* prompt.
To select ipopt *as solver, type {}option solver ipopt;* at the ampl: prompt.
To exit, type quit at the ampl: prompt
There is online documentation and SNOPT information and an AMPL newsgroup
See also: Dakota, GNU Linear Programming Kit, ipopt, lpsolve, snopt, TAO/PETSc
*Note: *There are some AMPL free access options.

awk

Description: pattern scanning and processing language. awk scans an input file inputfile for lines that match any of a set of patterns specified in scriptfile. With each pattern in scriptfile _there can be an associated action that will be performed when a line of {}inputfile _matches the pattern. A pattern-action statement has the form:
pattern

Either pattern or action may be omitted. If there is no action, the matching line is printed
Individual awk commands are frequently used within shell or perl scripts to perform text transformations on fields within lines of text
TO RUN:
*awk -f *scriptfile inputfile
See also: lua, newLISP, perl

Ceylon

Description: IDE, compiler and runtime environment for the Ceylon programming language* *from Red Hat Software. It is intended to be a platform for writing large programs in teams and is targeted for both Java and JavaScript virtual machines. It has been designed with modularity and clarity as key top-level features, and it comes with an extensive command-line toolkit and an Eclipse-based IDE
TO RUN:
athena% add -f ceylon
athena% eclipse (to launch Ceylon-enabled Eclipse IDE)
athena% *ceylon compile *options file-or-module (to compile Ceylon and Java source to modules)
athena% *ceylon compile-js *options file-or-module (to compile Ceylon source to JavaScript)
athena% *ceylon doc *_options classpath _(to generate API documentation)
athena% *ceylon run *_options module _(to run a Java-based module)
athena% *ceylon run-js *_options module _(to run a JavaScript-based module)
athena% *ceylon help *(to get info about command-line help)
There is local toolset, language spec and API documentation; also vendor documentation, FAQand tour. See also the Ceylon Web page
See also: Dart, Fantom, Frege, HACK, Haxe, jython, Kotlin, scala

clisp

Description: Common Lisp compiler and interpreter. Also included are almost all of CLOS, a foreign language interface and a socket interface. An X11 interface is available through CLX and Garnet. Command line editing is provided by readline
TO RUN:
athena% clisp
Author site is here
See also: Allegro Common Lisp

Clojure

Description: Java-based, LISP-like dynamic programming language that compiles to Java bytecode
TO RUN:
athena% *clojure *(to run interactively; see documentation for compiling to Java class files)
There is a Web page, a reference guide, Wikipedia article and extended guide
See also: Allegro Common Lisp, Frege, guile, Hugs 98, Java Development Kit, jython, Kotlin,racket, scheme, SCM
*Note: *This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
sudo to root and install from the clojure1.2 or clojure1.4 Ubuntu package using aptitude or synaptic

cobra

Description: .NET/mono programming language compiler. cobra is a new language, under active development. It supports quick, expressive coding, fast execution, static and dynamic binding, support for unit tests and contracts, lambdas and closures
TO RUN:
athena% add -f mono
athena% cobra -ver 4.3 -c_ file.cobra (to compile {}file.cobra_ to CIL byte code file.exe)
athena% *mono -ver 4.3 *options file.exe _(to execute CIL byte code file {}file.exe_)
athena% cobra -ver 4.3 -h *(to see all {}cobra* command-line options)
The main Cobra page is here; documentation starts from here
See also: fsharpc, gdc, Java Development Kit, mcs, scala
Note: cobra *is being phased out, the -ver* switch is needed to make it accessible from an older mono locker. The version is not the cobra version.

Dart

Description: runtime environment for the Dart programming language. Dart *is an Open Source language from Google primarily intended for structured Web application design. It is intended to replace JavaScript but also supports a {}Dart* to JavaScript converter for browsers that do not currently support {*}Dart *natively. The development environment includes an integrated Dart-enabled version of the Chromium browser (Dartium) to allow direct incorporation of Dart code into html
TO RUN:
athena% add dart-lang
athena% dart file.dart _(to run* Dart *script file {}file.dart_)
athena% *dart2js -o *file.js file.dart _(to convert Dart {}file.dart_ to JavaScript file.js)
athena% *dartanalyzer *options file.dart _(to run static analyzer on {}file.dart_)
athena% *dartdoc *_options _(to generate API documentation)
athena% *pub *_options _(to use Dart package manager)
athena% chrome & (to launch Dart-enabled Chrome browser)
There is a web site, Wikipedia article and tutorial article. Vendor documentation starts here, with tools guide, tutorials and API reference
See also: Ceylon, Fantom, HACK, Haxe, jython, Kotlin, scala

Egison

Description: functional programming language written in Haskell whose primary feature is non-linear pattern matching with backtracking
TO RUN:
athena% add egison
athena% egison_ _(to run the interactive interpreter)
athena%* egison-tutorial *(to run tutorial demos)
There is an online manual, cheat sheet, and Web page
See also: EiffelStudio, Erlang, Frege, ghc, gprolog, Hugs 98, OCaml, Picat, sml, SWI Prolog

EiffelStudio

Description: development environment and command-line compiler for the *Eiffel *programming language. This is an object-oriented language that incorporates "programming by contract" in addition to the usual features of object-oriented languages
TO RUN:
athena% *add eiffel *
athena% estudio_ _(to run IDE)
athena% *ec *options file _(to use command-line compiler to compile Eiffel source file {}file_. See also README.hello_world)
Documentation is here; see also the local README.athena and the Eiffel Home Page, and gobo utility documentation. There is also an archival documentation site
See also: ***Egison,* Erlang, gdc, ghc, Hugs 98, OCaml, python, ruby, scala, sml, g++

Erlang

Description: functional programming language that incorporates features more commonly associated with an operating system such as concurrent processes, scheduling, memory management, distributed computing and networking
TO RUN:
athena% *erl *options files
At the *erl *> prompt:
1> toolbar:start(). starts the toolbar
2> halt(). will exit the runtime
Documentation is here and here; see also the Erlang Home Page
See also: ***Egison,* EiffelStudio, Fantom, ghc, Hugs 98, OCaml, python, ruby, Rust, scala, sml, g++
*Note: *This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
sudo to root and install from the erlang-base, erlang-toolbar and related Ubuntu packages using aptitude or synaptic

Fabric

Description: Java-based, federated, distributed language for securely and reliably storing, sharing and computing information
TO RUN:
athena% add fabric
athena%* fabc *options file.fab _(to compile Fabric source file {}file.fab_)
athena% *fab-store --store *_store-host-name _(to start a store; will leave a running process)
athena% fab -name **{}worker-host-name* *-make-principal_ store-host-name _(to create principal object)
athena% fab --name **{}worker-host-name* *_main-class _(to start worker)
An introductory README is here. There is a local paper (pdf), compiler API documentation, system API documentation and a Fabric page

Fantom

Description: general purpose object-oriented programming language that runs on the JRE and JavaScript. The language supports functional programming through closures and concurrency through the Actor model. Fantom takes a "middle of the road" approach to its type system, blending together aspects of both static and dynamic typing. Graphical applications are supported via the fwt toolkit (fantom widget toolkit)
TO RUN:
athena% setup fantom
athena% fan file.fan _(to compile and run* fantom *script file {}file.fan, or to build an executable {}pod{_}file; see documentation for details)
athena% fansh *(to run interactive {}fantom* shell)
athena% fant *_options _(to run fantom *tests)
athena% *flux *(to run IDE/editor)
There is a Website, cheat sheet, Wikipedia article and local documentation. See also the local README
See also: ***Ceylon, Dart, *Erlang, Frege, HACK, Haxe, jython, Kotlin, mcs, ruby, Rust, scala

Frege

Description: non-strict, pure functional programming language in the spirit of Haskell. It enjoys a strong static type system with type inference. Higher rank types are supported, though type annotations are required for that. Frege programs are compiled to Java and run in a JVM
TO RUN:
athena% add frege-lang
athena%* fregec options file.fr (to compile {}Frege* source in file.fr)
Typing fregec -help provides a summary of command-line options
athena%* frege package or module (to run compiled {}Frege* package or module)
athena% frege-repl (to run Frege REPL)
Typing :help at the frege> prompt provides a summary of command options
There is a web site with API documentation, a local language manual and slide presentation, and a wiki documentation page
See also: ***Ceylon,*[ Clojure|What Runs Where on Athena - Languages#Clojure],[ Egison|What Runs Where on Athena - Languages#Egison], Fantom,[ ghc|What Runs Where on Athena - Languages#ghc], Haxe, Hugs 98, Java Development Kit, jython, Kotlin, scala

fsharpc (F#)

Description: compiler and interactive interpreter for F# language, which runs in .NET/mono environments. F# is a variation of the ML functional programming language, with strong similarities to the *OCaml *dialect
TO RUN:
athena% add -f mono
and run commands below:
athena% *fsharpc *options file.fs _(to compile {}file.fs_ to bytecode file file.exe)
athena% *mono *file.exe _(to execute bytecode file {}file.exe_)
athena% *fsharpi *(to run interactive interpreter)
Documentation sites are here and here; there is also the F# Survival Guide
See also: cobra, Kotlin, mcs, OCaml, scala, sml

Gambas

Description: language and developement environment similar to, but not an exact clone of Visual Basic. Supports a variety of object-oriented extensions that allow interfacing applications to networking, database, audiovisual and other components (not all of these are available in the version on Athena due to missing dependencies)
TO RUN:
athena% *gambas3 & *
A documentation site is here
See also: Eclipse, mcs
*Note: *This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
sudo to root and install from the gambas3 Ubuntu package using aptitude or synaptic

gcj

Description: GNU Java compiler
TO RUN:
athena% add -f gcc-6plus
athena% gcj -O -o **{}file* --main=*<main class> options file.java
Please see file /mit/gcc-6plus/README for notes on linking to libraries in the gcc-6pluslocker. A default link will link to older libraries in the debathena release which may be incompatible.
See also: Java Development Kit
Note: *The {}gcj* compiler is a front-end to the* gcc compiler; it compiles your application to an executable binary by default. It can optionally compile to a .class file by using the *-C command-line switch. In using the latter, there is also a gij bytecode interpreter that can run classes generated by gcj (it works analogously to Oracle's java command). At run time, binaries generated from gcj will need access to libgcc_s.so and libgcj.so libraries supplied with gcj. There is an older version of gcj in the debathena release.

gdc

Description: native compiler for D language, based on gcc
TO RUN:
athena%* gdc *options file.d
There is a Web page and overview article. D sites on the Web are here and here
See also: cobra, EiffelStudio, gcc, g++, Java Development Kit, mcs (C#)
This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
sudo to root and install from the gdc Ubuntu package using aptitude or synaptic.

GDL (IDL clone)

Description: command-line interpreter and incremental compiler for the GNU Data Language, which is very similar to the commercial IDL language. Primarily used in scientific and geodata processing applications. Supports graphical output and compatible with many IDL programs
TO RUN:
athena% *gdl *(to start the interpreter and reach the GDL> command prompt)
GDL> *.run *myfile _(to compile and run a GDL program file {}myfile.pro_)
If the runtime prints something like:
% Compiled module: MYMODULE.
you can execute that particular module by typing:
GDL> MYMODULE
to run a script _batchfile.pro _containing batch commands (which is distinct from a GDL program):
GDL> @batchfile
Typing HELP,/LIB at the GDL> prompt gives a list of functions and procedures. There is a GDL Web page and an introductory tutorial
See also: matlab, octave, yorick

ghc (Glasgow Haskell Compiler)

Description: compiler and interpreter for Haskell *functional programming language. {}Haskell* is a purely functional language, featuring static typing, higher-order functions, polymorphism, type classes and monadic effects
TO RUN:
athena% ghc **{}options __{*}-o *file _{}file.hs (to compile source file {}file.hs_ to binary executable file)
athena% *ghci *(to start an interactive session in the interpreter)
Local documentation is at file:///usr/share/doc/ghc-doc/html/index.html; there is also an author site and the Haskell Home Page
See also: Egison, EiffelStudio, Erlang, Frege, Hugs 98, OCaml, Rust, sml

GNAT

Description: GNU Ada compiler
TO RUN:
athena% add -f gcc-6plus
athena%* gnatmake *options file.adb _(to compile source file {}file.adb to binary executable {}file_)
Please see file /mit/gcc-6plus/README for notes on linking to libraries in the gcc-6pluslocker. A default link will link to older libraries in the debathena release which may be incompatible.
There is a documentation page; please consult documentation for other usage modes

Go

Description: compilers for Go programming language from Google. Go is a systems programming language that incorporates and extends features of various modern languages including C, C++ and Java. There are two implementations: go in the ggo locker and gccgo in the gcc-6plus locker
TO RUN:
go:
athena% *setup ggo *(to run default version, currently 1.9)
athena% go run_ options file.go (to compile and run source file {}file.go_)
athena% go build_ options file.go (to compile source file {}file.go_ to binary file)
athena% godoc **{}command _(for summary information about {{}}command_. Typing {*}godoc go *will print useful information)
athena% *godoc --http=:6060 *(to start a local http server, launch browser at [http://localhost:6060/)
]
There is command documentation
----gccgo:
athena% add -f gcc-6plus
athena% *gccgo -g *options *-O2 -o *file file.go _(to compile source file {}file.go_ to binary file, dynamic link)
athena% go command options (to run command processor; type go with no command-line options for information)
Please see file /mit/gcc-6plus/README for notes on linking to libraries in the gcc-6pluslocker. A default link will link to older libraries in the debathena release which may be incompatible.
There is a Go home page with documentation
See also: gcc, g++, Java Development Kit, Nim, Rust
Note: go in the ggo locker is newer (currently at version 1.9) than gccgo in the gcc-6pluslocker (currently at version 1.6). There is an older version of gccgo in the debathena release.

gprolog

Description: Prolog compiler and interpreter conforming to Prolog ISO standard. Supports Prolog+ programs for constraint solving over finite domains
TO RUN:
athena% *gprolog *(for interpreter command-line interface)
athena% gplc **{}options* -o *myfile myfile.pl _(to compile source file {}myfile.pl_ to binary myfile)
There is an author Web page and local online documentation at
file:///usr/share/doc/gprolog-doc/gprolog.html/index.html
See also:[ Egison|What Runs Where on Athena - Languages#Egison], Picat, SWI Prolog
Note: *At the *?- Prolog command prompt, you can load a Prolog program myprog.pl containing facts and rules in the current directory by typing consult(myprog). *(without the {}.pl* extension). You can also start entering Prolog statements interactively by typing *[istdraft:user].* instead and entering Prolog code (type ctrl-d to terminate input). To exit Prolog type ctrl-d or halt. at the ?- prompt. Limited editing commands are available within the interpreter environment.
This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
sudo to root and install from the gprolog and gprolog-doc Ubuntu packages using aptitude or synaptic.

HACK

Description: Open Source web programming language for the HHVM (Hip Hop Virtual Machine) that is largely compatible with php. It allows programmers to use both static and dynamic typing
TO RUN:
athena% setup hacklang
athena% *hhvm *file.php (to run HACK code in file file.php)
There are HACK and hhvm Websites, a Wikipedia article and a tutorial. Vendor documentation starts here, and an introductory article is here. See the README.athena file for additional information
See also: Ceylon, Dart, Fantom, Haxe, jython, Kotlin, scala

Haxe

Description: Haxe is an Open Source language and compiler that can produce applications and source or bytecode for multiple platforms from a single code base. Target languages currently supported include Neko, Flash, JavaScript, C++, Java, Apache CGI and NodeJS. It is often used to develop Web applications. Neko is a high-level dynamically typed language created by the author of Haxe. It comes with a compiler that converts Neko source code to bytecode and a runtime engine
TO RUN:
For each target language, a file compile.hxml can be created and copied to the local directory where Haxe source code to be compiled is located. See documentation for details (compile.hxmlcontains haxe command line arguments that can result in excessively long command lines if they are put on the command line). For some target languages, additional Haxe components must be downloaded once and put in a local working directory within the user's home directory. The working directory must be specified by running a command once as indicated below
athena% add haxe
To compile Haxe source code:
athena% haxelib setup (once only, to set local working directory)
athena% haxelib install hxcpp (once only, for C++ setup)
athena% haxelib install hxjava (once only, for Java setup)
athena% haxe compile.hxml (to generate target language bytecode or binary)
Specific examples to run Haxe-generated binaries or bytecode:
athena%* neko myfile.n* (runs Neko bytecode created by haxe in myfile.n)
athena%* java -jar java.jar (runs Java bytecode created by {}haxe* in java.jar)
athena%* myfile* (runs binary myfile created by haxe from C++ source code)
JavaScript: open browser to file:///<local directory>/myfile.html, where myfile.html *is an html page that encapsulates {}myfile.js* created by haxe
Flash: open browser to file:///*<local directory>{}/myfile.html*, where myfile.html is an* htmlpage that encapsulates {}myfile.swf created by {}haxe*
athena% nekoc myfile.neko (compiles myfile.neko to myfile.n bytecode)
athena% neko myfile.n (runs myfile.n Neko bytecode file)
There is a Haxe Website, Neko Website, Haxe documentation, Haxe API documentation and Haxe tutorial
See also: Ceylon, Dart, Fantom, Frege, HACK, jython, Kotlin, scala

Hugs 98

Description: interactive programming environment for Haskell 98, the de facto standard for the Haskell functional programming language
TO RUN:
athena% hugs
Typing :set at the Hugs> prompt will display current settings
Local html documentation starts at file:///usr/share/doc/hugs/users_guide/index.html; there is also a Hugs home page and the Haskell Home Page
See also: Clojure, Egison, EiffelStudio, Erlang, Frege, ghc, OCaml, sml
*Note: *This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
sudo to root and install from the hugs Ubuntu package using aptitude or synaptic

J

Description: mathematical programming language that is a synthesis of APL with the FP and FLfunction-level languages. Incorporates extensive graphics capabilities and various extensions
TO RUN:
athena% add -f j
athena%* jqt & *(for graphical interface)
athena%* jhs *(for Web server)
athena%* jconsole *(for command-line console interface)
There is a vendor site with Wiki and introduction, a Wikipedia article and local intro guide and J for C programmers
See also: euler, yorick
Note: *The *-f command line option in the add command is to avoid launching a different jconsole that is part of the JDK. jconsole does not display a command line prompt while running, but indents the cursor by several spaces

Java Development Kit

Description: programming environment for developing applications or applets that are platform and architecture independent, based on a Java Virtual Machine. applications can be run stand-alone with a Java interpreter, but more commonly one uses applets run from within a Java-enabled Web browser such as firefox. javac is a compiler that compiles Java source code into an intermediate bytecode form that can then be interpreted by java (the runtime interpreter). appletviewer is a viewer for applets embedded within an html document.
There are multiple versions on Athena, in the Athena release and in various java lockers; the release version may or may not be the same as the "current" version accessible through the javalocker. To tell what version is in the release, type java -version without adding or attaching any java lockers. Typing* add -f java* will use the current default version in the java locker, and typing java -version again will tell you what version it is.
Java Web Start is a framework that allows launching Java applications directly by clicking on appropriate URLs within Web browsers, provided that a special mime type is configured for this.
TO RUN:
athena% *add -f java *(to use the latest default java locker JDK, currently 1.8.0_172; not necessary to use the java version in the debathena release)
athena% *add -f java_v10.0.1 *(to use the latest JDK 10.0.1)
athena% *add -f java_v9.0.4 *(to use the latest JDK 9.0.4)
athena% *add -f java_v1.7.0_79 *(to use the latest 1.7 JDK 1.7.0_79)
athena% *add -f java_v1.6.0_38 *(to use the latest 1.6 JDK 1.6.0_38)
athena% *add -f java_v1.5.0_22 *(to use the latest 1.5 JDK 1.5.0_22)
athena% javac myfile.java _(creates {}myfile.class_ intermediate code from source code file myfile.java)
athena% *java *myfile _(interprets intermediate code file generated by the compiler. Do not include the _.class extension)
athena% appletviewer* *myfile.html (views applet embedded in an html file)
athena% javaws* (to launch {}Java Web Start* application manager)
There is also:

• javadoc which generates API docs in html
• javah which creates C header and stub files for a Java class
• javap which is a compiled Java file disassembler
• jdb a Java language debuggerSee Web pages for local JDK 10 documentation, local JDK 9.0.4 documentation, local JDK 1.8.0 documentation, local JDK 1.7.0 documentation, local JDK 1.6.0 documentation, local JDK 1.5.0 documentation, local JDK 1.4.2 documentation, local Java 3d Documentation; Java tutorials, "Hello, World" in Java and a local documentation starting page. A free Web based Java textbook is here, Eckel's Thinking in Java is here, a Java FAQ is also available.
  Java 3d and the Advanced Imaging API are also installed in the current 1.8.0_172 java locker and in the java_v1.7.0_79 locker
  Applets embedded within html files can be run on any platform that has a Java-aware Web browser, but current releases of Web browsers may not be fully compatible with latest Java features. If this causes problems use appletviewer instead; but note that there may also be applet tag incompatibilities between appletviewer and various Web browsers.
  See also: ant, Clojure, cobra, Eclipse, Frege,[ gcj|What Runs Where on Athena - Languages#gcj], gdc, Go, IntelliJ IDEA, JBuilder, jython, Kotlin, mcs (C#), netBeans, python, scala, yorick

  Julia

  Description: high level dynamic programming language for technical computing developed at MIT by Professor Alan Edelman, Jeff Bezanson, Stefan Karpinski and Viral Shah. Julia uses syntax that is familiar to users of other technical computing environments. It provides a compiler, distributed parallel execution (though this is not currently supported on Athena), numerical accuracy and a mathematical function library. The library, mostly written in Julia itself, also integrates mature C and Fortran libraries for linear algebra, random number generation, FFTs and string processing. Juno is a new interactive development environment for Julia based on Light Table.
  TO RUN:
  athena% add julia
  To run command-line julia:
  athena%* julia*
  athena% julia file.jl (to run julia script* file.jl*)
  To run Juno *within {}Atom* (64 bit only):
  Please follow one-time setup instructions here, followed by:
  athena% atom
  followed by Julia -> Start Julia
  To run IJulia Notebooks:
  Please follow one-time setup instructions here, followed by:
  athena%* julia*
  at the julia> prompt, type:
  julia> using IJulia
  julia> notebook()
  There is a local README with important additional information, a Julia page, local online documentation and a development site
  MIT-specific and IJulia information is here
  See also: euler, GNU Scientific Library, matlab, Numerical Recipes, octave, OpenModelica, SAGE, scilab, yorick
  Note: Julia is currently under rapid development and the julia Athena locker is updated twice annually, before the start of each academic term. If you need to run the most recent version available the best way to proceed is to clone the git sources and build it yourself:
  git clone git://github.com/JuliaLang/julia.git
  cd julia
  make

  jython

  Description: python interpreter that generates Java bytecode- this allows direct access to Java class libraries from within python scripts
  TO RUN:
  athena% *jython *(for an interactive interpreter session)
  or executable script in jython with first line (jython must be on path for this to work):
  *#!/usr/bin/env jython *
  Local documentation is at file:////usr/share/doc/jython-doc/html/javadoc/index.html, a Jython Website and a jyton book
  See also: Ceylon, Clojure, Dart, Fantom, Frege, HACK, Haxe, Java Development Kit, Kotlin, python, scala, Sikuli
  *Note: jythonc *is no longer available. An article detailing workarounds is here

  Kotlin

  Description: statically typed programming language that compiles to JVM byte codes and JavaScript. It incorporates variable type inference, higher-order functions (closures), extension functions, code in interfaces and first-class delegation
  TO RUN:
  athena% add kotlin
  athena% *idea & *(to run Kotlin-aware IntelliJ IDEA IDE)
  athena%* kotlinc-jvm *options files (to run JVM Kotlin compiler)
  athena%* {}kotlinc-js *options files (to run JS Kotlin compiler)
  There is documentation, API documentation, a home page and important local information
  See also: Ceylon, Clojure, Dart, Fantom, Frege, fsharpc, HACK, Haxe, IntelliJ IDEA, Java Development Kit, jython, scala

  logo

  Description: Logo programming language; frequently used to introduce programming concepts to young children
  TO RUN:
  athena% logo
  Documentation is at file:///usr/share/doc/ucblogo/html/html/usermanual.html
  See also: Processing, scheme

  lua

  Description: extensible, general-purpose scripting language designed for ease of use
  TO RUN:
  athena% *lua *(to start an interactive session with the interpreter)
  athena% lua file.lua _(to run a lua source script {}file.lua_)
  athena% lua file.luac _(to run a lua bytecode file {}file.luac_)
  athena% luac -o **{}file.luac _{{}}file.lua* (to compile a {}lua* source script {}file.lua to bytecode file {}file.luac_)
  There is a lua home page with online documentation; local documentation starts at
  file:///usr/share/doc/lua5.1-doc/doc/index.html
  See also: awk, newLISP, perl, python, ruby, Tcl/Tk
  *Note: *bytecode files don't offer significant speedup other than faster loading; they are mostly useful for protecting source code from accidental changes and off-line syntax checking

  mcs (C#, mono programming environment)

  Description: C# compiler, part of Mono computing environment
  TO RUN:
  athena% add -f mono
  athena% *csharp *(to run interactive interpreter)
  athena% *mcs *options file.cs _(to compile C# source file {}file.cs_ to CIL byte code file file.exe, all profiles and C# 1.0, 2.0, 3.0, 4.0, 5.0 specifications)
  athena% *dmcs *options file.cs _(to compile C# source file {}file.cs_ to CIL byte code file file.exe, 4.0 profile)
  athena% *mono *options file.exe _(to execute CIL byte code file {}file.exe_)
  The main Mono page is here; documentation starts from here and here
  See also: cobra, Fantom, fsharpc, Gambas, gdc, Java Development Kit, Rust, scala
  Note: *other {}mono* components including the compilers above are also installed in the debathena release; the versions in the mono locker are more recent; the *-f* switch in the add command ensures that the versions in the mono locker are first in your path. The cobra and F# language compilers are also installed in the mono locker

  nasm

  Description: 80x86 assembler designed for portability and modularity. Supports a wide range of object formats and macros. Also supports a variety of variant instructions
  TO RUN:
  athena% *nasm *_options file.asm _
  There is local documentation at file:///usr/share/doc/nasm/html/nasmdoc0.html and a home page. A Linux assembly page may also have useful information
  *Note: *This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
  sudo to root and install from the nasm Ubuntu package using aptitude or synaptic

  newLISP

  Description: extensible, embeddable scripting language based on LISP
  TO RUN:
  athena% add newlisp
  athena%* newlisp *(to start an interactive session with the interpreter)
  athena% newlispdoc_ _(to generate documentation for newLISP source files in current directory)
  athena% newlisp-edit_ _(to launch the editor/IDE)
  There is a newLISP home page with documentation and tutorials; a Wikipedia article; also a local online manual
  See also: awk, guile, lua, perl, python, ruby, Tcl/Tk

  Nim

  Description: statically typed, imperative systems programming language with extensive metaprogramming support, generics, exception tracking and optional garbage collection built in. Rivals C in performance
  TO RUN:
  athena%* add nim-lang*
  athena% *nim *options program.nim _(to compile and optionally run Nimrod source file {}program.nim_)
  athena% nimble *COMMAND_ options (to run {}nimble{} package maintainer; see documentation for {}COMMAND{_}* options)
  athena% koch options COMMAND (to run the maintenance program; see documentation for COMMAND options)
  athena% nimgrep options pattern replacement file/directory (to run the search-and-replace tool)
  There is author and local documentation, tutorials here and here, a forum and home page; What is special about Nim?, What makes Nim practical?, How I start: Nim
  See also: gcc, g++, Go, python, Rust
  Note: Nim was formerly called Nimrod

  OCaml

  Description: compiler, interpreter and related utilities for *Caml *functional programming language
  TO RUN:
  athena% *ocaml *(to start an interactive session)
  athena% *ocamlc -o *program program.ml _(to generate executable bytecode file {}program _from caml source)
  athena% ocamlopt **{}options __{*}-o *program program.ml _(to generate binary {}program _from caml source)
  There is a home page and tutorial starting point; local documentation starts at
  file:///usr/share/doc/ocaml-doc/ocaml.html/index.html
  See also: Egison, EiffelStudio, Erlang, fsharpc, ghc, Hugs 98, sml
  Note: *bytecode executable files require access to {}ocamlrun* runtime to execute; ocamlc *build is configured to find this at */usr/bin/ocamlrun. *ocamlopt *compiler requires access to system C compiler to create binaries

  perl

  Description: general-purpose programming language particularly well suited to system management tasks and as a substitute for shell scripts. Has many built-in functions, particularly for string and text handling
  TO RUN:
  athena% perl file.pl
  or executable script in Perl with first line:
  #!/usr/bin/env perl
  There is documentation on the Web for Perl 5 and Perl 6; the man page (man perl) will point you to other local documentation
  See also: awk, lua, newLISP, python, ruby, Tcl/Tk, yorick

  Picat

  Description: logic-based multi-paradigm programming language aimed for general-purpose applications. Picat is a rule-based language, in which predicates, functions, and actors are defined with pattern-matching rules. Picat incorporates many declarative language features including explicit non-determinism, explicit unification, functions, list comprehensions, constraints, and tabling. Picat also provides imperative language constructs, such as assignments and loops. Picat can be used for not only symbolic computations but also for scripting and modeling tasks
  TO RUN:
  athena% add picat
  athena%* picat *(to run interactive interpreter)
  athena% *picat *file.pi (to compile and run Picat code in file.pi from the Athena prompt)
  Picat>* cl(myprog)* (to load and compile Picat program myprog in file myprog.pi within the interpreter)
  There is a home page, local get started, tutorial, manual and newsgroup
  See also:[ Egison|What Runs Where on Athena - Languages#Egison], gprolog, SWI Prolog

  Processing

  Description: Java-based programming language and environment for users who want to program images, animation and interactions. Created to teach the fundamentals of programming in a visual context and to serve as a software sketch book and professional production tool
  TO RUN:
  athena% *add processing *
  athena% *processing *(to run GUI)
  athena% *processing-java *_options input output _(to run sketches from the command line)
  There is a Processing home page with tutorials and local reference documentation
  See also:[ logo|What Runs Where on Athena - Languages#turtle], scheme, Sikuli, yorick

  python

  Description: general-purpose, extensible scripting language
  TO RUN:
  athena% python (for interactive mode)
  athena% ipython (for enhanced interactive shell)
  or executable script in Python with first line:
  #!/usr/bin/env python
  athena% idle (for GUI interactive shell)
  The man page (man python) will point you to much detailed documentation
  There is a Python Website
  NumPy* is a numerical routine package that has been added to the {}python* version in the Athena release. To access routines in the package from the *>>>* prompt:
  *>>> from numpy import **
  To get help:
  >>> help()
  help> numpy
  There is a NumPy page with links to documentation and a tutorial
  SciPy is a package of scientific tools for python *depending on numpy*. To access routines in the package from the *>>>* prompt:
  >>> from scipy import ... (replace *... *with routines to import)
  To get help:
  >>> help()
  help> scipy
  There is a SciPy page with links to documentation and a tutorial
  matplotlib adds plotting routines to Python. To access routines in the package from the *>>>*prompt:
  >>> from matplotlib import ... (replace *... *with routines to import)
  *>>> from pylab import **
  To get help:
  >>> help()
  help> matplotlib
  There is a matplotlib page with links to documentation and a tutorial
  See also: boost, EiffelStudio, Erlang, gnuplot, GNU Scientific Library, IT++, Java Development Kit, jython, lua, matlab, newLISP, Nim, perl, ruby, tecplot, yorick

  racket (formerly plt-scheme)

  Description: racket Scheme development environment, consisting of a GUI development environment (drracket), command-line interpreter (racket), graphics-capable interpreter (gracket), Scheme compiler (mzc) and help-system interface (plt-help); designed primarily for teaching Scheme programming
  TO RUN:
  athena% add -f racket
  athena% *drracket & *(to run GUI programming environment
  athena% *gracket & *(to run graphics-capable interpreter)
  athena% *racket *(to run command-line interpreter)
  athena% *mzc *options file.scm (to compile file.scm)
  athena% plt-help (to access help system)
  There is local 6.12 documentation and a web site
  "Structure and Interpretation of Computer Programs" is here
  See also: Allegro Common Lisp, Clojure, guile, scheme, SCM
  Note: add -f is required to access the versions in the racket lockers instead of the one in the *debathena *release.The former is likely to be newer

  ruby

  Description: general-purpose, object-oriented scripting language
  TO RUN:
  athena% ruby ruby_file.rb
  or executable script in Ruby scripting language with first line:
  #!/usr/bin/env ruby
  athena% irb (for interactive mode)
  Documentation is here
  See also: EiffelStudio, Erlang, Fantom, lua, newLISP, perl, python, Rust

  Rust

  Description: compiler and related utilities for the Rust *programming language. {}Rust* is a curly-brace, block-structured expression language. It visually resembles the C language family, but differs significantly in syntactic and semantic details. Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency
  It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles
  TO RUN:
  athena% add rust-lang
  athena% *rustc *options file.rs (to compile source code file file.rs)
  athena% *rustc *(to see command-line options)
  athena% *rustdoc *options input (to generate Rust documentation from Rust source code)
  athena% cargo command args (to run Rust package manager)
  There is a local manual, local tutorial and home page
  See also: Erlang, Fantom, ghc, g++, Go, mcs, Nim, ruby
  Note: Rust is under very rapid development and it is likely that the locker installation will become outdated before the next update

  scala

  Description: object-oriented, functional and statically typed programming language that interoperates with Java and .NET. scala is extensible and is itself written in Java (and thus requires a JVM to run)
  TO RUN:
  athena% scalac file.scala _(to compile scala source file to bytecode file {}file.class_)
  athena% scala file _(to run scala class file {}file.class_; as in Java, the _.class_ extension is omitted)
  athena% *scala *(for interactive interpreter, *:q *to exit)
  There is a website with documentation
  See also: Ceylon, cobra, Dart, EiffelStudio, Erlang, Fantom, Frege, fsharpc, HACK, Haxe, Java Development Kit, jython, Kotlin, mcs

  scheme

  Description: MIT Scheme, a dialect of Lisp developed for educational applications
  TO RUN:
  athena% add scheme
  athena% scheme (to run an interactive scheme session)
  athena% edwin (to run an edwin editor session)
  "Structure and Interpretation of Computer Programs" is here, and there is html and pdfdocumentation
  See also: Allegro Common Lisp, Clojure, guile, Processing, racket, SCM

  SCM

  Description: compact, fast command-line Scheme interpreter with SLIB Scheme library
  TO RUN:
  athena% scm
  There is local SCM documentation at file:///usr/share/doc/scm/scm.html, SLIB documentation at file:///usr/share/doc/scm/Xlibscm.html and an SCM page
  "Structure and Interpretation of Computer Programs" is here
  See also: Allegro Common Lisp, Clojure, guile,[ racket|What Runs Where on Athena - Languages#drscheme], scheme
  *Note: *This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
  sudo to root and install from the scm Ubuntu package using aptitude or synaptic

  Sikuli

  Description: MIT-developed visual scripting language that allows automated generation and testing of user interfaces
  TO RUN:
  athena% sikuli-ide & (to run IDE)
  athena% sikuli-ide *--args *{}arguments* -r *sikuli script (to run a script on the command line)
  There is a home page, documentation and a tutorial page
  See also: jython, Processing
  Note: This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
  sudo to root and install from the sikuli-ide Ubuntu package using aptitude or synaptic.
  There is a bug that makes sikuli-ide crash on launch; to work around this you can sudo to root and add the following classes to /usr/bin/sikuli-ide:
  /usr/share/maven-repo/com/google/guava/guava/debian/guava-debian.jar:/usr/share/maven-repo/org/jruby/ext/posix/jnr-posix/debian/jnr-posix-debian.jar:/usr/share/java/jaffl.jar

  sml (Standard ML of New Jersey)

  Description: compiler, interactive system and programming environment for the Standard MLlanguage
  TO RUN:
  athena% *sml *(to start an interactive session)
  There is an author site and documentation links
  See also: Egison, EiffelStudio, Erlang, fsharpc, ghc, Hugs 98, OCaml

  SWI Prolog

  Description: ISO compatible Prolog compiler, with various enhancements including a C++ interface, execution profiler and GUI application development environment
  TO RUN:
  athena% *swipl *(for command-line interface)
  athena% *xpce *(for interface to GUI system)
  There is an author Web page, local online reference manual starting at
  *file:///usr/share/doc/swi-prolog-doc/Manual/index.html *
  and user guide starting at file:///usr/share/doc/swi-prolog-doc/UserGuide/index.html
  See also: Egison, gprolog, Picat
  Notes:
  At the ?- Prolog command prompt, you can load a Prolog program myprog.pl containing facts and rules in the current directory by typing [istdraft:myprog]. *(without the {}.pl* extension). You can also start entering Prolog statements interactively by typing *[istdraft:user].* instead which changes the prompt to |: ( type ctrl-d to terminate entry mode and return to the ?- prompt). To exit Prolog type ctrl-d or halt. at the ?- prompt. Within Prolog, you can invoke the built-in editor to create file myfile by typing set_prolog_flag(editor, pce_emacs). followed by edit(file(myfile)).
  This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
  sudo to root and install from the swi-prolog and swi-prolog-doc Ubuntu packages using aptitude or synaptic

  yorick

  Description: interpreted programming language, designed for postprocessing or steering large scientific simulation codes. Smaller scientific simulations or calculations, such as the flow past an airfoil or the motion of a drumhead, can be written as standalone yorick programs. The yorick language is designed to be typed interactively at a keyboard, as well as stored in files for later use. Yorick includes an interactive graphics package
  TO RUN:
  athena% yorick
  There is an author Web page, local documentation starting point at
  file:///usr/share/doc/yorick-doc/README.html and pdf manual:
  file:///usr/share/doc/yorick-doc/manual/yorick.pdf.gz
  See also: euler, GDL, J, Java, Julia, nickle, PARI/GP, perl, Processing, python, SAGE, SciPy
  *Note: *This application is no longer installed. You can install it temporarily (on a debathena-cluster machine) or permanently (on a debathena-workstation or non-Athena Ubuntu machine) but not on the Athena dialups by doing the following:
  sudo to root and install from the yorick, yorick-doc and related Ubuntu packages using aptitude or synaptic

Debuggers / Development Environments

ant

Description: Java build utility, conceptually similar to make
TO RUN:
athena% *ant *
Requires at least one xml build file (usually named build.xml) in the directory you invoke it from, in addition to your Java source files. Default java used is the one debathena release, but you can change this to the latest java locker version by setting the JAVA_HOME environment variable to
/afs/athena.mit.edu/software/java/current/distrib/home
There is a development site that includes documentation
See also: Java Development Kit, JBuilder, NetBeans

antlr, antlrworks

Description: antlr is a language tool for constructing recognizers, interpreters, compilers and translators from grammatical descriptions containing actions in a variety of target languages (Java and C are currently supported on Athena). antlrworks is an IDE and debugger for antlr
TO RUN:
athena% add antlr
----4.5 java version:
athena% antlr4 **{}options* file.g4 (to generate lexer and parser java code from {}antlr* grammar description file file.g4)
athena% ajavac *_file.java _(to create classes for main program, lexer and parser)
athena% grun file r options_ _(to test the compiled executable)
4.5 antlrworks:
athena% antlrworks2 &
----3.4 java version:
athena% antlr -ver 3.4 **{}options* file.g (to generate lexer and parser java code from {}antlr{*}grammar description file file.g)
athena% ajavac -ver 3.4_ Main.java fileLexer.java fileParser.java (to build java executable using {}Main.java_ as a driver program)
athena% ajava -ver 3.4_ Main _(to run the compiled executable)
3.4 C language version:
athena% antlr -ver 3.4_ file1.g file2.g (to generate C files {}file2.c_, file1Lexer.c, file1Parser.c)
athena% gcc -o **{}Main __-O2_ *Main.c -I. -I/mit/antlr/include* {}file2.c_ file1Lexer.c file1Parser.c *-L/mit/antlr/lib -lantlr3c *(to compile to Main)
athena% setenv LD_LIBRARY_PATH /mit/antlr/lib (C shell)
or
athena%* export LD_LIBRARY_PATH=/mit/antlr/lib* (bash shell)
athena% Main input (to run compiled binary Main _using input data in input_)
3.4 antlrworks:
athena% antlrworks -ver 3.4 &
----Note: *There is currently no {}C* inplementation for antlr 4.5. In the 3.4 launch commands above, antlr is equivalent to java org.antlr.Tool in the antlr documentation, and antlrworks is equivalent to java -jar antlrworks-1.4.3.jar
ajavac and ajava are wrappers for invoking javac and java that set an appropriate CLASSPATHbefore invoking these java commands
There is a development site that includes 4.5 documentation and 3.4 documentation; also an antlrworks 2 page

CMake

Description: cross-platform build system generator. Projects specify their build process with platform-independent CMake listfiles included in each directory of a source tree with the name CMakeLists.txt. Users build a project by using CMake to generate a build system for a native tool on their platform
TO RUN:
athena% cmake _options path-to-source _(to run cmake)
athena% ccmake _options path-to-source _(to run *ccmake *curses interface)
athena% cpack -G generator _options _(to run packaging program)
athena% ctest _options _(to run the test driver)
Running cmake --help-full will print detailed help; there are man pages for cmake and other utilities; html help is available from here; there is a CMake page

Cscope

Description: developer's tool for browsing source code; cbrowser is a GUI front end for Cscope
To run:
athena% add cscope
athena% cscope *_options _(to run {}Cscope* in command-line mode)
athena% cbrowser & (to run cbrowser GUI)
athena% *man cscope *(for help)
There is a web page
See also: dbx, gdb, lint, TotalView, valgrind

dbx, dbxtool

Description: Developer Studio source-level debugging tool for a variety of languages including C, C++, FORTRAN and Java. Use with programs compiled with the -g compiler switch
TO RUN:
athena% add sunsoft_v12.6
athena% dbx _file _(command-line version)
athena% dbx{*}tool *& _ _(GUI version)
There is documentation
See also:[ Cscope|What Runs Where on Athena - Languages#Cscope], gdb, lint, TotalView, valgrind
Note: There are additional utilities in the Solaris Studio suite that allow checking for memory leaks and code coverage; type man discover, man uncover and man tcov for details

Eclipse

Description: open, extensible IDE for anything and nothing in particular. One major use is a Java IDE
TO RUN:
athena% add -f eclipse-sdk
athena% eclipse
There is a development site, documentation site and FAQs
See also: Gambas, IntelliJ IDEA, Java Development Kit, JBuilder, NetBeans, Solaris Studio
Note: *On debathena, there is an older version of Eclipse installed in the release and accessible as */usr/bin/eclipse; the version in the eclipse-sdk lockers is generally newer and also has a variety of preinstalled plugins for MIT users.

gdb

Description: gnu C, C++ and FORTRAN dynamic debugger which can attach running processes. Use with programs compiled with the -g compiler switch
To run:
athena% gdb file(s)
athena% man gdb (for help)
See also: Cscope, dbx, lint, TotalView, valgrind

IntelliJ IDEA

Description: Java Integrated Development Environment with support for the Kotlin programming language
TO RUN:
athena% add kotlin
athena% idea &
There is a home page
See also: Eclipse, Java Development Kit, JBuilder, Kotlin, NetBeans, Solaris Studio

JBuilder Foundation

{_}Note: __(old- last free version that runs on Athena)_
Description: Java Integrated Development Environment from Borland. Supplied with integrated Java Development Kit and ant
TO RUN:
athena% add jbuilder
athena% jbuilder &
There are version 2005 What's New, Release Notes, pdf manuals
See also: ant, Eclipse, IntelliJ IDEA, Java Development Kit, NetBeans
Note: *Jbuilder* now comes with an internal ant distribution (currently 1.6.2)

NetBeans

Description: Java Integrated Development Environment from Oracle
TO RUN:
athena% *add netbeans *
athena% netbeans &
There is a Development site, Knowledge Base
See also: ant, Eclipse, Java Development Kit, IntelliJ IDEA, JBuilder, Solaris Studio

Oracle Developer Studio

Description: Oracle integrated development environment
TO RUN:
athena% add sunsoft_v12.6
athena% *sunstudio & *
There is Developer Studio 12.6 documentation and overview; also a local documentation starting point
See also: Eclipse, NetBeans

TotalView

Description: Fortran, C and C++ debugger particularly well suited for high performance multiprocessor and multithreaded systems
TO RUN:
athena% add totalview
athena% totalview file options (for GUI version)
athena% *totalviewcli *(for command-line version)
There is local and vendor site documentation, and a home page.
See also: Cscope, gdb, dbx, ftnchek, lint, valgrind
Note: See end of README.athena for note on usage on recent Ubuntu releases

valgrind

Description: profiler and dynamic memory allocation debugger for Linux programs. Use with programs compiled with the -g compiler switch
TO RUN:
athena% valgrind options ./binarytotest
There is online help, starting from file:///usr/share/doc/valgrind/html/index.html, and an author Website
See also: Cscope, dbx, TotalView