Tuesday, January 19, 2010
What language for software reuse?
The RiSE community want to know from you if there is a specific programming language, or a type of languages, that is better for software. What do you think about it? Answer the poll on the left sidebar and let us know your opinion. If you prefer, post a comment saying the reasons for your choice(s). Cheers!
Subscribe to:
Post Comments (Atom)
6 comments:
I suggest that the poll should be redesigned so that some “null” hypotheses are fulfilled. In practice, only few developers are really expert in more than one programming languages.Further, only a minority of programmers do coding committed with software reuse. Thus, my suggestion is to add options like “I have no idea”, “I am not able to compare between those”. Perhaps if you focus only on the paradigms, you might increase the certainty of answers you get.
You're completely right, Durão. I believe that many other question should be asked before we ask this one, for example: what language people are experienced, what they know about software reuse, and so on.
Unfortunately we cannot change the pull right now. This pull will give us just a small snap shot about what readers think about it. But a further analysis of the result can be done, and it will be interesting, taking into account all the treats of validity. ;)
cheers.
Hello,
I'm quite interested in this subject, so I've written a few digressions on this. In advance, is not a criticism at all on the format of the poll or anything else (as I have no knowledge of the work behind it), but simply an attempt to understand what it's goals are and an honest expectation of an interesting work-to-come. Therefore, I freely assumed the poll as an attempt to characterize language and language features and their impact on reuse and just wrote as things came to my mind at the risk of being far off (sorry if it is the case, and sorry for the looong comment :)
One of the first things I thought when facing the poll was "what exactly am I evaluating?". In some sense, i see programming languages having language characteristics (syntax, semantics, pragmatics,...), runtime characteristics (interpreters, VMs, GCs, etc) and external characteristics (libraries available, FFI, etc). All of them seems to have an impact on reuse.
So, for example, one might conclude C or Java is better for software reuse considering the amount of available libraries for those languages -- not a _language_ (syntax, etc) characteristics per-se. Or C might get voted if the notion of "lingua franca" strikes (ie. the usual view that anything has an interface with C). Or, more interesting, if the runtime commitment most languages make (virtual machine, garbage collection, etc) is considered to have a negative impact on reuse -- as it's said, you want a banana and get a gorilla holding the banana and the entire jungle. But again, not a language characteristic.
Then, available libraries (either available natively for the language or easily (?) interoperable) sure is an aspect concerning reuse. But one external to the language, I think.
On the language side, one of the first things that usually come up is the characteristics of the type system. And I'm afraid the word "static" embraces far too much meaning (quite different ones) across languages, which I think most of us have no experience to reason about (unless properly educated in a variety of languages which manifest the _significant_ variations). The point being, can I safely regard all type systems as equal when analyzing their reuse impact? Or are they really very different beasts in this regard? For example, consider type inference: it certainly removes the notion of static type == explicit-type-restriction-everywhere, when the latter seems to be a popular target of criticism for its alleged reuse problems.
From the type system, we can go to the module system and its impact on reuse. Gilad Bracha (scientist, former JVM engineer) makes a point in two of his blog posts:
http://gbracha.blogspot.com/2009/06/ban-on-imports.html
http://gbracha.blogspot.com/2009/07/ban-on-imports-continued.html
Now, going down on the poll's language list, there is ruby. What caught my attention is remembering it is a smalltalk descendent but without the smalltalk characteristics that would appeal to a reuse discussion. Namely, the absence of the notion of "application" (considered an artificial boundary by some): a smalltalk system is made of live objects running that, in principle, can be instantly used by any other object - and so, composed and reused without artificial bureaucracy or complexity. Once more, not a language characteristics per-se -- in this case, system design. An appealing characteristic but not off with its drawbacks, one might say. But I digress...
A similar notion was carried by Symbolic's (much glorified, as it seems) Genera operating system and development environment, for it's Lisp Machines: no strong "application" boundary, which means: is not up to the designer of a given "application" to select what will be exposed to reuse and what won't (in the form of a library, or whatever): everything in the entire system is simply there to be reused all the time, at the function level.
[...]
[...]
Which brings me to Lisp. On one hand, I think it would be interesting to characterize it, since "Lisp", as it is, stands for a family of very different languages. For instance, Common Lisp and Scheme exhibits very different characteristics (available libraries, module system, standard philosophy, etc) which seems to concern reuse in different ways.
On the other, "Lisp" might stand for a set of language characteristics that are common to Lisps. For example, lazy evaluation, homoiconicity, metalinguistic abstractions, .... Or, maybe to a lesser degree (in respect to "language characteristic", not significance to reuse), meta object protocols, and such. Such things are more often than not praised for the special versatility in gives to the language. One might easily think of those as important tools for reuse software.
Finally, in a disruptive tangent, javascript comes to mind as one of the most used languages of the world, one which the "reuse phenomena" seems to have peculiar (non-positive) behavior.
So, all the reflections above comes from my difficulty of making sense of these aspects when facing the poll's question. I guess I felt overwhelmed by the number of things (and their interplays) to be distilled from each option, and wanted to share this.
Cheers,
Thiago
I am developing a new approach to software development and reuse through Model-driven development and code generation, named ABSE (Atom-Based Software Engineering) http://www.abse.info and the generation/reuse language is Lua http://www.lua.org, developed at PUC-Rio
The choice of Lua is due to its ease of use and setup, and because execution is very fast.
I believe that Thiago has exposed many of the point when we talk about software reuse and what language is more appropriate to it. What I conclude from his ideas, and it is what I believe also,is that the software reuse does not depend on the programming language you use.
But I would like to go deeper in this question. Software reuse is achieved with highly skilled and intelligent people. And the programming language can help with this in the moment to hire the right people. It is a subjective opinion, but I think that the programming language [that was chose, not imposed] can tell much more about a developer than an interview.
software reuse = right people. OK, many of you could argue that a systematic approach to software reuse could overcome this situation. Maybe you're right, maybe not. Not everything in life is systematic. New situations happen, and you need to decide how to deal with them. But one thing I believe is: for the opportunistic software reuse, you need the right people.
Post a Comment