
Programming Can Be Fun Again - icey
http://blog.polyglotprogramming.com/2011/9/5/programming-can-be-fun-again
======
alexatkeplar
Dean Wampler keeps repeating this idea that ORMs have been an epic wrong turn
for coders and that SQL-wrangling functional tools like Scala Play's Anorm
represent a much more efficient way forward. I agree that being able to
map/filter/fold over record collections is very cool, and definitely part of
the solution, but it's crazy to think that going back to embedding brittle,
non-type-safe, non-DRY, database-specific SQL calls into a host functional or
OOP language is the best way to do this. We're using Squeryl for Scala and
very happy with it - it's fully type-safe, uses very easy to define case
classes for each db record type, and crucially allows all of that FP
fold/map/filter goodness over the data models which are exposed.

Joyless heavyweight frameworks and flabby design patterns are definitely the
problem, but Dean's survivalist-style head back to basics and raw SQL isn't
going to let us build rich complex software in 2011.

------
Dn_Ab
As someone who only does functional programming I do not think their power
lies in their erm functionality. I have a hypothesis.

I think the key lies in how easy is it to look at your code and trigger the
pathways in your brain associated with elegance. No offence to Java, it gets
the job done but due to boilerplate, the likelihood of your code resulting in
such triggers is much less than say clojure or scala. Consider the popularity
of CofeeScript, node.js, python, ruby. These are not idiomatically functional
languages but due to reduced boilerplate they too also make it easier for your
code to be appreciated on an aesthetic level. What is the gain in this?

I have a belief that an appreciation for elegance is the natural outcome in a
universe with a principle of least action. Prefer the explanation which takes
less energy to unfold. So anways what happens is that your brain rewards you
for writing code that tries to be elegant and turns aesthetic knobs. Pushing
you for more and more of a hit. And you start to become more motivated to
write code that rewards you thusly and a side-effect being programming is more
enjoyable and you are more likely or encouraged to write code that is
appreciable. Since code is meant for humans, as a start, optimizing in this
way is ideal. Train yourself to appreciate algorithmic and mathematical
elegance and you reap the rewards there too.

~~~
Meai
I don't know functional programming but I agree with your sentiment. I even
think this is the reason why languages like C++ and Java are abused so much.
Over the years of use, people start learning little tricks and hacks, and they
want to deploy those. They find them elegant, while everyone else who has to
read them...actually thinks they are horribly overcomplicated. C++ template
programming is awful, but some people love it because they love how elegant
their code can become. They love that they can immerse themselves in the
language features. Unfortunately this provides a net detriment to the code you
are writing. No matter how good your code is, someone will have to read it
again, even if it's just you. Code should be simple. I believe code should be
difficult to write bad. In the common languages though it's very easy to write
undecipherable code. In Javascript for example, it's hard to write code that
needs more than a few moments to understand. It's even hard to write "class"
hierarchies!

------
acangiano
Functional programming is admittedly fun, at least for those who are
mathematically inclined. The problem is that it's hard, at least at this
stage, to justify using a functional programming language as your _main_ tool.

Want to develop web applications? Nothing from the functional programming camp
comes even close to the polished experience of using Ruby on Rails. Yes, I
know about Play and other web frameworks for Scala, Clojure, and Haskell, but
- and I repeat - they aren't even remotely close to the level of support,
libraries, plugins, and documentation that you can get from the Rails world.

Want to develop mobile apps for iOS or Android? That's typically Objective-C
or Java territory. Yes, you can develop Android in Scala, but you are a
pioneer then (and you are virtually on your own if you encounter any issues
with the stack, as very little documentation and community support is
available for it).

Want to develop desktop applications? Again, functional programming languages
are rarely the best supported option. C#, Objective-C, C++, or even Object
Pascal (Delphi) are all fine choices. Opt for Scala, Clojure, or Haskell and
you'll find little documentation and support, and in the case of the first
two, you'll have GUIs that look anything but native.

So what are these functional programming languages good for? So far I've only
found them to be good at doing heavy lifting in the back-end or in GUI-less
scripts. An important spot for sure, but not the most prominent one to justify
adopting either as my _main_ tool.

I love functional programming languages and I wish I could drop everything and
write web apps in Clojure or Haskell. But the hustler in me wants to get stuff
done and cannot justify the world of pain and waste of time I'd experience,
especially when there are already tools that are simply better suited for the
task at hand.

