Sandbox

Language	Paradigm(s)	Standarized	Type strength	Type safety	Expression of types	Type Compatability	Type checking	Intended use	Design goals
ActionScript	imperative programming, object-oriented, event-driven programming	Yes , ECMA	strong	safe			static	Web design
Ada	concurrent, distributed programming, generic programming, imperative programming, object-oriented	Yes , ANSI, ISO	strong	safe	explicit	nominative	static	Embedded, Realtime applications	Reliability
ALGOL 68	concurrent, imperative programming	No	strong	safe		structural	static or dynamic	Application	Readability, Structure
BASIC	procedural programming	Yes , ANSI, ISO	varies by dialect					Education	Simplicity
C	imperative programming	Yes , ANSI C89, ISO C90/C99	weak	unsafe	explicit	nominative	static	System	Low level access, Minimal constraint
C#	imperative programming, object-oriented, generic programming, reflective programming	Yes , ECMA, ISO	strong	safe (but unsafe allowed)	implicit	nominative	static	Application	Rapid application development
C++	imperative programming, object-oriented, generic programming	Yes , ISO	strong	safe (but unsafe allowed)	explicit, partially implicit	nominative, structural	static, dynamic	Application, System	Abstraction, Efficiency, Compatibility
Clean	functional programming, generic programming	No	strong		implicit		static	General	Correctness, Modularity
COBOL	imperative programming, object-oriented	Yes	strong				static	Business and Financial Applications	Readability
ColdFusion	procedural programming, object-oriented	No	weak		implicit		dynamic	Web Development	Rapid Application Development, Ease of use
Common Lisp	imperative programming, functional programming, object-oriented	Yes	strong	safe			dynamic	General	Standardize Lisp
D	imperative programming, object-oriented, generic programming	No	strong	safe	explicit		static	Application, System	Compilability, Correctness, Efficiency
Eiffel	imperative programming, object-oriented, generic programming	Yes , ECMA-367, ISO/IEC 25436:2006	strong	safe		nominative	static	Application	Correctness, Efficiency, Design by contract
Erlang	functional programming, concurrent, distributed programming	No	strong				dynamic	Telecom and distributed applications	Fault tolerance, Scalability
Forth	imperative programming, stack-oriented	Yes , ANSI	none	n/a	n/a	n/a	n/a	Application, Embedded systems	Compact implementations
Fortran	imperative programming, procedural programming, object-oriented	Yes	strong	safe		nominative	static	Scientific and numeric applications	Runtime efficiency, Simple syntax
Groovy	imperative programming, object-oriented, aspect-oriented programming	No	strong	safe	implicit		dynamic	Application	JVM compatibility
Haskell	functional programming, generic programming, lazy evaluation	No	strong		implicit	structural	static	Application	lazy evaluation, Explicit side-effect
J	array programming, function-level programming, tacit programming	No	strong	safe			dynamic	Data processing	Terseness, Expressiveness, Powerful Data Manipulation
Java	imperative programming, object-oriented, generic programming, reflective programming	No	strong	safe	explicit	nominative	static	Application	Write once run anywhere
JavaScript	imperative programming, object-oriented, functional programming, reflective programming	Yes	weak				dynamic	Client side web scripting
Joy	functional programming, stack-oriented	No	strong	safe			dynamic	functional programming research	concatenative
Lisp	functional programming, reflective; others vary by dialect	No	strong				dynamic	General	Simple notation for Lambda calculus, Homoiconicity
Lua	procedural programming, imperative programming, reflective	No	strong	safe	implicit		dynamic	Host-driven Scripting	Small, embedded, configuration.
Mathematica	functional programming, procedural programming	No	strong				dynamic	Numeric computation and visualization
Object Pascal (Delphi)	imperative programming, object-oriented, generic programming	No	strong	safe (but unsafe allowed)	explicit	nominative	static	Application, System	Readability, Rapid application development, Modularity
Objective-C	imperative programming, object-oriented, reflective programming	Yes	weak		explicit		static	Application	Smalltalk like, Component based code reuse, C compatibility
Ocaml	object-oriented, functional programming, imperative programming, generic programming	No	strong	safe	implicit	structural	static	Application	Efficiency, Robustness, Correctness
Oz	logic programming, functional programming, imperative programming, object-oriented, concurrent programming - multi paradigm	No					dynamic	Education
Pascal	imperative programming, procedural programming	Yes	strong	safe	explicit		static	Education	Readability, Discipline, Modularity
Perl	imperative programming, procedural programming, reflective programming, functional programming, object-oriented, generic programming	No	weak		implicit		dynamic	Text processing, Scripting	Terseness, Expressiveness
PHP	imperative programming, object-oriented, reflective programming	No	weak				dynamic	Web Application, CLI	Robustness and Simplicity
Prolog	logic programming	Yes , ISO	strong				dynamic	Problem solving, Artificial intelligence	declarative programming
Python	imperative programming, object-oriented, functional programming, aspect-oriented programming, reflective programming	No	strong	safe	implicit		dynamic	Application, Education, Scripting	Simplicity, Readability, Expressiveness, Modularity
Ruby	imperative programming, object-oriented, aspect-oriented programming, reflective programming	No	strong		implicit		dynamic	Application, Scripting	Expressiveness, Readability
Scala	object-oriented, functional programming, generic programming	No	strong		partially implicit		static	Education
Scheme	functional programming	Yes	strong				dynamic (latent)	General, Education	Minimalistic, Lexical Scoping
Smalltalk	object-oriented, concurrent programming, event-driven programming, imperative programming, declarative programming	Yes , ANSI	strong	safe	implicit		dynamic	Application, Education	Uniformity, Pure object oriented
Tcl	imperative programming, procedural programming, event-driven programming	No					dynamic	Application, Scripting
Visual Basic	component-oriented programming, event-driven programming	No	strong	safe		nominative	static	Application	Rapid application development, Simplicity
Visual Basic .NET	object-oriented, event-driven programming	No	strong				static	Application	Rapid application development, Simplicity
Windows PowerShell	imperative programming, object-oriented, functional programming, pipeline programming, reflective programming	No	strong	safe	implicit		dynamic
Language	Paradigm(s)	Standarized	Type strength	Type safety	Expression of types	Type Compatability	Type checking	Intended use	Design goals

