Ist Haskell für produktiven Einsatz geeignet oder eher nur eine Herausforderung für den Programmierer?

Michael E.

nachtfeuer schrieb:

nein nein, kein Bange, das erste K steht für Kann...

(das nächste mal schreibe ich wohl besser KBLKNVLLKNL)

KVLKNL: kann vor Lachen kaum noch lesen.

DHDAFG. HHDNK. (=> Das hast du aber fein gemacht. Hier hast du nen Keks.)

audacia

nix? schrieb:

werauchimmer.... schrieb:

Oder wenns um Threads geht, wie würde man sowas in Haskell programmieren?
http://doc.qt.nokia.com/4.6/threads-mandelbrot.html
Kann jemand die RenderThread::run-Methode in Haskellcode schreiben und erklären, wie sie dann einfach parallelisiert werden kann?

Kann das keiner?

Die Frage ist eher: hat irgendjemand die Bemüßigung, extra für dich seitenlangen Quelltext zum Spaß nach Haskell zu übersetzen, anstatt seinem Tagwerk nachzugehen?

knivil

werauchimmer.... schrieb:

Oder wenns um Threads geht, wie würde man sowas in Haskell programmieren?
http://doc.qt.nokia.com/4.6/threads-mandelbrot.html
Kann jemand die RenderThread::run-Methode in Haskellcode schreiben und erklären, wie sie dann einfach parallelisiert werden kann?

Ich muss sagen, schoen eingefaerbt und multi-threaded: http://hackage.haskell.org/package/hfractal
Andere Links zum Thema: http://gregheartsfield.com/fractal-hs/ oder http://web.cecs.pdx.edu/~mpj/pubs/composing-fractals.html

hmm - ich sehe beim Mandelbrotviewing jetzt aber nicht sofort den spezifischen Vorteil der Verwendung von Fun.Prog. - ?

meine mandelbrot-viewer in C/C++ ohne/mit X11 Ausgabe sind nicht so viel länger evtl sogar kürzer (228 Zeilen für 2D-Ausschnitte der 4D-Mandelbrotmenge (Quaternionen) mit Fileausgabe ohne X11), wahlweise parallelisiert mittels

#pragma omp parallel for schedule ... // openMP

ich seh' gerade, mein C/C++ Programm ist großzügig kommentiert

ohne Kommentare sind's nur 151 Zeilen, eine Funktion für die Berechnung von ganzen Bilderserien (Variation der quaternionischen j-Koordinate) schon mitgezählt.

Mr. N schrieb:

Es hat in Haskell viele Abstraktionen, die in C++ undenkbar wären. Ich versuche ja auch in C++ möglichst abstrakt zu programmieren, aber Haskell bietet da nochmal deutlich mächtigere Tools.

Es ist wahrscheinlich schwer, dafuer Beispiele anzugeben, aber faellt dir gerade was ein? Rein aus Neugier, nicht weil ich dagegen argumentieren wollen wuerde.

knivil

zum Beispiel schrieb:

ohne Kommentare sind's nur 151 Zeilen, eine Funktion für die Berechnung von ganzen Bilderserien (Variation der quaternionischen j-Koordinate) schon mitgezählt.

Dann messe dich mit http://www.bestinclass.dk/index.php/2009/10/brians-functional-brain/ oder http://blog.willdonnelly.net/2009/10/14/brians-purely-functional-brain/ .

asddd schrieb:

Es ist wahrscheinlich schwer, dafuer Beispiele anzugeben, aber faellt dir gerade was ein? Rein aus Neugier, nicht weil ich dagegen argumentieren wollen wuerde.

Z.B. Der ganze parallele Kram in Haskell.

knivil schrieb:

Dann messe dich mit http://www.bestinclass.dk/index.php/2009/10/brians-functional-brain/ oder http://blog.willdonnelly.net/2009/10/14/brians-purely-functional-brain/ .

kein problem - meine C/C++ Version ist 45 Zeilen lang, inklusive X11 Ausgabe im Fenster und Parallelisierung.

g++ foo.c -o foo -O3 -fopenmp -lX11 -lm

Starte ich meinen 45-Zeiler, kann ich im gnome-system-monitor schön sehen, wie die Lastkurven für alle 4 CPU cores auf 100% gehen, während die Zellularen Muster herumschwirren ...

hier das Wesentliche:

int main(int argc, char* argv[]){
  d = XOpenDisplay(NULL);
  if(d == NULL) return(1);
  s = DefaultScreen(d);
  bp = BlackPixel(d, s);
  wp = WhitePixel(d, s);
  r = RootWindow(d, s);
  w = XCreateSimpleWindow(d, r, 0, 0, W, H, 1, bp, wp);

[...]

  while(1){
  #pragma omp parallel for schedule(dynamic, 1) private(r)
  for(y = 0; y < H; y++){
    for(x = 0; x < W; x++){
      n = ison(O[((y+1)*W+x) % (W*H)]) + ison(O[((y-1)*W+x) % (W*H)]) \
        + ison(O[((y)*W+x-1) % (W*H)]) + ison(O[((y)*W+x+1) % (W*H)]) \
        + ison(O[((y+1)*W+x-1) % (W*H)]) + ison(O[((y-1)*W+x-1) % (W*H)]) \
        + ison(O[((y+1)*W+x+1) % (W*H)]) + ison(O[((y-1)*W+x+1) % (W*H)]);
      i = y*W+x;
      switch(O[i]){
      case 1: N[i] = -1;
      case -1: N[i] = 0;
      case 0: N[i] = n == 2? 1:0; }}}

[...]  

  for(y = 0; y < H; y++){
    for(x = 0; x < W; x++){
      if(N[y*W+x]) XSetForeground(d, gc, wp);
      else XSetForeground(d, gc, bp);
      XDrawPoint(d, w, gc, x, y); }}
    XFlush (d); }
  XCloseDisplay(d); }