Should a project of mine scale to the point of needing a fast functional
programming language for core functionality in the back-end, I'll be happy to
employ it there.

~~~
haliax
Completely disagree about Ruby on Rails, the experience of using happstack (
<http://happstack.com/index.html> ) blows it out of the water.

The RAM Cloud database is really natural to use; it eliminates problems like
object-relational mismatch and SQL injection by letting you do everything in
idiomatic Haskell.

Plus, the type-system, monads, and algebraic datatypes make it much easier to
write clean, correct code. Albeit, only once you've passed the learning curve.

~~~
mobileman
That learning curve is the problem. Building a business ultimately requires
people to be cogs at some level.

------
glassx
"programming did become fun again when I started using functional programming
as my main paradigm"

That's exactly what happened to me.

Even though I mostly program in C# (at work) and Ruby (for personal projects)
these days, my code and my team's is full of functional idioms, mostly thanks
to LINQ, lambda support in C# and lazy evaluation (IEnumerable generators).

Now our code is much shorter, way more readable and much safer compared to
what it used to be. We avoid mutability and state changes (meaning, we don't
use mutable variables or flags), most functions are testable by themselves,
code reuse is much better, objects are much thinner, and even 17 old interns
are fluent on such idioms by now. In fact, most new hires already come with
LINQ experience, which is cool.

I don't know why the "fun" factor was increased so much, but it did for me. I
believe it is because we're forced to think in a straight, linear way that
produces the cleanest, safest code possible. It is like some kind of puzzle.
It's just like working in Haskell: you have to think before you code.

Well, also it helps a lot that mundane tasks such as calculating the largest
number in a list is reduced to list.Max()...

------
wccrawford
Some of us never thought it stopped being fun.

------
edoloughlin
I've been working on a Cloure project for a few months now and, as the article
says, it just felt natural to use the objects that came directly from the
(relational) database without doing any ORM-type manipulation. My years of
non-functional experience meant that I've had this niggling doubt that I've
been doing the right thing. It's nice to have some validation...

------
michaelochurch
I find C and C++ fun to _write_. The difference is that functional languages
make (50th-percentile) code fun to _read_. In C++ and Java, even 90th-
percentile is a bitch to read, hence people don't. At best, those responsible
for maintaining it will skim it. This is also why the "broken windows" pattern
(once things get ugly, people "hack" them and they get uglier) sets in so
rapidly in C++/Java projects.

Functional programming encourages beautiful code (although it certainly _can_
be ugly.) A consequence of this is that people, even if they're not skilled
enough to write pretty code, actually read code-- not because they need to,
because they want to-- and become better programmers as a result.

Functional programming, for a passionate programmer, refines the aesthetic
sense and 2-4 years of it will give most people the skill to be a passable
software architect (whether they are passable or great depends on talent IMO).
Not so with C++ or Java. You can spend 10+ years in those languages and get
really, really good at optimization but still have no aesthetic sense.

You also learn faster when using FP languages because you can _do_ more in
them. You get to see the consequences of your architectural decisions long
before the project goes multi-developer and is handed off to someone else or a
team.

Functional programming is not a great career move. It makes you a difficult
fit for 90% of jobs that are out there, and it makes a lot of people think
you're a hipster jackass. But it's rocket fuel for your skill as a programmer.

~~~
mobileman
I think this is one of the commentaries I've read on FP. I was a FP junkie and
DSL addict until I realized my business was going to fail because I couldn't
hire the right people at the budget I had.

It is why I'm an alcoholic now. Java makes me drink as I wait for Ocaml to be
main stream

------
earl
from the article: " as a Scala advocate, many developers complain to me that
the immature support for Scala in IDEs is a real blocker for introducing the
language in their Java environments. I understand the practical issue of
meeting this now-typical expectation of Java shops, but I actually don’t
really care. I seldom use IDEs anymore. My Scala code is so compact that I use
Emacs for it."

sUnless you happen to be doing greenfield development, this is a dealbreaker
-- I like using scala, but it has to call / manipulate the enormous api
surface from 1.5mm lines of existing java. And for that, I need tool support.

------
georgieporgie
I've recently started having fun (for the first time in years) tinkering with
Project Euler problems, writing C#, and playing with Arduino. Android looks
like it's going to be fun, but so far it's a lot of mucking around the huge
infrastructure they created, trying to figure out how to do what I want.

C++ is no longer fun for me.

