February 2010 - Haskell-Cafe

Virus alert while installing happstack
by Maciej Podgurski 15 Feb '10

15 Feb '10

Hi, I tried to install happstack via "cabal install happstack" on my WinXP system. While installation progress, my anti-virus software (Avira AntiVir) warned me about dll_hsc_make.exe and files_hsc_make.exe to be a Trojan horse called "TR/Dropper.Gen". It's a bit confusing to get a virus alert while installing Haskell packages. Has anyone experienced this problem? And can I trust these files to be harmless? Besh wishes, Maciej

4 3

performance issue and HGL
by Vojtěch Knyttl 15 Feb '10

15 Feb '10

Hello, I've created a simple Mandelbrot set generator, using HGL, the source is viewable at: http://pastebin.dqd.cz/cUmg/ 1. The problem is, that it is very slow. It is obvious that what takes the most time is the "mandel" function computation. I have no idea, how it can be improved. 2. What is the easiest way of changing a color and plotting a pixel with it? Do I always have to "create a pen" for it? Isn't there a simple way? Already – using a line to plot a pixel is probably not the best way… Thanks

2 1

running HGL on OSX
by Vojtěch Knyttl 15 Feb '10

15 Feb '10

Hello, I am having difficulties running HGL on Mac OSX, Snow Leopard. Here is what I've done: –– 1. Installed X11 for OSX ("About" dialog says: The X Window System, XQuartz 2.3.4 (xorg-server 1.4.2-apple45)) –– 2. Got X11 from Hackage – configured, built and installed – however, there where quite a lot of warnings: … [ 8 of 25] Compiling Graphics.X11.Xlib.Color ( Graphics/X11/Xlib/Color.hs, dist/build/Graphics/X11/Xlib/Color.o ) Graphics/X11/Xlib/Color.hs:38:0: Warning: The import of `Foreign.C.Types' is redundant except perhaps to import instances from `Foreign.C.Types' To import instances alone, use: import Foreign.C.Types() [ 9 of 25] Compiling Graphics.X11.Xlib.Font ( dist/build/Graphics/X11/Xlib/Font.hs, dist/build/Graphics/X11/Xlib/Font.o ) Graphics/X11/Xlib/Font.hsc:167:1: Warning: A do-notation statement discarded a result of type CInt. Suppress this warning by saying "_ <- xTextExtents font_struct c_string (fromIntegral nchars) direction_return font_ascent_return font_descent_return overall_return", or by using the flag -fno-warn-unused-do-bind … and so on. –– 3. Got HGL package, built and installed with some warnings like: … [ 1 of 27] Compiling Graphics.HGL.Internals.Flag ( Graphics/HGL/Internals/Flag.hs, dist/build/Graphics/HGL/Internals/Flag.o ) Graphics/HGL/Internals/Flag.hs:1:0: Warning: Module `Prelude' is deprecated: You are using the old package `base' version 3.x. Future GHC versions will not support base version 3.x. You should update your code to use the new base version 4.x. … –– Now, when I try to run simple program like: main = runGraphics $ withWindow_ "Hello World Window" (300, 200) $ \ w -> do drawInWindow w $ text (100, 100) "Hello World" drawInWindow w $ ellipse (100, 80) (200, 180) getKey w it says: $ ghci graphics.hs GHCi, version 6.12.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Loading package ffi-1.0 ... linking ... done. Ok, modules loaded: Main. Prelude Main> main Loading package syb-0.1.0.2 ... linking ... done. Loading package X11-1.5.0.0 ... can't load .so/.DLL for: X11 (dlopen(libX11.dylib, 9): image not found) Prelude Main> Just to precise, I have X11 running (it can be seen in the OSX dock) Thanks

2 2

Using Cabal during development
by Limestraël 14 Feb '10

14 Feb '10

