ted.neward@newardassociates.com | Blog: http://blogs.newardassociates.com | Github: tedneward | LinkedIn: tedneward
The question everybody asks is always the same:
... which is usually just a mask for the real question:
First, there was distributed objects
Then, there was Service Oriented Architecture
Hey what about domain specific languages
No we meant "lightweight SOA"
Wait, microservices
No, I mean serverless
Something something blockchain! Low-code! No-code!
2025: Who the hell knows anymore
O-O languages have "ruled the roost" since 1990
C++ (native) -> Java/C# (VMs) -> Python/Ruby/JS
Functional languages chose to remain mostly irrelevant
"monads, monads, monads!"
but functional features moved into languages
Compiled, interpreted, transpiled: who cares anymore?
Python JITs into bytecode during execution
Java jshell lets us REPL Java; Java24 gives us insance-main
Kotlin compiles to bytecode, transpiles to JS, compiles to CPU
2025: You can use anything so long as it's Java/C#/Python/JS
oh, fine, Kotlin/Swift for mobile
and I guess we can be OK with Javascript everywhere
1990: Use anything you want so long as it's an RDBMS
2025: Use anything you want so long as it's not an RDBMS
Oh, and it's totally acceptable to rewrite everything an RDBMS gave you
Like guaranteed execution and compensation (transactions)
Or on-database code execution (sprocs)
Expert systems will make people obsolete!
Fuzzy logic will make people obsolete!
Genetic algorithms will make people obsolete!
Image recognition will make people obsolete!
Natural language will make people obsolete!
Retrieval-augmented generation will make people obsolete!
2025: AI is for real, no, really, we mean it this time!
We stand on the threshold of a Renaissance in programming languages
the next N years will be all about:
pushing new boundaries
exploring new approaches
getting over the "object-oriented" hill
maybe even making money with them!
the demand for software remains infinite
the speed of development has never been slower
the level of abstraction needs to elevate
RAG remains nondeterministic and untrustworthy
Practitioners
Academics
... want to figure out new ways of doing stuff
more efficiently
more succinctly
more flexibly
more portably
or doing entirely new stuff we couldn't do before!
... all within programming languages or platforms
virtual machines as a language?
languages built up out of other languages?
what if the language could straddle the network?
compile into multiple target deployment artifacts?
Lisp
Self
Simula
Occam
ML
... want to get stuff done
quickly (on time)
cheaply (under budget)
correctly
with minimal surprise
... these two groups have been uninterested in working together
... they've been downright hostile towards one another
... don't get languages done enough to be useful
they lack good integration possibilities
they lack decent "commodity" features (such as GC)
... don't get languages done enough to be useful
they lack good integration possibilities
they lack decent "commodity" features (such as GC)
But getting those details right is hard
and has nothing to do with language design
which, remember, is the Academics' entire goal
don't get exposed
Practitioners never discover the concepts that might be useful
don't get used
Practitioners never learn how to use the new concept or tool
don't get discussed
Practitioners can't gather/provide feedback on the concept or language
... which means the feedback loop is broken!
... they are just clones of a clone
... they never get beyond a toy state
... they often lack any kind of rigor or discipline to them
they cram new features in their current language
lookin' at you, C#!
lookin' at you, Java!
or argue about whose mainstream language is "best"
lookin' at you, audience!
Virtualization
Language Tools
Service boundaries
A Renewed Focus on Linguistics
VMs allow language designers to defer decisions
CPU/code generation (incl register usage, alignment, etc)
memory allocation
object layout
... so these "low-level" details can be safely ignored
"trap doors" (FFI) exist to allow dropping to a lower level
parser generators/libraries/approaches
ANTLR, GOLD, parser expression grammars
grammar debuggers
ANTLR workbench
AST generators
optimizing backends
LLVM, GCC, JVM, CLR, (other VMs)
With the desire to create "no-dependencies" deployments...
... using a language-agnostic network interface (HTTP/JSON)...
... suddenly nobody cares what you write code in
This allowed several languages to challenge Java/.NET in the enterprise
Ruby, NodeJS, Go, Rust...
If the encapsulation barrier is truly opaque, why not...
Something new: Erlang? Elixir? Jolie?
Something old: Smalltalk? FORTRAN?
Something crazy: F#? LOLCODE? Intercal?
Domain-Specific Languages tied to our specific domain?
let's take brief side trip for a second
Greeks had no concept of "blue"
never appears in any of the ancient texts (Homer, etc)
"Homer’s comparison of the sea not to the sky, or another blue-colored thing, but to wine, (is) quite interesting. Throughout Homer’s poetry, the sea is referred to as 'wine-dark.'"
https://greekreporter.com/2024/02/17/did-ancient-greeks-see-blue/
Other terms were used
kyaenos was often used for colors on the darker end of the spectrum
violet, black, dark blue, brown, dark green
glaukos used infor lighter colors
yellow, grey, light green, or light blue
... but no "blue", as we know it
What's the difference between
"friend" and "bestie"?
"house" and "home" and the Spanish casa?
the "love" you feel for pets, friends, family, or spouse?
English: "love"
Greeks: eros, storge, philia, agape
Eskimos, "snow", and you
https://www.scientificamerican.com/article/linguists-find-proof-of-sweeping-language-pattern-once-deemed-a-hoax/
how many words for a concept, as a percentage of the total words in the language?
https://charleskemp.com/code/lexicalelaboration.html
Language shapes thought
Each language seeks to conceptualize certain constructs directly within the language
Niklaus Wirth called this a "separation of concerns"
We call these constructs "first-class citizens"
... and sometimes language hide details behind "syntactic sugar"
single entry point
well-defined parameters and return values
union of state and data (object)
relationships between types (inheritance)
polymorphic response to messages (dynamic binding)
encapsulation of details (access control)
Type inference; parametric polymorphism
"pure" functions
higher-order functions
partial application of functions
sequential and monadic comprehensions
conditionals
recursion
dynamic typing
functions-as-types
garbage collection
programs as expressions
a symbol type
a notation for code using trees of symbols and constants (AST)
dynamic evaluation of code
development speed/iteration cycles
distribution/network models
concurrency and the end of the "free lunch"
application security
"user enablement"
user interface
say "it's just like HTML" one more time....
... and a whole bunch more we haven't thought of yet
ANTLR (parser generator) generates C#/Java/Python/C++ parsers and ASTs
Several packages provide JVM or CLR bytecode generation
some even ship with it in the standard library (Python!)
LLVM is a back-end compiler toolchain (Swift, Crystal, Rust, more)
... and lots of other languages are open-source, for reference and instruction
Pizza
Nemerle
Katahdin
Jolie
Ballerina
Wing
Mint
Inform7
a service-oriented programming language
"it is designed to reason effectively about the key questions of (micro)service development, including the following:
What are the APIs exposed by services?
How can these APIs be accessed?
How are APIs implemented in terms of concurrency, communication, and computation?
built on top of the JVM
"More in general, Jolie brings a structured linguistic approach to the programming of services, including constructs for access endpoints, APIs with synchronous and asynchronous operations, communications, behavioural workflows, and multiparty sessions. Additionally, Jolie embraces that service and microservice systems are often heterogeneous and interoperability should be a first-class citizen: all data in Jolie is structured as trees that can be semi-automatically (most of the time fully automatically) converted from/to different data formats (JSON, XML, etc.) and communicated over a variety of protocols (HTTP, binary protocols, etc.). Jolie is an attempt at making the first language for microservices, in the sense that it provides primitives to deal directly with the programming of common concerns regarding microservices without relying on frameworks or external libraries."
https://mint-lang.com/
"programming language for writing single page applications"
incorporates HTML, CSS, JS into one unified language
written in Crystal
Hello world
component Main {
fun render : Html {
<button>
"Click ME!"
</button>
}
}
Counter component
component Counter {
state counter = 0
fun increment { next { counter: counter + 1 } }
fun decrement { next { counter: counter - 1 } }
fun render {
<div>
<button onClick={decrement}>"Decrement"</button>
<span><{ Number.toString(counter) }></span>
<button onClick={increment}>"Increment"</button>
</div>
}
}
https://www.winglang.io/
combines infrastructure and runtime code
cloud services as first-class citizens
local simulation (of cloud services)
deploy to any cloud
bring cloud;
let q = new cloud.Queue();
let b = new cloud.Bucket() as "Bucket: Last Message";
q.addConsumer(inflight (m: str) => {
b.put("latest.txt", m);
});
new cloud.Function(inflight (s: str) => {
log("Cloud Function was called with ${s}");
q.push(s);
});
https://ganelson.github.io/inform-website/
Currently in it's 7th revision (Inform7)
"... a programming language for creating interactive fiction, using natural language syntax. Using natural language and drawing on ideas from linguistics and from literate programming, Inform is widely used as a medium for literary writing, as a prototyping tool in the games industry, and in education, both at school and university level (where Inform is often assigned material for courses on digital narrative)."
Example Inform7 code
Before taking the crate:
if the player is wearing the hat:
now the hat is in the crate;
say "As you stoop down, your hat falls into the crate.“
the source for Inform7 is, itself, a story
this is "literate programming"
https://ganelson.github.io/inform/ and click away!
formal fork of the language (easier if it's OSS, of course)
extend the syntax
revamp the definition/semantics
restrict the syntax
"internal" DSL
Consider... Javascript + XML (e4x)
// Use an XML literal to create an XML object
var order = <order>
<customer>
<firstname>John</firstname>
<lastname>Doe</lastname>
</customer>
<item>
<description>Big Screen Television</description>
<price>1299.99</price>
<quantity>1</quantity>
</item>
</order>
// Construct the full customer name
var name = order.customer.firstname + " " + order.customer.lastname;
// Calculate the total price
var total = order.item.price * order.item.quantity;
"... but my boss won't let me!"
"... but my team won't let me!"
"... but what if I'm wrong?"
some bosses are just unshakeable
either go above them
or around them
or find a new boss
most bosses are willing to listen; make your case about them
benefits to the team
means by which you mitigate the costs
make sure there's a support structure in place
for some, demonstrate the utility after the fact
consider your team composition; will this benefit some but not others?
show them, don't tell them
create some examples
look to solve small problems quickly
get them involved in the process/R&D
make sure you are starting from a firm foundation
make use of all those existing tools mentioned earlier
make sure you are solving a real problem
before creating the language, establish the model
be ready to be wrong about some parts
iterate early, iterate often
Look to language enhancements; where'd they come from?
Look to new languages coming out
what do they do
how do they do it
why'd they choose to do it that way
Explore creating your own new languages
start by reinventing the wheel
maybe build an "esoteric" language, just for fun
then turn your imagination loose a little
Architect, Engineering Manager/Leader, "force multiplier"
http://www.newardassociates.com
http://blogs.newardassociates.com
Sr Distinguished Engineer, Capital One
Educative (http://educative.io) Author
Performance Management for Engineering Managers
Books
Developer Relations Activity Patterns (w/Woodruff, et al; APress, forthcoming)
Professional F# 2.0 (w/Erickson, et al; Wrox, 2010)
Effective Enterprise Java (Addison-Wesley, 2004)
SSCLI Essentials (w/Stutz, et al; OReilly, 2003)
Server-Based Java Programming (Manning, 2000)