DIVBOX DIVBOX DIVBOX DIVBOX DIVBOX

DIVBOX DIVBOX DIVBOX DIVBOX DIVBOX

DIVBOX DIVBOX DIVBOX DIVBOX DIVBOX

DIVBOX DIVBOX DIVBOX DIVBOX DIVBOX

a

Non-existant link"

Math

$a_{i}=\sum _{k=0}^{n}1/overk*b_{i}$

Doesn't work ....

c

blah

''blaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa this looks horrible aaaaaaaaaaaaaaaaaaaa we should fix this somehow aaaaaaaaaaaaaaaaaaaaaaaaah''

''blah''

#Your Language Here

#Python <Python> def avr24(data):

   if len(data)==0:
       return 0
   else:
       return sum(data)/float(len(data))

</Python>

XFeeds

<xfeeds contentcolour="#eeeeee" feedlimit="3" totallimit="10"> http://blog.rosettacode.org/?feed=rss2 http://blog.rosettacode.org/?feed=comments-rss2 </xfeeds>

Syntax highlighting

<c>#include <iostream>

1. include <gmpxx.h>

mpf_class f(mpf_class x); double f(double x);

int main() {

unsigned int start = 1;
unsigned int end = 1000;
mpf_class sum = 0;
double dsum = 0;

for( unsigned int x = start;
  x <= end;
  ++x   )
{
 sum += f(mpf_class(x));
 dsum += f((double) x);
}

std::cout << "Sum of f(x) from " << start << " to " << end << " is " << sum << " (GMP float) or " << dsum << " (IEEE 64-bit float)" <<  std::endl;
return 0;

}

mpf_class f(mpf_class x) {

return ( 1 / ( x * x ) );

}

double f(double x) {

return ( 1 / ( x * x ) );

} </c>

Expression test

Currently there are 2,650 articles, but if someone added another, there would be 2651 articles. Totally, there are 20,475 pages, which means that 17825 pages are not articles.

Your Language Here

Works with: Yourlanguagehere

Testing a standard language solution header.

Works with: Yourlanguagehere version 2.5

Works with: Display name version 2.5

Your Language Here

Testing a standard language solution header with different display name.

Animated FIFO

colorForth

source
colorForth
code

26 →

170 ¬

224-234 αßΓπΣσµτΦΘΩ

236 ∞

241-243 ±≥≤

244 ⌠

245 ⌡

246 ÷

247 ≈

248 °

251 √

253 ²

<sub> normal_sub

<sup> normal^sup