Cabal/cabal-install are good tools for distribution and installation, but I was wondering -- as I was starting to learn how to use Cabal -- how do usually Haskell developpers build their softwares (and especially medium or big libraries) while they are still developping them ? With cabal-install, by doing one 'cabal configure' once and 'cabal build' each time they have altered their code ? With only Cabal, through some 'runhaskell Setup.hs build's ? The point is that I am currently writing a binding for an SDL-like library called SFML. My project is now 55-file wide (and I will have to add some more), uses hsc2hs and has a little executable (for testing purposes) in which I add some code each time I add functionnalities to my binding. What I mean is that it would be a pain to have to compile it by hand whenever I add something to my code. Currently, I compile it by using a simple shell script, but it's a little bit lousy, I think. -- View this message in context: http://old.nabble.com/Using-Cabal-during-development-tp27515446p27515446.ht… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

16 26

pandoc code bocks not working
by Anatoly Yakovenko 14 Feb '10

14 Feb '10

i am getting these failures with pandoc, or maybe i am not using markdown correctly 1. hello world ~~~~~~~~~ code block failed ~~~~~~~~~ * hello world ~~~~~~~~~ code block failed ~~~~~~~~~ * hello world clode block failed hello world =========== ~~~~~~~~~ code block ok ~~~~~~~~~

1 0

ANN: wyvern, a Dragon Go Server "client"
by wagnerdm＠seas.upenn.edu 14 Feb '10

14 Feb '10

I've just done the first release of wyvern [1], a small program to play moves for you on the Dragon Go Server [2], along with point releases for two supporting libraries. On DGS, people play many games of go simultaneously, making only one move per day in each game (about). A commonly requested feature is the ability to specify several moves in advance, and have them be played automatically whenever the opponent logs in. Wyvern provides this capability, as well as the ability to program in advance several "branches" -- conditional on the opponent's move. Along with wyvern, I've been developing two supplementary libraries. The "dgs" library [3] is a very small wrapper around DGS' handy robot interface. The "sgf" library [4] is a parser for the SGF file format (used to store games of go) that strives to balance using the type system to enforce the construction of correct SGF trees against conveniently manipulating said trees. It was also something of an experiment for me in documentation writing -- I may have gone a little overboard. =) If, like me, you love to mix Haskell and go, I invite you to check out one or more of these and let me know what you think. ~d [1] http://dmwit.com/wyvern [2] http://www.dragongoserver.net/ [3] http://hackage.haskell.org/package/dgs [4] http://hackage.haskell.org/package/sgf

1 0

Atom Examples
by Tom Hawkins 14 Feb '10

14 Feb '10

On Sun, Feb 14, 2010 at 1:30 AM, Yves Parès <limestrael(a)gmail.com> wrote: > > I've been interested in using Atom since I saw this: > http://blog.sw17ch.com/wordpress/?p=84 > However those samples are very outdated, do you have newer ones? Unfortunately, no. I wish I had the time to write Atom examples and tutorials, but I don't. So in lieu of a tutorial, here's a few modules we use on our real projects -- with limited documentation. Arbiter.hs: A general purpose non-preemptive arbiter than implements Lamport's bakery algorithm. We use this to arbitrate multiple software components that need to use the CAN protocol stacks for sending multi-packet messages. This is a good example that illustrates some of the benefits of atomic state transitions rules. What I find interesting is it works without any centralized arbiter logic; notice there are no rule declarations in mkArbiter. ECU.hs: This is the hardware abstraction layer to our ECU. Nothing too interesting, but a good example of how to wire Atom up to external C code. Note the ECU record includes a bunch of expressions (E types) and variables (V types). The expressions form the inputs, like ADCs and discrete inputs, and the mutable variables form the outputs, such as PWMs and discrete outputs. It also provides hooks to send and receive CAN messages. EVU.hs: The eVU is a little display mounted on the dash. It presents the driver with information such as charge pressure, mode settings, and fault conditions. The ECU talks to the eVU via the CAN bus. This is a good example because it illustrates a common object-oriented pattern we tend to use all over the place: the object contructor (mkEVU) creates some state variables, defines rules for stuff to do, and packages the state variables into an abstract type, or object (EVU); then methods operate on this object. In the case of EVU, the object constructor defines variables for the things the eVU displays, and it defines a rule to periodically send this information to the eVU device via CAN. And the methods set the various display elements such as the active fault code (setCode), the accumulator pressure (setCharge), and the active mode (setMode). Sensors.hs: Sensor processing, which takes data from the hardware abstraction layer (ECU.hs). One interesting feature is the oil temperature sensor computation. Based on a 1-D lookup table the 'lookup1D' function searches the table for the corresponding points and performs interpolation. In C, this probably would have been written as a for-loop that would compute the lookup on every sample. But because change in oil temperature is much slower than the sample rate of the system, we only need to search one row of the table every 50 samples or so (i.e. with rules 'below', 'above', 'next', and 'found'). This effectively spreads out the computation over many samples, thus lowering the processing latency of every sample. Doing this type of time-sharing in C would be tricky. But in Atom, it's trivial. One of the many ways Atom benefits hard realtime programming. I hope this helps. -Tom

