Sharing and reuse in programming

[Trygve Reenskaug]

Half asleep last night I got an idea:

	Sharing technology	Sharing
1	Subroutines/procedures	FORTRAN, Algol, Friends, C Behavior: Sharing subroutine/procedure library: APIs Example: https://en.wikipedia.org/wiki/Carbon_(API) State: No sharing or a shared database. All within a singe computer, e.g., a von Neumann machine. Collapses if you redefine processor instruction set / OS
2	Classes	Java, Ruby, & Friends (C++?) Shared class library. Example: https://docs.oracle.com/javase/8/docs/api/ All within a singe computer, e.g., a von Neumann machine. House of cards that collapses if you redefine the mother of all classes: class Object.
3	Objects	DCI Context binds roles to objects, classes unspecified In my current BabyIDE, all Data objects are instances of Smalltalk classes. In my new Personal Programming (PP), objects are on the net           and could be identified with their UUID and accessed with RPC Within single or networked computers Collapses if you redefine communication standards.

Unlike most of my ideas, this one has survived breakfast.
Does it make sense?
Is it interesting?

[James O Coplien]

Most of the great literature on reuse notes that we reuse two things: commodities, and design. Methods and even classes tend to be overly contextualized to be broadly reuse.

Most code reuse became discredited in the industry in the early- to mid-1990s. But, more broadly, the answer to your question depends on your expectations and what you mean by “reuse.” There is a distinction between use and reuse in the literature, and something must first be used to be reused. To me and to many others reuse is an economic phenomenon related to intent and planning, rather than something related to technology. In his article “Where does reuse start?” Tracz traces the foundations back to domain analysis and business models; one just needs to choose a suitable technology to capture that analysis. Any of your suggestions may work. And the most reused software is still the  UN*X C library.

Tracz further distinguishes carry-over from reuse. Use of Windows is not reuse, but software carry-over. They have different economic benefits and relate to different approaches.

To me, the reuse part of DCI comes in the what-the-system-is part and the domain analysis practice in coming up with classes. We discussed this a bit at the meeting last Wednesday in Tokyo (where I must have autographed 15 copies of the Multi-Paradigm book.)

Will Tracz (IBM / Loral) has written a great book about this. On the web, see:

http://tracz.org/will/tracz-publist.html

https://www.amazon.com/Confessions-Used-Program-Salesman-Tracz/dp/0201633698

https://www.researchgate.net/publication/3560775_Software_reuse_myths_revisited

--
You received this message because you are subscribed to the Google Groups "object-composition" group.
To unsubscribe from this group and stop receiving emails from it, send an email to object-composit...@googlegroups.com.
To post to this group, send email to object-co...@googlegroups.com.
Visit this group at https://groups.google.com/group/object-composition.
For more options, visit https://groups.google.com/d/optout.

[Trygve Reenskaug]

Interesting but you miss the point.  You are wasting my time.

We DO share procedure libraries. We DO share classes. We DO share something like objects over the net that are accessible through PHP (https://www.yr.no/place/Norway/Oslo/Oslo/Meteorologisk_institutt/data.html#php)

Method and classes ARE broadly reused. I gave examples in my post. Above is another even if it isn't so clear.

--

The essence of object orientation is that objects collaborate  to achieve a goal.
Trygve Reenskaug      mailto: try...@ifi.uio.no
Morgedalsvn. 5A       http://folk.uio.no/trygver/
N-0378 Oslo             http://fullOO.info
Norway                     Tel: (+47) 22 49 57 27

[James O. Coplien]

So would you please then elucidate the point, if there indeed is one?

Sendt fra min iPhone

Den 21. okt. 2017 kl. 16.56 skrev Trygve Reenskaug <try...@ifi.uio.no>:

[James O Coplien]

Sendt fra min iPhone

> Den 21. okt. 2017 kl. 14.41 skrev Trygve Reenskaug <try...@ifi.uio.no>:
>
> We DO share procedure libraries. We DO share classes. We DO share something like objects over the net that are accessible through PHP

All negligible compared to the C or C++ or Objective C image most people share when using Windows or MacOS.

We also share common bus designs, compilers, and keyboard layouts.

What's your point?

[Trygve Reenskaug]

I was looking at technologies for packaging and sharing reusable program modules of some kind. Possibly also marketable.
Thought it interesting to classify as subroutines, classes, and objects.
I tghink it is a neat classification.
Have googled the nature of  C image, what it is, and how I can buy an extension. No success.

On 21.10.2017 15:48, James O Coplien wrote:

What's your point?

[Raoul Duke]

i am a day jobber programmer wading through industrial run of the mill muck day in day out. i have never been good at groking complicated models. thus i do yearn for clarity, sanity, axiomatics, overall "the right abstractions". so i think it is good for me and anybody i will hace to work with to learn about the design choices and ramifications. there are provably higher level approaches but most of us only get to think about it at the level of ascii code in whatever language we've been told to use. so we probably can benefit from trying to understand compare/contrast of possibly mundane things like function vs. method. (for me i hope when people think about them day to day they start to eg see the sweater thread of logic that leads to maybe eg wanting more pure fp than overly statefully conflated confusing oop)

[James O Coplien]

Den 21. okt. 2017 kl. 16.24 skrev Trygve Reenskaug <try...@ifi.uio.no>:

I was looking at technologies for packaging and sharing reusable program modules of some kind. Possibly also marketable.

Now I feel you are wasting your own time.

As I said in my mail, it is not an issue of technology. A plain .a archive file suffices. The trygve compiler is “reused" as a jar file — but most people just reuse the source from git.

If you are serious about this, I suggest you read the reuse literature, which will underscore that looking for technological “enablers” for technology is the wrong place to look. For years inheritance was heralded by our community as a (or the) solution to reuse, and it ended not only making programs incomprehensible but really didn’t achieve reuse goals. Unfortunately, the word is left over from that experience and I am concerned that might be the sense in which the word is being used here.

Or maybe you mean simply use and not reuse — which is why I asked the question for which you could not find the time to answer. More seriously, is your goal to save people typing? testing? design? These are economic drivers and most of the benefit lies in good domain analysis and the building of a community

[Matthew Browne]

Hi Trygve,
Regarding objects connected over the web, some people are now applying the Actor Model to the web, and the idea is gaining traction. So I would look into that, since I think your vision is similar in many ways. I heard about this through coworkers, and could follow up with them to see if they know of additional resources, but here are two articles about this I found via Google:

https://www.infoq.com/articles/reactive-cloud-actors
https://dzone.com/articles/distributed-systems-done-right-embracing-the-actor-model

--

[Rune Funch Søltoft]

Back when I studied we were using Emerald. A programming language and environment with a memory space distributed across nodes in a network. That might also have some sources of inspiration 

Mvh

Rune

[Trygve Reenskaug]

Thanks.
Programming the web is clearly a hot question without a good answer. I thought we had discussed Actors before and searched my message library.  Here's a fund of wisdom about DCI, often from Cope. I could have enjoyed reading forever.
It seems to me that DCI is a much better fit for IoT then Actors since we focus on using networked computers, real or virtual,  to getting something done.  IoT is a huge and virgin market for DCI.

[Matthew Browne]

I think both paradigms have contributions to make. Actors are certainly well-suited to concurrency and distributed systems. I also see them as complementary with OO / DCI.