News aggregator

Call For Presentations: Compose 2016, New York,Feb 4-5

haskell-cafe - Wed, 11/18/2015 - 4:01am
Compose is a conference for typed functional programmers, focused specifically on Haskell, OCaml, F#, and related technologies. It will be held in New York on Thursday and Friday, Feb 4-5, 2016. Registration will be open shortly. To get a sense of Compose, you can check out the great talks from the 2015 conference: Below is our call for presentations. We recognize the deadline is tight, so feel free to submit proposals and ideas on the less-polished side. * * * The audience for Compose is Haskell, OCaml, F#, or SML developers who are looking to increase their skills or learn new technologies and libraries. Presentations should be aimed at teaching or introducing new ideas or tools. We are also interested in presentations aiming at taking complex concepts, such as program derivation, and putting them into productive use. However proposals on anything that you suspect our audience m
Categories: Offsite Discussion

Antti-Juhani Kaijanaho (ibid): Doctoral defense approaching, dissertation publicly available

Planet Haskell - Wed, 11/18/2015 - 2:16am

I will be defending my doctoral dissertation “Evidence-based programming language design: a philosophical and methodological exploration” on December 4, 2015 at noon, in the Seminarium building, auditorium S212, of the University of Jyväskylä. My opponent will be Professor Lutz Prechelt (Freie Universität Berlin, Germany), and the custos is Professor Tommi Kärkkäinen (University of Jyväskylä).

The defense is public; anyone may come. Dress code for the audience is whatever one would wear to any lecture or regular academic activity at the university (no formal dress required). There is a Facebook event page.

The dissertation manuscript was reviewed (for a permission to publish and defend) by Professor Matthias Felleisen (Northeastern University, USA) and Professor Andreas Stefik (University of Nevada, Las Vegas, USA). The dissertation incorporates most of my licentiate thesis, which was examined last year by Doctor Stefan Hanenberg (University of Duisburg-Essen, Germany) and Professor Stein Krogdahl (University of Oslo, Norway).

The dissertation is now publicly available as a PDF.

The dissertation mentions Haskell in several places, although that is not its main focus.


Kaijanaho, Antti-Juhani
Evidence-Based Programming Language Design. A Philosophical and Methodological Exploration.
Jyväskylä: University of Jyväskylä, 2015, 256 p.
(Jyväskylä Studies in Computing
ISSN 1456-5390; 222)
ISBN 978-951-39-6387-3 (nid.)
ISBN 978-951-39-6388-0 (PDF)
Finnish summary

Background: Programming language design is not usually informed by empirical studies. In other fields similar problems have inspired an evidence-based paradigm of practice. Such a paradigm is practically inevitable in language design, as well. Aims: The content of evidence-based programming design (EB-PLD) is explored, as is the concept of evidence in general. Additionally, the extent of evidence potentially useful for EB-PLD is mapped, and the appropriateness of Cohen’s kappa for evaluating coder agreement in a secondary study is evaluated. Method: Philosophical analysis and explication are used to clarify the unclear. A systematic mapping study was conducted to map out the existing body of evidence. Results: Evidence is a report of observations that affects the strength of an argument. There is some but not much evidence. EB-PLD is a five-step process for resolving uncertainty about design problems. Cohen’s kappa is inappropriate for coder agreement evaluation in systematic secondary studies. Conclusions: Coder agreement evaluation should use Scott’s pi, Fleiss’ kappa, or Krippendorff’s alpha. EB-PLD is worthy of further research, although its usefulness was out of scope here.

Keywords: programming languages, programming language design, evidence-based paradigm, philosophical analysis, evidence, systematic mapping study, coder agreement analysis

Categories: Offsite Blogs

reactive-banana project examples

haskell-cafe - Tue, 11/17/2015 - 10:47pm
Could I get some pointers to projects using reactive-banana. I'm looking for projects that have code testing their Behaviors. _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe< at >
Categories: Offsite Discussion

The new GHC users guide

Haskell on Reddit - Tue, 11/17/2015 - 3:23pm
Categories: Incoming News

Need source code for FRAN (Functional Reactive Animation)

Haskell on Reddit - Tue, 11/17/2015 - 3:21pm

To learn about the subject I decided to follow through the implementation of simplest FRP library. This paper seems to be one of the first to talk about it and has small implementation. But I can't find the source code for this FRAN thing. Help needed.

If there are other options that I could follow the implementation and learn from it, please inform me.

submitted by dulgon
[link] [6 comments]
Categories: Incoming News

There is any Web framework without haskell templates ?

Haskell on Reddit - Tue, 11/17/2015 - 3:17pm

The main problem for me in haskell templates, it's that i can't give developing of fronted parts to my colleagues, because of they don't know haskell.

submitted by cali4888
[link] [8 comments]
Categories: Incoming News

It’s All About Morphisms

Haskell on Reddit - Tue, 11/17/2015 - 1:02pm
Categories: Incoming News

Morte's expressivity of `zipWith` and `min`

Haskell on Reddit - Tue, 11/17/2015 - 12:13pm