2 1

ANN: Dungeons of Wor - a largish FRP example and a fun game, all in one!
by Patai Gergely 14 Feb '10

14 Feb '10

Hello all, I just uploaded the first public version of Dungeons of Wor [1], a homage to the renowned three-decade-old arcade game, Wizard of Wor. While it makes a fine time killer if you have a few minutes to spare, it might be of special interest to the lost souls who are trying to figure out FRP. The game was programmed using the Simple version of the experimental branch of Elerea [2], which provides first-class discrete streams to describe time-varying quantities, and the main game logic is described as a composition of streams instead of a world state transformer. Developing in this manner was an interesting experience, and I'll write about it in more detail over the weekend. All the best, Gergely [1] http://hackage.haskell.org/package/dow [2] http://hackage.haskell.org/packages/archive/elerea/1.2.3/doc/html/FRP-Elere… -- http://www.fastmail.fm - The professional email service

7 10

ANN: atom-1.0.0
by Tom Hawkins 14 Feb '10

14 Feb '10

Atom is a Haskell DSL for designing hard realtime embedded software. The 1.0 release is meant to indicate some level of stability; most of the core has been unchanged for quite some time. That said, there are a few interesting changes in 1.0. First the var' family of variable declarations (bool', word8', double', etc.) are no longer part of the Atom monad. For example: bool' :: Name -> V Bool This cleaned up quite a bit of code in our production design. This also made the randomization in Atom's unit testing framework monadless as well. The other significant change with 1.0 is all state variables are now packed into a hierarchical C structure that matches the hierarchy of the Atom design. Not only does this make the generated C a bit more legible, it is now possible to interface external C code directly to Atom's state variables and arrays. Prior to this change, all interfacing had to be done through var' declarations and action calls -- too often a messy process. To further aid interfacing to external code, Atom now generates a header file that exposes both the iterative function and the hierarchical state structure. -Tom http://hackage.haskell.org/package/atom

3 2

hsWidgets: yet another GUI library
by Yuras Shumovich 13 Feb '10

13 Feb '10

Hello First of all, sorry my pure english... My aim was to prove that haskell GUI library can be: - pure: does not use any kind of mutable variables - statically typed: does not use existential types, Data.Dynamic, etc. - easy to use: simple things should be simple - easy to extend: writing new widgets should be as simple as possible The result is here: http://community.haskell.org/~YurasShumovich/hsWidgets/ Usage example: http://community.haskell.org/~YurasShumovich/hsWidgets/src/Test.hs The library is based on X11 and is tested on Linux and Mac OS. It is only an experiment in haskell GUI design, so it is mainly useless (currently only label, button and button with label are implemented) and looks ugly. Your comments and ideas are highly welcome.

1 0