C# ist eine Mehrzweck- und Mehrparadigmen-Programmiersprache.
C# umfasst statische Typisierung, starke Typisierung, lexikalische Skalierung,
imperative, deklarative, funktionale, generische, objektorientierte,
und komponentenorientierte Programmierung.
https://dotnet.microsoft.com/en-us/languages/csharp

Java ist eine hochentwickelte, klassenbasierte, objektorientierte Programmiersprache
die so konzipiert ist, dass sie so wenig Implementierungsabhängigkeiten wie möglich aufweist.
Es handelt sich um eine universelle Programmiersprache, die es Programmierern ermöglicht, einmal zu schreiben,
überall ausführen können, was bedeutet, dass kompilierter Java-Code auf allen Plattformen
die Java unterstützen, ohne dass eine Neukompilierung erforderlich ist.
Wikipedia
https://dotnet.microsoft.com/en-us/languages/csharp

"C++ (ausgesprochen: Ze plus plus) ist eine allgemeine Programmiersprache.
Sie verfügt über imperative, objektorientierte und generische Programmierfunktionen,
und bietet außerdem Möglichkeiten zur Speichermanipulation auf niedriger Ebene."
-- Wikipedia.org/C++
http://www.cplusplus.org/

Ada ist eine moderne Programmiersprache, die für große, langlebige Anwendungen

• und insbesondere für eingebettete Systeme, bei denen Sicherheit und Schutz unerlässlich sind.

Ada ist eine strukturierte, statisch typisierte, imperative und objektorientierte Hochsprachenprogrammierung, die aus Pascal und anderen Sprachen hervorgegangen ist.
Sie bietet integrierte Unterstützung für Design by Contract, extrem starke Typisierung, explizite Parallelität, Tasks, synchrone Nachrichtenübergabe, geschützte Objekte und Nicht-Determinismus.
Wikipedia

Paradigma:Multi-Paradigma: strukturiert, imperativ, objektorientiert, aspektorientiert, nebenläufig, array, verteilt, generisch, prozedural, meta
https://www.adaic.org

Assembler

In der Computerprogrammierung ist die Assemblersprache, oft einfach als Assembly bezeichnet
und üblicherweise als ASM oder asm abgekürzt, ist eine Programmiersprache auf niedriger Ebene
mit einer sehr starken Übereinstimmung zwischen den Anweisungen in der Sprache
und den Maschinencodebefehlen der Architektur.
Wikipedia

Tcl

Tcl ist eine interpretierte, dynamische Programmiersprache auf hohem Niveau und für allgemeine Zwecke.
Sie wurde mit dem Ziel entwickelt, sehr einfach, aber mächtig zu sein.
Tcl gießt alles in die Form eines Befehls, sogar Programmierkonstrukte wie die Zuweisung von Variablen und die Definition von Prozeduren.
www.tcl.tk/

Python ist eine leicht zu erlernende, leistungsstarke Programmiersprache.
Sie verfügt über effiziente High-Level-Datenstrukturen und einen einfachen, aber effektiven Ansatz zur objektorientierten Programmierung.
www.python.org

Perl ist eine Familie von zwei interpretierten, dynamischen Hochsprachen für allgemeine Zwecke.
www.perl.org

Node.js® ist eine JavaScript-Laufzeitumgebung, die auf der V8 JavaScript-Engine von Chrome aufbaut.
nodejs.org

Julia ist eine leistungsstarke, dynamische Hochsprachenprogrammierung.
Sie ist zwar eine Allzwecksprache und kann zum Schreiben jeder beliebigen Anwendung verwendet werden,
eignen sich viele ihrer Funktionen besonders für die numerische Analyse und die Computerwissenschaften.
julialang.org/

Ruby ist...
Eine dynamische, quelloffene Programmiersprache mit dem Schwerpunkt auf Einfachheit und Produktivität.
Sie hat eine elegante Syntax, die natürlich zu lesen und einfach zu schreiben ist.
www.ruby-lang.org

