Languages around 1985

Ada (1980): Real-time systems, embedded systems, safety-critical applications.
Stdout Function: Ada.Text_IO.Put_Line (prints a string with a newline, e.g., Ada.Text_IO.Put_Line("Hello World");).

ALGOL (1960): Algorithmic and scientific programming, influenced modern language design.
Stdout Function: outstring (in ALGOL 60, e.g., outstring(2, "Hello World");, where 2 is the output channel for stdout).

APL (1962): Mathematical and array-based computations, interactive environments.
Stdout Function: ⎕ (quad, e.g., ⎕←'Hello World', displays the string directly to the console).

Awk (1977): Text processing, data extraction, reporting for Unix pipelines.
Stdout Function: print (e.g., print "Hello World", outputs to stdout with a newline).

BCPL (1967): Systems programming, precursor to C, used for compiler writing.
Stdout Function: writef (e.g., writef("Hello World\n"), formats and writes to stdout).

CLU (1974): Modular programming, data abstraction, influencing object-oriented design.
Stdout Function: stream$putl (e.g., stream$putl(stream$primary_output(), "Hello World"), writes a line to the primary output stream).

DIBOL (1970): Business applications, similar to COBOL, for DEC systems.
Stdout Function: WRITES (e.g., WRITES(0, "Hello World"), where 0 is the terminal output channel).

Eiffel (1985): Object-oriented programming, emphasizing design by contract.
Stdout Function: io.put_string (e.g., io.put_string("Hello World%N"), where %N adds a newline).

Forth (1970): Embedded systems, real-time control, stack-based programming.
Stdout Function: TYPE (e.g., "Hello World" TYPE, prints the string from the stack to stdout).

GPSS (1961): Discrete event simulation, modeling systems like queues.
Stdout Function: None (GPSS is a simulation language with no direct stdout function; output is typically to reports or files, e.g., via PRINT blocks for simulation results).

Icon (1977): String and list processing, goal-directed execution for text analysis.
Stdout Function: write (e.g., write("Hello World"), writes to stdout with a newline).

Jovial (1960): Embedded systems, particularly for military and aerospace.
Stdout Function: WRITE (e.g., WRITE(TERM, "Hello World"), where TERM is the terminal output device).

Logo (1967): Educational programming, graphics, teaching computational concepts.
Stdout Function: print (e.g., print [Hello World], prints the list or string to the console).

Miranda (1985): Functional programming, lazy evaluation, non-strict language research.
Stdout Function: putStr (e.g., putStr "Hello World\n", prints the string to stdout; early versions used implicit output for expressions).

ML (1973): Functional programming, type inference, theorem proving.
Stdout Function: print (e.g., print "Hello World\n", prints to stdout; early ML used print for strings).

Modula-2 (1978): Systems programming, modular design, real-time applications.
Stdout Function: WriteString (e.g., WriteString("Hello World"); WriteLn;, from the InOut module, with WriteLn for a newline).

MUMPS (1966): Database-driven applications, particularly in healthcare.
Stdout Function: WRITE (e.g., WRITE "Hello World",!, where ! adds a newline).

Occam (1983): Concurrent programming, for transputer-based parallel systems.
Stdout Function: out.string (e.g., out.string("Hello World", 0, screen!), where screen! is the output channel).

PL/I (1964): General-purpose, combining scientific, business, systems programming.
Stdout Function: PUT (e.g., PUT LIST('Hello World');, prints to the default output stream, typically stdout).

PostScript (1982): Page description, used for desktop publishing and printing.
Stdout Function: print (e.g., (Hello World) print, prints the string to the current output device, typically stdout in interactive mode).

Prolog (1972): Logic programming, artificial intelligence, expert systems.
Stdout Function: write (e.g., write('Hello World'), nl., where nl adds a newline).

Ratfor (1975): Structured programming, preprocessor for Fortran readability.
Stdout Function: write (e.g., write(6, *) "Hello World", where 6 is the stdout unit, inherited from Fortran).

REXX (1979): Scripting, automation, general-purpose programming on IBM systems.
Stdout Function: SAY (e.g., SAY 'Hello World', prints to stdout with a newline).

Scheme (1975): Functional programming, education, AI research.
Stdout Function: display (e.g., (display "Hello World") (newline), where newline adds a newline).

Simula (1967): Simulation modeling, introduced object-oriented concepts.
Stdout Function: outtext (e.g., outtext("Hello World"); outimage;, where outimage flushes the line to stdout).

Smalltalk (1972): Object-oriented programming, GUI development, prototyping.
Stdout Function: Transcript show: (e.g., Transcript show: 'Hello World'; cr, where cr adds a newline).

SNOBOL (1964): String manipulation, pattern matching for text processing.
Stdout Function: OUTPUT (e.g., OUTPUT = "Hello World", assigns the string to the OUTPUT variable, which writes to stdout).

SQL (1974): Database querying and management.
Stdout Function: None (SQL is a query language with no direct stdout function; output is typically via database client tools, e.g., SELECT 'Hello World'; in interactive clients).