[Haskell] Improvements to GHC

[Greg Woodhouse]

(Sorry about replying at the top. This web interface doesn't seem to want to let me do otherwise.)
 
I was just reading Wadler's article "How enterprises use functional languages, and why they don't" when your message came through. A definite "must read" for anyone wanting to promote the use of Haskell, IMO.
 
Just a couple of thoughts: An easily installable integrated development environment is a must. I understand I was fortunate in getting GHC to compile on the first try (but I "cheated" and used DarwinPorts to download and compile it under OS X -- it worked beautifully, but took forever). Another issue is training. I can go to the bookstore and pick up books on Scheme or Common Lisp, but I had to send away for a Haskell text, and am still finding it a challenge. I think of myself as a pretty quick study when it comes to programming languages, but wrapping my head around the monad concept (to my satisfaction, anyway) is still proving quite a challenge. The mechanics aren't the problem: it's the intuition. I think Einstein once said that if you can't explain something to a school child, you don't really understand it. How do you explain monads to a school child? What about examples of real projects? Anyone that is interested can download source for open source projects and see C or Perl
 or Java in action. For people that learn best by example, where do they start with Haskell? Oh, and there's another big one: databases. I work in medical record systems, which means large highly transactional databases. One of the reasons I'm jumping so quickly into the monad concept is that I had been thinking about is a method of structuring database applications. The three big questions that come to mind when I think about Haskell (or any new language) are: How do I program TCP/IP? How do I program databases? and, How do I program graphical user interfaces? 

John Lask <jvlask at hotmail.com> wrote:
I would like to sound out the Haskell community on what the feeling are most 
desirable to improve the "commerciality" (i.e. its general use) of ghc and 
Haskell in general (as distinct from feature set)

my pick would be to

1) GHC runtime to be dynamically loaded.
Enable the ghc runtime system to be loaded as a shared object/dll 
rather than being statically compiled in.
I think the reason this has yet to be done is because it is a rather 
tricky issue, perhaps
those in the know can comment.

2) Improving Haskell support for records.
There has been much discussion over the years, some experimentation, 
but which alas has
amounted to no change or improvement in Haskell record support. Again 
in my opinion the area
that Haskell compares least favourably with other languages is in the 
area of record support particularly
a) no distinct namespace for record fields
(forcing people to resort to the module system to resolve name 
space clashes)
b) subclassing on records would be great.

All these things have been discussed before. The most important is (a) 
as it would obviate some of the
tortured coding that currently appears in many Haskell modules. 
Additionally

c) first class labels would be nice

3) Macro / conditional compilation / compiler meta language / additional 
binding forms
These are perhaps distinct issues but can be discussed together.
The prevalent use of #ifdef and the cpp is indicative of the general 
need to have some standard means by
which differences between compilers ghc/hugs/nhc can be accommodated for 
in the source code.
To date this issue has not been tackled in any meaningful way, perhaps 
we can continue
to use cpp but for the sake of portability

A means of defining additional binding forms would be nice as it would 
further facilitate embedded dsl
for which Haskell is pre-eminent, and which use is a great motivator 
for venturing into
Haskell in the first place.

4) Taking up the issue of portability and byte codes in a recent thread.
The lvm used in the helium compiler perhaps offers the opportunity of 
defining a standard
Haskell byte code platform which other compilers can target for 
instance ghc/hugs
(hugs has in its code base the possibility of writing out a compiled 
form aka compiler)
- thereby separating the compile time and run time platforms, providing 
a standard Haskell target platform.

_______________________________________________
Haskell mailing list
Haskell at haskell.org
http://www.haskell.org/mailman/listinfo/haskell



===
Gregory Woodhouse  <gregory.woodhouse at sbcglobal.net>



"Einstein was a giant. He had his head in the clouds and his feet on the ground."

-- Richard P. Feynman









-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org//pipermail/haskell/attachments/20051116/587a62b6/attachment-0001.htm