MATLAB ist eine Umgebung für numerische Analysen sowie eine Computerprogrammiersprache der vierten Generation.
Matlab gilt als Matrizenlabor, das als eine Sprache für technische Berechnungen bekannt ist. Matlab wurde sowohl in C, C++ als auch in Java geschrieben.
Anmerkung: Derzeit wird der Großteil unserer Matlab-bezogenen Forschung mit Octave durchgeführt.
https://de.mathworks.com/products/matlab.html
https://de.mathworks.com/products/matlab-online.html

Octave ist eine interpretierte Hochsprachenprogrammierung, die für numerische Berechnungen verwendet wird.
Sie ist auch eine operativ wichtige Bedrohungs-, Vermögens- und Schwachstellenbewertung.
https://octave.org/

Die Wolfram Language ist eine allgemeine Multi-Paradigma-Programmiersprache, die von Wolfram Research entwickelt wurde.
Sie legt den Schwerpunkt auf symbolische Berechnungen, funktionale Programmierung und regelbasierte Programmierung und kann beliebige Strukturen und Daten verwenden.
Sie ist die Programmiersprache des mathematischen Programms für symbolische Berechnungen Mathematica. https://www.wolfram.com/language/

Maple ist eine Umgebung für symbolische und numerische Berechnungen sowie eine Mehrparadigmen-Programmiersprache.
Sie deckt mehrere Bereiche des technischen Rechnens ab, wie symbolische Mathematik, numerische Analyse, Datenverarbeitung, Visualisierung und andere.
https://www.maplesoft.com/support/help/Maple/view.aspx?path=ProgrammingGuide/Chapter01

Die Modelica-Sprache ist eine Sprache zur Modellierung von cyber-physischen Systemen,
Sie unterstützt die akausale Verbindung von Komponenten, die durch mathematische Gleichungen gesteuert werden, um die Modellierung von ersten Prinzipien zu erleichtern.
Sie bietet objektorientierte Konstrukte, die die Wiederverwendung von Modellen erleichtern, und kann bequem verwendet werden
für die Modellierung komplexer Systeme, die z. B. mechanische, elektrische, elektronische, magnetische, hydraulische, thermische, steuerungs-, strom- oder prozessorientierte Teilkomponenten enthalten.
https://modelica.org/modelicalanguage.html
www.openmodelica.org

Ballerina ist eine Open-Source-Programmiersprache für die Cloud, die es einfacher macht, Netzwerkdienste zu nutzen, zu kombinieren und zu erstellen.
/ballerina.io

import ballerina/graphql;
import ballerina/http;
import ballerinax/mysql;
import ballerinax/mysql.driver as _;

configurable string user = ?;
configurable string password = ?;
configurable string host = ?;
configurable int port = ?;
configurable string database = ?;
configurable string apiEndpoint = ?;

public type Album record {
    string id;
    string title;
    string artist;
    decimal price;
    Currency currency = USD;
};

public enum Currency {
    USD,
    LKR,
    EUR,
    GBP
}

service / on new graphql:Listener(9000) {
    private final mysql:Client db;
    private final http:Client forex;
    private final Currency baseCurrency = USD;

    function init() returns error? {
        self.db = check new (host, user, password, database, port);
        self.forex = check new (apiEndpoint);
    }

    resource function get album(string id, Currency currency = USD) returns Album|error {
        Album album = check self.db->queryRow(`SELECT * FROM Albums WHERE id=${id}`);
        if currency != self.baseCurrency {
            string query = string `from=${self.baseCurrency}&to=${currency}`;
            record {decimal rate;} exchange = check self.forex->get(string `/curerncyConversion?${query}`);
            album.price = album.price * exchange.rate;
            album.currency = currency;
        }
        return album;
    }
}

Nim ist eine statisch typisierte kompilierte Systemprogrammiersprache.
Sie kombiniert erfolgreiche Konzepte aus ausgereiften Sprachen wie Python, Ada und Modula.
nim-lang.org/

import std/parsecfg
import std/[strutils, streams]

