Frequently Asked Questions

Why are you designing a new programming language?

Soon, chips will only get "wider", not faster, because of power consumption problems. Already, Sun sells single CPU chips that provide 64 threads of execution. It's easy to use this much parallelism with embarrassingly, obviously parallel problems (like running web servers, or Monte Carlo simulations), but for general computing, programmed by ordinary programmers, using that much parallelism effectively is difficult with today's languages, even the Java Programming Language^TM, which is the best of the bunch.

Fortress aims to make parallelism more tractable in several ways. First, parallelism is the default. This is intended to push tool design, library design, and programmer skills in the direction of parallelism. Second, we're designing the language to be more friendly to parallelism. Side-effects are discouraged because side-effects require synchronization to avoid bugs. Fortress provides transactions, so that programmers are not faced with the task of determining lock orders, or tuning their locking code so that there is enough for correctness, but not so much that performance is impeded. The Fortress looping constructions, together with the library, turns "iteration" inside out; instead of the loop specifying how the data is accessed, the data structures specify how the loop is run, and aggregate data structures are designed to break into large parts that can be effectively scheduled for parallel execution. Fortress also includes features from other languages intended to generally help productivity -- test code and methods, tied to the code under test; contracts that can optionally be checked when the code is run; and properties, that might be too expensive to run, but can be fed to a theorem prover or model checker. In addition, Fortress includes safe-language features like checked array bounds, type checking, and garbage collection that have been proven-useful in Java. Fortress syntax is designed to resemble mathematical syntax as much as possible, so that anyone solving a problem with math in its specification can write a program that can be more easily related to its original specification.

What is Fortress?

Fortress is a new programming language designed for high-performance computing (HPC) with high programmability. In order to explore breakaway approaches to improving programmability, the Fortress design has not been tied to legacy language syntax or semantics; all aspects of HPC language design have been rethought from the ground up. As a result, we are able to support features in Fortress such as transactions, specification of locality, and implicit parallel computation, as integral features built into the core of the language. Features such as the Fortress component system and test framework facilitate program assembly and testing, and enable powerful compiler optimizations across library boundaries. Even the syntax and type system of Fortress are custom-tailored to modern HPC programming, supporting mathematical notation and static checking of properties such as physical units and dimensions, static type checking of multidimensional arrays and matrices, and definitions of domain-specific language syntax in libraries. Moreover, Fortress has been designed with the intent that it be a "growable" language, gracefully supporting the addition of future language features. In fact, much of the Fortress language itself (even the definition of arrays and other basic types) is encoded in libraries atop a relatively small core language.

Is Fortress a language intended only for high-performance computing?

No. Fortress is a general-purpose programming language. Its support for large-scale parallelism and management of data locality, its use of mathematical notation for syntax, and its static checking of units and dimensions (among other things) make it particularly well suited to high-performance computing.

Is Fortress an extension of the Java(TM) programming language? What about Fortran?

Fortress is a new language. Although many of its features are inspired by existing languages, it isn't an extension of any of them. Syntactically, many Fortress expressions closely resemble mathematical notation.

Is Fortress designed to replace the Java programming language?

No. Although Fortress and the Java programming language are both general-purpose programming languages, the design tradeoffs are significantly different. The Java programming language is designed to use a familiar syntax and class system while providing as much portability as possible. As a result, it is well suited for network and embedded programming. In contrast, Fortress uses many novel language features in an attempt to alleviate the tension between modern software engineering principles and high performance computing. Fortress is well suited to programming on massively parallel computers, as well as on smaller systems.

How does Fortress compare to Chapel? How does it compare to X10?

