Programming Languages - a means to an end

Programming Languages: 

My professor always reminded me that engineers solve problems by building applications.  Programming is just a means to an end. Below are the programming languages that I am familiar with.  If the group already has the standard environment I use it.  

Caveat:

It doesn't really matter what programming language is chosen, unless the following several system capabilities that are difficult to achieve within systems realization are resolved architecturally:

1) performance, 

2) security,

3) safety,

4) reliability

5) maintainability. 

Many groups ignore theses capabilities and try to mitigate after systems are started, in mid-line or nearly complete.  Many teams realize that these attributes are important to resolve before getting to far down the line.  

All computing processor elements contain instruction sets; these instructions sets are binary encoded then mapped to an assembly language.  An assembly language contains human mnemonic associated for each binary encoded instruction.  Simple translators remap the assembly language back into the binary encoded instruction set actually utilized by the computing processors. 

FORTRAN - Formula Translator 

FORTRAN invented by IBM group lead by Backus.  Many high end DOE analyses utilize FORTRAN libraries. The modern language Julia enables runtime and static linking to these libraries. Like AFNL - Fortran Numerical Library and PETSC ( https://www.mcs.anl.gov/petsc/index.html ). About 20 high quality scientific frameworks depend on PETSC:

https://www.mcs.anl.gov/petsc/index.html 

Pascal - A language invented by Dr. Nicklaus Wirth; a famous professor that Claude Comair admires.  Everyone in the world admires Claude Comair, even if they don't know him.  Pascal was designed to improve upon ALGOL.

ADA contained constructs available in DOD's programming language design contest, originally labelled A, B, C and D.  The winner was given the name ADA; named after Ada Lovelace - Charles Babbage's funding agent that created the first mechanical computer to weave rugs in the 1880's. ADA was extensively utilized in wide variety of DOD, NASA in safety critical applications.   The ADA ecosystem packaged concurrency, real-time and safety critical implementations.  

C - A language written to support the building of the Unix operating system; after IBM and AT&T failed to create MULTICS.  It is rumored by some that the original monsters in the first person RPG cursor based game called Rogue where the monsters were the VP's of AT&T and IBM. Rogue was widely available in all Unix operating systems and derivatives like BSD and now Linux. Unix was written in C; AT&T Electronic Switching Systems V5 (5ESS) runs Unix; the 5ESS scales to 1,000,000 lines cross connect.   

As a side note, IBM and AT&T are also responsible for the nibble, byte, hexadecimal and 24-bit limitation.   The address space limitation on early IBM mainframes was 24-bits 

( https://en.wikipedia.org/wiki/IBM_System/360 )

The corresponding AT&T switch had 24 serial / voice grade circuits sampled at 8 bits at 8 Khz; initially switch signalling, called robbed bit, was embedded in the sampling such that the voice signal line rate was 56kps.  Eventually robbed bit signalling was eliminated providing 64 kps.  The T1 cable contained 24 voice grade lines aggregated.   Bell Labs Technical Journal archives detail how various generations of switches were built including limitations associated with previous work: 

https://web.archive.org/web/20110810202426/http://www.alcatel-lucent.com/bstj/#1980

LISP - LIS Processing - an early form of AI was written in LISP; derivatives of LISP included OPS, CLIPS and ART that were utilized in formulating rule based expert systems.  LISP basic processing structure was a list; there were three primary instructions: "car", "cdr" and "cons".  "Car" : constant address reference returns the first list element.  "CDR" constant decrement reference returns list without first element. "CONS" constructs lists. 

https://www.math.utah.edu/docs/info/emacs-lisp-intro_toc.html

XWindows / XLib - 1987 ( https://tronche.com/gui/x/xlib/) / Xt / Qt - MIT created the XWindow system originally in LISP; rewritten in C to achieve performance.  XWindows still contains reference to atoms and atom lists.   XLib is the base library. Xt wrapped Xlib in a toolkit with an event loop synchronizing graphics. XLib / Xt were written in C. Groups moving to C++ wrapped Xt. Qt is the current open source derivative with active support; an open source group. ( https://www.qt.io/ ).  Qt has C++ bindings.  

C++ - experimentally released internally inside of AT&T in 1985, standardized in 1998; made OO - Object Oriented programming paradigm mainstream.   

C and C++, in the hands of inexperienced programmers can lead to various security and safety issues.  Security issues are vulnerabilities that can lead to the computer being administratively compromised, that in turn leads to a distributed system compromise.  Safety issues include resource consumption such that the processor, memory, network or disk becomes resource exhausted.  Depending on administrative policies, resource exhaustion can lead to system being rebooted as the primary recovery method.    

Java - is another popular OO language that eliminated C++ complexities in favor of security and safety.  Checkout James Goslings recent video https://www.youtube.com/watch?v=XhFugYDH--c 

Security and safety are built-in to the language, including how the language checks, instantiates and creates objects. The Java ecosystem includes extensive libraries, including concurrency / threads, networking, distributed objects, and methods to interface to C and C++ libraries. Because it checks everything on startup; it is known to be slow.     

Other early OO languages include Smalltalk  (1980), Objective-C (1984).

Smalltalk, CSP and Erlang are examples of message based systems. Agent message based systems mimic humans and can be safer than pure OO systems that enable direct remote calls to functional methods.  Software agents consider object state on message receipt and may decide to apply or wait for some other action to complete.

Erlang is a functional programming language utilized inside Ericsson's telecommunication switching systems.  Erlang was released to public in 1998 along with OTP (Open Telecom Platform) library subsystem.  Erlang has several unique capabilities not commonly available in other languages: (1) fail-fast and recover logic, (2) true lightweight processes not implemented by POSIX threads, (3) an internal scheduler, (4) supervisory control trees - similar to Unix process spawns, (5) non-fifo message queues, message are pattern matched, (6) hot loading distributed runtime code, (6) network switch type connections, if node A connect to node B and node B connects to node C, nodes A and C are auto-connected (unless the default network connection mode is set overridden), (7) a replicated database and many other features that developers struggle to build.  For some, Erlang is difficult to learn due to it's non-standard lisp-like syntax, recursive functions, and single immutable variable assignments.  

Elixir - similar to Python - ties into the Erlang ecosystem

Matlab - a proprietary language utilized in many engineering communities with extensive library support.  Octave is an alternative open source version but is not completely compatible with existing libraries.  Matlab basic data structures are matrices and vectors; the modern language Julia also utilizes matrices and vectors as basic data structures.  Matlab, Octave and Julia ease engineering programming allowing many mathematical operator symbols, like x and + and advanced operators like divergence and curl essential in solving differential equations, to operate on matrices and vectors.  

Julia language is a modern LLVM. that may some day replace Matlab.  Julia lang is derived from an LLVM utilized at CERN. Several good modeling packages exist:

Differential Equations 

Convex Optimization

Conic Optimization 

Julia ML - SGD

DeepChem 

https://github.com/jtmatamalas/MMCAcovid19.jl - Markov Model Chain 

SIER Model 

GPU Interfaces

PyCall enables calling any python library.


Python

Python has extensive interfaces and libraries available.

Eland is a good python client library enabling interactions with Elasticsearch index.




Comments

Post a Comment

Popular posts from this blog

New Wheels, Old Wheels, Threading the Needle

Image
  Business focal personnel pursue driving efficiencies higher to reduce costs enabling increased marketplace performance.  Technology often helps automate complex processes, reducing costs. Wheels are synonymous with Tech, we can choose to make new wheels, use old wheels or integrate. Threading the Needle requires minimizing the organization delta, using Old Wheels, adding a New Wheel (/ML/Data Science), integration to... Generate growth !!! $100 M plus in 5 Minutes a 10X ROI starting in 2010. Growth shows benefit of New Wheel; New Wheels can be replaced with cheaper Newer Wheels.
Read more

Bahill ( Eye Tracking & Baseball Hall of Fame ), Grad School and Systems Engineering Curricula

Bahill's Lab Research Assistant and Departments System Admin supporting professors research. Bahill is a Systems Control Theory INCOSE fellow http://sysengr.engr.arizona.edu/ https://sie.engineering.arizona.edu/news-events/bahills-baseball-vision-study-still-hit  https://duckduckgo.com/?q=bahill+systems+theory&t=chromentp&ia=web   https://duckduckgo.com/?q=bahill+systems+theory+incose&t=chromentp&ia=web Stark was Bahill's Professor -  https://duckduckgo.com/?q=stark+bahill&t=chromentp&ia=web Together at China Lake they invented night vision capabilities.  In Bahill's lab I supported his eye tracking research group and the optical equipment generating targets, an infrared eye detector glasses, an the analytics packages that recorded the target state space trajectories, the horizontal, vertical and rotational eye movement - state space trajectories, along with the computed differentials between the target and what the eye was looking at.  T...
Read more

Portfolio Derivative Analysis

Image
  Tick data analysis indicating consistent non-linear stock market correlations across multiple days: Gaps indicate opportunity, as stocks are moving opposite -  delta in gap is possible profit  if you short one side and buy high side. Same stock pairs, similar correlation patterns.: Correlated Stocks are chosen by finding most similar profiles in large graphs. This technique can be applied to many different types of fintech systems: stocks, derivatives, crypto. forex and other funds,  Derivatives create co-associated graphs correlated and evolving across time.  In the graphs below the metric is normalized logarithmic (0.0-1.0) generated every three seconds.  The underlying infrastructure combines EMQX, an MQTT broker capable of sustaining 100 M connections fed into a HPC / MPI streaming infrastructure capable of running 100 M active cooperative agent processes coordinated by its own scheduler.  it has been shown to scale up to handle 5000 financial st...
Read more