let configFile = "example.ini"
var f = newFileStream(configFile, fmRead)
assert f != nil, "cannot open " & configFile
var p: CfgParser
open(p, f, configFile)
while true:
  var e = next(p)
  case e.kind
  of cfgEof: break
  of cfgSectionStart:   ## a `` has been parsed
    echo "new section: " & e.section
  of cfgKeyValuePair:
    echo "key-value-pair: " & e.key & ": " & e.value
  of cfgOption:
    echo "command: " & e.key & ": " & e.value
  of cfgError:
    echo e.msg
close(p)

Io ist eine Programmiersprache, die sich auf Ausdrucksstärke durch Einfachheit konzentriert.
iolanguage.org

 #!/usr/bin/env io  

/* The Computer Language Shootout
   http://shootout.alioth.debian.org
   Contributed by Ian Osgood, Steve Dekorte */

Vector := Sequence clone setItemType("float32") setEncoding("number")

MandelbrotSet := Object clone do(
    max_iterations := 50
    limit          := 2 squared
    dim            := 200
    org_r := -1.5
    org_i := -1
    ext_r :=  2
    ext_i :=  2

    calc := method(
        cr := Vector clone setSize(dim squared)
        ci := Vector clone setSize(dim squared)

        size := 0
        for(y, 0, dim-1,
            Ci := ((y * ext_i / dim) + org_i)
            for(x, 0, dim-1,
                Cr := ((x * ext_r / dim) + org_r)
                cr atPut(size, Cr)
                ci atPut(size, Ci)
                size = size + 1
            )
        )

        zr := cr clone
        zi := ci clone
        zr2 := Vector clone setSize(size)
        zi2 := Vector clone setSize(size)
        temp := Vector clone setSize(size)

        max_iterations repeat(
            temp copy(zr) *= zi

            zr2 copy(zr) square
            zi2 copy(zi) square

            zr copy(zr2) -= zi2 += cr
            zi copy(temp) *= 2  += ci
        )

        self result := zi2 + zr2
    )

    printSet := method(
        writeln("P4\n", dim, " ", dim)
        out := File standardOutput
        i := 0
        dim repeat(
            (dim / 8) repeat(
                pixel := 0
                8 repeat(
                    pixel = pixel shiftLeft(1)
                    if (limit > result at(i), pixel = pixel | 1)
                    i = i + 1
                )
                out write(pixel asCharacter)
            )
            /* if (dim%8!=0, ) */
        )
    )

    printSet := method(
        writeln("P4\n", dim, " ", dim)
        out := File standardOutput
        i := 0
        dim repeat(
            (dim / 8) repeat(
                pixel := 0
                8 repeat(
                    pixel = pixel shiftLeft(1)
                    if (result at(i) < limit, pixel = pixel | 1)
                    i = i + 1
                )
                out write(pixel asCharacter)
            )
            /* if (dim%8!=0, ) */
        )
    )
)

MandelbrotSet dim := System args at(1) asNumber
MandelbrotSet do( calc; printSet )

A language for humans and computers
Crystal’s syntax is heavily inspired by Ruby’s, so it feels natural to read and easy to write,
and has the added benefit of a lower learning curve for experienced Ruby devs.
Crystal is statically type checked, so any type errors will be caught early by the compiler rather than fail on runtime.
Moreover, and to keep the language clean, Crystal has built-in type inference, so most type annotations are unneeded.
https://crystal-lang.org/

 # A very basic HTTP server  
require "http/server"

server = HTTP::Server.new do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hello world, got #{context.request.path}!"
end

puts "Listening on http://127.0.0.1:8080"
server.listen(8080)

CUDA is a parallel computing and programming platform introduced by NVIDIA for general computing of GPUs.
It helps developers speed up computing applications by leveraging the potential of GPUs.
The CUDA Toolkit has everything you need for creating GPU-accelerated applications in popular languages like
C, C++, Python, MATLAB, Fortran, etc.
https://developer.nvidia.com/cuda-zone

