Programming Language index

This is my new project: "Hello, World! in 1001 Programming Languages". The languages will be sorted Alphabetically. The page is not stable on mobile devices yet, and many other features are coming soon.

According to Evans Data Corporation Data's Global Developer Population and Demographic Study, there are 26.9 million software developers in the world.

Currently here are 113 hello world programs in different languages

Check out my blog for latest updates or for other projects:

Blog

**Note: information about languages are mainly from Wikipedia, just basic overview and if you want to find out more about them you can check out my Bibliothecae of programming languages where I put learning materials of programming languages (pdf books, codes, projects...). I am trying to get official books of these programming languages and place them in ma biblioteca.

So..., Let's dive into Matrix⬇️

Python

Year:1991 Developer: Python Software Company Influenced By:ABC, Ada, ALGOL 68, APL, C, C++, CLU, Dylan, Haskell, Java, Lisp, Modula-3,Perl, Standard ML Filename Extension: .py Users: 8.2 million

Python is TOP ONE programming language by 2021. By rating rate 29.93%. Python is an interpreted high-level general-purpose programming language. Its design philosophy emphasizes code readability with its use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects. Used in building websites and applications, data science, machine learning, hacking.

"Hello World" program in Python

print('Hello, World!')

Java

Year:1995 Developer: Oracle Corporation Influenced By:CLU, Simula67, Lisp, Smalltalk, Ada 83, C++, C#, Eiffel, Mesa, Modula-3, Oberon, Objective-C, Pascal, Object Pascal Filename Extension: .java Users: 9.007 million

Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let programmers "write once, run anywhere" meaning that compiled Java code can run on all platforms that support Java without the need for recompilation. Mainly used in Android Development.

// "Hello, World!" Program
                class HelloWorld {
                  public static void main(String[] args) {
                        System.out.println("Hello, World!"); 
                      }
                }

JavaScript

Year:1995 Developer: Brenden Eich Influenced By:Java, Scheme, AWK, HyperTalk Filename Extension: .js Users: 12.4 million

JavaScript (JS), is a programming language that conforms to the ECMAScript specification. JavaScript is high-level, often just-in-time compiled, and multi-paradigm. It has curly-bracket syntax, dynamic typing, prototype-based object-orientation, and first-class functions. JavaScript is the only programming language native to the web browser, that's why it has so large community. It's most used programming language, alongside web it is also used to create browser-based games and, with the help of certain frameworks, mobile apps for different operating systems.

