3 ms·
If "we" already know these things are hard, why are "we" all programming in languages with mutable state? That seems to indicate that "we" are all idiots, or m
by jimbokun 17y ago
If "we" already know these things are hard, why are "we" all programming in languages with mutable state? That seems to indicate that "we" are all idiots, or masochists.
I found the analogy to garbage collection just right. It's obvious now that for large parts of the problem space of writing computer programs, having garbage collection built into the language makes programs significantly easier to write and understand. Joel Spolsky made the argument that object oriented programming didn't do nearly as much to make programming more productive as automated memory management did, and I agree.
So why not take this other problem that is very hard to reason about, and build constructs into the language that take care of it for you automatically? I think the fact this seems so obvious to you that it's hardly worth saying points to how powerful the argument is. If it's so obvious, why is almost everyone still programming with mutable state and with so little support for "time management" constructs? Isn't this the same thing as stubbornly clinging to free and malloc in programs where garbage collection would work just fine?
- tybris 17y ago> why are "we" all programming in languages with mutable state? My argument is not against closure or using immutable objects. My argument is against trying to rebrand a problem that has been well-known and well-studied for over 40 years. Clojure does a bit of copying (memory management, not "time management") to force you to avoid concurrency problems that arise in some scenarios. Arguably that is a good thing, because people tend to think of concurrency when it's too late. However, it too ultimately has a mutable authoritative source where the same issues arise. Moreover, the hardest concurrency and consistency problems arise in distributed systems. Using Clojure certainly isn't the answer to that. > Isn't this the same thing as stubbornly clinging to free and malloc in programs where garbage collection would work just fine? People "stubbornly clinge" to programming with free and malloc (in C), because it allows them to have very specific control over how their program will behave. This allows you to perform very effective optimizations. Moreover, because it is cumbersome, C programmers will avoid dynamic memory, which will again make your program faster and more durable. The same thing will apply to mutable objects. Clojure simply restricts you to a certain model, which is not necessarily most efficient. Does that mean Clojure is bad? No it means it's not the right tool for every job.
- loup-vaillant 17y ago> Clojure simply restricts you to a certain model, which is not necessarily most efficient. So does C. You don't use mutable array because they are the best solution. You use them because they're the best supported datastructure in C. Sometimes even when a shared immutable tree would be most efficient. For a well-know, well-studied, and still unsolved problem, rebranding isn't wrong. It's the only way. I think pervasive mutation falls in this category. So does the widespread use of the Qwerty layout.
- drewr 17y agoNo, it's not the right tool for every job. Rich isn't arguing that kernel drivers be written in Clojure. His work addresses the pain he feels -- writing concurrent, high-level applications that model the real world. Also, you'd be amazed at how much control you have over the underlying system in Clojure; you just rarely have to wield it.
- jrockway 17y agoIf "we" already know these things are hard, why are "we" all programming in languages with mutable state? That seems to indicate that "we" are all idiots, or masochists. The same reason people still use C -- perceived efficiency, and 30+ years of history. Computers are just a big block of mutable state that runs instructions, after all, so the first thing that comes to mind is to program them without abstracting that away. The reason we stick with this is that nobody wants to give up their favorite language (mostly for perceived employment reasons, if you don't know Java, you are unemployable or something), and "their favorite language" doesn't support immutability well. Try writing composible effectful computations in Java. Doesn't work. So you have to do something else. (If you have effectful computations that know about each other, you can put them in a class. If they don't know about each other, you basically have to manage the state manually.) I experimented with this recently in Perl, via MooseX::Data (http://github.com/jrockway/MooseX-Data/ http://github.com/jrockway/MooseX-Data/). It ports various category-theoretic type classes to Perl. (You could do this in any language, although Java is not one of them unless you want to copypaste the standard liftM-in-terms-of->>= code into every class that implements "Monad", etc. Scala fixes this particular problem.) Anyway, without special syntax, it ends up being a real mess. For example, consider incrementing a global state variable by one: use MooseX::Data::Function::State; sub S() { MooseX::Data::Function::State:: } # save typing my $inc = S->get->bind( S->new( function => sub { my ($state) = @_; S->mreturn($state+1); }, )->bind( S->put )); And printing it: my $print = S->get->bind( S->new( function => sub { my ($state) = @_; say $state; S->mreturn($state); }, ), ); So now to inject 42 into the environment, increment it twice, and print it: my $result = $inc->bind($inc)->bind($print)->runState(42); This prints 44 and returns [44, 44], as expected. (44 is the state, 44 is the unlifted return value of $print->apply(44).) Anyway, this is an awful lot of code compared to the imperative version: sub inc { $_++ } sub prnt { print } $_ = 42; inc; print; return $_ (The functional version composes better, though; you can write a function that acts on "the" shared state, and you can compose these arbitrarily. In Perl, you only get one $_ per program. The tree-numbering example here is an excellent demonstration of composablity: http://www.haskell.org/ghc/docs/latest/html/libraries/mtl/Control-Monad-State-Lazy.html#3 http://www.haskell.org/ghc/docs/latest/html/libraries/mtl/Co... Note how there is no mutable state here, just a bunch of functions that pass (s,a) pairs to each other. And yet, you don't see that, you "see" composable mutable state. In this case, we are composing numberTree with itself recursively.) To get back to my original point, with the right language, immutability is as expressive as mutable state. The increment example in Haskell: import Control.Monad.State type Step = StateT Int IO Int -- save typing inc, prnt :: Step inc = do x <- get let x' = x + 1 put x' return x' prnt = do x <- get liftIO.putStrLn $ show x return x main = runStateT (inc >> inc >> prnt) 42 -- or prnt << inc << inc This prints: 44 (44,44) It is worth pointing out that I combined the function calls with >> instead of >>= so you can see that the values are being passed implicitly (via get and put), rather than as arguments to the individual functions, which would look like (putStrLn.show) . (1+) . (1+) $ 42 Anyway, it's a function of languages. If everyone was using Haskell, very few programs would be using mutable state. But since they are using Java, and the only state encapsulation tool Java supports well are classes, that's what everyone uses. Very few people care about "doing it right", they care about having a working program. And while class-based state encapsulation is inferior to immutability in many ways, most developers don't know this, and don't care.