<html>
<head>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-1">
</head>
<body bgcolor="#FFFFFF" text="#000000">
Yep, I'm verbose in my questions. I put the core question(s) in
bold. Everything else is elaboration for clarity.<br>
<br>
<b>- How interactive and "live" can GHCI make Haskell? What are the
limits?</b><b> By "live", I mean on-the-fly coding.<br>
<br>
</b><b>- Would it be possible to make a Haskell plugin for something
like the Light Table IDE even if it required some
behind-the-scenes trickery?</b><b><br>
<br>
</b><b>- How dependent is Haskell's interactivity on it's structure
as a language and how much of it is dependent on the given
compiler?</b><b> Is it that GHC could never provide on-the-fly
coding or is it that the idea of highly interactive coding is
completely incompatible with the core principles that make Haskell
work? (static type system vs. dynamic type system)<br>
<br>
</b><b>- Could GHC/GHCi be used or extended to provide a more
functional reactive Haskell similar to Elm such that you could
play with your code the same way you can with SuperCollider or
Chuck?</b><br>
<br>
By interactive, I mean that the language allows for the programmer
to edit the program's source as it's running and see the results of
the edit play out in the current running session without having to
restart the program. A lot of languages use this for debugging
(GHCi), but I know that this feature is typically very limited
unless you have a dynamic, reactive, and/or interpreted language.
There seems to be many tricks out there for at least giving the
illusion of "live coding" such as interpreting the files being
edited and leaving everything that's not dependent on it compiled.
I've also read about having the compiler and interpreter actively
dance around each other in the source, with the interpreter managing
the files that were recently edited, providing the slow but
interactive functionality with only the code local to the
programmer's current activity, and the compiler recompiling files
after they've been left alone for a while. I totally don't know what
I'm talking about here with regard to compiler behavior, but is this
interactive behavior even possible with GHC/GHCI given how much
optimization takes place at compile time? Can you cherry pick like
that? Can you even distinguish between files anymore once it's been
melted down into C--? I'm really taking to Haskell for general
purpose programming and I'm finding little to complain about, but
there is one thing that Haskell lacks in that other expressive
high-level languages like Lisp, Python, and Ruby seem to have.
Interactivity. I like that Haskell has both a good compiler and a
nice interpreter, but I don't know whether (in the future) the two
could work together to provide GHCI's human-centric interactivity
with GHC's computer-centric optimization. Can I have good
performance and eat my cake too?<br>
<br>
I was incredibly inspired by the prototype of the Light Table IDE
project that got funding recently. I, like many, really liked how it
gave very quick feedback in multiple ways to what you are doing.
That helps me tremendously and its probably the most powerful
feature a language could ever include imo. I have no doubt that such
a project can become a successful reality, but the language that
Light Table was performing this interactivity with was Clojure and
it seems like only dynamic interpreted languages will work. Is
Haskell, despite its differences from Lisp and the fact that it is a
mostly compiled language, disqualified from granting the coder a
true interactive environment? GHCi is REALLY powerful and helpful in
this regard, but it seems limited to a debugger and a useful tool
for tutorials.<br>
<br>
I'm asking this because Haskell seems to have everything I would
want in a language that is not C. The only competitor to it as a
functional language, in my opinion, is Lisp because of this
interactivity. Haskell seems to be doing everything right as a
modern, high-level, functional language, but it would be perfect
(for me) if it further reduced the barrier between the coder and the
code by supporting this interactive paradigm. Interactivity is a
killer feature for me and I love things like the friendly
interactive shell for their focus on it.<br>
<br>
I've used Vim plugins before for compiled languages where my changes
were automatically compiled as I made them and a live preview
presented after each compilation. In this sense, I know that
virtually any language can act like you are directly affecting your
software during run-time, but I'm talking about the sweet spot
between that fake method and something like SuperCollider where
musicians can modify their code in real-time as their code runs in
real-time and not suffer from any interruptions or sudden delays -
the source language is the same language that you use to interface
with it. I think this is the ideal way to program and I believe it
is an important feature for any language that aims to serve the
human and not the machine.<br>
<br>
I want to use Haskell's high-level, expressive, and modular language
as the way to play with the code I've written. Whether it's for
debugging, experimentation, scripting, or learning and exploring. If
this is possible (even if it's just theory and speculation for now),
Haskell will be that language that lets me code the way I want to.<br>
<br>
Sorry for the long message, I didn't want any ambiguity to my
question.<br>
- Michael<br>
<br>
<br>
</body>
</html>