[Haskell-cafe] Backward compatibility

[Adrian May]

Well I'm enormously grateful to Niklas for fixing those two things. Simon
was right that people are very supportive around here.

Even though I've been advised against WASH already, it seems important to
fix that stuff because it's a liability to Haskell to have broken code
kicking around where people might find it. I found flippi just by googling
for "haskell wiki engine", in fact I think I was pointed there by
wikipedia, and there's nothing on the WASH page to warn anybody. So it's
great that Niklas fixed it, thereby preventing impressionable people from
having a Rails-day like I did.

But is it correct to extrapolate from the fact that people like you can fix
it in 5 and 75 minutes, that everybody else can and that's how industry
should calculate its maintenance costs? You guys all know a hell of a lot
more about Haskell than I do, but I've been playing with it for a few years
now, and I never met anybody independently of Haskell who had even heard of
it.

On 3 May 2013 16:44, Ertugrul Söylemez <es at ertes.de> wrote:

> If it's your decision, you shouldn't be afraid to make it.  You are the
> manager of your team!  Don't let yourself be stabbed by another manager.
> Recognize that your choice can lead to higher productivity


Middle management in big companies isn't really about minimising
maintenance costs, or even getting anything done. It's about
building yourself a botnet of colleagues you can trigger to DDoS one
another. You don't need much of a trigger: it's the timing that counts:
every bot has to perceive the attack to be already underway and successful
by the time you trigger them. Then they'll be grateful that you pointed out
something they hadn't noticed before, after all, they wouldn't want to
screw up with any other bot. The main reason you'd want to DDoS somebody at
all is so that all your bots know the network is operational and that
they're safer on the inside. That's why most managers spend more time
trying to sabotage one another's projects than doing anything useful
themselves, and why the most useless of them always wind up at the top.

It's in that context that I'd like you to try and imagine why my priorities
might be different from yours. Please don't say that it's my culture's
fault. That would be true, but it wouldn't be helpful because if nothing
improved in the last 3000 years it probably won't in the next 3000 either.

Whether a manager wants to behave in this Machiavellian way or not, he'd
better assume that he's surrounded by botnets that want him on the inside.
If he has any aspirations to keep both his job and a modicum of autonomy,
he wouldn't want to give them a trigger on a plate. Backward compatibility
is a very potent trigger because everybody knows what it means, and it
would be potty to imagine you could convert somebody else's botnet into
mutinying against the controller with the notion that backward
compatibility doesn't matter. Referential transparency is not a very good
defence because nobody knows what you're talking about.

Take a guess how fast I can hire programmers here in Taiwan: about once
every 3 months. I turn down 90% of applicants cos I know they'd waste more
of my time than they save. I'm talking about the kind of people who can
spend a whole week wondering why the bug never changes before I come along
and ask them if they're even editing the right file. It's not obvious to
people in my position why writing a coding standard that says "nobody is
allowed to write anything that a monkey wouldn't understand" is a bad idea.

Hopefully I've now shown that I must be nuts to be interested in Haskell at
all. So why am I? Well I described my OP as a lullaby, not a rant. If you
want to hear a rant, ask me what I think of imperative programming. Last
time I saw an 8 million line project land in the bin, I could have said
that I'd told them so 2 years earlier, but instead, I actually shed tears
for all the developers who'd been stuck in that office til 11 every night,
chasing bugs around in circles that could never be fixed. For the guy who
was publicly humiliated for giving a presentation about how to track a bug
down through all that spaghetti and then fix it by wrapping "if (p!=NULL)"
around the crash instead of wondering what was null or why, when in all
fairness, that was the only thing any of them ever did. For that whole
quirky culture that refers to bugs by a six-digit ID beginning with 3, and
that doesn't lose it's cool even after two months unable to even build the
thing, followed by another two when it can't make it to the idle screen
without crashing. Of course I knew it would be pointless to ask those
self-satisfied architects if they'd finally figured out that it wasn't
smart to riddle the build system with cyclic dependencies so the testers
didn't even know what they were testing, or to chop the whole thing into a
guzzillion separate pseudo-processes so every debugger would spend 90% of
his time trying to single-step over those asynchronous interfaces. Did they
fail? I'm afraid not. The controllers just rounded up their best bots,
found another venture capitalist and proudly boasted about how they'd
turned 2 million lines into 8 in only two years. How would the VC know to
ask why they needed all those lines if no new features were coming out?