... die restlichen 17 Zeilen sind hauptsächlich Variablendeklarationen und Erzeugung eines zufälligen Musters als Anfangszustand.

und da die 4 Zeilen

n = ison(O[...]) + ison(...) + ...

eigentlich eine 3-mal fortgesetzte zeile darstellen, komme ich genau genommen auf 42 Zeilen

knivil

In der Clojure- bzw. Haskell-Variante sind "includes" und Leerzeilen mitgezaehlt worden. Dabei war die Zeilenlaenge auf 80 Zeichen begrenzt. Es wurde eine uebliche (uebersichtliche) Formatierung eingehalten. Dort ist auch ein SDL-Eventloop enthalten, der auf SDL-Quit reagiert. Es werden Rechtecke gezeichnet und nicht nur Pixel. Auch koenntest du deine Version zum Download anbieten ...

no tricks - ich zähle alles mit! - auch #includes, und die längste Zeile ist 75 Z. lang, im Durchschnitt 30 Zeichen/Zeile

... die 28 wesentlichen zeilen stehen ja schon da, und viel mehr ist nicht dran außer paar Deklarationen und einer for-Schleife für einen zufälligen Anfangszustand ...

#include <stdlib.h>
#include <X11/Xlib.h>
#define w 256
#define h 256
#define isOn(c) (c == 1? 1:0)
Display* D;
Window W;
GC gc;
int s, bp, wp, i, n, 
[...]

knivil

Ich wuerde es gern ausprobieren ..

ich bin jetzt durch ein paar umstellungen bei 37 Zeilen C/C++ angelangt (34 zeilen, wenn man die verlängerte Zeile als einzelne zählt) - nach wie vor gilt: nur 1 Anweisung pro Zeile, und alles ist mitgezählt.

ich würde das 37 Zeilen-Programm ja posten, habe aber im Augenblick leider nicht die Zeit, mich detailliert in die diesbezügliche rechtliche Lage einzuarbeiten (copyright, Haftungsfragen, Lizenz usw.)

ich würde das 37 Zeilen-Programm ja posten, habe aber im Augenblick leider nicht die Zeit, mich detailliert in die diesbezügliche rechtliche Lage einzuarbeiten (copyright, Haftungsfragen, Lizenz usw.)

Was für Probleme sollte es denn da geben? Oder ist das nur ein billiger Vorwand?

ich bin jetzt durch ein paar umstellungen bei 37 Zeilen C/C++ angelangt

Wenn du so weiter machst, hast du bald einen Einzeiler...

ich meine disclaimer usw. - ist mir jetzt zu viel Aufwand für 37 Zeilen, das wasserdicht abzuklopfen. Vllt wäre der Disclaimer dann 10 x länger als das Programm

Ich habe fast alle zeilen schon gepostet, das bisschen was fehlt, sind ein paar augenfällige Variablendeklarationen

int O[W*H], N[W*H];

und eine Schleife, die das Array O (=old) mit einem Zufallsmuster als Anfangszustand

float rnd = (double)rand() / (double)RAND_MAX;
    O[i] = rnd < 0.2? 0:1;

vorbelegt.

Sonst noch was, was gut mit Funk.Prog geht ?

ich meine disclaimer usw. - ist mir jetzt zu viel Aufwand für 37 Zeilen, das wasserdicht abzuklopfen.

Du brauchst doch keinen Disclaimer, wenn du hier ein bisschen Sourcecode postest. Macht doch sonst auch keiner...

otze

zum Beispiel schrieb:

Sonst noch was, was gut mit Funk.Prog geht ?

Schreib dein programm erstmal so, dass es die selbe funktionalität liefert. zum beispiel haste die sterbenden Felder nicht gezeichnet die in der original Implementation gezeichnet werden.

Felder mit Wert -1 (dying) werden doch gezeichnet:

if(N[y*W+x]) XSetForeground(d, gc, wp);

frosch03

Oh man, ihr redet hier über Haskell, und ich habs schon fast wieder übersehen

Ich liebe Haskell, aber man muss schon auch feststellen, das Haskell momentan
nicht für den alltäglichen Einsatz geeignet ist. Damit Joe-Programmer
glücklich wird, braucht er einen Benutzungsoberfläche und diese mit Haskell zu
erstellen ist Pain!

Und wenn Joe-Programmer irgendwo Code produziert, der zwar Compiliert, aber
halt doch nicht tut was er will, dann braucht er einen Debugger. Auch das ist
in Haskell ein dickes Manko.

Allerdings darf man ein's nicht vergessen: Dass eine Sprache Turing-Complete
ist, bedeutet, dass man alle "lösbaren Probleme" mit selbiger Sprache auch
theoretisch lösen kann. Nur ist das im Zweifel unendlich schwer.

Niemand würde behaupten, dass man in Brainfuck ähnlich gut Coden kann, wie
z.B. in C/C++, nur weil auch Brainfuck Turing-Complete ist. (Siehe hierzu:
http://www.paulgraham.com/avg.html) Und in diesem Sinne ist Haskell
deutlich mächtiger, als der ganze Rest.

Übrigens finde ich es total gut, dass Haskell nix für den durchschnittlichen
Programmierer ist. Man stelle sich mal vor was von Haskell übrig bleiben würde,
wenn es von einer Horde Kompetenzsimulanten überrannt werden würde, wie es einst
mit Java gesehen ist

in diesem Sinne, :p
frosch03