console.log('Hello, World!);

C#

Year:2000 Developer: Anders Hejlsberg (Microsoft) Influenced By: C++, Cω, Eiffel, F#, Haskell, Icon, J#, J++, Java, ML, Modula-3, Object Pascal, VB Filename Extension: .cs, .csx Users: 6.7 million

C# (C Sharp) is a general-purpose, multi-paradigm programming language. C# encompasses static typing, strong typing, lexically scoped, imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming disciplines Mainly used in Windows Application, Game Development, Backend Development.

using System;
                    Console.WriteLine("Hello, World!");

C/C++

Year:1985 Developer:Bjarne Stroustrup Influenced By:Ada, ALGOL 68, C, CLU, ML, Mesa, Modula-2, Simula, Smalltalk Filename Extension: .cpp, .cc, .cxx Users: 6.3 million

C++ is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C programming language, or "C with Classes". The language has expanded significantly over time, and modern C++ now has object-oriented, generic, and functional features in addition to facilities for low-level memory manipulation. Mainly used in Game Development


                #include <iostream>
                int main() {
                  std::cout<<"Hello World!";
                  return 0;
                }

PHP

Year:1995 Developer:The PHP Development Team, Zend Technologies Influenced By:Perl, HTML, C, C++, Java, Tcl, JavaScript, Hack Filename Extension: .php Users: 3.08 million

PHP is a general-purpose scripting language geared towards web development. It was originally created by Danish-Canadian programmer Rasmus Lerdorf in 1994. The PHP reference implementation is now produced by The PHP Group. PHP originally stood for Personal Home Page, but it now stands for the recursive initialism PHP: Hypertext Preprocessor. Used for: developing dynamic web pages.

<html>
 <head>
  <title>PHP Test</title>
 </head>
 <body>
 <?php echo 'Hello World'; ?> 
 </body>
</html>

R

Year:1993 Developer: Ross Ihaka and Robert Gentleman (R Code Team) Influenced By: Common Lisp, S, Scheme, XLispStat Filename Extension: .r, .rdata .rds, .rda Users: over 2 million

R is a programming language and free software environment for statistical computing and graphics supported by the R Core Team and the R Foundation for Statistical Computing. It is widely used among statisticians and data miners for developing statistical software and data analysis.

>  #Hello World program
                    > print("Hello World!")

Objective-C

Year:1984 Developer:Tom Love and Brad Cox Influenced By: C, SmallTalk Filename Extension: .h, .m, .mm Users: ~240,000

Objective-C is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. Originally developed by Brad Cox and Tom Love in the early 1980s, it was selected by NeXT for its NeXTSTEP operating system. Objective-C was the standard programming language supported by Apple for developing macOS (which descended from NeXTSTEP) and iOS applications

#import <Foundation/Foundation.h>
            int main(int argc, const char * argv[]) {
              @autoreleasepool {
                     NSLog(@"Hello, World!");
            }
            return 0;
            }

TypeScript

Year:2012 Developer:Microsoft Influenced By: C#, Java, JavaScript Filename Extension: .ts, .ts Users: About 60% of JS developers already use TS, so about 8 million

TypeScript is a programming language developed and maintained by Microsoft. It is a strict syntactical superset of JavaScript and adds optional static typing to the language. TypeScript is designed for the development of large applications and transcompiles to JavaScript.[5] As TypeScript is a superset of JavaScript, existing JavaScript programs are also valid TypeScript programs. TypeScript may be used to develop JavaScript applications for both client-side and server-side execution (as with Node.js or Deno).

let message: string = 'Hello, World!';
                console.log(message);

Swift

Year:2014 Developer: Apple Inc. Influenced By: Objective-C, Rust, Haskell, Ruby, Python, C# Filename Extension: .swift Users: 348,000

Swift is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. Swift was developed as a replacement for Apple's earlier programming language Objective-C, as Objective-C had been largely unchanged since the early 1980s and lacked modern language features. Swift works with Apple's Cocoa and Cocoa Touch frameworks, and a key aspect of Swift's design was the ability to interoperate with the huge body of existing Objective-C code developed for Apple products over the previous decades. It is built with the open source LLVM compiler framework and has been included in Xcode since version 6, released in 2014. On Apple platforms, it uses the Objective-C runtime library which allows C, Objective-C, C++ and Swift code to run within one program.

//Hello World in Swift
                println("Hello, world!")

Kotlin

Year:2011 Developer: JetBrains Influenced By: C#, Eiffel, Gosu, Groovy, Java, JavaScript, ML, Python, Scala, Swift Filename Extension: .kt, .kts, .ktm Users: 4 million

Kotlin is a cross-platform, statically typed, general-purpose programming language with type inference. Kotlin is designed to interoperate fully with Java, and the JVM version of Kotlin's standard library depends on the Java Class Library, but type inference allows its syntax to be more concise. Kotlin mainly targets the JVM, but also compiles to JavaScript or native code (via LLVM). Used for Android Development.

package org.kotlinlang.play 
                    fun main() {                        
                        println("Hello, World!")       
                    }

List of Programming Languages

List of programming languages alphabetically. Note that there are not only programming languages, but scripting, markup, frameworks and other types of PL.

ABAP

Year:1983 Developer: SAP SE Influenced By: Objective-C, COBOL, SQL Filename Extension: .abap Users:over 22,000

ABAP (Advanced Business Application Programming, originally Allgemeiner Berichts-Aufbereitungs-Prozessor, German for "general report preparation processor") is a high-level programming language created by the German software company SAP SE. It is currently positioned, alongside Java, as the language for programming the SAP NetWeaver Application Server, which is part of the SAP NetWeaver platform for building business applications.

REPORT Test.
                    WRITE 'Hello World'.

ABC

Year:1987 Developer: Centrum Wiskunde & Informatica (CWI) Influenced By: SETL, ALGOL 68 Filename Extension: .abc Users: 520

ABC is an imperative general-purpose programming language and integrated development environment (IDE) developed at CWI, Netherlands by Leo Geurts, Lambert Meertens, and Steven Pemberton. It is interactive, structured, high-level, and intended to be used instead of BASIC, Pascal, or AWK. It is intended for teaching or prototyping, but not as a systems-programming language.

ABC had a major influence on the design of the language Python

\ Hello world in ABC /
WRITE "Hello, World!"

ActionScript

Year:1998 Developer: Macromedia Influenced By: JavaScript, Java Filename Extension: .as Users: Over 500

ActionScript was an object-oriented programming language originally developed by Macromedia Inc. (later acquired by Adobe Systems). It is influenced by HyperTalk, the scripting language for HyperCard.[2] It is now an implementation of ECMAScript (meaning it is a superset of the syntax and semantics of the language more widely known as JavaScript), though it originally arose as a sibling, both being influenced by HyperTalk.

ActionScript was used primarily for the development of websites and software targeting the Adobe Flash Player platform, used on Web pages in the form of embedded SWF files.

import flash.text.TextField;
                    import flash.text.TextFormat;
                    
                    var message:TextField = new TextField();
                    message.x = message.y = 5;
                    message.width = 300;
                    message.height = 50;
                    
                    var tf:TextFormat = new TextFormat(); 
                    tf.color = 0xFF0000;
                    tf.size = 32;
                    tf.bold = true;
                    
                    message.defaultTextFormat = tf;
                    message.text = "Hello World!";
                    MovieClip(root).addChild(message);

Ada

Year:1980 Developer: MIL-STD-1815, Ada-2012 Influenced By: C++ Filename Extension: .ads, .adb Users: ~2500

Ada is a structured, statically typed, imperative, and object-oriented high-level programming language, extended from Pascal and other languages. It has built-in language support for design by contract (DbC), extremely strong typing, explicit concurrency, tasks, synchronous message passing, protected objects, and non-determinism. Ada improves code safety and maintainability by using the compiler to find errors in favor of runtime errors.

with Ada.Text_IO; use Ada.Text_IO;
                    procedure Hello is
                    begin
                      Put_Line ("Hello, world!");
                    end Hello;

Alice

Year:2000 Developer: Saarland University Influenced By: ML, Oz Users: 2,200

Alice ML is a programming language designed by the Programming Systems Laboratory[2] at Saarland University, Saarbrücken, Germany. It is a dialect of Standard ML, augmented with support for lazy evaluation, concurrency (multithreading and distributed computing via remote procedure calls) and constraint programming.

*Example code form Wikipedia:*
                    fun fib 0 = 0
                    | fib 1 = 1
                    | fib n = fib(n-1) + fib(n-2);

Apex

Year:2007 Developer: Salesforce.com Filename Extension: .Apex Users: Over 1,900

Apex is a strongly typed, object-oriented programming language that allows developers to execute flow and transaction control statements on Salesforce servers in conjunction with calls to the API. Apex code can be initiated by Web service requests and from triggers on objects.

String helloWorld = 'Hello World'

APL

Year:1966 Developer: Larry Breed, Dick Lathwell, Roger Moore and others Influenced By: Mathematical notation Filename Extension: .apl Users: 850

APL (named after the book A Programming Language) is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages

@ This program is very simple in APL!
                    'Hello World!'
                    @ In APL, anything that is printed in quotes is printed to the terminal. (@ in APL signifies a comment)
                    @ If the "Hello World statement needed to be stored, then you could use the following :
                    h<-'Hello World'
                    h
                    
                    @Typing h causes h's value to be printed.

AutoLisp

Year:1986 Developer: Autodesk, Basis Software Influenced By: Lisp, XLISP Filename Extension: IDE: AutoCAD Users: over 500

AutoLISP is a popular high-level language used for programming in CAD Packages such as AutoCAD, BricsCAD or ZWCAD. Using AutoLISP, you can create customised CAD commands to perform actions in order to generate the desired output. AutoLISP comes already loaded with a full version of AutoCAD.

(alert "Hello world!.")

Arduino

Year:2005 Developer: arduino.cc Filename Extension: Hardware: Arduino UNO Users: over million IDE downloads

Arduino is an open-source hardware and software company, project, and user community that designs and manufactures single-board microcontrollers and microcontroller kits for building digital devices. Arduino boards are able to read inputs - light on a sensor, a finger on a button, or a Twitter message - and turn it into an output - activating a motor, turning on an LED, publishing something online.

void setup() {
                    // put your setup code here, to run once:
                    Serial.begin(9600);
                    Serial.println(Hello World!");
                  }

Assembly Language

First appeared:1949 (ARC Assembly Language) Enviroment: IBM PC, NASM program

In computer programming, assembly language (or assembler language), sometimes abbreviated asm, is any low-level programming language in which there is a very strong correspondence between the instructions in the language and the architecture's machine code instructions. Because assembly depends on the machine code instructions, every assembly language is designed for exactly one specific computer architecture. Assembly language may also be called symbolic machine code.

Assembly code is converted into executable machine code by a utility program referred to as an assembler. The conversion process is referred to as assembly, as in assembling the source code. Assembly language usually has one statement per machine instruction (1:1), but constants, comments, assembler directives, symbolic labels of program and memory locations, and macros are generally also supported.

Classic Hello World program in Assembly language:
                    .begin
                    BASE    .equ 0x3fffc0       !Starting point of the memory mapped region
                    COUT    .equ 0x0            !0xffff0000 Console Data Port
                    COSTAT  .equ 0x4            !0xffff0004 Console Status Port.
                    
                             .org 2048
                             add %r0, %r0, %r2
                             add %r0, %r0, %r4
                             sethi BASE, %r4
                    
                    Loop:    ld [%r2 + String], %r3 !Load next char into r3
                             addcc %r3,%r0,%r3
                             be End                 ! stop if null.
                    
                    Wait:    ldub [%r4+COSTAT], %r1
                             andcc %r1, 0x80, %r1
                             be Wait
                             stb %r3, [%r4+COUT]    !Print to console
                             add %r2, 4, %r2        !increment String offset (r2)
                             ba Loop
                    End:     halt
                    
                            .org 3000
                    
                    ! The "Hellow, world!" string
                    
                    String: 0x48, 0x65, 0x6c, 0x6c, 0x6f
                    0x2c, 0x20, 0x77, 0x6f, 0x72 
                    0x6c, 0x64, 0x21, 0x0a, 0
                    
                    .end

AWK

Year:1977 Developer: Alfred Aho, Peter Weinberger, and Brian Kernighan Influenced By: C, sed, SNOBOL Filename Extension: .awk Users: over 2,100

AWK is a domain-specific language designed for text processing and typically used as a data extraction and reporting tool. Like sed and grep, it is a filter, and is a standard feature of most Unix-like operating systems.

# Hello world in AWK
                    BEGIN {
                     print "Hello World!"
                    }

Bash

Year:1989 Developer: Brian Fox Influenced By: Bourne shell Platform: GNU Users: over 500

Bash is a Unix shell and command language written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell. it has been used as the default login shell for most Linux distributions. A version is also available for Windows 10 via the Windows Subsystem for Linux. It is also the default user shell in Solaris 11. Bash was also the default shell in all versions of Apple macOS prior to the 2019 release of macOS Catalina, which changed the default shell to zsh, although Bash currently remains available as an alternative shell.

#!/bin/sh
                    echo "Hello, World!"

BASIC

Year:1964 Developer: John G. Kemeny, Thomas E. Kurtz Influenced By: ALGOL 60, FORTRAN II, JOSS Users: over 2,000 (1964 v.)

BASIC (Beginners' All-purpose Symbolic Instruction Code) is a family of general-purpose, high-level programming languages whose design philosophy emphasizes ease of use. The original version was designed by John G. Kemeny and Thomas E. Kurtz and released at Dartmouth College in 1964. They wanted to enable students in fields other than science and mathematics to use computers. At the time, nearly all use of computers required writing custom software, which was something only scientists and mathematicians tended to learn.

In addition to the language itself, Kemeny and Kurtz developed the Dartmouth Time Sharing System (DTSS), which allowed multiple users to edit and run BASIC programs at the same time. This general model became very popular on minicomputer systems like the PDP-11 and Data General Nova in the late 1960s and early 1970s. Hewlett-Packard produced an entire computer line for this method of operation, introducing the HP2000 series in the late 1960s and continuing sales into the 1980s. Many early video games trace their history to one of these versions of BASIC.

The emergence of early microcomputers in the mid-1970s led to the development of a number of BASIC dialects. BASIC fell from use in the early 1990s, as newer machines with far greater capabilities came to market and other programming languages (such as Pascal and C) became tenable. In 1991, Microsoft released Visual Basic, combining a greatly updated version of BASIC with a visual forms builder. This reignited use of the language and "VB" remains a major programming language in the form of VB.NET.

10 REM Hello World in BASIC
                    20 PRINT "Hello World!"

bc programming language

Year:1975 Developer: Robert Morris and Lorinda Cherry of Bell Labs, Philip A. Nelson Influenced By: C Filename Extension: .bc Users: less than 50

bc, for basic calculator (often referred to as bench calculator), is "an arbitrary-precision calculator language" with syntax similar to the C programming language. bc is typically used as either a mathematical scripting language or as an interactive mathematical shell.

$ result=$(echo "hello world" | bc)
                    $ echo $result

Bourne shell

Year:1979 Developer: Stephen Bourne OS: Unix Users: over 500

The Bourne shell is a shell command-line interpreter for computer operating systems. The Bourne shell was the default shell for Version 7 Unix. Unix-like systems continue to have /bin/sh—which will be the Bourne shell, or a symbolic link or hard link to a compatible shell—even when other shells are used by most users.

#!/bin/sh
                    var="Hello World"
                    # print it 
                    echo "$var"

Brainfuck

Year:1993 Developer: Urban Müller Paradigm: Esoteric, imperative, structured FIlename Extension: .b,.bf Users: ...Well, it has over 8,000 downloads on VSCode, but their is no use in SD.

Brainfuck is an esoteric programming language, notable for its extreme minimalism, and most minimalist programming language too, the language consists of only eight simple commands

An esoteric programming language (sometimes shortened to esolang) is a programming language designed to test the boundaries of computer programming language design, as a proof of concept, as software art, as a hacking interface to another language (particularly functional programming or procedural programming languages), or as a joke. Such languages are often popular among hackers and hobbyists.

While it is fully Turing complete, it is not intended for practical use, but to challenge and amuse programmers. Brainfuck simply requires one to break commands into microscopic steps. The language's name is a reference to the slang term brainfuck, which refers to things so complicated or unusual that they exceed the limits of one's understanding.

As brainfuck is turing-complete can be used to prove about what is computable and what is not. If something is computable using brainfuck, it is computable using any turing complete language. But, Brainf*uck has no official practical use rather than challenging, testing and amusing.

All 8 BF Commands:

> - Increment the data pointer (to point to the next cell to the right).
< - Decrement the data pointer (to point to the next cell to the left).
+ - Increment (increase by one) the byte at the data pointer.
- - Decrement (decrease by one) the byte at the data pointer.
. - Output the byte at the data pointer.
, - Accept one byte of input, storing its value in the byte at the data pointer.
[ - If the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching ] command.
] - If the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching [ command.

>++++++++[<+++++++++>-]<.>++++[<+++++++>-]<+.+++++++..+++.>>++++++[<+++++++>-]<+
                    +.------------.>++++++[<+++++++++>-]<+.<.+++.------.--------.>>>++++[<++++++++>-
                    ]<+.

Clipper

Year:1985 Developer: Graftxsoft Users: ~500

Clipper is an xBase compiler that implements a variant of the xBase computer programming language. It is used to create or extend software programs that originally operated primarily under MS-DOS. Although it is a powerful general-purpose programming language, it was primarily used to create database/business programs.

@ simple hello world program
                    ? "Hello World!"

Clojure

Year:2007 Developer: Rich Hikey Influenced By: C#, C++, Common Lisp, Erlang, Haskell, Java, ML, Prolog, Racket, Ruby, Scheme, Wolfram Language Filename Extension: .clj .cljs .cljc .edn Users: ~178,000

Clojure is a dynamic, general-purpose programming language, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming. Clojure is a compiled language, yet remains completely dynamic – every feature supported by Clojure is supported at runtime. Clojure provides easy access to the Java frameworks, with optional type hints and type inference, to ensure that calls to Java can avoid reflection.

; Hello World program in Clojure
                    (ns clojure.examples.hello
                    (:gen-class))
                 (defn hello-world []
                    (println "Hello World"))
                 (hello-world)

COBOL

Year:1959 Developer: CODASYL, ANSI, ISO Influenced By: AIMACO, COMTRAN, FACT, FLOW-MATIC Filename Extension: .cbl, .cob, .cpy, .ccp .cobol Users: over 180,000

COBOL (COmmon Business-Oriented Language) is a compiled English-like computer programming language designed for business use. It is an imperative, procedural and, since 2002, object-oriented language. COBOL is primarily used in business, finance, and administrative systems for companies and governments. COBOL is still widely used in applications deployed on mainframe computers, such as large-scale batch and transaction processing jobs. However, due to its declining popularity and the retirement of experienced COBOL programmers, programs are being migrated to new platforms, rewritten in modern languages or replaced with software packages. Most programming in COBOL is now purely to maintain existing applications; however, many large financial institutions were still developing new systems in COBOL as late as 2006.

* Hello World in COBOL

                    *****************************
                    IDENTIFICATION DIVISION.
                    PROGRAM-ID. HELLOWRD.

                    PROCEDURE DIVISION.
                    DISPLAY "SIMPLE HELLO WORLD".
                    STOP RUN.
                    *****************************

CoffeeScript

Year:2009 Developer: Jeremy Ashkenas Influenced By: Haskell, JavaScript, Perl, Python, Ruby, YAML Filename Extension: .litcoffee Users: 23,000

CoffeeScript is a programming language that compiles to JavaScript. It adds syntactic sugar inspired by Ruby, Python and Haskell in an effort to enhance JavaScript's brevity and readability. Specific additional features include list comprehension and destructuring assignment.

console.log("Hello, World")

Common Lisp (CL)

Year:1984 Developer: ANSI X3J13 committee Influenced By: Lisp, Lisp Machine Lisp, Maclisp, Scheme, Interlisp Filename Extension: .lisp, .lsp, .l, .cl Users: over 500

Common Lisp (CL) is a dialect of the Lisp programming language. The Common Lisp language was developed as a standardized and improved successor of Maclisp.

(DEFUN HELLO ()
                    (PRINT 'HELLO))

CUDA

Year:2007 Developer: NVIDIA Users: 40,000

CUDA (or Compute Unified Device Architecture) is a parallel computing platform and application programming interface (API) that allows software to use certain types of graphics processing unit (GPU) for general purpose processing – an approach called general-purpose computing on GPUs (GPGPU). CUDA is a software layer that gives direct access to the GPU's virtual instruction set and parallel computational elements, for the execution of compute kernels.

// Hello world in CUDA
                    __global__ void cuda_hello(){
                      printf("Hello World from GPU!\n");
                    }
                    
                    int main() {
                      cuda_hello<<<1,1>>>(); 
                      return 0;
                    }
                }

Crystal

Year:2014 Developer: Manas Technology Solutions Influenced By: Ruby, C, Rust, Go, C#, Python Filename Extension: .cr Users: 18,000

Crystal is a general-purpose, object-oriented programming language, it is a compiled language with static type-checking, but specifying the types of variables or method arguments is generally unneeded. Types are resolved by an advanced global type inference algorithm. Crystal is currently in active development. It is released as free and open-source software under the Apache License version 2.0.

# Hello world in Crystal
                    put "Hello World"

C Shell

Year:1978 Developer: Bill Joy Written In: C Users: over 500

The C shell (csh or the improved version, tcsh) is a Unix shell created by Bill Joy while he was a graduate student at University of California, Berkeley in the late 1970s. It has been widely distributed, beginning with the 2BSD release of the Berkeley Software Distribution (BSD) which Joy first distributed in 1978. The C shell is a command processor which is typically run in a text window, allowing the user to type and execute commands. The C shell can also read commands from a file, called a script. Like all Unix shells, it supports filename wildcarding, piping, here documents, command substitution, variables and control structures for condition-testing and iteration.

#!/bin/csh
                    echo Hello World.

CSS

Year:1996 Developer: World Wide Web Consortium (W3C) Filename Extension: .css Users: ~4 million

Cascading Style Sheets (CSS) is a style sheet language used for describing the presentation of a document written in a markup language such as HTML. CSS is a cornerstone technology of the World Wide Web, alongside HTML and JavaScript. CSS is designed to enable the separation of presentation and content, including layout, colors, and fonts. This separation can improve content accessibility, provide more flexibility and control in the specification of presentation characteristics, enable multiple web pages to share formatting by specifying the relevant CSS in a separate .css file which reduces complexity and repetition in the structural content as well as enabling the .css file to be cached to improve the page load speed between the pages that share the file and its formatting.

/* Hello World in CSS */
                    body:before {
                        content: "Hello World";
                    }

cT

Year:1989 Developer: David Andersen, Bruce Sherwood, Judith Sherwood, and Kevin Whitley Filename Extension: .ct Users: ?

The cT programming language is an algorithmic language like C, Pascal, Fortran, and Basic, but greatly enhanced by multimedia capabilities, including easy-to-use support for color graphics, mouse interactions, and even movies in QuickTime or Video for Windows format.

D

Year:2001 Developer: D Language Foundation Influenced By: C, C++, C#, Eiffel, Java, Python Filename Extension: .d Users: ~4,000

D, also known as Dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is a distinct language. The design goals of the language attempted to combine the performance and safety of compiled languages with the expressive power of modern dynamic languages. Idiomatic D code is commonly as fast as equivalent C++ code, while also being shorter. The language as a whole is not memory-safe but does include optional attributes designed to check memory safety.

// Hello World in D
                    import std.stdio;
                    void main()
                    {
                      writefln("Hello World!");
                    }

Dart

Year:2012 Developer: Google Influenced By: C, C++, C#, Erlang, Java, JavaScript, Kotlin, Ruby, Smalltalk, Strongtalk, TypeScript Filename Extension: .dart Users: ~4,000

Dart is a programming language designed for client development, such as for the web and mobile apps. It is developed by Google and can also be used to build server and desktop applications. Dart is an object-oriented, class-based, garbage-collected language with C-style syntax. Dart can compile to either native code or JavaScript. It supports interfaces, mixins, abstract classes, reified generics, and type inference.

 main()  {
                   print ('Hello world!');
                 }

Delphi

Year:1995 Developer: Embarcadero Technologies Influenced By: Pascal Filename Extension: .delphi Users: ~7,000

Delphi is a software product that uses the Delphi dialect of the Object Pascal programming language and provides an integrated development environment (IDE) for rapid application development of desktop, mobile, web, and console software, currently developed and maintained by Embarcadero Technologies. Delphi includes a code editor, a visual designer, an integrated debugger, a source code control component, and support for third-party plugins. The code editor features Code Insight (code completion), Error Insight (real-time error-checking), and refactoring. The visual forms designer has the option of using either the Visual Component Library (VCL) for pure Windows development or the FireMonkey (FMX) framework for cross-platform development. Database support is a key feature and is provided by FireDAC (Database Access Components). Delphi is known for its fast compilation speed, native code, and developer productivity.

Program Hello_World;
                    {$APPTYPE CONSOLE}
                    
                    Begin
                     WriteLn('Hello World');
                    End.

Eiffel

Year:1986 Developer: Eiffel Software Influenced By: Ada, Simula, Z Filename Extension: .e Users: ~1,000

Eiffel is an object-oriented programming language designed by Bertrand Meyer (an object-orientation proponent and author of Object-Oriented Software Construction) and Eiffel Software. Meyer conceived the language in 1985 with the goal of increasing the reliability of commercial software development; the first version becoming available in 1986. In 2005, Eiffel became an ISO-standardized language. The design of the language is closely connected with the Eiffel programming method. Both are based on a set of principles, including design by contract, command–query separation, the uniform-access principle, the single-choice principle, the open–closed principle, and option–operand separation.

class
                  HELLO_WORLD
                create
                  make
                feature
                  make
                    do
                      print ("Hello, world!%N")
                    end
                end

Elixir

Year:2011 Developer: Influenced By: Clojure, Erlang, Ruby Filename Extension: .ex, .exs Users: ~65,000

Elixir is a functional, concurrent, general-purpose programming language that runs on the BEAM virtual machine used to implement the Erlang programming language. Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications. Elixir also provides productive tooling and an extensible design. The latter is supported by compile-time metaprogramming with macros and polymorphism via protocols.

# Hello world in Elixir
                    defmodule HelloWorld do
                     IO.puts "Hello, World!"
                    end

EMACS Lisp

Year:1985 Developer: GNU Project Influenced By: Common Lisp, Maclisp Filename Extension: .el, .elc Users: over 500

Emacs Lisp is a dialect of the Lisp programming language used as a scripting language by Emacs (a text editor family most commonly associated with GNU Emacs and XEmacs). It is used for implementing most of the editing functionality built into Emacs, the remainder being written in C, as is the Lisp interpreter. Emacs Lisp is also termed Elisp, although there is also an older, unrelated Lisp dialect with that name.

(print "Hello, World!")

Euphoria

Year:1993 Developer: openEuphoria Group Influenced By: BASIC Filename Extension: .e, .ex, .exw, .edb Users: ~500

Euphoria (End User Programming Hierarchial Objects for Robust Interpreted Applications) is a general-purpose high-level imperative-procedural interpreted language. A translator generates C source code and the GNU compiler collection (GCC) and Open Watcom compilers are supported. Alternatively, Euphoria programs may be bound with the interpreter to create stand-alone executables. A number of graphical user interface (GUI) libraries are supported including Win32lib and wrappers for wxWidgets, GTK+ and IUP. Euphoria has a simple built-in database and wrappers for a variety of other databases.

-- Hello World in Euphoria
                    puts(1, "Hello World!\n")

Erlang

Year:1986 Developer: Ericsson Influenced By: Lisp, PLEX, Prolog, Smalltalk Filename Extension: .erl, .hrl Users: 120,000

Erlang is a general-purpose, concurrent, functional programming language, and a garbage-collected runtime system. The term Erlang is used interchangeably with Erlang/OTP, or Open Telecom Platform (OTP), which consists of the Erlang runtime system, several ready-to-use components (OTP) mainly written in Erlang, and a set of design principles for Erlang programs.

The Erlang runtime system is designed for systems with these traits:

Distributed
Fault-tolerant
Soft real-time
Highly available, non-stop applications
Hot swapping, where code can be changed without stopping a system

-module(hello).
                    -export([hello_world/0]).
                
                    hello_world() -> io:fwrite("hello, world\n").

F#

Year:2005 Developer: Microsoft, The F# Software Foundation Influenced By: C#, Erlang, Haskell, ML, OCaml, Python, Scala Filename Extension: .fs, .fsi .fsx, .fsscript Users: 48,000

F# (F sharp) is a functional-first, general purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. F# is most often used as a cross-platform Common Language Infrastructure (CLI) language on .NET, but it can also generate JavaScript and graphics processing unit (GPU) code

(* Hello World in F# *)
                    printf "Hello World!\n"

Fortran

Year:1957 Developer: John Backus Influenced By: Speedcoding Filename Extension: .f, .for, .f90 Users: over 150,000 (TIOBE rate: 1.08%)

Fortran (formerly FORTRAN) is a general-purpose, compiled imperative programming language that is especially suited to numeric computation and scientific computing.

Fortran was originally developed by IBM in the 1950s for scientific and engineering applications, and subsequently came to dominate scientific computing. It has been in use for over six decades in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics, geophysics, computational physics, crystallography and computational chemistry. It is a popular language for high-performance computing and is used for programs that benchmark and rank the world's fastest supercomputers.

Fortran has had numerous versions, each of which has added extensions whilst largely retaining compatibility with preceding versions. Successive versions have added support for structured programming and processing of character-based data (FORTRAN 77), array programming, modular programming and generic programming (Fortran 90), high performance Fortran (Fortran 95), object-oriented programming (Fortran 2003), concurrent programming (Fortran 2008), and native parallel computing capabilities (Coarray Fortran 2008/2018).

As of August 2021, Fortran was ranked 13th in the TIOBE index, a measure of the popularity of programming languages, climbing 29 positions from its ranking of 42nd in August 2020. Also Fortran is the world's first modern standart high-level programming language.

!helloWorld program in Fortran 90
                    program helloworld
                  print *, "Hello, World!"
               end program helloworld

Forth

Year:1970 Developer: Charles H. Moore Influenced By: Burroughs large systems, Lisp, APL Filename Extension: .f, .frt, .fth, .fs, .4th, .forth Users: 2,380

Forth is a procedural, stack-oriented programming language and interactive environment designed by Charles H. "Chuck" Moore and first used by other programmers in 1970. Although not an acronym, the language's name in its early years was often spelled in all capital letters as FORTH, but Forth is more common. Forth combines a compiler with an integrated command shell, where the user interacts via subroutines called words. Words can be defined, tested, redefined, and debugged without recompiling or restarting the whole program. All syntactic elements, including variables and basic operators, are defined as words. A stack is used to pass parameters between words, leading to a Reverse Polish Notation style.

 : HELLO  ( -- )CR."Hello, World!";

Genie

Year:2008 Developer: Jamie McCracken Influenced By: Python, Boo, D, Object Pascal Filename Extension: .gs Users: 130

Genie is a modern, general-purpose high-level programming language in development since 2008. It was designed as an alternative, simpler and cleaner dialect for the Vala compiler, while preserving the same functionality of the Vala language. Genie uses the same compiler and libraries as Vala; the two can indeed be used alongside each other. The differences are only syntactic.

Genie allows access to C libraries, especially those based in GObject (like GTK), without using a different application binary interface (ABI). During compilation, the code is first translated to C source and header files, which are then compiled to platform-specific machine code using any available C compiler like GCC, thus allowing cross-platform software development. Programs developed in Vala and Genie do not depend on the GNOME Desktop Environment, usually requiring only GLib.

[indent=4]
                    init
                      print "Hello, world!"

Go

Year:2009 Developer: Google Influenced By: C, Oberon-2, Limbo, Active Oberon, communicating sequential processes, Pascal, Oberon, Smalltalk, Newsqueak, Modula-2, Alef, APL, BCPL, Modula, occam Filename Extension: .go Users: 2.1 million

Go is a statically typed, compiled programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. Go is syntactically similar to C, but with memory safety, garbage collection, structural typing, and CSP-style concurrency.

Go is influenced by C, but with an emphasis on greater simplicity and safety. The language consists of:

A syntax and environment adopting patterns more common in dynamic languages: Optional concise variable declaration and initialization through type inference, Fast compilation and Remote package management and online package documentation.

Distinctive approaches to particular problems: Built-in concurrency primitives, like light-weight processes (goroutines), channels, and the select statement. An interface system in place of virtual inheritance, and type embedding instead of non-virtual inheritance and A toolchain that, by default, produces statically linked native binaries without external dependencies.

A desire to keep the language specification simple enough to hold in a programmer's head, in part by omitting features that are common in similar languages.

Go is mostly used for building cloud-native apps.

package main
                    import "fmt"

                    func main() {
                      fmt.Println("Hello, world!")
                    }

Groovy

Year:2003 Developer: James Strachan Influenced By: Java, Python, Ruby, Smalltalk Filename Extension: .groovy, .gvy, .gy, .gsh Users: 126,000

Apache Groovy is a Java-syntax-compatible object-oriented programming language for the Java platform. It is both a static and dynamic language with features similar to those of Python, Ruby, and Smalltalk. It can be used as both a programming language and a scripting language for the Java Platform, is compiled to Java virtual machine (JVM) bytecode, and interoperates seamlessly with other Java code and libraries. Groovy uses a curly-bracket syntax similar to Java's. Groovy supports closures, multiline strings, and expressions embedded in strings. Much of Groovy's power lies in its AST transformations, triggered through annotations.

Groovy is the 15th most popular language by TIOBE index

println "Hello World"

Hack

Year:2014 Developer: Facebook Influenced By: PHP, OCaml, Java, C#, Scala, Haskell Filename Extension: .hack, .hh, .php Users: 26,000

Hack is a programming language for the HipHop Virtual Machine (HHVM), created by Facebook as a dialect of PHP. The language implementation is open-source, licensed under the MIT License. Hack allows programmers to use both dynamic typing and static typing. This kind of a type system is called gradual typing, which is also implemented in other programming languages such as ActionScript. Hack's type system allows types to be specified for function arguments, function return values, and class properties; however, types of local variables are always inferred and cannot be specified.

<<__EntryPoint>>
                    function main(): void {
                      echo 'Hello, World!';
                    }

Haskell

Year:1990 Developer: The Glasgow Haskell Team Influenced By: Clean, FP, Gofer, Hope and Hope+, Id, ISWIM, KRC, Lisp, Miranda, ML and Standard ML, Orwell, SASL, Scheme, SISAL Filename Extension: .hs, .lhs Users: 463,000

Haskell is a general-purpose, statically typed, purely functional programming language with type inference and lazy evaluation. Designed for teaching, research and industrial application, Haskell has pioneered a number of advanced programming language features such as type classes, which enable type-safe operator overloading. Haskell's main implementation is the Glasgow Haskell Compiler (GHC).

Haskell is used in academia and industry. For 2021, Haskell is the 27th most popular programming language by PYPL Index

module Main (main) where
                    main :: IO ()
                    main = putStrLn "Hello, World!"

HTML

Year:1993 Developer: WHATWG Type of format: Document file format Extended from: SGML Filename Extension: .html, .htm Users: over 7 million

The HyperText Markup Language, or HTML is the standard markup language for documents designed to be displayed in a web browser. It can be assisted by technologies such as CSS and scripting languages such as JavaScript

WHat it does: Web browsers receive HTML documents from a web server or from local storage and render the documents into multimedia web pages. HTML describes the structure of a web page semantically and originally included cues for the appearance of the document.

HTML elements are the building blocks of HTML pages. With HTML constructs, images and other objects such as interactive forms may be embedded into the rendered page. HTML provides a means to create structured documents by denoting structural semantics for text such as headings, paragraphs, lists, links, quotes and other items.

HTML can embed programs written in a scripting language such as JavaScript, which affects the behavior and content of web pages. Inclusion of CSS defines the look and layout of content. The World Wide Web Consortium (W3C), former maintainer of the HTML and current maintainer of the CSS standards, has encouraged the use of CSS over explicit presentational HTML since 1997.

The latest version HTML5 was released in 22 January, 2008 and is still widely used nowadays. HTML is used by 93.5% of all the websites whose markup language we know.

<!DOCTYPE html>
                    <html>
                        <head>
                            <title>This will print "Hello World" on the page</title>
                        </head>
                        <body>
                            <div>
                                  <p>Hello world!</p>
                            </div>
                        </body>
                    </html>

Icon

Year:1977 Developer: Ralph Griswold Influenced By: SNOBOL, SL5, ALGOL Filename Extension: .icon Users: over 1,000

Icon is a very high-level programming language based on the concept of "goal-directed execution" in which code returns a "success" along with valid values, or a "failure", indicating that there is no valid data to return. The success and failure of a given block of code is used to direct further processing, whereas conventional languages would typically use boolean logic written by the programmer to achieve the same ends. Because the logic for basic control structures is often implicit in Icon, common tasks can be completed with less explicit code. Icon was designed by Ralph Griswold after leaving Bell Labs where he was a major contributor to the SNOBOL language. SNOBOL was a string-processing language with what would be considered dated syntax by the standards of the early 1970s. After moving to the University of Arizona, he further developed the underlying SNOBOL concepts in SL5, but considered the result to be a failure. This led to the significantly updated Icon, which blends the short but conceptually dense code of SNOBOL-like languages with the more familiar syntax of ALGOL-inspired languages like C or Pascal. Like the languages that inspired it, the primary area of use of Icon is managing strings and textual patterns. String operations often fail, for instance, finding "the" in "world". In most languages, this requires testing and branching to avoid using a non-valid result. In Icon most of these sorts of tests are simply not required, reducing the amount of code written by the programmer. Complex pattern handling can be accomplished in a few lines of terse code, similar to more dedicated languages like Perl but retaining a more function-oriented syntax familiar to users of other ALGOL-like languages. Icon is not object-oriented, but an object-oriented extension called Idol was developed in 1996 which eventually became Unicon. It also inspired other languages, with its simple generators being especially influential; Icon's generators were a major inspiration for the Python programming language.

procedure main()
                      write("Hello world")
                    end

IDL

Year:1977 Developer: David Stern & ITT Visual Information Solutions (ITT VIS) Filename Extension: .pro Users: ~12,000

IDL (Interactive Data Language) is a programming language used for data analysis. It is popular in particular areas of science, such as astronomy, atmospheric physics and medical imaging. IDL shares a common syntax with PV-Wave and originated from the same codebase, though the languages have subsequently diverged in detail. There are also free or costless implementations, such as GNU Data Language (GDL) and Fawlty Language (FL).

; Hello World in IDL (Interactive Data Language)
                     print, "Hello World"

Inform

Year:1993 Developer: Graham Nelson Type: Interactive fiction Filename Extension: .ni, .i7x Users: 460

Inform is a programming language and design system for interactive fiction originally created in 1993 by Graham Nelson. Inform can generate programs designed for the Z-code or Glulx virtual machines. Versions 1 through 5 were released between 1993 and 1996. Around 1996, Nelson rewrote Inform from first principles to create version 6 (or Inform 6). Over the following decade, version 6 became reasonably stable and a popular language for writing interactive fiction. In 2006, Nelson released Inform 7 (briefly known as Natural Inform), a completely new language based on principles of natural language and a new set of tools based around a book-publishing metaphor.

[ Main;
              print "Hello world^";
        ];

Io

Year:2002 Developer: Steve Dekorte, Jonathan Wright, Jeremy Tregunna Influenced By: Smalltalk, NewtonScript, Self, Lua, Lisp, Python, Act1 Filename Extension: .io Users: 4,700

Io is a pure object-oriented programming language inspired by Smalltalk, Self, Lua, Lisp, Act1, and NewtonScript. Io has a prototype-based object model similar to the ones in Self and NewtonScript, eliminating the distinction between instance and class. Like Smalltalk, everything is an object and it uses dynamic typing. Like Lisp, programs are just data trees. Io uses actors for concurrency. Remarkable features of Io are its minimal size and openness to using external code resources. Io is executed by a small, portable virtual machine.

"Hello, world!" println

J

Year:1990 Developer: Kenneth E. Iverson, Roger Hui Influenced By: APL Filename Extension: .ijs Users: 2,500

The J programming language is an array programming language based primarily on APL. J uses only the basic ASCII character set, resorting to the use of the dot and colon as inflections to form short words similar to digraphs. Most such primary (or primitive) J words serve as mathematical symbols, with the dot or colon extending the meaning of the basic characters available. J is a very terse array programming language, and is most suited to mathematical and statistical programming, especially when performing operations on matrices. It has also been used in extreme programming and network performance analysis.

'Hello, world!'

Julia

Year:2012 Developer: Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors Influenced By: , Dylan, Lis, Lua, Mathematic, Wolfram Language, MATLA, Perl, Python, Ruby, Scheme, Filename Extension: .jl Users: 17,000

Julia is a high-level, high-performance, dynamic programming language. While it is a general-purpose language and can be used to write any application, many of 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.

println("Hello, World!")

KornShell

Year:1983 Developer: David Korn Written In: C Filename Extension: .ksh Users: over 600

KornShell (ksh) is a Unix shell which was developed by David Korn at Bell Labs in the early 1980s and announced at USENIX on July 14, 1983. The initial development was based on Bourne shell source code. Other early contributors were Bell Labs developers Mike Veach and Pat Sullivan, who wrote the Emacs and vi-style line editing modes' code, respectively. KornShell is backward-compatible with the Bourne shell and includes many features of the C shell, inspired by the requests of Bell Labs users.

#!/bin/ksh
                    print "Hello World"

LabView

Year:1986 Developer: National Instruments Written In: C, C++ Users: 2,000

Laboratory Virtual Instrument Engineering Workbench (LabVIEW): 3 is a system-design platform and development environment for a visual programming language from National Instruments. The graphical language is named "G"; not to be confused with G-code. The G dataflow language was originally developed by Labview,[2] LabVIEW is commonly used for data acquisition, instrument control, and industrial automation on a variety of operating systems (OSs), including Microsoft Windows as well as various versions of Unix, Linux, and macOS.

LadderLogic

Year:1994 Users: ~200

Ladder logic was originally a written method to document the design and construction of relay racks as used in manufacturing and process control. Each device in the relay rack would be represented by a symbol on the ladder diagram with connections between those devices shown. In addition, other items external to the relay rack such as pumps, heaters, and so forth would also be shown on the ladder diagram. Ladder logic has evolved into a programming language that represents a program by a graphical diagram based on the circuit diagrams of relay logic hardware. Ladder logic is used to develop software for programmable logic controllers (PLCs) used in industrial control applications.

Sample Program:
                    ------[ ]--------------[ ]----------------( )
                     Key switch 1     Key switch 2         Door motor

Lisp

Year:1958 Developer: John McCarthy Influenced By: IPL Filename Extension: .lisp, .cl, .asd, .ros, .lsp, .el, .fnl Users: 66,700

Lisp (historically LISP) is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation. Originally specified in 1958, Lisp is the second-oldest high-level programming language. Only Fortran is older, by one year. Lisp has changed since its early days, and many dialects have existed over its history. Today, the best-known general-purpose Lisp dialects are Racket, Common Lisp, Scheme, and Clojure.

Lisp was originally created as a practical mathematical notation for computer programs, influenced by (though not originally derived from) the notation of Alonzo Church's lambda calculus. It quickly became the favored programming language for artificial intelligence (AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, conditionals, higher-order functions, recursion, the self-hosting compiler, and the read–eval–print loop.

(print "Hello, World!")

LiveCode

Year:2001 Developer: LiveCode Ltd. Influenced By: HyperTalk Users: 1,500

LiveCode (formerly Revolution and MetaCard) is a cross-platform rapid application development runtime system inspired by HyperCard. It features the LiveCode Script (formerly MetaTalk) programming language which belongs to the family of xTalk scripting languages like HyperCard's HyperTalk.

-- Hello world in LiveCode
                    answer "Hello World!"

Logo

Year:1967 Developer: Bolt, Beranek and Newman Influenced By: Lisp Filename Extension: .lgo, .lg Users: 1,250

Logo is an educational programming language. Logo is widely known for its use of turtle graphics, in which commands for movement and drawing produced line or vector graphics, either on screen or with a small robot termed a turtle. The language was conceived to teach concepts of programming related to Lisp and only later to enable what Papert called "body-syntonic reasoning", where students could understand, predict, and reason about the turtle's motion by imagining what they would do if they were the turtle. There are substantial differences among the many dialects of Logo, and the situation is confused by the regular appearance of turtle graphics programs that are named Logo.

;Hello World in Logo
                    DRUCKEZEILE [Hello World!]

Lua

Year:1993 Developer: Roberto Ierusalimschy Influenced By: C++, CLU, Modula, Scheme, SNOBOL Filename Extension: .lua Users: 269,000

Lua ("Moon" portuguese) is a lightweight, high-level, multi-paradigm programming language designed primarily for embedded use in applications. Lua is cross-platform, since the interpreter of compiled bytecode is written in ANSI C, and Lua has a relatively simple C API to embed it into applications.

Lua was originally designed in 1993 as a language for extending software applications to meet the increasing demand for customization at the time. It provided the basic facilities of most procedural programming languages, but more complicated or domain-specific features were not included; rather, it included mechanisms for extending the language, allowing programmers to implement such features. As Lua was intended to be a general embeddable extension language, the designers of Lua focused on improving its speed, portability, extensibility, and ease-of-use in development.

Used in Game Development

print("Hello, World!")

Maple

Year:1982 Developer: Waterloo Maple (Maplesoft) Written In: C, Java, Maple Filename Extension: .mpl, .mi, .mm Users: 7,300

Maple is a symbolic and numeric computing environment as well as a multi-paradigm programming language. It covers several areas of technical computing, such as symbolic mathematics, numerical analysis, data processing, visualization, and others. A toolbox, MapleSim, adds functionality for multidomain physical modeling and code generation. Maple's capacity for symbolic computing include those of a general-purpose computer algebra system. For instance, it can manipulate mathematical expressions and find symbolic solutions to certain problems, such as those arising from ordinary and partial differential equations.

# Hello World in Maple
                    >> printf("Hello World!");

MATLAB

Year:1978 Developer: MathWorks Influenced By: APL, EISPACK, LINPACK, PL/0, Speakeasy Filename Extension: .m, .p, .mex*, .mat, .fig, .m .mlapp, .mltbx, .mlappinstall, .mlpkginstall Users: 4 million

MATLAB (an abbreviation of "matrix laboratory") is a proprietary multi-paradigm programming language and numeric computing environment developed by MathWorks. MATLAB allows matrix manipulations, plotting of functions and data, implementation of algorithms, creation of user interfaces, and interfacing with programs written in other languages.

Although MATLAB is intended primarily for numeric computing, an optional toolbox uses the MuPAD symbolic engine allowing access to symbolic computing abilities. An additional package, Simulink, adds graphical multi-domain simulation and model-based design for dynamic and embedded systems.

classdef  Hello
                      methods
                        function greet(obj)
                          disp('Hello!')
                        end
                      end
                classdef

Mercury

Year:1995 Developer: University of Melbourne Influenced By: Prolog, Hope, Haskell Filename Extension: .m Users: 400

Mercury is a functional logic programming language made for real-world uses. Mercury is a purely declarative logic programming language. It is related to both Prolog and Haskell. It features a strong, static, polymorphic type system, and a strong mode and determinism system. The official implementation, the Melbourne Mercury Compiler, is available for most Unix and Unix-like platforms, including Linux, macOS, and for Windows.

 :- module hello.
                    :- interface.
                    :- import_module io.
                    :- pred main(io::di, io::uo) is det.
                   
                    :- implementation.
                    main(!IO) :-
                        io.write_string("Hello, World!\n", !IO).

ML

Year:1973 Developer: Robin Milner and others at the University of Edinburgh Influenced By: ISWIM Filename Extension: .ml Users: 950

ML (Meta Language) is a general-purpose functional programming language. It is known for its use of the polymorphic Hindley–Milner type system, which automatically assigns the types of most expressions without requiring explicit type annotations, and ensures type safety – there is a formal proof that a well-typed ML program does not cause runtime type errors. ML provides pattern matching for function arguments, garbage collection, imperative programming, call-by-value and currying. It is used heavily in programming language research and is one of the few languages to be completely specified and verified using formal semantics. Its types and pattern matching make it well-suited and commonly used to operate on other formal languages, such as in compiler writing, automated theorem proving, and formal verification.

print "Hello, world!\n"

MLQ5

Year:2055 Users: ~3,000

MQL5 is an actively used programming language created in 2005. MQL4 (MetaQuotes Language 4) and MQL5 (MetaQuotes Language 5) are integrated programming languages designed for developing trading robots, technical market indicators, scripts and function libraries within the MetaTrader software. The primary objective of MQL4 and MQL5 is automation of trading and facilitation of operational analysis. MQL4 and MQL5 comprises an extensive codebase source code library used for developing trading robots.

Example Code from Wikipedia:
                    #property version   "1.00"
        #property script_show_inputs

        #include <Trade\Trade.mqh>

        input int StopLoss=100; // Stop Loss
        input int TakeProfit=100; // Take Profit
        //+------------------------------------------------------------------+
        //| Script program start function                                    |
        //+------------------------------------------------------------------+
        void OnStart()
  {
   CTrade trade;
        //---
   long 
   stoplevel=SymbolInfoInteger
     (Symbol(),SYMBOL_TRADE_STOPS_LEVEL);
   Print("Minimum stop level is: ",stoplevel);
   double ask=SymbolInfoDouble(Symbol(),SYMBOL_ASK);
   double bid=SymbolInfoDouble(Symbol(),SYMBOL_BID);
   double sl = NormalizeDouble(bid - StopLoss*Point(),Digits());
   double tp = NormalizeDouble(ask + TakeProfit*Point(),Digits());
        //---
   bool result=trade.Buy(0.01,Symbol(),ask,sl,tp,"test");
        //---
   Print("Success? ",result);
  }
        //+------------------------------------------------------------------+

NATURAL

Year:1971 Developer: ADABAS Influenced By: Java, COBOL Users: less 50

Natural is a proprietary fourth-generation programming language. It was not part of the initial (1971) Adabas release. Natural programs can be "run" interpretively or "executed" as compiled objects. Compiled programs can more directly use operating system services, and run faster. Proponents say that Natural has evolved from a competitor of COBOL to "being in competition with Java as language of choice for writing services (SOA)."

Natural, which includes a built-in screen-oriented editor, has two main components: the system and the language. The system is the central vehicle of communication between the user and all other components of the processing environment. The language is structured and less procedural than conventional languages. Natural objects (programs, maps, data areas, etc.) are stored in libraries, similar in structure to a DOS directory, and can be named with identifiers up to 8 characters. Objects, even if they are of different types, cannot have the same name. Natural provides both online and batch execution and programming testing utilities. Versions exist for z/OS, z/VSE, BS2000/OS, Linux, Unix and Windows.

* Hello World in NATURAL
                    WRITE 'Hello World!'
                    END

NXT-G

Year:2006

NXT-G v2.0 is a graphical programming environment that comes bundled with the NXT. With careful construction of blocks and wires to encapsulate complexity, NXT-G can be used for real-world programming. Parallel "sequence beams" are actually parallel threads, so this software is quite good for running a handful of parallel sense/respond loops (example: wait 60 seconds, play a "bonk" sound at low volume if battery is low, loop), or blending autonomous control with bluetooth or other "remote control". The language supports virtual instruments for all Lego branded and most 3rd party sensors/components. Version 2.0 contains new tutorial challenges, a remote control, custom graphics and sound designers, and new Lego color sensor support.

main()
                    {
                      TextOut(0, LCD_LINE1, "Hello World!");
                    }

OCaml

Year:1996 Developer: INRIA Influenced By: C, Caml, Modula-3, Pascal, Standard ML Filename Extension: .ml, .mli Users: ~100,000

OCaml (Objective Caml) is a general-purpose, multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. The OCaml toolchain includes an interactive top-level interpreter, a bytecode compiler, an optimizing native code compiler, a reversible debugger, and a package manager (OPAM). OCaml was initially developed in the context of automated theorem proving, and has an outsize presence in static analysis and formal methods software. Beyond these areas, it has found serious use in systems programming, web development, and financial engineering, among other application domains.

print_endline "Hello World!"

OpenCL

Year:2009 Developer: Apple Inc. Influenced By: C99, CUDA, C++14, C++17 Filename Extension: .cl, .clcpp Users: 34,000

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. OpenCL provides a standard interface for parallel computing using task- and data-based parallelism.

/*hello.cpp*/
                    #define CL_USE_DEPRECATED_OPENCL_2_0_APIS

                    #include<CL/cl.hpp>
                    #include<iostream>
                    #include <fstream>
                    
                    int main() 
                    {
                        std::vector<cl::Platform> platforms;
                        cl::Platform::get(&platforms);
                    
                        auto platform = platforms.front();
                        std::vector<cl::Device> devices;
                        platform.getDevices(CL_DEVICE_TYPE_CPU, &devices);
                    
                        auto device = devices.front();
                    
                        std::ifstream helloWorldFile("hello.cl");
                        std::string src(std::istreambuf_iterator<char>(helloWorldFile), (std::istreambuf_iterator<char>()));
                    
                        cl::Program::Sources sources( 1, std::make_pair(src.c_str(), src.length() + 1));
                    
                        cl::Context context(device);
                        cl::Program program(context, sources);
                    
                        auto err = program.build("-cl-std=CL1.2");
                    
                        char buf[16];
                        cl::Buffer memBuf(context, CL_MEM_WRITE_ONLY | CL_MEM_HOST_READ_ONLY, sizeof(buf));
                        cl::Kernel kernel(program, "Hello", &err);
                        kernel.setArg(0, memBuf);
                    
                        cl::CommandQueue queue(context, device);
                        queue.enqueueTask(kernel);
                        queue.enqueueReadBuffer(memBuf, GL_TRUE, 0, sizeof(buf), buf);
                    
                        std::cout << "hello";
                        std::cin.get();
                    
                    }

/*hello.cl*/
                        __kernel void HelloWorld(__global char* data)
                    {
                        data[0] = 'H';
                        data[1] = 'E';
                        data[2] = 'L';
                        data[3] = 'L';
                        data[4] = 'O';
                        data[5] = ' ';
                        data[6] = 'W';
                        data[7] = 'O';
                        data[8] = 'R';
                        data[9] = 'L';
                        data[10] = 'D';
                        data[11] = '!';
                        data[12] = '\n';
                    }

OpenEdge ABL

Year:2006 Developer: Progress Software Corporation Type: RDBMS Users: 13,000

OpenEdge Advanced Business Language, or OpenEdge ABL for short, is a business application development language created and maintained by Progress Software Corporation (PSC). The language, typically classified as a fourth-generation programming language, uses an English-like syntax to simplify software development. The language was called PROGRESS or Progress 4GL up until version 9, but in 2006 PSC changed the name to OpenEdge Advanced Business Language (OpenEdge ABL) in order to overcome a presumed industry perception that 4GLs were less capable than other languages. A subset of the language, called SpeedScript, is used in the development of web applications.

OpenEdge can be used for:

Microsoft Windows GUI (Graphical User Interface)
WWW Programming (UNIX and Windows)
CHUI (CHaracter User Interface) (UNIX and Windows)
JSON and XML appserver programming (UNIX and Windows)
as well background process programming (UNIX and Windows).

DEFINE VARIABLE w AS HANDLE NO-UNDO.
                    CREATE WINDOW w ASSIGN 
                        WIDTH = 50
                        HEIGHT = 5
                        MESSAGE-AREA = FALSE
                        STATUS-AREA = FALSE.   
                    CURRENT-WINDOW = w.
                    
                    DEFINE BUTTON btnOK LABEL "OK" SIZE 12 BY 1.2.
                    FORM 
                       "Hello World!" VIEW-AS TEXT AT COL 20 ROW 2
                       btnOK AT COL 20 ROW 4
                       WITH FRAME f SIZE 50 BY 5 NO-BOX THREE-D.
                    
                    VIEW FRAME f.
                    ENABLE btnOK WITH FRAME f.
                    WAIT-FOR "CHOOSE" OF btnOK.
                    DELETE OBJECT w.

Oz

Year:1991 Developer: Mozart Consortium Influenced By: Erlang, Lisp, Prolog Filename Extension: .oz Users: 850

Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Université catholique de Louvain, for programming language education. It has a canonical textbook: Concepts, Techniques, and Models of Computer Programming.

functor
                    import
                      System
                      Application
                    define
                      {System.showInfo "Hello World!"}
                      {Application.exit 0}
                    end

Pascal

Year:1970 Developer: Niklaus Wirth Influenced By: ALGOL W, Simula 67 Filename Extension: .pp, .pas, .inc Users: 174,000

Perl is a general-purpose programming language originally developed for text manipulation and now used for a wide range of tasks including system administration, web development, network programming, GUI development, and more.

Based on Wirth's book Algorithms + Data Structures = Programs, Pascal was developed on the pattern of the ALGOL 60 language. Wirth was involved in the process to improve the language as part of the ALGOL X efforts and proposed a version named ALGOL W. This was not accepted, and the ALGOL X process bogged down. In 1968, Wirth decided to abandon the ALGOL X process and further improve ALGOL W, releasing this as Pascal in 1970.

Pascal enabled defining complex datatypes and building dynamic and recursive data structures such as lists, trees and graphs. Pascal has strong typing on all objects, which means that one type of data cannot be converted to or interpreted as another without explicit conversions. Unlike C (and most languages in the C-family), Pascal allows nested procedure definitions to any level of depth, and also allows most kinds of definitions and declarations inside subroutines (procedures and functions). A program is thus syntactically similar to a single procedure or function. This is similar to the block structure of ALGOL 60, but restricted from arbitrary block statements to just procedures and functions.

Pascal is an imperative and procedural programming language that was originally designed for teaching programming languages. Today, it's been mostly replaced by C, C++ and Java, but it's still used as an introduction to programming

program Hello;
                    begin
                      writeln ('Hello, Wolrd.');
                    end.

Perl

Year:1987 Developer: Larry Wall Influenced By: AWK, BASIC, C, C++, Lisp, sed, Unix shell Filename Extension: .plx, .pl, .pm, .xs, .t, .pod, .cgi Users: 57,000

Perl is a family of two high-level, general-purpose, interpreted, dynamic programming languages.

The overall structure of Perl derives broadly from C. Perl is procedural in nature, with variables, expressions, assignment statements, brace-delimited blocks, control structures, and subroutines. Perl 5 added features that support complex data structures, first-class functions (that is, closures as values), and an object-oriented programming model. These include references, packages, class-based method dispatch, and lexically scoped variables, along with compiler directives (for example, the strict pragma).

Perl 7 was announced on 24 June 2020 at "The Perl Conference in the Cloud" as the successor to Perl 5. Perl 7 is designed to be backwards compatible with modern Perl 5 code.

Perl was originally developed for text manipulation and now used for a wide range of tasks including system administration, web development, network programming, GUI development, and more.

print "Hello, World!\n";

Plankalkül

Year:1948 Developer: Konrad Zuse Paradigm: Procedural Influenced By: Begriffsschrift - a book on logic by Gottlob Frege, published in 1879 Users: Nein

Plankalkül (German: "Plan Calculus") is a programming language designed for engineering purposes by Konrad Zuse between 1942 and 1945. It was the FIRST high-level programming language to be designed for a computer.

Plankalkül has drawn comparisons to the language APL, and to relational algebra. It includes assignment statements, subroutines, conditional statements, iteration, floating point arithmetic, arrays, hierarchical record structures, assertions, exception handling, and other advanced features such as goal-directed execution. The Plankalkül provides a data structure called generalized graph (verallgemeinerter Graph), which can be used to represent geometrical structures.

Features of the Plankalkül:

Local Variables (no global vars)
Functions do not support recursion
Functions only supports call by value
Composite types are arrays and tuples
Conditional expressions
For loop and a while loop
Data Types:

bit - 1 oder 0
boolean - Ja-Nein-Werte(yes-no value)
Arrays
Records

R1.1(VO[:sig]) => R0
                    R1.2(V0[:m x sig]) => R0
                    0 => i | m + 1 => j
                    [W [ i < j -> [ R1.1(v0)[i: m x sig]) => R0 | i + 1 => i ] ] ]
                    END
                    R1.3() => R0
                    'H';'e';'l';'l';'o';',';' ';'W';'o';'r';'l';'d';'!' => Z0[: m x sig] R1.2(Z0) => R0
                    END

PL/I

Year:1964 Developer: IBM Influenced By: COBOL, Fortran, ALGOL 60 Users: ?, it's very old langauge

PL/I (Programming Language One, sometimes written PL/1) is a procedural, imperative computer programming language developed and published by IBM. It is designed for scientific, engineering, business and system programming. It has been used by academic, commercial and industrial organizations since it was introduced in the 1960s, and is still used.

PL/I's main domains are data processing, numerical computation, scientific computing, and system programming. It supports recursion, structured programming, linked data structure handling, fixed-point, floating-point, complex, character string handling, and bit string handling. The language syntax is English-like and suited for describing complex data formats with a wide set of functions available to verify and manipulate them.

Hello2: proc options(main);
                  put list ('Hello, World!');
               end Hello2;

PostScript

Year:1982 Developer: Adobe Systems Influenced By: Mesa, Interpress, Lisp Users: 11,700

PostScript (PS) is a page description language in the electronic publishing and desktop publishing business. It is a dynamically typed, concatenative programming language.

%!PS 
                    /Courier         % name the desired font
                    20 selectfont    % choose the size in points and establish 
                                     % the font as the current one
                    72 500 moveto    % position the current point at 
                                     % coordinates 72, 500 (the origin is at the 
                                     % lower-left corner of the page)
                    (Hello World!) show    % stroke the text in parentheses
                    showpage         % print all on the page

Processing

Year:2001 Developer: Casey Reas, Ben Fry Filename Extension: .pde Users: 63,000

Processing is a free graphical library and integrated development environment (IDE) built for the electronic arts, new media art, and visual design communities with the purpose of teaching non-programmers the fundamentals of computer programming in a visual context. Processing uses the Java language, with additional simplifications such as additional classes and aliased mathematical functions and operations. It also provides a graphical user interface for simplifying the compilation and execution stage. The Processing language and IDE have been the precursor to other projects including Arduino, Wiring and p5.js.

// This prints "Hello World." to the IDE console.
                   println("Hello World.");

Prolog

Year:1972 Developer: Alain Colmerauer, Robert Kowalski Influenced By: Planner Filename Extension: .pl, pro, .P Users: 70,000

Prolog is a logic programming language associated with artificial intelligence and computational linguistics. Prolog has its roots in first-order logic, a formal logic, and unlike many other programming languages, Prolog is intended primarily as a declarative programming language: the program logic is expressed in terms of relations, represented as facts and rules. A computation is initiated by running a query over these relations.

% Hello World in Prolog %
                    hello :- display('Hello World!') , nl .

Q

Year:2003 Developer: kx Systems Influenced By: A+, APL, Scheme, k Filename Extension: .q Users: 650

Q is a programming language for array processing, developed by Arthur Whitney. It is proprietary software, commercialized by Kx Systems. Q serves as the query language for kdb+, a disk based and in-memory, column-based database. Kdb+ is based on the language k, a terse variant of the language APL. Q is a thin wrapper around k, providing a more readable, English-like interface.

q)"Hello world!"
                    "Hello world!"

Racket

Year:1995 Developer: PLT Inc. Influenced By: Scheme, Eiffel Filename Extension: .rkt Users: over 6,000

Racket is a general-purpose, multi-paradigm programming language based on the Scheme dialect of Lisp. It is designed as a platform for programming language design and implementation. In addition to the core Racket language, Racket is also used to refer to the family of programming languages and set of tools supporting development on and with Racket. Racket is also used for scripting, computer science education, and research.

;; Hello world in Racket
                    #lang racket/base
                    "Hello, World!"

React

Year:2013 Developer: Facebook Written In: JavaScript Filename Extension: .js Users: 60,000

React (also known as React.js or ReactJS) is a free and open-source front-end JavaScript library for building user interfaces or UI components. It is maintained by Facebook and a community of individual developers and companies. React can be used as a base in the development of single-page or mobile applications. However, React is only concerned with state management and rendering that state to the DOM, so creating React applications usually requires the use of additional libraries for routing, as well as certain client-side functionality.

ReactDOM.render(
                    <h1>Hello, world! </h1>,
                    document.getElementById('root')
                    );

Red

Year:2011 Developer: Nenad Rakočević Influenced By: Rebol, Scala, Lua Filename Extension: .red, .reds Users: ~8,000

Red is a programming language designed to overcome the limitations of the programming language Rebol. Red was introduced in 2011 by Nenad Rakočević, and is both an imperative and functional programming language. Its syntax and general usage overlaps that of the interpreted Rebol language.

The implementation choices of Red intend to create a full stack programming language: Red can be used for extremely high-level programming (DSLs and GUIs) as well as low-level programming (operating systems and device drivers). Key to the approach is that the language has two parts: Red/System and Red.

Red [Title: "Simple hello world script"]
                  print "Hello World!"

Ring

Year:2016 Users: ~500

The Ring is a practical general-purpose multi-paradigm language. The supported programming paradigms are imperative, procedural, object-oriented, declarative using nested structures, functional, meta programming and natural programming. The language is portable (Windows, Linux, macOS, Android, WebAssembly, etc.) and can be used to create Console, GUI, Web, Games and Mobile applications. The language is designed to be simple, small and flexible.

func sayHello
                  oView {
                    lblMsg.setText("Hello" + txtName.text())
                }

RPG

Year:1959 Developer: IBM Users: less 50

Report Program Generator (or RPG for short) is a high-level programming language serves a wide array of business applications and uses. It is an IBM proprietary programming module and a vast majority of its later versions can only be accessed on IBM i- or OS/400-based systems.

**Hello World program in RPG IV
                dsply 'Hello World';
                return;

Ruby

Year:1995 Developer: Yukihiro Matsumoto Influenced By: Ada, Basic, C++, CLU, Dylan, Eiffel, Lisp, Lua, Perl, Python, Smalltalk Filename Extension: .rb Users: 2.1 million

Ruby is an interpreted, high-level, general-purpose programming language. And it's also 14th most popular langauge in the world.

Ruby is dynamically typed and uses garbage collection and just-in-time compilation. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming.

Ruby is most used for building web applications.

puts "Hello, World!"

Rust

Year:2010 Developer: Rust Foundation Influenced By: Alef, C#, C++, Cyclone, Erlang, Haskell, Limbo, Newsqueak, OCaml, Ruby, Scheme, Standard ML, Swift Filename Extension: .rs, .rlib Users: 1.2 million

Rust is a multi-paradigm, high-level, general-purpose programming language designed for performance and safety, especially safe concurrency. Rust is syntactically similar to C++, but can guarantee memory safety by using a borrow checker to validate references. Rust achieves memory safety without garbage collection, and reference counting is optional.

Rust has been voted the "most loved programming language" in the Stack Overflow Developer Survey every year since 2016, though only used by 7% of the respondents in the 2021 survey.

Rust is great for building things like operating systems, file systems, and game engines.

fn main() {
                    println!("Hello, World!");
                }

S

Year:1976 Developer: John CHambers, Rick Backer, Allan Wilks Influenced By: C, APL, PPL, Fortran Filename Extension: .s Users: ~500

is a statistical programming language developed primarily by John Chambers and (in earlier versions) Rick Becker and Allan Wilks of Bell Laboratories. The aim of the language, as expressed by John Chambers, is "to turn ideas into software, quickly and faithfully". The modern implementations of S is R, a part of the GNU free software project.

cat("Hello world\n")

SAS

Year:1976 Developer: Anthony James Barr Filename Extension: .sas Users: 8,000

The SAS (Statistical Analysis System) language is a computer programming language used for statistical analysis It can read in data from common spreadsheets and databases and output the results of statistical analyses in tables, graphs, and as RTF, HTML and PDF documents. The SAS language runs under compilers that can be used on Microsoft Windows, Linux, and various other UNIX and mainframe computers. The SAS System and World Programming System (WPS) are SAS language compilers.

TITLE "Hello World!";
                    data _null_;
                      PUT "Hello world!";
                    run;

Scala

Year:2004 Developer: Programming Methods Laboratory of École Polytechnique Fédérale de Lausanne Influenced By: Common Lisp, Eiffel, Erlang, F#, Haskell, Java, OCaml, Oz, Pizza, Scheme, Smalltalk, Standard ML Filename Extension: .scala, .sc Users: 460,000

Scala is a strong statically typed general-purpose programming language which supports both object-oriented programming and functional programming. Designed to be concise, many of Scala's design decisions are aimed to address criticisms of Java.

Unlike Java, Scala has many features of functional programming languages like Scheme, Standard ML, and Haskell, including currying, immutability, lazy evaluation, and pattern matching. It also has an advanced type system supporting algebraic data types, covariance and contravariance, higher-order types (but not higher-rank types), and anonymous types. Other features of Scala not present in Java include operator overloading, optional parameters, named parameters, and raw strings. Conversely, a feature of Java not in Scala is checked exceptions, which has proved controversial.

The name Scala is a portmanteau of scalable and language, signifying that it is designed to grow with the demands of its users.

object HelloWorld extends App {
                    println("Hello, World!")
                  }

Scheme

Year: 1975 Developer: Guy L. Steele and Gerald Jay Sussman Influenced By: ALGOL, MDL, Lisp Filename Extension: .scm, .ss Users: ~2,000

Scheme is a minimalist dialect of the Lisp family of programming languages. Scheme consists of a small standard core with several tools for language extension.

Scheme was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support first-class continuations.

; Hello World in Scheme

                (display "Hello, world!")
                (newline)

Shell script

Year:1971

A shell script is a computer program designed to be run by the Unix shell, a command-line interpreter. The various dialects of shell scripts are considered to be scripting languages. Typical operations performed by shell scripts include file manipulation, program execution, and printing text. A script which sets up the environment, runs the program, and does any necessary cleanup, logging, etc. is called a wrapper.

The term is also used more generally to mean the automated mode of running an operating system shell; in specific operating systems they are called other things such as batch files (MSDos-Win95 stream, OS/2), command procedures (VMS), and shell scripts (Windows NT stream and third-party derivatives like 4NT—article is at cmd.exe), and mainframe operating systems are associated with a number of terms.

The typical Unix/Linux/POSIX-compliant installation includes the KornShell (ksh) in several possible versions such as ksh88, Korn Shell '93 and others. The oldest shell still in common use is the Bourne shell (sh); Unix systems may also include the C shell (csh), Bash (bash), a Remote Shell (rsh), a Secure Shell (ssh) for SSL telnet connections, and a shell which is a main component of the Tcl/Tk installation usually called tclsh; wish is a GUI-based Tcl/Tk shell. The C and Tcl shells have syntax quite similar to that of said programming languages, and the Korn shells and Bash are developments of the Bourne shell, which is based on the ALGOL language with elements of a number of others added as well. On the other hand, the various shells plus tools like awk, sed, grep, and BASIC, Lisp, C and so forth contributed to the Perl programming language.

Other shells available on a machine or available for download and/or purchase include Almquist shell (ash), PowerShell (msh), Z shell (zsh, a particularly common enhanced KornShell), the Tenex C Shell (tcsh), and a Perl-like shell (psh). Related programs such as shells based on Python, Ruby, C, Java, Perl, Pascal, Rexx etc. in various forms are also widely available. Another somewhat common shell is Old shell (osh), whose manual page states it "is an enhanced, backward-compatible port of the standard command interpreter from Sixth Edition UNIX."

#!/bin/sh
                    # This is a comment!
                    echo Hello World

Smalltalk

Year:1972 Developer: Alan Kay, Dan Ingalls, Adele Goldberg Influenced By: Lisp, Simula, Euler, IMP, Planner, Logo, Sketchpad, ARPAnet, Burroughs B5000 Filename Extension: .st Users: 2,000

Smalltalk is an object-oriented, dynamically typed reflective programming language. Smalltalk was created as the language underpinning the "new world" of computing exemplified by "human–computer symbiosis". It was designed and created in part for educational use, specifically for constructionist learning

Transcript show: 'Hello World!'.

SPARK

Year:1988 Developer: Altran and AdaCore Influenced By: Ada, Eiffel Users: Over 500

SPARK is a formally defined computer programming language based on the Ada programming language, intended for the development of high integrity software used in systems where predictable and highly reliable operation is essential. It facilitates the development of applications that demand safety, security, or business integrity.

object hello
                    {
                      def main(args: Array[String])
                      {
                        print("\n\n>>>>> START OF PROGRAM <<<<<\n\n");
                            
                        println("Hello World.")
                            
                        print("\n\n>>>>> END OF PROGRAM <<<<<\n\n");
                      }
                    }

SQL

Year:1974 Developer: ISO/IEC Influenced By: Datalog Filename Extension: .sql Users: 7 million

SQL (Structured Query Language) is a domain-specific language used in programming and designed for managing data held in a relational database management system (RDBMS), or for stream processing in a relational data stream management system (RDSMS). It is particularly useful in handling structured data, i.e. data incorporating relations among entities and variables.

SQL offers two main advantages over older read–write APIs such as ISAM or VSAM. Firstly, it introduced the concept of accessing many records with one single command. Secondly, it eliminates the need to specify how to reach a record, e.g. with or without an index.

Originally based upon relational algebra and tuple relational calculus, SQL consists of many types of statements, which may be informally classed as sublanguages, commonly: a data query language (DQL), a data definition language (DDL), a data control language (DCL), and a data manipulation language (DML). The scope of SQL includes data query, data manipulation (insert, update and delete), data definition (schema creation and modification), and data access control. Although SQL is essentially a declarative language (4GL), it also includes procedural elements.

SELECT * FROM helloworld WHERE phrase = "Hello, World!"

Stata

Year:1985 Developer: StataCorp Written In: C Users: over 500

Stata is a general-purpose statistical software package developed by StataCorp for data manipulation, visualization, statistics, and automated reporting. It is used by researchers in many fields, including economics, sociology, political science, biomedicine, and epidemiology.

.program hello
                     1. display "Hello, World!"
                     2. end
                   .hello

TCL

Year:1988 Developer: Tcl Core Team Influenced By: AWK, Lisp Filename Extension: .tcl, .tcb Users: 13,000

Tcl (Tool Command Language, pronounced "tickle") is a high-level, general-purpose, interpreted, dynamic programming language. It was designed with the goal of being very simple but powerful. Tcl casts everything into the mold of a command, even programming constructs like variable assignment and procedure definition. Tcl supports multiple programming paradigms, including object-oriented, imperative and functional programming or procedural styles. It is commonly used embedded into C applications, for rapid prototyping, scripted applications, GUIs, and testing. Tcl interpreters are available for many operating systems, allowing Tcl code to run on a wide variety of systems. Because Tcl is a very compact language, it is used on embedded systems platforms, both in its full form and in several other small-footprint versions.

# Hello World in Tcl
                    puts "Hello World!"

Vala

Year:2006 Developer: Jürg Billeter, Raffaele Sandrini Influenced By: C, C++, C#, D, Java, Boo Filename Extension: .vala, .vapi Users: ~100

Vala is an object-oriented programming language with a self-hosting compiler that generates C code and uses the GObject system. Vala is syntactically similar to C# and includes notable features such as anonymous functions, signals, properties, generics, assisted memory management, exception handling, type inference, and foreach statements. Its developers, Jürg Billeter and Raffaele Sandrini, wanted to bring these features to the plain C runtime with little overhead and no special runtime support by targeting the GObject object system. Rather than compiling directly to machine code or assembly language, it compiles to a lower-level intermediate language. It source-to-source compiles to C, which is then compiled with a C compiler for a given platform, such as GCC or Clang.

void main () {
                  print ("Hello World\n");
                }

VBA

Year:1993 Developer: Microsoft Influenced By: QuickBASIC, Visual Basic Filename Extension: .cpp Users: over 100

Visual Basic for Applications (VBA) is an implementation of Microsoft's event-driven programming language Visual Basic 6, which was declared legacy in 2008, and is an associated integrated development environment (IDE). Although pre-.NET Visual Basic is no longer supported or updated by Microsoft, the VBA programming language was upgraded in 2010 with the introduction of Visual Basic for Applications 7 in Microsoft Office applications. As of 2020, VBA has held its position as "most dreaded" language.

Sub helloWorld()
                      msgbox ("Hello, World!")
                    end Sub

VB.NET

Year:2001 Developer: Microsoft Influenced By: Classic Visual Basic Filename Extension: .vb Users: ~5,000

Visual Basic, originally called Visual Basic .NET (VB.NET), is a multi-paradigm, object-oriented programming language, implemented on .NET, Mono, and the .NET Framework. Microsoft launched VB.NET in 2002 as the successor to its original Visual Basic language, the last version of which was Visual Basic 6.0.

Visual Basic is often used in conjunction with the Windows Forms GUI library to make desktop apps for Windows. Programming for Windows Forms with Visual Basic involves dragging and dropping controls on a form using a GUI designer and writing corresponding code for each control.

Console.WriteLine("Hello World")

VBScript

Year:1996 Developer: Microsoft Influenced By: Visual Basic Filename Extension: .vbs, .vbe, .wsf, .wsc Users: 14,000

VBScript ("Microsoft Visual Basic Scripting Edition") is an Active Scripting language developed by Microsoft that is modeled on Visual Basic. It allows Microsoft Windows system administrators to generate powerful tools for managing computers with error handling, subroutines, and other advanced programming constructs. It can give the user complete control over many aspects of their computing environment.

VBScript uses the Component Object Model to access elements of the environment within which it is running; for example, the FileSystemObject (FSO) is used to create, read, update and delete files. VBScript has been installed by default in every desktop release of Microsoft Windows since Windows 98;[1] in Windows Server since Windows NT 4.0 Option Pack; and optionally with Windows CE (depending on the device it is installed on).

MsgBox("Hello, World!")

Verilog

Year:1984 Developer: Prabhu Goel, Phil Moorby, Chi-Lai Huang, and Douglas Warmke Influenced By: Pascal, C, Fortran, Ada Filename Extension: .v, .vh Users: 21,000

Verilog, standardized as IEEE 1364, is a hardware description language (HDL) used to model electronic systems. It is most commonly used in the design and verification of digital circuits at the register-transfer level of abstraction. It is also used in the verification of analog circuits and mixed-signal circuits, as well as in the design of genetic circuits.[1] In 2009, the Verilog standard (IEEE 1364-2005) was merged into the SystemVerilog standard, creating IEEE Standard 1800-2009. Since then, Verilog is officially part of the SystemVerilog language. The current version is IEEE standard 1800-2017.

module main;
                    
                     initial
                     begin
                      $display("Hello, World");
                      $finish ;
                     end
                    
                    endmodule

VHDL

Year:1983 Developer: U.S. Department of Defense Influenced By: Pascal, Ada Filename Extension: .vhd Users: over 30,000

Very High-Speed Integrated Circuit Hardware Description Language (VHDL) is a description language used to describe hardware. It is utilized in electronic design automation to express mixed-signal and digital systems, such as ICs (integrated circuits) and FPGA (field-programmable gate arrays). VHDL has been standardized by the Institute of Electrical and Electronics Engineers (IEEE) as IEEE Std 1076; the latest version (as of April 2020) of which is IEEE Std 1076-2019. To model analog and mixed-signal systems, an IEEE-standardized HDL based on VHDL called VHDL-AMS (officially IEEE 1076.1) has been developed.

 --Hello World in VHDL

                    entity helloworld IS
                    end helloworld;
                    
                    architecture/span> hw OF helloworld IS
                    
                    begin
                    
                    assertFALSE
                    report "HELLO, WORLD!" 
                    severity note;

                    
                    end hw;

Visual Basic

Year:1991 Developer: Microsoft Influenced By: BASIC Filename Extension: .vb Users: over 15,000

The original Visual Basic (also referred to as Classic Visual Basic) is a third-generation event-driven programming language from Microsoft known for its Component Object Model (COM) programming model first released in 1991 and declared legacy during 2008. Microsoft intended Visual Basic to be relatively easy to learn and use. Visual Basic was derived from BASIC and enables the rapid application development (RAD) of graphical user interface (GUI) applications, access to databases using Data Access Objects, Remote Data Objects, or ActiveX Data Objects, and creation of ActiveX controls and objects.

A programmer can create an application using the components provided by the Visual Basic program itself. Over time the community of programmers developed third-party components. Programs written in Visual Basic can also make use of the Windows API, which requires external functions declarations.

Private Sub Form_Load()
                  MsgBox "Hello, World!" 
                End Sub

Visual FoxPro

Year:1995 Developer: Microsoft Influenced By: Visual Basic Filename Extension: .prg Users: ~6,900

Visual FoxPro was a Microsoft data-centric procedural programming language that subsequently became object-oriented. It was derived from FoxPro (originally known as FoxBASE) which was developed by Fox Software beginning in 1984.

In all languages traditionally the first example is printing "Hello World". Probably doing that is easiest in VFP:

? "Hello World"s

Vue.js

Year:2014 Developer: Evan You Type: JavaScript framework (written in TypeScript) Filename Extension: .js Users: According surveys 28.8% of JS users use Vue.js, so it's about 3.6 million

Vue.js (commonly referred to as Vue) is an open-source model–view–viewmodel front end JavaScript framework for building user interfaces and single-page applications

Vue.js features an incrementally adaptable architecture that focuses on declarative rendering and component composition. The core library is focused on the view layer only. Advanced features required for complex applications such as routing, state management and build tooling are offered via officially maintained supporting libraries and packages. Vue.js allows for extending HTML with HTML attributes called directives. The directives offer functionality to HTML applications, and come as either built-in or user defined directives.

<div id ="app" >
                      {{ message }}
                    <div>

var app = new Vue({
                    el: '#app',
                    data: {
                      message: 'Hello Vue!'
                    }
                  })

XHTML

Year:2000 Developer: W3C Influenced By: XML, HTML Filename Extension: .xhtml, .xht, .html, .xml Users: over 100

Extensible HyperText Markup Language (XHTML) is part of the family of XML markup languages. It mirrors or extends versions of the widely used HyperText Markup Language (HTML), the language in which Web pages are formulated. While HTML, prior to HTML5, was defined as an application of Standard Generalized Markup Language (SGML), a flexible markup language framework, XHTML is an application of XML, a more restrictive subset of SGML. XHTML documents are well-formed and may therefore be parsed using standard XML parsers, unlike HTML, which requires a lenient HTML-specific parser.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
                    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
                    <html xmlns="http://www.w3.org/1999/xhtml">
                     <head>  <title>Hello World program</title> </head>
                      <body>
                       <p>Hello, World!</p>
                    </body>
                    </html>