"I am not seeing anything here that would differentiate this from x86 assembly"
¯\_(ツ)_/¯
Anyway, if you insist on mapping something new in computing onto something you already know, you will pretty much always find some way of accomplishing this. While it might seem clever, it really just reiterates Turing-completeness, and so is not particularly interesting.
The question is whether your mapping is appropriate (it's not) or straightforward (also not).
Of course, this is a problem, because to understand something, you typically first have to map it onto something you already understand, but the key is to not stop there.
As to "something new": no, software architecture is not new. Not new at all. The seminal book is from 1996: Software Architecture: Perspectives on an Emerging Discipline, by Mary Shaw and David Garlan.
https://www.amazon.com/Software-Architecture-Perspectives-Em...
The paper trail is much older.
There is an entire discipline behind this, and in this discipline, FP is a small corner of the small corner that is the call/return architectural style, of all the myriad of architectural styles available. You can argue that this whole discipline of computer science with conferences, many thousands of peer-reviewed articles, many books etc. is all just BS, but I think you'd have a hard time arguing that case. And it would be you who'd have to make the case, because the discipline is well-established.
All Objective-S does is to say "hey, let's take this talk of connectors and components seriously and program with them". It's also not the first language to do this, there was ArchJava. Alas, this was an extension of Java with architectural constructs such as connectors, which is the wrong way around: connectors are more general.
Taking the definitions from "Software Architecture: Perspectives on an Emerging Discipline" [1], you have the following:
- components
- connectors
- configurations (systems)
Guice (and other dependency injection frameworks) clearly address the third part: configurations. AOP is, at best, an implementation technique.
[1] http://www.amazon.com/Software-Architecture-Perspectives-Eme...
Hughes claims FP provides two (2) kinds of glue: functional composition and lazy evaluation.
It turns out lazy evaluation is actually not really a useful kind of glue, so subtract that one from the two initially presented:
2 - 1 = 1
> Does it mainly bash John Hughes for bragging about how good FP is?
> Or does it mainly advertise for the author's language, Objective Smalltalk?
Neither. It notes that John Hughes had a fantastic insight, but one that seems to not get a lot of attention: we need lots of different kinds of glue.
And yes, the article somewhat assumes that you either know what a connector is, or that you would read the linked Mary Shaw article to figure it out, as it is foundational for the field of software architecture. If you don't know what a connector is and don't care to find out, the article probably won't make a lot of sense to you.
And it's good for me to learn that apparently a lot of people don't know what a connector is, so I'll have to keep that in mind when communicating about this stuff. Thanks!
You could start with the main Wikipedia article on Software Arcitecture: https://en.wikipedia.org/wiki/Software_architecture
Or one of the others: https://en.wikipedia.org/wiki/Architecture_description_langu... https://en.wikipedia.org/wiki/Software_architecture_descript...
They cover the basics and have lots of references.
Or take a look at one of the books:
https://www.amazon.com/Software-Architecture-Perspectives-Em...
https://www.amazon.com/Software-Architecture-Foundations-The...
Here's a taxonomy of connectors, that should give you a quick overview:
https://isr.uci.edu/events/wesas2000/position-papers/mehta.p...
And of course there is the classic from 1994, published in IEEE Software: "Architectural Mismatch: Why Reuse Is So Hard"
https://www.ics.uci.edu/~taylor/ICS221/papers/ArchMismatch.p...
Turns out that one of the reasons Reuse is So Hard™ is that the connectors don't match.
With the followup 14 years later: "Architectural Mismatch: Why Reuse Is Still So Hard"
https://repository.upenn.edu/cgi/viewcontent.cgi?article=107...
Turns out that the connectors still don't match.
Cheers.