You thought I was pissed off with Haskell? Oh no. That's not what I'm
pissed off about.

But I'm still not crazy enough to start a project at work in Haskell: what
I'm debating is whether or not to give people a few presentations and a few
hours in the week to study your language in the hope that it will improve
their imperative code, plant a seed of suspicion that OO might not be the
last word, nurture a healthy fear of data, and perhaps one day take over
Haskell stuff that I might foolishly dare to write for the company. This
language has got an important message for the world, and the reason I'm
trying to tell you guys this stuff is that I want it to get through.

Once they sent a security consultant to lecture us about how to avoid
writing vulnerabilities through which people could jailbreak their phones
from the network. Towards the end of the day when he'd explained how buffer
overflows work, he dropped "using a language other than C/C++" into his
list of possible remedies. The whole room was immediately filled with
uproarious laughter. I have to go at this gently and ensure that the carrot
looks bigger than the stick at all times. And I can't make myself
vulnerable to easy pot-shots about backward compatibility or anything else.

So what would their first impression be? They'd be dazzled but scared.
***Please bear in mind that if I scare a report by making him feel that his
job security depends on him learning something new or taking more
responsibility, then he's liable to throw a tantrum and plot against me in
self defence.*** If most of his colleagues also think I'm crazy to be going
on about this offbeat language, then I'm toast. At the beginning they'll
spend a lot of time feeling humiliated by it always saying No, and there'll
be a strong tendency for them to say:

    "It's not my fault: none of the examples on the web work either, and
not even Adrian can make them work."

At that point I look like an idiot and Haskell at that company will be
caught in the crossfire of my assassination. That's why breaking old code
is best avoided (as long as it doesn't conflict with progress) especially
in a world where lots of unmaintained stuff is still on the web.

That's why I'm very grateful to Niklas for fixing that prehistoric code.
And why I think it's better only to deprecate things if you really need to.
Does that make me ultra-conservative? Where I work, conservative is when
you're still worried about how long it takes to dereference a virtual.

Do you finally see where I'm coming from? If you want this language to
catch on, you have to think about programming the people, not just the
computers. You could also just soldier on as a brilliant microculture until
you get swamped by something like F# that's not even where you were in 98,
and one day people will tell you "Haskell? Monads? That's not what I mean
by FP. FP is something like F#." (Apologies to anybody who works on F#: my
issue with it is that nobody I know is likely to figure out the functional
way to do something if it's that easy for them to bottle out and do it the
imperative way.)

Maybe that is the new plan. Maybe Haskell already gave up wanting to be
anything but a research platform. Maybe you guys calculate that if I really
want to push FP I should be pushing some hybrid like F# or Ocaml. Remember
how C++ succeeded where Smalltalk failed because it sneaked the changes
under the table instead of calling for revolution. If that is the plan then
I'd appreciate somebody putting me in the picture. Otherwise, please try to
understand that the problems I'm up against are not about whether Num is
derived from Eq or whatever.

mfG,
Adrian.




On 4 May 2013 02:33, Niklas Hambüchen <mail at nh2.me> wrote:

> All right, here you go: https://github.com/nh2/WashNGo
>
>
> https://github.com/nh2/WashNGo/commit/08010e7404219470a827f3e4172004f9d2aedc29
>
> Took me around 75 minutes.
>
> Think about it a bit:
>
> I just ported thirty thousand lines of code that I have never seen
> before and that has bit-rotted for over six years to the latest
> programming environment.
>
> It being Haskell, I am pretty confident it does *exactly* what it's
> supposed to do.
>
> I want to see anyone do that with an equivalently sized + outdated Ruby
> / Python project.
>
>
> On 02/05/13 13:27, Adrian May wrote:
> > I just tried to use Flippi. It broke because of the syntax change so I
> > tried WASH. I couldn't even install it because of the syntax change. I
> > persisted for a while but gave up because getPackageId doesn't exist in
> > any form at all anymore. This was only the install script: what would
> > WASH itself have in store for me to get my brain around?
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20130504/4579e89a/attachment.htm>