Fortress is one of three languages for high-performance computing developed as part of the DARPA HPCS Program. The others are X10 (from IBM) and Chapel (from Cray). X10 is an extension to the Java(TM) programming language that supports high performance computing with a message-passing-based protocol for thread-to-thread communication. Chapel is a parallel language based on a shared memory model. Fortress differs from both of these languages in several respects. In an attempt to improve programmability for high-performance computing, Fortress syntax emulates mathematical notation as closely as possible. It has a novel type system to better integrate functional and object-oriented programming, it allows for specification of data distribution through the use of distribution" data structures, it supports static checking of physical units and dimensions, it supports embedding of domain-specific language syntax in programs, and it includes a component system to facilitate the process of compiling, linking, and deploying programs.

In what ways does Fortress syntax resemble mathematical notation?

The NAS (NASA Advanced Supercomputing) Conjugate Gradient Parallel Benchmark is a small program used in high-performance computing to evaluate and compare performance of parallel supercomputers. A description of this benchmark can be found at: http://www.nas.nasa.gov/Resources/Software/npb.html Here is its implementation in Fortress.

Note the use of subscripts and superscripts, the fact that multiplication is represented simply by writing the operands side by side (placing spaces in between them), the rendering of rational expressions, and the use of Unicode symbols for variables and operators.

What support does Fortress provide for parallelism and locality?

Fortress is designed to make parallel programming as painless as possible. Many of the core language constructs in Fortress, including function argument evaluation and for" loops, are parallel by default. Threads can synchronize using atomic code blocks. Fortress supplements this implicit fork-join threading model with explicit futures, and provides programmers with ways to control where particular threads are run and how large objects are laid out in memory.

Where can I download the code?

A preliminary, open source, interpreter implementing a small core of Fortress language features is available here. This interpreter runs on the JVM. To try out the code, you can check out our Subversion repository and follow the build instructions in the included README file. You can also download a pre-build zip file of the Project Fortress distribution, though it is not always up to date. Our intention is to grow this implementation over time, with the help of university partners and other interested third parties. We expect that many parts of this interpreter will be used as components of a complete Fortress compiler, which is our long term goal.

How far along are you?

We have released a series of draft specifications of the language and we have published formal calculi and soundness proofs of several of the core language features. We've presented a demo showing parallel Fortress execution on a number of small programs at Sun Open House 2006 in Menlo Park CA. Look for source code, tutorials, and other supporting materials to be released at: http://research.sun.com/projects/plrg

See also the ProjectStatus page for information on what Fortess features are implemented and which features you should not yet try.

What platforms will Fortress run on?

Fortress has been designed to run well on a variety of platforms, including supercomputers with large stores of addressable memory, commodity clusters, workstations, etc. Many aspects of the language have been designed to be as portable as possible. Our initial implementation effort targets the JVM.

How do you plan to convince programmers to use your language?

Fortress uses a widely known syntax that has evolved over thousands of years: mathematical notation. It allows programmers to reason in their problem domain without translating entities such as quantities and physical units into unfamiliar abstractions. We expect these features will help to keep the learning curve down for new programmers. We are also soliciting feedback on the language design from HPC programmers, in government, academia, and industry, in order to improve the design and to get more buy-in. But our primary strategy for getting programmers to adopt our language is to design the best language we can. We aren't tying our hands behind our back by attempting to support legacy and obsolete language features.

Does Fortress support some form of static effects tracking to prevent using side effects within parallel constructs?

No. To our knowledge there is no system of static effects tracking that deals gracefully with large shared arrays, the bread and butter of parallel computing. There are systems that attack the problem in a limited way--for example by allowing computations to access only a single array element in an individual parallel computation, or by partitioning an array into disjoint pieces--but Fortress is designed for general-purpose parallel programming.

Will Fortress support nested data parallelism for fine-grained parallelism a la NESL and Haskell NDP?

There is nothing preventing the implementation of such a system within Fortress, and we already have code submitted to provide prefix-style operations for certain Generators. Our goal is to desugar comprehensions in such a way that NESL-style treatment of comprehensions ought to be efficient. We're not specifically implementing NESL or NDP-style arrays at present, though we may do so once we have more of the basic language constructs in place.

Insert Your Questions, here