A Software Framework for Neuromorphic Computing
Lava is an open source SW framework to develop applications for neuromorphic hardware architectures.
It provides developers with the abstractions and tools to develop distributed and massively parallel applications.
These applications can be deployed to heterogeneous system architectures containing conventional processors
as well as neuromorphic chips that exploit event-based message passing for communication.
The Lava framework comprises high-level libraries for deep learning, constrained optimization, and others for productive algorithm development.
It also includes tools to map those algorithms to different types of hardware architectures.

https://github.com/lava-nc
https://github.com/lava-nc/lava

Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design.
Built by experienced developers, it takes care of much of the hassle of web development,
so you can focus on writing your app without needing to reinvent the wheel.
It's free and open source. Ridiculously fast.
https://djangoproject.com

PLY

PLY is a pure-Python implementation of the compiler construction tools lex and yacc.
The main goal of PLY is to stay fairly faithful to the way in which traditional lex/yacc tools work.
This includes supporting LALR (1) parsing as well as providing extensive input validation, error reporting, and diagnostics.
http://www.dabeaz.com/ply/

Create production-grade machine learning models
TensorFlow is an end-to-end open source platform for machine learning.
It has a comprehensive, flexible ecosystem of tools, libraries and community resources
that lets researchers push the state-of-the-art in ML and developers easily build and deploy ML powered applications.
https://www.tensorflow.org/

Sinumerik

Die SINUMERIK ONE ist das digital native, zukunftssichere CNC-System für hochproduktive Werkzeugmaschinen.
Für ungeahnte neue Möglichkeiten, Ideen und Geschäftsmodelle;
für schnellere Innovationen durch das nahtlose Zusammenspiel von virtueller Sphäre und realer Welt
SINUMERIK ONE ist weit mehr als eine leistungsstarke Hardware-Innovation.

https://new.siemens.com/us/en/products/automation/systems/cnc-sinumerik.html

Die TNC7 kombiniert die bekannte Klartext-Programmierung mit einer neu entwickelten grafischen Programmierung,
einer anpassbaren Benutzeroberfläche und intelligenten Funktionen.

Einfache Erstellung von NC-Programmen mit KLARTEXT HEIDENHAIN-Steuerungen
sind werkstattorientiert, das heißt, sie sind für die Programmierung direkt an der Maschine konzipiert.
Mit der Klartext-Programmierung können Sie das Auswendiglernen von G-Codes vergessen.

Die MillPlus ist eine exklusiv für DMG entwickelte Steuerung.
Aus diesem Grund ist DMG für die Beantwortung von Fragen zur MillPlus zuständig.

https://news.heidenhain.com/machine-tool/tnc7
picture copyright Heidenhain

Unterstützung der breitesten Palette von CNC-Systemen in der Industrie,
FANUC bietet alles, was Sie jemals für Ihre CNC benötigen
von preisgünstigen Steuerungen mit leistungsstarker Funktionalität
bis hin zu Hochleistungssteuerungssystemen für komplexe Maschinen.
Steuerungen, Motoren und Verstärker, Kabel und Stecker werden in
einfach zu installierenden Paketen, die auf Ihre speziellen Anforderungen zugeschnitten sind.
Schnell zu programmieren und einfach zu bedienen, garantieren sie höchste Qualität und kurze Zykluszeiten.

picture copyright Fanuc
https://www.fanuc.eu

Röders bietet eine eigene hochflexible nc-Hochsprache für seine RMS6-Steuerungen an.
Die Röders RMS-Sprache ist für die parametrische Entwicklung mit dem Schwerpunkt HSM und HSC konzipiert.
Bild copyright Röders
https://roeders.de/

Datron bietet eine hochflexible nc-Programmiersprache auf hohem Niveau.
Die Kommandonamen sind sprachabhängig.
Die Datron-Sprache ist für die parametrische Entwicklung konzipiert
und kann mit einer Fanuc-ähnlichen interpretierten Syntax gemischt werden.
Wie Röders ist Datron auf HSM und HSC spezialisiert.

https://www.datron.com
picture copyright Datron