I think I've heard from /u/tekmo that one of Morte's goal is being used as a common compile-target of functional languages. That is, functional code would be stored on Morte and compiled to/from higher-level languages, making Morte the ideal language for code storage and communication. I can't find the source, so I'm not sure if he actually claimed that.

I think there is a result that one can't express zipWith nor min in linear-time on the calculus of constructions [1]. Given the importance of those functions, wouldn't that undermine Morte's goals as a common subset? Or did I misunderstand the result of that paper?

[1] About primitive recursive algorithms,

submitted by SrPeixinho
[link] [13 comments]
Categories: Incoming News

turn off "thread blocked indefinitely in an STMtransaction"?

haskell-cafe - Tue, 11/17/2015 - 10:52am
I find the following mildly annoying: Prelude> import Control.Concurrent.STM Prelude Control.Concurrent.STM> atomically retry *** Exception: thread blocked indefinitely in an STM transaction Is there a way to not raise this exception, and block the thread? I don't see this behaviour (raising the exception) mentioned in the API docs nor in the defining paper (Composable memory transactions, PPoPP'05) that is referenced there. I understand it might come in handy for debugging, but sometimes (e.g., for teaching) I might really want a transaction that never commits. For instance, I am forkIO'ing some worker threads and the main program really should do absolutely nothing. So I thought I could just block the main thread. I can make some work-around with forM [1..n] $ \ p -> ( if p < n then void . forkIO else id ) $ forever $ do but that feels clumsy (since asymmetric). - J.W.
Categories: Offsite Discussion

Is there something comparable to C++ destructors and shared pointers in Haskell?

Haskell on Reddit - Tue, 11/17/2015 - 8:08am

For things that can't be garbage-collected of course. I mean this:

class File final { public: File(std::string path) { /* ... */ } // Delete copy constructor so it's not copyable. File(const File&) = delete; File& operator=(const File&) = delete; ~File() { close(fd); } /* ... */ private: int fd; };

This way you can use the class safely:

void file() { File file("/path"); // ... // File is reliably closed. }

You can't return a closed file handle from a function like you can return a closed file handle from bracket or withFile, because the copy constructor was deleted.

badFunction :: IO Handle badFunction = bracket openFile closeFile (\handle -> return handle)

For resources that need to be shared there is shared_ptr:

std::shared_ptr<File> file() { auto file = std::make_shared<File>("/path"); // ... return file; }

This way, a file will not be closed until all references to it are gone, shared_ptr is deterministic, so the resources are released the very moment the last shared_ptr goes out of scope or is destroyed along with its parent object.

struct This final { std::shared_ptr<File> file; }; struct That final { std::shared_ptr<File> file; }; struct Other final { This a; That b; }; Other function() { auto file = std::make_shared<File>("/path"); This this{file}; That that{file}; return Other{this, that}; }

Of course, you can probably circumvent all this in C++, but is there any truly safe alternative to this in Haskell (i.e. one that makes it impossible to use a closed file handle until all references to it are gone, unless you import some kind of an Unsafe module)?

submitted by lamefun
[link] [56 comments]
Categories: Incoming News

Why does the TensorFlow paper sound suspiciously like Haskell ?

Haskell on Reddit - Tue, 11/17/2015 - 5:00am

I am a newbie with Haskell and Machine learning. I just dabble in them occasionally. I know this might sound stupid, hence throw away.

Has anyone read the TensorFlow paper ? Many of the things said in it sound suspiciously like how Haskell concepts sound ?

Like these "The graph represents a dataflow computation, with extensions for allowing some kinds of nodes to maintain and update persistent state and for branching and looping control structures within the graph."

"In a TensorFlow graph, each node has zero or more inputs and zero or more outputs, and represents the instantiation of an operation."

Isn't that exactly what a function is ?

"Values that flow along normal edges in the graph (from outputs to inputs) are tensors arbitrary dimensionality arrays where the underlying element type is specified or inferred at graph construction time. "

"Since our model includes mutable state, control dependencies can be used directly by clients to enforce happens before relationships." <- State monad ?

"Our implementation also sometimes inserts control dependencies to enforce orderings between otherwise independent operations as a way of, for example, controlling the peak memory usage." <- IO Monad

Would Haskell yield itself better to a Machine Learning framework implementation on the above lines ?

If all this sounds really stupid please feel free to ignore me.

Thank you.

submitted by oneplusta
[link] [8 comments]
Categories: Incoming News

In haskell

Haskell on Reddit - Mon, 11/16/2015 - 7:30pm

What is wrong with my code ?

anyBigNumbers _ [] = True anyBigNumbers [] _ = False

I need to get that result

anyBigNumber 100 [ 4,5, 600 ] true anyBigNumber 100 [ 4,5, 6 ] false

by the way I am taking student homework from google to learn

submitted by Germany22221
[link] [21 comments]
Categories: Incoming News

New Functional Programming Job Opportunities

haskell-cafe - Mon, 11/16/2015 - 7:00pm
Here are some functional programming job opportunities that were posted recently: Haskell Developer (ON SITE) at CJ Affiliate by Conversant Software Engineer - Functional Programmer - Erlang at Change Healthcare Cheers, Sean Murphy
Categories: Offsite Discussion