Prototyping vs. Implementation languages
Programming languages worth mentioning could be crudely distributed across the Prototyping - Implementation spectrum, with some languages at each extreme and some right in the middle. The last ones are the most interesting.
As an obvious example of a prototyping language (which basically means a high-level, dynamically (but strongly) typed with a minimalistic, non-verbose polished syntax) there is Python3. The opposite (verbose, cluttered with cryptic types which won't compile, low-level) you, probably all know is C++.
We are not talking about PHP or Java here because sane, intelligent people would not consider them to be a pleasant subjects worth of mentioning.
The languages in the middle - high-level-enough (which means based on the right principles) that they could be used for quick prototyping and produce a native code that is good-enough for a production - are, obviously, Common Lisp and most recent Go Go's static typing is very lightweight and minimalistic - good-enough.
Haskell could be considered as a prototyping-and-implementation language due to polymorphic (parameterized) types and type-inference . So is LuaJit, and Julia which are dynamically typed (Julia uses type-signatures, but is typed like Common Lisp).
This is rather an easy question. The big idea here is Layers of DLSs, along with REST principles and Message Passing (which just a natural leverage of the classic Client-Server model with the principles from the Functional Programming paradigm).
The strategy is Start prototyping with a high-level language and then implement critical parts in low-level languages or, even better, FFI them). This is how everyone are leveraging numerical Fortran libraries, modern Cuda GPU toolkits and other highly specialized, low-level libraries.