You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
@@ -696,6 +717,42 @@ For more information, you can visit the [COBOL programming language Wikipedia pa
696
717
```
697
718
@LIA.cobol
698
719
720
+
### Coq : `@LIA.coq`
721
+
722
+
Coq is an interactive theorem prover and functional programming language developed by the French Institute for Research in Computer Science and Automation (INRIA). It is designed for formal verification of mathematical proofs and software programs, allowing developers to write and verify complex mathematical statements and algorithms. Coq is based on the Calculus of Inductive Constructions (CIC), a powerful type theory that supports dependent types, higher-order logic, and formal reasoning. The backend here uses the Coq compiler to execute Coq code, ensuring correctness and reliability of the proofs and programs.
723
+
724
+
For more information, you can visit the [Coq programming language Wikipedia page](https://en.wikipedia.org/wiki/Coq).
725
+
726
+
---
727
+
728
+
```coq
729
+
Require Import ZArith.
730
+
Open Scope Z_scope.
731
+
Goal forall a b c:Z,
732
+
(a + b + c) ^ 2 =
733
+
a * a + b ^ 2 + c * c + 2 * a * b + 2 * a * c + 2 * b * c.
734
+
intros; ring.
735
+
Qed.
736
+
```
737
+
@LIA.coq
738
+
739
+
### D : `@LIA.d`
740
+
741
+
D is a systems programming language with C-like syntax and static typing. It combines the power and performance of C and C++ with the safety and expressiveness of modern programming languages like Rust and Swift. D is designed for writing efficient, maintainable, and scalable software, making it ideal for system programming, game development, and high-performance applications. The backend here uses the DMD (Digital Mars D) compiler to compile D code, ensuring fast and reliable execution.
742
+
743
+
For more information, you can visit the [D programming language Wikipedia page](https://en.wikipedia.org/wiki/D_%28programming_language%29).
744
+
745
+
---
746
+
747
+
```d
748
+
import std.stdio;
749
+
750
+
void main()
751
+
{
752
+
writeln("Hello, World!");
753
+
}
754
+
```
755
+
@LIA.d
699
756
700
757
### Elixir : `@LIA.elixir`
701
758
@@ -847,6 +904,27 @@ main = putStrLn "hello world"
847
904
```
848
905
@LIA.haskell_withShell
849
906
907
+
908
+
### IO : `@LIA.io`
909
+
910
+
Io is a prototype-based, object-oriented programming language that was developed by Steve Dekorte in the early 2000s. It is known for its simplicity, minimalism, and powerful message-passing model, making it ideal for building dynamic and interactive applications. Io is inspired by Smalltalk, Self, and Lisp, and it provides a flexible and extensible environment for creating domain-specific languages and frameworks. The backend here uses the Io interpreter to execute Io code, ensuring fast and efficient execution.
911
+
912
+
For more information, you can visit the [Io programming language Wikipedia page](https://en.wikipedia.org/wiki/Io_%28programming_language%29).
913
+
914
+
---
915
+
916
+
```io
917
+
"Hello, world!" println
918
+
```
919
+
@LIA.io
920
+
921
+
As an alternative, you can also run it within an interactive REPL shell.
922
+
923
+
```io
924
+
"Hello, world!" println
925
+
```
926
+
@LIA.io_withShell
927
+
850
928
### Java : `@LIA.java`
851
929
852
930
Java is a widely-used, class-based, object-oriented programming language that was developed by Sun Microsystems (now owned by Oracle) and released in 1995. It is designed to be platform-independent, meaning that compiled Java code can run on any platform that supports the Java Virtual Machine (JVM). Java is known for its portability, scalability, and strong memory management features, making it ideal for building large-scale enterprise applications, Android apps, and web services. The language's syntax is similar to C++, but it simplifies many complex features, making it easier to learn and use. The backend here uses `jdk-21_linux-x64_bin`, the latest version of the Java Development Kit (JDK), to compile and execute Java code, ensuring cutting-edge performance and compatibility with modern Java features.
Kotlin is a modern, statically typed programming language developed by JetBrains in 2011. It is designed to be fully interoperable with Java and runs on the Java Virtual Machine (JVM). Kotlin combines object-oriented and functional programming features, making it a versatile language for building Android apps, web services, and enterprise applications. It is known for its conciseness, safety features, and expressive syntax, which reduce boilerplate code and improve developer productivity. The backend here uses the Kotlin compiler to compile Kotlin code, ensuring compatibility with the JVM and access to the Java ecosystem.
1075
+
1076
+
For more information, you can visit the [Kotlin programming language Wikipedia page](https://en.wikipedia.org/wiki/Kotlin_%28programming_language%29).
1077
+
1078
+
---
1079
+
1080
+
```kotlin
1081
+
funmain() {
1082
+
println("Hello, World!")
1083
+
}
1084
+
```
1085
+
@LIA.kotlin
1086
+
1087
+
### Lua : `@LIA.lua`
1088
+
1089
+
Lua is a lightweight, high-level programming language designed for embedded systems, scripting, and game development. It was developed in the early 1990s by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes at the Pontifical Catholic University of Rio de Janeiro. Lua is known for its simplicity, efficiency, and extensibility, making it ideal for integrating with other languages and platforms. It provides a powerful set of features, including first-class functions, coroutines, and metatables, which enable developers to build flexible and scalable applications. The backend here uses the Lua interpreter to execute Lua code, ensuring fast and reliable execution.
1090
+
1091
+
For more information, you can visit the [Lua programming language Wikipedia page](https://en.wikipedia.org/wiki/Lua_%28programming_language%29).
Octave is a high-level, interpreted programming language primarily used for numerical computations and data analysis. It is compatible with MATLAB and provides a similar syntax and functionality, making it a popular choice for scientific computing, machine learning, and signal processing. Octave supports matrix operations, plotting, and algorithm development, allowing users to prototype and test complex mathematical models efficiently. The backend here uses the Octave interpreter to execute Octave code, ensuring compatibility with MATLAB scripts and toolboxes.
1130
+
1131
+
For more information, you can visit the [Octave programming language Wikipedia page](https://en.wikipedia.org/wiki/GNU_Octave).
Pascal is a high-level, procedural programming language developed by Niklaus Wirth in the late 1960s. It was designed to encourage good programming practices and provide a structured approach to software development. Pascal is known for its readability, simplicity, and strong typing, making it ideal for teaching programming concepts and developing reliable software. It introduced many features that are now common in modern programming languages, such as block structures, data structures, and modular programming. The backend here uses the Free Pascal compiler to compile Pascal code, ensuring compatibility and efficient execution.
@@ -1064,6 +1182,28 @@ my $x = 42;
1064
1182
```
1065
1183
@LIA.perl_withShell
1066
1184
1185
+
### PostScript : `@LIA.postscript`
1186
+
1187
+
PostScript is a page description language developed by Adobe Systems in the early 1980s. It is used primarily in the printing and graphics industries to describe the layout and appearance of documents, images, and other visual content. PostScript is known for its flexibility, scalability, and device independence, making it ideal for generating high-quality output on a wide range of printers and displays. It uses a stack-based programming model, where operations are performed by pushing and popping values on a data stack. The backend here uses the Ghostscript interpreter to execute PostScript code, ensuring compatibility and efficient rendering.
1188
+
1189
+
For more information, you can visit the [PostScript programming language Wikipedia page](https://en.wikipedia.org/wiki/PostScript).
1190
+
1191
+
---
1192
+
1193
+
```postscript
1194
+
%!PS
1195
+
<< /PageSize [420 100] >> setpagedevice % Set page size to A5
1196
+
/Courier % name the desired font
1197
+
20 selectfont % choose the size in points and establish
1198
+
% the font as the current one
1199
+
72 50 moveto % position the current point at
1200
+
% coordinates 72, 500 (the origin is at the
1201
+
% lower-left corner of the page)
1202
+
(Hello world!) show % paint the text in parentheses
1203
+
showpage % print all on the page
1204
+
```
1205
+
@LIA.postscript
1206
+
1067
1207
### Prolog : `@LIA.prolog`
1068
1208
1069
1209
Prolog is a logic programming language that was developed in the early 1970s by Alain Colmerauer and Robert Kowalski. It is based on formal logic and provides a declarative approach to problem-solving, where programs are defined as sets of logical rules and facts. Prolog is particularly well-suited for tasks involving symbolic reasoning, artificial intelligence, and natural language processing. It is known for its pattern matching and backtracking capabilities, which allow for efficient search and inference. The backend here uses the SWI-Prolog interpreter to execute Prolog code, ensuring compatibility and efficient execution.
@@ -1349,6 +1489,50 @@ println("Hello World")
1349
1489
```
1350
1490
@LIA.v_withShell
1351
1491
1492
+
### Verilog : `@LIA.verilog`
1493
+
1494
+
Verilog is a hardware description language (HDL) used for designing digital circuits and systems. It was first introduced in the 1980s and has since become a standard language for modeling and simulating digital circuits. Verilog is known for its simplicity, expressiveness, and support for both behavioral and structural modeling of hardware components. It is widely used in the semiconductor industry for designing integrated circuits, field-programmable gate arrays (FPGAs), and other digital systems. The backend here uses the Icarus Verilog simulator to execute Verilog code, ensuring compatibility and efficient simulation of digital circuits.
1495
+
1496
+
For more information, you can visit the [Verilog programming language Wikipedia page](https://en.wikipedia.org/wiki/Verilog).
1497
+
1498
+
---
1499
+
1500
+
```verilog
1501
+
module hello_world;
1502
+
initial begin
1503
+
$display("Hello, world!");
1504
+
$finish;
1505
+
end
1506
+
endmodule
1507
+
```
1508
+
@LIA.verilog
1509
+
1510
+
### VHDL : `@LIA.vhdl`
1511
+
1512
+
VHDL (VHSIC Hardware Description Language) is a hardware description language used for designing digital circuits and systems. It was developed in the 1980s as part of the U.S. Department of Defense's VHSIC (Very High-Speed Integrated Circuit) program. VHDL is known for its versatility, expressiveness, and support for both behavioral and structural modeling of hardware components. It is widely used in the semiconductor industry for designing integrated circuits, field-programmable gate arrays (FPGAs), and other digital systems. The backend here uses the GHDL simulator to execute VHDL code, ensuring compatibility and efficient simulation of digital circuits.
1513
+
1514
+
For more information, you can visit the [VHDL programming language Wikipedia page](https://en.wikipedia.org/wiki/VHDL).
1515
+
1516
+
---
1517
+
1518
+
```vhdl
1519
+
library ieee;
1520
+
use ieee.std_logic_1164.all;
1521
+
1522
+
entity hello_world is
1523
+
end hello_world;
1524
+
1525
+
architecture rtl of hello_world is
1526
+
begin
1527
+
process
1528
+
begin
1529
+
report "Hello, world!";
1530
+
wait;
1531
+
end process;
1532
+
end rtl;
1533
+
```
1534
+
@LIA.vhdl(hello_world)
1535
+
1352
1536
### Zig : `@LIA.zig`
1353
1537
1354
1538
Zig is a general-purpose, statically typed programming language designed for robustness, optimality, and clarity. It was first released in 2016 by Andrew Kelley. Zig aims to offer a modern alternative to C with improved safety and performance features, including manual memory management, a comprehensive standard library, and support for cross-compilation. The language provides fine-grained control over system resources and emphasizes compile-time checks and correctness. Zig's syntax is designed to be simple and expressive, making it suitable for systems programming, embedded development, and performance-critical applications. The backend here uses the Zig compiler to compile Zig code, ensuring efficient execution and cross-platform compatibility.
0 commit comments