Julia (programming language) | EPFL Graph Search

Are you an EPFL student looking for a semester project?

Work with us on data science and visualisation projects, and deploy your project as an app on top of GraphSearch.

Julia is a high-level, general-purpose dynamic programming language. Its features are well suited for numerical analysis and computational science. Distinctive aspects of Julia's design include a type system with parametric polymorphism in a dynamic programming language; with multiple dispatch as its core programming paradigm. Julia supports concurrent, (composable) parallel and distributed computing (with or without using MPI or the built-in corresponding to "OpenMP-style" threads), and direct calling of C and Fortran libraries without glue code. Julia uses a just-in-time (JIT) compiler that is referred to as "just-ahead-of-time" (JAOT) in the Julia community, as Julia compiles all code (by default) to machine code before running it. Julia is garbage-collected, uses eager evaluation, and includes efficient libraries for floating-point calculations, linear algebra, random number generation, and regular expression matching. Many libraries are available, including some (e.g., for fast Fourier transforms) that were previously bundled with Julia and are now separate. Julia can work with other languages, e.g. has special (keyword) support for calling C language libraries; and e.g. for working with Python, R, Rust, C++, SQL with use of extra packages and to work with or even to compile Julia code to JavaScript. Julia can be compiled to binary executables using a package for it supporting all Julia features. Small binary executables can also be made using a different package but then the Julia runtime is not included in the executable, e.g. down to 9 KB (then without e.g. the garbage collector since it is part of Julia's runtime, i.e. with similar limited capabilities to the C language), for computers or even microcontrollers, such as Arduino with 2 KB of RAM. By default, Julia code depends on the Julia runtime to support all Julia features, e.g. threading, but some (non-idiomatic, to smaller or larger degree) Julia code can be compiled to small executables (with limited Julia capabilities). In both cases no source code needs to be distributed.

About this result

This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.

Related concepts (131)

Related courses (23)

Related lectures (127)

OpenCL

OpenCL (Open Computing Language) is a framework for writing programs that execute across heterogeneous platforms consisting of central processing units (CPUs), graphics processing units (GPUs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs) and other processors or hardware accelerators. OpenCL specifies programming languages (based on C99, C++14 and C++17) for programming these devices and application programming interfaces (APIs) to control the platform and execute programs on the compute devices.

Complex data type

Some programming languages provide a complex data type for complex number storage and arithmetic as a built-in (primitive) data type. A complex variable or value is usually represented as a pair of floating-point numbers. Languages that support a complex data type usually provide special syntax for building such values, and extend the basic arithmetic operations ('+', '−', '×', '÷') to act on them. These operations are usually translated by the compiler into a sequence of floating-point machine instructions or into library calls.

Dynamic programming language

In computer science, a dynamic programming language is a class of high-level programming languages, which at runtime execute many common programming behaviours that static programming languages perform during compilation. These behaviors could include an extension of the program, by adding new code, by extending objects and definitions, or by modifying the type system. Although similar behaviors can be emulated in nearly any language, with varying degrees of difficulty, complexity and performance costs, dynamic languages provide direct tools to make use of them.

Mettre en pratique les bases de la programmation vues au semestre précédent. Développer un logiciel structuré. Méthode de debug d'un logiciel. Introduction à la programmation scientifique. Introductio

The course introduces the foundations on which programs and programming languages are built. It introduces syntax, types and semantics as building blocks that together define the properties of a progr

Learn the concepts, tools and API's that are needed to debug, test, optimize and parallelize a scientific application on a cluster from an existing code or from scratch. Both OpenMP (shared memory) an

Random Field Ising Model on Graphs PHYS-642: Statistical physics for optimization & learning

Explores the Random Field Ising Model on random graphs, discussing belief propagation updates and population dynamics.

Python Programming: File Handling and Exceptions

Explores file handling and exceptions in Python programming, covering reading, writing, and error handling strategies.

Scala Lens Compilation

Covers the compilation process of Scala Lens and the use of iterable collections for padding results.