Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/naemazam/Hello-World
I don't Know What is Your First Language and Don't Want to know Why You Select it. But As a Programmer i know, The Smile When You run Your First Code. After That We made Thousands of Mistake In our DEV life. We did Debug, Copycat or Googling But never Forget This First 2 Words. Let's Combine Our First Happiness In A single Page.
https://github.com/naemazam/Hello-World
apache-groovy c dart elixir elm fortran go graphql haskel hello-world hellogithub helloworld helloworld-programs naemazam
Last synced: 29 days ago
JSON representation
I don't Know What is Your First Language and Don't Want to know Why You Select it. But As a Programmer i know, The Smile When You run Your First Code. After That We made Thousands of Mistake In our DEV life. We did Debug, Copycat or Googling But never Forget This First 2 Words. Let's Combine Our First Happiness In A single Page.
- Host: GitHub
- URL: https://github.com/naemazam/Hello-World
- Owner: naemazam
- License: mit
- Created: 2021-11-13T16:15:15.000Z (about 3 years ago)
- Default Branch: main
- Last Pushed: 2021-11-14T11:54:28.000Z (about 3 years ago)
- Last Synced: 2024-08-03T23:28:48.393Z (4 months ago)
- Topics: apache-groovy, c, dart, elixir, elm, fortran, go, graphql, haskel, hello-world, hellogithub, helloworld, helloworld-programs, naemazam
- Homepage: https://naemazam.github.io/Hello-World/
- Size: 215 KB
- Stars: 2
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-golang-repositories - Hello-World
README
Hellow World!!!
Let's Combine Programmers First Emotion In One Page.
## Before Start
There are about 700 programming languages, including esoteric coding languages. in the world. It's a Lot. Isn't It ? I don't Know What is Your First Language and Don't Want to know Why You Select it. But As a Programmer i know, The Smile When You run Your First Code. After That We made Thousands of Mistake In our DEV life. We did Debug, Copycat or Googleing But never Forget This First 2 Words. Let's Combine Our First Smail In A single Page. [Me](https://naemazam.github.io/) (Naem Azam) Try My best To start It.
Don't Miss My [Youtube Video](https://www.youtube.com/channel/UCTE1zfR8xpBXqgjvOgH0Nfw)
Let's Start
Languages Are On Alphabetical Order
A
Assembly language
Apache Groovy
C
C
C#
C++
css
Clojure
D
Dart
E
Elixir
Elm
F
Fortran
G
Go
GraphQL
H
haskel
html
J
JavaScript
Julia
Java
K
Kotlin
L
LaTeX
Lua
M
Markdown
Matlab
O
Octive
P
Python
PHP
Perl
R
Ruby
R
Rust
S
Swift
shell script
Scala
Solidity
T
TypeScript
# Assembly language
Low-level programming language
assembly 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.
It used one-letter mnemonics developed by David Wheeler, who is credited by the IEEE Computer Society as the creator of the first "assembler". Reports on the EDSAC introduced the term "assembly" for the process of combining fields into an instruction word.
ASM filename suffix is mostly used for Assembler Source Code Format files. ASM files are supported by software applications available for devices running Linux, Mac OS, Windows. Files with ASM extension are categorized as Developer Files files. The Developer Files subset comprises 1185 various file formats.
## Print Hellow World In asm
A minimal-size version
```asm
; hello-DOS.asm - single-segment, 16-bit "hello world" program
;
; assemble with "nasm -f bin -o hi.com hello-DOS.asm"
org 0x100 ; .com files always start 256 bytes into the segment
; int 21h is going to want...
mov dx, msg ; the address of or message in dx
mov ah, 9 ; ah=9 - "print string" sub-function
int 0x21 ; call dos services
mov ah, 0x4c ; "terminate program" sub-function
int 0x21 ; call dos services
msg db 'Hello, World!', 0x0d, 0x0a, '$' ; $-terminated message
```
Individual-character output along with string output
```asm
; hello2-DOS.asm - single-segment, 16-bit "hello world" program
;
; This demonstrates single-character output as well as string output
; via DOS services
;
; assemble with "nasm -f bin -o hi.com hello2-DOS.asm"
org 0x100 ; .com files always start 256 bytes into the segment
; int 21h is going to want...
mov dx, msg ; the address of or message in dx
mov ah, 9 ; ah=9 - "print string" sub-function
int 0x21 ; call dos services
mov dl, 0x0d ; put CR into dl
mov ah, 2 ; ah=2 - "print character" sub-function
int 0x21 ; call dos services
mov dl, 0x0a ; put LF into dl
mov ah, 2 ; ah=2 - "print character" sub-function
int 0x21 ; call dos services
mov ah, 0x4c ; "terminate program" sub-function
int 0x21 ; call dos services
msg db 'Hello again, World!$' ; $-terminated message
```
DOS2 length-delimited output
```asm
; hello3-DOS.asm - single-segment, 16-bit "hello world" program
;
; Use DOS 2.0's service 40 to output a length-delimited string.
;
; assemble with "nasm -f bin -o hi.com hello3-DOS.asm"
org 0x100 ; .com files always start 256 bytes into the segment
; int 21h needs...
mov dx, msg ; message's address in dx
mov cx, len
mov bx, 1 ; Device/handle: standard out (screen)
mov ah, 0x40 ; ah=0x40 - "Write File or Device"
int 0x21 ; call dos services
mov ah, 0x4c ; "terminate program" sub-function
int 0x21 ; call dos services
msg db 'New hello, World!', 0x0d, 0x0a ; message
len equ $ - msg ;msg length
```
a Linux-compatible version
```asm
;"hello, world" in assembly language for Linux
;
;to build an executable:
; nasm -f elf hello.asm
; ld -s -o hello hello.o
section .text
; Export the entry point to the ELF linker or loader. The conventional
; entry point is "_start". Use "ld -e foo" to override the default.
global _start
section .data
msg db 'Hello, world!',0xa ;our dear string
len equ $ - msg ;length of our dear string
section .text
; linker puts the entry point here:
_start:
; Write the string to stdout:
mov edx,len ;message length
mov ecx,msg ;message to write
mov ebx,1 ;file descriptor (stdout)
mov eax,4 ;system call number (sys_write)
int 0x80 ;call kernel
; Exit via the kernel:
mov ebx,0 ;process' exit code
mov eax,1 ;system call number (sys_exit)
int 0x80 ;call kernel - this interrupt won't return
```
# Apache Groovy
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.
Developer: Guillaume Laforge (PMC Chair); Jochen Theodorou (Tech Lead); Paul King; Cedric Champeau
Stable release: 3.0.9 (September 2, 2021; 2 months ago)
Platform: Java SE
Paradigm: Object-oriented, imperative, scripting
Designed by: James Strachan
License: Apache License 2.0
First appeared: 2003; 18 years ago
Filename extensions .groovy, .gvy, .gy, .gsh
## Print Hellow World In Groovy
```Groovy
print "Hello World!\n"
```
# C
C is a general-purpose, procedural computer programming language supporting structured programming, lexical variable scope, and recursion, with a static type system. By design, C provides constructs that map efficiently to typical machine instructions.
Designed by: Dennis Ritchie
First appeared: 1972; 49 years ago
Paradigm: Multi-paradigm: imperative (procedural), structured
Typing discipline: Static, weak, manifest, nominal
Stable release: C17 / June 2018; 3 years ago
Preview release: C2x (N2596) / December 11, 2020; 10 months ago
## Print Hellow World In C
```c
#include
int main()
{
printf("Hello, World!");
return 0;
}
```
# C#
C# is a general-purpose, multi-paradigm programming language. C# encompasses static typing, strong typing, lexically scoped, imperative, declarative, functional, generic, object-oriented, and component-oriented programming disciplines.
Developer: Mads Torgersen (Microsoft)
Designed by: Anders Hejlsberg (Microsoft)
First appeared: 2000; 21 years ago
Family: C
Typing discipline: Static, dynamic, strong, safe, nominative, partially inferred
Stable release: 10.0 / 8 November 2021; 2 days ago
## Print Hellow World In C#
```c#
namespace HelloWorld
{
class Hello {
static void Main(string[] args)
{
System.Console.WriteLine("Hello, World!");
}
}
}
```
# C++
C++ is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C programming language, or "C with Classes".
Developer: ISO/IEC JTC1 (Joint Technical Committee 1) / SC22 (Subcommittee 22) / WG21 (Working Group 21)
Designed by: Bjarne Stroustrup
Stable release: C++20 (ISO/IEC 14882:2020) / 15 December 2020; 10 months ago
Typing discipline: Static, nominative, partially inferred
Filename extensions: C,.cc,.cpp,.cxx,.c++,.h,.H,.hh,.hpp,.hxx,.h++
Preview release: C++23 / 23 October 2021; 20 days ago
Family: C
## Print Hellow World In C++
```c++
#include
using namespace std;
int main()
{
cout << "Hello, World!";
return 0;
}
```
# css
Cascading Style Sheets 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. Wikipedia
Developed by: World Wide Web Consortium (W3C)
Latest release: CSS 2.1: Level 2 Revision 1; (April 12, 2016; 5 years ago)
Initial release: December 17, 1996; 24 years ago
Container for: Style rules for HTML elements (tags)
Contained by: HTML Documents
## Print Hellow World In C++
```css
h1 {
color: DeepSkyBlue;
}
Hello, world!
```
# Clojure
Clojure is a dynamic and functional dialect of the Lisp programming language on the Java platform. Like other Lisp dialects, Clojure treats code as data and has a Lisp macro system. The current development process is community-driven, overseen by Rich Hickey as its benevolent dictator for life.
Designed by: Rich Hickey
License: Eclipse Public License
Platform: Java; JavaScript.NET
Typing discipline: dynamic; strong
Stable release: 1.10.3 / 4 March 2021; 8 months ago
First appeared: 2007; 14 years ago
Filename extensions: .clj.cljs.cljc.edn
## Print Hellow World In Clojure
```Clojure
(ns clojure.examples.hello
(:gen-class))
(defn hello-world []
(println "Hello World"))
(hello-world)
```
# Dart
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.
Developer: Google
Stable release: 2.14.1 / 8 September 2021; 2 months ago
First appeared: October 10, 2011; 10 years ago
Designed by: Lars Bak and Kasper Lund
License: BSD
Filename extensions: dart
Paradigm: Multi-paradigm: functional, imperative, object-oriented, reflective
## Print Hellow World In Dart
```Dart
void main() {
print('Hello, World!');
}
```
# Elixir
Elixir is a functional, concurrent, general-purpose programming language that runs on the BEAM virtual machine which is also used to implement the Erlang programming language. Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications.
Platform: Erlang
Typing discipline: dynamic, strong, duck
Stable release: 1.12 / 19 May 2021; 5 months ago
License: Apache License 2.0
First appeared: 2012; 9 years ago
Paradigm: multi-paradigm: functional, concurrent, distributed, process-oriented
Filename extensions: ex,.exs
## Print Hellow World In Elixir
```Elixir
IO.puts("Hello, World!")
```
# Elm
Elm is a domain-specific programming language for declaratively creating web browser-based graphical user interfaces. Elm is purely functional, and is developed with emphasis on usability, performance, and robustness.
Typing discipline: Static, Strong, Inferred
Stable release: 0.19.1 / October 21, 2019; 2 years ago
License: Permissive (Revised BSD)
First appeared: March 30, 2012; 9 years ago
Paradigm: Functional
## Print Hellow World In Elm
```Elm
String helloWorld = "Hello, World!";
```
# Fortran
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
Designed by: John Backus
First appeared: 1957; 64 years ago
Paradigm: Multi-paradigm: structured, imperative (procedural, object-oriented), generic, array
Typing discipline: strong, static, manifest
Typical Fortran source files have a file extension of . f90, . for, and . f.
## Print Hellow World In Fortran
```Fortran
program hello
! This is a comment line; it is ignored by the compiler
print *, 'Hello, World!'
end program hello
```
Having saved your program to hello.f90, compile at the command line with:
```Fortran
$> gfortran hello.f90 -o hello
```
To run your compiled program:
```Fortran
./hello
Hello, World!
```
# Go
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.
Implementation language: Go, Assembly language (gc); C++ (gofrontend)
Typing discipline: Inferred, static, strong, structural, nominal
First appeared: November 10, 2009; 11 years ago
OS: DragonFly BSD, FreeBSD, Linux, macOS, NetBSD, OpenBSD, Plan 9, Solaris, Windows
License: 3-clause BSD + patent grant
Paradigm: Multi-paradigm: concurrent, functional, imperative, object-oriented
Designed by: Robert Griesemer, Rob Pike, Ken Thompson
Source code for a program written in Go, a programming language originally developed by Google; contains code written in plain text format that must be compiled before being run as a program. Go is loosely based off of the programming language C, which uses the . C file extension for its source code.
## Print Hellow World In Go
```Go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
```
# GraphQL
GraphQL is an open-source data query and manipulation language for APIs, and a runtime for fulfilling queries with existing data. GraphQL was developed internally by Facebook in 2012 before being publicly released in 2015.
Developer(s): Facebook, and community
Initial release: September 14, 2015
Written in: Implementations in Java, JavaScript, Ruby, Scala, others
Stable release: June 2018
GraphQL, Cube. js, Apollo, Oracle PL/SQL, and Oracle PL/SQL are the most popular alternatives and competitors to graphql.
## Print Hellow World In GraphQL
```GraphQL
```
# haskel
Haskell is a general-purpose, statically typed, purely functional programming language with type inference and lazy evaluation.
Typing discipline: Inferred, static, strong
Stable release: Haskell 2010 / July 2010; 11 years ago
First appeared: 1990; 31 years ago
Filename extensions: hs,.lhs
Paradigm: Purely functional
Preview release: Haskell 2020 announced
Filename extensions .hs, .lhs
## Print Hellow World In haskel
```haskel
// The root provides a resolver function for each API endpoint
var root = {
hello: () => {
return 'Hello world!';
},
};
```
# html
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 Cascading Style Sheets and scripting languages such as JavaScript.
Developed by: WHATWG
Latest release: Living Standard; (2021)
Initial release: 1993; 28 years ago
Extended from: SGML
Extended to: XHTML
Contained by: Web browser
File extention .html/.htm
## Print Hellow World In html
```html
Hello World
```
# JavaScript
JavaScript, often abbreviated as 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 dynamic typing, prototype-based object-orientation and first-class functions. Wikipedia
First appeared: December 4, 1995; 25 years ago
Designed by: Brendan Eich of Netscape initially; others have also contributed to the ECMAScript standard
Stable release: ECMAScript 2021 / June 2021; 5 months ago
Paradigm: event-driven, functional, imperative
Typing discipline: Dynamic, weak, duck
JavaScript files are stored with the . js extension.
## Print Hellow World In JS
```JavaScript
console.log('Hello, World!');
```
# Julia
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.
Typing discipline: Dynamic, strong, nominative, parametric, optional
Implementation language: Julia, C, C++, Scheme, LLVM
Stable release: 1.6.3 / 23 September 2021; 48 days ago
First appeared: 2012; 9 years ago
Filename extensions: jl
License: MIT (core), GPL v2; a makefile option omits GPL libraries
Designed by: Alan Edelman, Jeff Bezanson, Stefan Karpinski, Viral B. Shah
## Print Hellow World In Julia
```Julia
println("Hello, World!")
```
# Java
Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible.
Designed by: James Gosling
First appeared: May 23, 1995; 26 years ago
Stable release: Java SE 17 / 14 September 2021; 56 days ago
Paradigm: Multi-paradigm: generic, object-oriented (class-based), functional, imperative, reflective, concurrent
Latest release: Java SE 16 (March 16, 2021)
Filename extensions: java,.class,.jar,.jmod
## Print Hellow World In Java
```java
class HelloWorld {
public static void main(String args[]) {
System.out.println("Hello, World!");
}
}
```
# Kotlin
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.
Developer: JetBrains
License: Apache License 2.0
Stable release: 1.5.31 / 20 September 2021; 49 days ago
Typing discipline: Inferred, static, strong
First appeared: July 22, 2011; 10 years ago
Filename extensions: kt,.kts,.ktm
Paradigm: Multi-paradigm: object-oriented, functional, imperative, block structured, declarative, generic, reflective, concurrent
## Print Hellow World In Kotlin
```kotlin
fun main(args: Array) {
println("Hello, World!")
}
```
# LaTeX
The LaTeX system is a markup language that handles typesetting and rendering, and can be arbitrarily extended by using the underlying macro language to develop custom macros such as new environments and commands. ...
In order to create a document in LaTeX, you first write a file, say document.
License: LaTeX Project Public License (LPPL)
[Repository](github.com/latex3/latex2e)
## Print Hellow World In LaTeX
```LaTeX
\documentclass[a4paper]{article}
\begin{document}
Hello world!
\end{document}
```
# Lua
High-level programming language.
Lua 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
Typing discipline: Dynamic, strong, duck
Designed by: Roberto Ierusalimschy; Waldemar Celes; Luiz Henrique de Figueiredo
Implementation language: ANSI C
First appeared: 1993; 28 years ago
Paradigm: Multi-paradigm: scripting, imperative (procedural, prototype-based, object-oriented), functional
Files that contain the extension LUA are a source code and script file type that contains code
## Print Hellow World In Lua
```Lua
print("Hello World")
```
# Markdown
High-level programming language.
Markdown is a lightweight markup language for creating formatted text using a plain-text editor. ... Markdown is widely used in blogging, instant messaging, online forums, collaborative software, documentation pages, and readme files.
Extended to: GitHub Flavored Markdown
UTI conformation: public.plain-text
Open format?: yes
## Print Hellow World In Markdown
```Markdown
print("Hello World")
```
# Matlab
MATLAB 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.
Developer: MathWorks
First appeared: late 1970s
Typing discipline: dynamic, weak
Designed by: Cleve Moler
Paradigm: multi-paradigm: functional, imperative, procedural, object-oriented, array
## Print Hellow World In Matlab
```Matlab
disp('Hello, World!');
```
# Octive
High-level programming language.
GNU Octave is software featuring a high-level programming language, primarily intended for numerical computations. Octave helps in solving linear and nonlinear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with MATLAB.
Developer(s): John W. Eaton and many others
License: 2007: GPL-3.0-or-later; 1992: GPL-2.0-or-later
Available in: 18 languages
Written in: C++ (main), Octave itself (scripts), C (wrapper code), Fortran (linear algebra wrapper code)
Stable release: 6.4.0 / 30 October 2021; 13 days ago
Operating system: Windows, macOS, Linux, BSD
Initial release: 4 January 1993; 28 years ago (first alpha release); 17 February, 1994; 27 years ago (version 1.0)
## Print Hellow World In Octave
```Octave
disp('Hello, World!')
```
# Python
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.
Developer: Python Software Foundation
First appeared: February 20, 1991; 30 years ago
Designed by: Guido van Rossum
Stable release: 3.10.0 / 4 October 2021; 40 days ago
Paradigm: Multi-paradigm: object-oriented, procedural (imperative), functional, structured, reflective
Typing discipline: Duck, dynamic, strong typing; gradual (since 3.5, but ignored in CPython)
Python Extention is .py
## Print Hellow World In python
```python
print("Hello, World!")
```
# PHP
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.
extention .php
## Print Hellow World In PHP
```php
```
# Perl
Perl is a family of two high-level, general-purpose, interpreted, dynamic programming languages. "Perl" refers to Perl 5, but from 2000 to 2019 it also referred to its redesigned "sister language", Perl 6, before the latter's name was officially changed to Raku in October 2019.
Developer: Larry Wall
License: Artistic License 1.0 or GNU General Public License
Implementation language: C
Typing discipline: Dynamic
First appeared: February 1, 1988; 33 years ago
Stable release: : 5.34.0 / 20 May 2021; 5 months ago; 5.32.1 / 23 January 2021; 9 months ago;
Filename extensions: plx,.pl,.pm,.xs,.t,.pod,.cgi
## Print Hellow World In perl
```perl
#!/usr/bin/perl
use strict;
use warnings;
print("Hello, World!");
```
# Ruby
Ruby is an interpreted, high-level, general-purpose programming language. It was designed and developed in the mid-1990s by Yukihiro "Matz" Matsumoto in Japan. Ruby is dynamically typed and uses garbage collection and just-in-time compilation.
The current stable version is 3.0. 2. Please be sure to read Ruby's License.
An RB file is a software program written in Ruby, an object-oriented scripting language. Ruby is designed to be simple, efficient, and easy to read. RB files can be edited with a text editor and run using Ruby. Ruby is available in several different versions, or "gems," including Ruby on Rails, Mongrel, and Capistrano.
## Print Hellow World In Rub
```rub
cat('Hello, World!')
```
# R
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
Developer: R Core Team
Typing discipline: Dynamic
First appeared: August 1993; 28 years ago
Stable release: 4.1.2 / 1 November 2021; 8 days ago
License: GNU GPL v2
Designed by: Ross Ihaka and Robert Gentleman
Paradigms: Multi-paradigm: procedural, object-oriented, functional, reflective, imperative, array
## Print Hellow World In R
```r
cat('Hello, World!')
```
# Rust
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.
Developer: The Rust Foundation
Stable release: 1.56.1 / November 1, 2021; 11 days ago
First appeared: July 7, 2010; 11 years ago
Filename extensions: rs,.rlib
Paradigms: Multi-paradigm: concurrent, functional, generic, imperative, structured
Typing discipline: Affine, inferred, nominal, static, strong
License: MIT or Apache 2.0
## Print Hellow World In Rust
```rust
fn main() {
println!("Hello, World!");
}
```
# Swift
Swift is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. and the open-source community.
Developer: Apple Inc. and open-source contributors
Designed by: Chris Lattner, Doug Gregor, John McCall, Ted Kremenek, Joe Groff, and Apple Inc.
OS: Apple's operating systems (Darwin, iOS, iPadOS, macOS, tvOS, watchOS), Linux, Windows 10, Android
Stable release: 5.5.1 / 26 October 2021; 14 days ago
First appeared: June 2, 2014; 7 years ago
License: Apache License 2.0 (Swift 2.2 and later); Proprietary (up to Swift 2.2)
Filename extensions: swift,.SWIFT
## Print Hellow World In Swift
```swift
print("Hello, World!")
```
# shell script
High-level programming language.
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.
## Print Hellow World In shell script
```bash
#!/bin/sh
# This is a comment!
echo Hello World # This is a comment, too!
```
now run chmod 755 first.sh to make the text file executable, and run ./first.sh.
```bash
$ chmod 755 first.sh
$ ./first.sh
Hello World
```
You will probably have expected that! You could even just run:
```bash
$ echo Hello World
Hello World
```
# Scala
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.
Designed by: Martin Odersky
First appeared: 20 January 2004; 17 years ago
Stable release: 3.0.2 / 1 September 2021; 2 months ago
License: Apache 2.0
Typing discipline: Inferred, static, strong, structural
Implementation language: Scala
Filename extensions: scala,.sc
## Print Hellow World In Scala
```Scala
object Hello {
def main(args: Array[String]) = {
println("Hello, World!")
}
}
```
# Solidity
Solidity is an object-oriented programming language for writing smart contracts. It is used for implementing smart contracts on various blockchain platforms, most notably, Ethereum
Solidity value types include booleans, integers, fixed point numbers, addresses, contract types, fixed-size byte arrays, rational and integer literals, and enums. Reference types such as arrays and structs can be stored in these options: memory , storage , and calldata .
The best alternative is JavaScript, which is both free and Open Source. Other great apps like Solidity are Ethereum (Free, Open Source), JSON (Free), CrossBrowdy (Free, Open Source) and Bytom (Free, Open Source)
## Print Hellow World In Solidity
```Solidity
pragma solidity ^0.4.22;
contract helloWorld {
function renderHelloWorld () public pure returns (string) {
return 'Hello, World!';
}
}
```
# TypeScript
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.
Developer: Microsoft
License: Apache License 2.0
Typing discipline: Duck, gradual, structural
Stable release: 4.4.4 / 12 October 2021; 28 days ago
First appeared: 1 October 2012; 9 years ago
Filename extensions: ts,.tsx
Paradigm: Multi-paradigm: functional, generic, imperative, object-oriented
## Print Hellow World In TypeScript
```typescript
let message: string = 'Hello, World!';
console.log(message);
```