vapid haskell sociology research question

when was the first time in using Haskell that you had the feeling
"wait a second, the code i just wrote to do what i want is to concise,
i can't possibly be done yet!" because of the old instincts you had
from more wordy languages? how long before you shook it off? :-)

raould <raould@gmail.com> writes:

> when was the first time in using Haskell that you had the feeling
> "wait a second, the code i just wrote to do what i want is to concise,
> i can't possibly be done yet!" because of the old instincts you had
> from more wordy languages? how long before you shook it off? :-)

I'd already visited things like ML and Lisp before I got to Haskell - ML
may have been the first language I used that had much type inference - I
think the larger surprise with Haskell for me was sometimes when I would
express things a bit optimistically in terms of what I thought it could
usefully compile, with the intent of seeing what the errors were and
letting them guide me, except the program would already compile and it
would turn out I could get away with the things I'd hoped but not
expected to get away with. For instance, the first time I wrote
something that exploited lazy evaluation to read something in one pass
that had forward references whose definition got resolved afterward
through laziness, I was rather pleased. Similarly, I was rather pleased
to be able to get away with writing things like,

http://www.haskell.org/pipermail/has...st/017065.html

and lately I have been happy to be able to write things like, say, a
recent function with a signature of,

doThing :: Class a b => a -> [b] -> Datatype

where I could make awkwardness about instances go away by arranging some
other things accordingly, to let me easily have a homogeneous collection
of things that were made from heterogeneous things, and it worked.

One thing I like about Haskell is it feels clean: for the level of
language that it is, I don't often run into what feel like simple things
that take a lot of semantic scaffolding to express compilably. I've
liked things from 6502 assembler to Modula-3 because while it might take
a lot of typing of text to get anything done, they still felt
semantically quite clean. Whereas, with Java, I hate it partly because a
lot of the boilerplate I need is semantic stuff I have to build between
what I want and what can be compiled. (Unlike many) I don't mind verbose
syntax, what I hate is when I have to put many actually meaningful
things in that feel like they're not the point of what I was trying to
express, they're about trying to placate the language's way of doing
things.

Mark

> liked things from 6502 assembler

oh my gosh, i so enjoyed doing 6510 on my C64 with Ocean's Laser
assembler [1] and Scanlon's book [2].

[1] http://nuclide.com/people/Luc/archives/2005/05/14/

[2] http://www.bugbookcomputermuseum.com...areDesign.html

> full-fledged server daemon needs to have, including multithreading.
> The code was about 10 lines in length, it was elegant and well
> comprehensible.

might you still have said code & be willing to post it? reading other
folk's interesting (but small so i don't get overwhelmed) haskell
might be good training for me.

sincerely.

On Tue, 21 Oct 2008 16:32:22 -0700, raould wrote:

>> liked things from 6502 assembler
>
> oh my gosh, i so enjoyed doing 6510 on my C64 with Ocean's Laser
> assembler [1] and Scanlon's book [2].
>
> [1] http://nuclide.com/people/Luc/archives/2005/05/14/
>
> [2] http://www.bugbookcomputermuseum.com...areDesign.html

So did I. I still have my (working) C64, the HEXMON cartridge, and
somewhere I think I've got the MOS Technology 6502 book. The 6502/6510
was an amazingly powerful chip for its day, and lots of fun to program.

AHS

Arved Sandstrom <dcest61@hotmail.com> writes:

> So did I. I still have my (working) C64, the HEXMON cartridge, and
> somewhere I think I've got the MOS Technology 6502 book. The 6502/6510
> was an amazingly powerful chip for its day, and lots of fun to program.

Yes, I had a lot of fun with the C64 too. (And the BBC Micro, but the
nice thing with the C64 is you could also program the diskette drive,
etc. separately.) Odd coincidence. (-: I assume that now I could find
online convenient collections of things like call points into the BASIC
interpreter for getting things like floating point arithmetic done.
Years ago I instead had to have all sorts of scattered notes from things
printed in magazine articles and the like. It'd be fun to have a job
doing 6502 programming again.

While 6502 assembler and Haskell may both seem very different, I guess I
like them both because they both fall at nice points on the tradeoff
between simplicity and power.

Mark