off-topic question: how well do you think linguistic relativity applies to PLs and programming?
Hi all, I recently got myself thinking about programming languages and their effects on programmers. I already knew that concept of "linguistic relativity" ( http://en.wikipedia.org/wiki/Linguistic_relativity ) and I was thinking that this may be relevant with programming too, although I don't have any concrete evidence. I was wondering if anyone else also find that idea of programming language's effect of the programmer interesting. Do we have any research on that kinds of things? Thanks,
This is my take, as a CS undergraduate.
I'm not sure if we can say that a programmer's language of choice
determines the way they think about programming (the strong version of
linguistic relativity for programming, as I see it). But I think it's
fairly obvious that the language we choose to use to solve a problem
affects how we think about the solution. That's basically the entire
raison d'être for domain-specific languages (DSLs)!
DSLs are popular (and becoming more so) precisely because the right
choice of DSL can make expressing the solution to a particular kind of
problem almost trivial. A poor choice can almost doom an endeavor.
Imagine trying to query a database in assembly language. No SQL. It
would at the very least require some mental gymnastics that a SELECT
statement simply obviates.
Similarly, functional programmers tend to think about maps and folds,
while imperative programmers tend to think about loops and iterators.
While they accomplish much the same thing, it's amazing to read code
and see what different directions they often lead.
(Ömer, sorry for the double-response. I wish GMail defaulted to
replying to the list. >_<)
- Lucas
On Fri, Jan 17, 2014 at 11:14 AM, Ömer Sinan Ağacan
Hi all,
I recently got myself thinking about programming languages and their effects on programmers. I already knew that concept of "linguistic relativity" ( http://en.wikipedia.org/wiki/Linguistic_relativity ) and I was thinking that this may be relevant with programming too, although I don't have any concrete evidence. I was wondering if anyone else also find that idea of programming language's effect of the programmer interesting. Do we have any research on that kinds of things?
Thanks, _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Lucas Paul
This is my take, as a CS undergraduate.
I'm not sure if we can say that a programmer's language of choice determines the way they think about programming (the strong version of linguistic relativity for programming, as I see it). But I think it's fairly obvious that the language we choose to use to solve a problem affects how we think about the solution. That's basically the entire raison d'être for domain-specific languages (DSLs)!
DSLs are popular (and becoming more so) precisely because the right choice of DSL can make expressing the solution to a particular kind of problem almost trivial. A poor choice can almost doom an endeavor. Imagine trying to query a database in assembly language. No SQL. It would at the very least require some mental gymnastics that a SELECT statement simply obviates.
I think this can be partially explained by noting that programming languages, and in particular the way that programmers use them, afford a capacity for essentially limitless amounts of abstraction, unlike human language and human communication. For example, I might easily have a magic library that does exactly what I want, with bindings for my programming language of choice, in which case I don't need to think about what to do, I just call the appropriate function. In human communication, while someone might have perfectly formulated exactly the idea I want to communicate, it is rarely sufficient for the purpose of communication to say "insert pages 204 through 356 of _Foobar_ by John Doe here" in the middle of a conversation :) -Keshav
On Wed, Jan 22, 2014 at 4:37 PM, Lucas Paul
(Ömer, sorry for the double-response. I wish GMail defaulted to replying to the list. >_<)
<gear icon> > Settings > General > Default reply behavior -- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
I would say it is more the concepts one uses than the programming language
that has an effect on the programmer.
After learning one OOP language it is not that hard to pick up another OOP
language
BUT
Functional programming concepts have such a wide array (pun intended) of
expression that it was hard for university graduates to use another
university's functional programming language; which was why Haskell came to
be. :)
Casey
On Fri, Jan 17, 2014 at 10:14 AM, Ömer Sinan Ağacan
Hi all,
I recently got myself thinking about programming languages and their effects on programmers. I already knew that concept of "linguistic relativity" ( http://en.wikipedia.org/wiki/Linguistic_relativity ) and I was thinking that this may be relevant with programming too, although I don't have any concrete evidence. I was wondering if anyone else also find that idea of programming language's effect of the programmer interesting. Do we have any research on that kinds of things?
Thanks, _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
-- -- Regards, KC
On 23/01/2014, at 1:36 PM, KC wrote:
I would say it is more the concepts one uses than the programming language that has an effect on the programmer.
After learning one OOP language it is not that hard to pick up another OOP language
It's not clear to me that that's true. Consider: my first OO language was Smalltalk. - everything is an object - there is no pointer arithmetic - bounds checking is obligatory - integers are bounded - single inheritance - no static types - anonymous functions used *extensively* and nest - classes are objects - you can define a variable in a class that belongs to the *class* (not its instances) but such that its subclasses (not their instances) have their own copy; inherited methods work on the receiver's copy My third OO language was C++ - numbers are not objects - there is pointer arithmetic - bounds checking was not available - integers have machine-dependent bounds - multiple inheritance - statically typed - no anonymous functions and no function nesting - classes were not objects - class instance variables are not available At least half the design patterns in the Gang Of Four book either make no sense for or are trivial in Smalltalk. What C++ programmer would ever think of passing a class as a parameter to a function so it could create instances of different classes? What C++ programmer, finding _that_ couldn't be done, would next try to pass an object-creating function? Answer: a Smalltalk or Lisp programmer writing C++. What Smalltalk programmer, faced with let's say a parsing problem, would ever say "I'll define a combinator for that"? Answer: one who knows Haskell and is about to switch back to it. What I see here is that a programming language has *many* aspects and exposure to native style in several of them definitely enlarges what you find easy to _think_ of, whereas the one you are using right now affects what is _easy to express_ once thought of. One thing we're seeing is a lot of convergence: current Fortran is an OO language with modules _and_ good array-crunching support, there are C, C++, and Objective C compilers that support anonymous functions (and Java, we keep being told, will get them Real Soon Now), LINQ in C# was inspired by functional programming, ... Right now, there are just three surviving languages where I trust myself to do concurrent programming without stupid blunders that take ages to fix: Ada, Erlang, and Haskell. We still need *new* ideas.
Ömer Sinan Ağacan
Hi all,
I recently got myself thinking about programming languages and their effects on programmers. I already knew that concept of "linguistic relativity" ( http://en.wikipedia.org/wiki/Linguistic_relativity ) and I was thinking that this may be relevant with programming too, although I don't have any concrete evidence. I was wondering if anyone else also find that idea of programming language's effect of the programmer interesting. Do we have any research on that kinds of things?
The Stanford Encyclopedia of Philosophy has a pretty good page about the "linguistic relativity hypothesis." Here's a quote from Sapir in 1929 followed by some random thoughts of mine on your (very interesting) question: "Human beings do not live in the objective world alone, nor alone in the world of social activity as ordinarily understood, but are very much at the mercy of the particular language which has become the medium of expression for their society." I think our tendency to form communities (societies?) around programming languages is interesting in this context. Rubyists, Pythonistas, Schemers, hackathons, mailing lists & IRC, conferences, books, and so on. Without considering community, it seems hard to say even what a programming language is. Are "idioms" part of language, for example? In natural language, we can't judge fluency based on adherence to a formal grammar; we need to consider dialectal (even "sociolectal") competence, range of vocabulary, and so on. In programming, we are bound by formal grammars, but they still don't capture the whole thing. (That language and culture are hard to tease apart seems like a commonplace notion. I think it's one reason why the concept of "linguistic relativity" seems somehow vacuous or at least hard to pin down in a productive way. It's one of those "controversial" ideas, right? -- that nobody really knows what to do with, or whether it's even falsifiable, and so on.) So given that involvement with a programming language is to some extent inextricable from community involvement, I think we can look there for some interesting effects. When someone becomes interested in Haskell and later develops a taste for algebra and starts spending weekends reading abstract math textbooks, that's a pretty significant influence, right? There's an interesting meme in the Haskell world, which I think I first heard in a talk by Simon Peyton-Jones, that laziness -- though sometimes useful in itself -- is mostly a way to keep up a demand for pure semantics, which is what's really important. So that's a formal language feature consciously designed to influence our behavior as a community, to make sure we don't stray from the pure vision of our ancestors (so to speak). It's a kind of metaprogramming -- the language programs us! It'd be interesting to read stories and research about individuals or even groups who have for some reason switched from one primary programming language to another. What happened? There are a lot of applicable Dijkstra quotes. For example the classic: "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration." Similar reasons are given for why university programs should begin with teaching a functional language, to instill certain good habits and values. Anyway, sorry for the longwindedness; I don't really have a thesis to drive, just writing down some thoughts. It's fun to think about the topic but it's so huge! -- Mikael Brockman (@mbrock)
participants (7)
-
Brandon Allbery -
KC -
Keshav Kini -
Lucas Paul -
Mikael Brockman -
Richard A. O'Keefe -
Ömer Sinan Ağacan