My Great Article

Here is some introductory text for my great article.

console.log("Hello, world!");

Here is a link to Google.

This is the conclusion of my great article. I hope you enjoyed it.

def my_function():
 print("Hello from Python!")

echo "Hello from the command line!"

#include <iostream>


int main() {
 std::cout << "Hello from C++!" << std::endl;
 return 0;
}

public class Main {
 public static void main(String[] args) {
 System.out.println("Hello from Java!");
 }
}

using System;


public class Program {
 public static void Main(string[] args) {
 Console.WriteLine("Hello from C#!");
 }
}

package main


import "fmt"


func main() {
 fmt.Println("Hello from Go!")
}

puts "Hello from Ruby!"

fun main() {
 println("Hello from Kotlin!")
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

print("Hello from Swift!")

fn main() {
 println!("Hello from Rust!");
}

<?php
echo "Hello from PHP!";
?>

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

print("Hello from Lua!")

print "Hello from Perl!\n";

print("Hello from R!")

void main() {
 print('Hello from Dart!');
}

console.log("Hello from TypeScript!");

console.log "Hello from CoffeeScript!"

printfn "Hello from F#!"

Write-Host "Hello from PowerShell!"

println("Hello from Julia!")

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

program hello
 print *, "Hello from Fortran!"
end program hello

section .data
 msg db 'Hello from Assembly!', 0


section .text
 global _start


_start:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 21
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall

main :: IO ()
main = putStrLn "Hello from Haskell!"

print_endline "Hello from OCaml!";

program Hello;
begin
 writeln('Hello from Pascal!');
end.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Module Program
 Sub Main(args As String())
 Console.WriteLine("Hello from Visual Basic!")
 End Sub
End Module

hello :-
 write('Hello from Prolog!'), nl.

(println "Hello from Clojure!")

(print "Hello from Lisp!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

module hello;
 initial begin
 $display("Hello from SystemVerilog!");
 $finish;
 end
endmodule

disp('Hello from MATLAB!')

BEGIN { print "Hello from AWK!" }

s/^/Hello from SED!/

"Hello from jq!"

echo "Hello from Nim!"

puts "Hello from Crystal!"

print_endline("Hello from Reason!");

import Html exposing (text)


main =
 text "Hello from Elm!"

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

{-# OPTIONS --safe #-}
module Main where


open import IO


main : IO ⊤
main = putStrLn "Hello from Agda!"

console.log "Hello from CoffeeScript!"

." Hello from Forth!" cr
bye

Transcript show: 'Hello from Smalltalk!'.

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

console.log "Hello from LiveScript!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

void main() {
 print("Hello from Vala!\n");
}

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

program hello
 print *, "Hello from Fortran!"
end program hello

section .data
 msg db 'Hello from Assembly!', 0


section .text
 global _start


_start:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 21
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall

main :: IO ()
main = putStrLn "Hello from Haskell!"

print_endline "Hello from OCaml!";

program Hello;
begin
 writeln('Hello from Pascal!');
end.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Module Program
 Sub Main(args As String())
 Console.WriteLine("Hello from Visual Basic!")
 End Sub
End Module

hello :-
 write('Hello from Prolog!'), nl.

(println "Hello from Clojure!")

(print "Hello from Lisp!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

module hello;
 initial begin
 $display("Hello from SystemVerilog!");
 $finish;
 end
endmodule

disp('Hello from MATLAB!')

BEGIN { print "Hello from AWK!" }

s/^/Hello from SED!/

"Hello from jq!"

echo "Hello from Nim!"

puts "Hello from Crystal!"

print_endline("Hello from Reason!");

import Html exposing (text)


main =
 text "Hello from Elm!"

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

{-# OPTIONS --safe #-}
module Main where


open import IO


main : IO ⊤
main = putStrLn "Hello from Agda!"

console.log "Hello from CoffeeScript!"

." Hello from Forth!" cr
bye

Transcript show: 'Hello from Smalltalk!'.

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

console.log "Hello from LiveScript!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

void main() {
 print("Hello from Vala!\n");
}

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

program hello
 print *, "Hello from Fortran!"
end program hello

section .data
 msg db 'Hello from Assembly!', 0


section .text
 global _start


_start:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 21
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall

main :: IO ()
main = putStrLn "Hello from Haskell!"

print_endline "Hello from OCaml!";

program Hello;
begin
 writeln('Hello from Pascal!');
end.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Module Program
 Sub Main(args As String())
 Console.WriteLine("Hello from Visual Basic!")
 End Sub
End Module

hello :-
 write('Hello from Prolog!'), nl.

(println "Hello from Clojure!")

(print "Hello from Lisp!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

module hello;
 initial begin
 $display("Hello from SystemVerilog!");
 $finish;
 end
endmodule

disp('Hello from MATLAB!')

BEGIN { print "Hello from AWK!" }

s/^/Hello from SED!/

"Hello from jq!"

echo "Hello from Nim!"

puts "Hello from Crystal!"

print_endline("Hello from Reason!");

import Html exposing (text)


main =
 text "Hello from Elm!"

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

{-# OPTIONS --safe #-}
module Main where


open import IO


main : IO ⊤
main = putStrLn "Hello from Agda!"

console.log "Hello from CoffeeScript!"

." Hello from Forth!" cr
bye

Transcript show: 'Hello from Smalltalk!'.

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

console.log "Hello from LiveScript!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

void main() {
 print("Hello from Vala!\n");
}

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

program hello
 print *, "Hello from Fortran!"
end program hello

section .data
 msg db 'Hello from Assembly!', 0


section .text
 global _start


_start:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 21
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall

main :: IO ()
main = putStrLn "Hello from Haskell!"

print_endline "Hello from OCaml!";

program Hello;
begin
 writeln('Hello from Pascal!');
end.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Module Program
 Sub Main(args As String())
 Console.WriteLine("Hello from Visual Basic!")
 End Sub
End Module

hello :-
 write('Hello from Prolog!'), nl.

(println "Hello from Clojure!")

(print "Hello from Lisp!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

module hello;
 initial begin
 $display("Hello from SystemVerilog!");
 $finish;
 end
endmodule

disp('Hello from MATLAB!')

BEGIN { print "Hello from AWK!" }

s/^/Hello from SED!/

"Hello from jq!"

echo "Hello from Nim!"

puts "Hello from Crystal!"

print_endline("Hello from Reason!");

import Html exposing (text)


main =
 text "Hello from Elm!"

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

{-# OPTIONS --safe #-}
module Main where


open import IO


main : IO ⊤
main = putStrLn "Hello from Agda!"

console.log "Hello from CoffeeScript!"

." Hello from Forth!" cr
bye

Transcript show: 'Hello from Smalltalk!'.

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

console.log "Hello from LiveScript!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

void main() {
 print("Hello from Vala!\n");
}

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

program hello
 print *, "Hello from Fortran!"
end program hello

section .data
 msg db 'Hello from Assembly!', 0


section .text
 global _start


_start:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 21
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall

main :: IO ()
main = putStrLn "Hello from Haskell!"

print_endline "Hello from OCaml!";

program Hello;
begin
 writeln('Hello from Pascal!');
end.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Module Program
 Sub Main(args As String())
 Console.WriteLine("Hello from Visual Basic!")
 End Sub
End Module

hello :-
 write('Hello from Prolog!'), nl.

(println "Hello from Clojure!")

(print "Hello from Lisp!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

module hello;
 initial begin
 $display("Hello from SystemVerilog!");
 $finish;
 end module

disp('Hello from MATLAB!')

BEGIN { print "Hello from AWK!" }

s/^/Hello from SED!/

"Hello from jq!"

echo "Hello from Nim!"

puts "Hello from Crystal!"

print_endline("Hello from Reason!");

import Html exposing (text)


main =
 text "Hello from Elm!"

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

{-# OPTIONS --safe #-}
module Main where


open import IO


main : IO ⊤
main = putStrLn "Hello from Agda!"

console.log "Hello from CoffeeScript!"

." Hello from Forth!" cr
bye

Transcript show: 'Hello from Smalltalk!'.

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

console.log "Hello from LiveScript!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

void main() {
 print("Hello from Vala!\n");
}

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

program hello
 print *, "Hello from Fortran!"
end program hello

section .data
 msg db 'Hello from Assembly!', 0


section .text
 global _start


_start:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 21
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall

main :: IO ()
main = putStrLn "Hello from Haskell!"

print_endline "Hello from OCaml!";

program Hello;
begin
 writeln('Hello from Pascal!');
end.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Module Program
 Sub Main(args As String())
 Console.WriteLine("Hello from Visual Basic!")
 End Sub
End Module

hello :-
 write('Hello from Prolog!'), nl.

(println "Hello from Clojure!")

(print "Hello from Lisp!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

module hello;
 initial begin
 $display("Hello from SystemVerilog!");
 $finish;
 end module

disp('Hello from MATLAB!')

BEGIN { print "Hello from AWK!" }

s/^/Hello from SED!/

"Hello from jq!"

echo "Hello from Nim!"

puts "Hello from Crystal!"

print_endline("Hello from Reason!");

import Html exposing (text)


main =
 text "Hello from Elm!"

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

{-# OPTIONS --safe #-}
module Main where


open import IO


main : IO ⊤
main = putStrLn "Hello from Agda!"

console.log "Hello from CoffeeScript!"

." Hello from Forth!" cr
bye

Transcript show: 'Hello from Smalltalk!'.

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

console.log "Hello from LiveScript!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

void main() {
 print("Hello from Vala!\n");
}

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

program hello
 print *, "Hello from Fortran!"
end program hello

section .data
 msg db 'Hello from Assembly!', 0


section .text
 global _start


_start:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 21
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall

main :: IO ()
main = putStrLn "Hello from Haskell!"

print_endline "Hello from OCaml!";

program Hello;
begin
 writeln('Hello from Pascal!');
end.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Module Program
 Sub Main(args As String())
 Console.WriteLine("Hello from Visual Basic!")
 End Sub
End Module

hello :-
 write('Hello from Prolog!'), nl.

(println "Hello from Clojure!")

(print "Hello from Lisp!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

module hello;
 initial begin
 $display("Hello from SystemVerilog!");
 $finish;
 end module

disp('Hello from MATLAB!')

BEGIN { print "Hello from AWK!" }

s/^/Hello from SED!/

"Hello from jq!"

echo "Hello from Nim!"

puts "Hello from Crystal!"

print_endline("Hello from Reason!");

import Html exposing (text)


main =
 text "Hello from Elm!"

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

{-# OPTIONS --safe #-}
module Main where


open import IO


main : IO ⊤
main = putStrLn "Hello from Agda!"

console.log "Hello from CoffeeScript!"

." Hello from Forth!" cr
bye

Transcript show: 'Hello from Smalltalk!'.

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

console.log "Hello from LiveScript!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

void main() {
 print("Hello from Vala!\n");
}

-module(hello).
-export([main/0]).


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada
<AppearanceSection></AppearanceSection>