News aggregator

Prisms and [Monad]Errors

Haskell on Reddit - Wed, 02/04/2015 - 9:09pm

In the same way that you can use classy lenses to avoid committing to a concrete state monad, you can use classy prisms to avoid committing to a concrete error monad.

There's a fair bit of prior art that demonstrate the use of classy lenses. A browse through Quine will uncover some examples, and there have been discussions here in the past about the technique.

However, there's much less material about classy prisms, and I only realised they could be assembled this way last night, so I've encoded what I've learnt in this gist:

submitted by nkpart
[link] [4 comments]
Categories: Incoming News

Haskell: Does it support cross compilation?

Haskell on Reddit - Wed, 02/04/2015 - 4:29pm

I want to generalize and port a small CLI utility ( that was coded in Erlang to a language/platform where I can easily generate a standalone binary that does not depend on vms, interpreters. I need to generate a binary for windows, linux, os x and bsds.

Up to now I could find that Go ( and and Ocaml ( have good support for cross compilation. I am trying to check if rust, nim and haskell have good support for it before choosing the programming language/platform. I would prefer to do it in Haskell, since this would be my first real project with it. However I could only find this: - - and it does not seem it has good support for generating binaries for another OS/architecture

I would like to know if it is supported by ghc or how do you manage to generate binaries for different plataforms.

Thanks in advance!

submitted by pyotrgalois
[link] [12 comments]
Categories: Incoming News

How does RTS judge that a STM transaction is blocked?

haskell-cafe - Wed, 02/04/2015 - 2:59pm
Hi, I met an issue while I was using xhb. When a certain property of root window being changed, it was supposed to give me an AccessError. But actually I got "thread blocked indefinitely in an STM transaction" when I waitForEvent. AFAIK, in xhb, it forks a thread to read what X server sends. Then parse and put it into a TChan. waitForEvent reads from the TChan. It is reasonable to me that if X server did not send anything, then waitForEvent would be blocked. But apparently there are some other policies in RTS. So what is that? And how should I debug it?
Categories: Offsite Discussion

Haskell opportunities at Facebook

Haskell on Reddit - Wed, 02/04/2015 - 2:00pm

Hi, friends –

I have a number of very interesting openings at Facebook HQ in Menlo Park, California. There are two different teams hiring.

The first set of positions are for an entirely new team. This project involves distributed systems, data mining, and machine learning. There may be roles on this team for less experienced candidates in a few months, but right now we are looking for people who have written a reasonable amount of Haskell, have built real production systems in some language or other (and have the scars to prove it), and can contribute in major ways to the design and construction of a demanding new system that we're building from scratch.

The second set of positions are for a cousin team, which is building on the success of our Haxl project to extend our capability to fight spam and malware. For these roles, we're open to a broader range of experience levels.

If you're interested, please drop me an email with a current CV.

submitted by bos
[link] [40 comments]
Categories: Incoming News

hiring fp engineers for information security systems

haskell-cafe - Wed, 02/04/2015 - 11:04am
About Guardtime We are team of US and Estonian scientists, network architects, software developers and security specialists who have decades of experience building cyber security solutions in our nations' military, supporting national objectives for mission and information assurance. In 2007 we invented Keyless Signature Infrastructure (KSI), a block-chain security technology designed for real-time detection and mitigation of cyber attack. About The Role We're looking for experienced functional software engineers to work on real-time backend systems dealing with high volume events. We need people who want to build systems to apply the power of workflow processing to security events to build deep intelligence platforms. We want people who understand the benefits of converged understanding over imperative understanding. About You - You should have an appetite for tackling complex and interesting software challenges. - Want to build systems that handle data on a global scale in a time
Categories: Offsite Discussion

2048 clone using Yampa FRP library

Haskell on Reddit - Wed, 02/04/2015 - 8:41am

Hey guys,

I've had quite a journey until I finally understood (at least the basics) of FRP using Yampa. There not a lot of examples one can work through to grasp the concepts. So I guess there is one more example now:

A simple clone of 2048 game using Yampa and Gloss. My goal was to make it work using the frp library, so the actual game logic code and rendering to Gloss window is not something of an interest (it was copied/converted from other people's code).

So there you have it. Another working example of Yampa in action. Quite small, might be useful for someone in the future.

If you have any suggestions, remarks and anything like that I'll gladly hear them out.

submitted by faorien
[link] [comment]
Categories: Incoming News

Haskell and Ethereum

Haskell on Reddit - Wed, 02/04/2015 - 7:09am

It seems almost inevitable that more and more financial transactions will be based on cryptocurrency and blockchain technologies such as bitcoin. There are many projects attempting to generalize blockchain transactions into a wider field of decentralized trustless platforms, one of the most notable being, which is attempting to turn the blockchain idea into a global shared virtual machine (the EVM). Ethereum promises to make complex transactions, like for example decentralized escrow, fairly trivial to encode.

So it, goes without saying that type safety and purity are really helpful for financial applications. I'm wondering who is interested in discussing in a constructive way what we can do to make Haskell a go-to language for these types of applications. (I'm focusing on Ethereum here because it seems to have a combination of being the most open, well funded and far along, but there are others coming notably Ripple is building Codius, I believe along similar lines.)

My questions are:

  • What is the state of current Haskell projects to support Ethereum and EVM coding?

  • Can you sketch out your ideas for a set of libraries or domain specific languages that could support coding EVM projects directly?

  • What are some strategies for compiling to EVM while leveraging existing compilers?

  • What are the implications for efficiency for functional languages considering each step of the EVM incurs cost?

  • How can we make sure that our efforts are combined?

submitted by biglambda
[link] [7 comments]
Categories: Incoming News

A theory of changes for higher-order languages — incrementalizing λ-calculi by static differentiation

Lambda the Ultimate - Wed, 02/04/2015 - 4:00am

The project Incremental λ-Calculus is just starting (compared to more mature approaches like self-adjusting computation), with a first publication last year.

A theory of changes for higher-order languages — incrementalizing λ-calculi by static differentiation
Paolo Giarusso, Yufei Cai, Tillmann Rendel, and Klaus Ostermann. 2014

If the result of an expensive computation is invalidated by a small change to the input, the old result should be updated incrementally instead of reexecuting the whole computation. We incrementalize programs through their derivative. A derivative maps changes in the program’s input directly to changes in the program’s output, without reexecuting the original program. We present a program transformation taking programs to their derivatives, which is fully static and automatic, supports first-class functions, and produces derivatives amenable to standard optimization.

We prove the program transformation correct in Agda for a family of simply-typed λ-calculi, parameterized by base types and primitives. A precise interface specifies what is required to incrementalize the chosen primitives.

We investigate performance by a case study: We implement in Scala the program transformation, a plugin and improve performance of a nontrivial program by orders of magnitude.

I like the nice dependent types: a key idea of this work is that the "diffs" possible from a value v do not live in some common type diff(T), but rather in a value-dependent type diff(v). Intuitively, the empty list and a non-empty list have fairly different types of possible changes. This makes change-merging and change-producing operations total, and allow to give them a nice operational theory. Good design, through types.

(The program transformation seems related to the program-level parametricity transformation. Parametricity abstract over equality justifications, differentiation on small differences.)

Categories: Offsite Discussion

Fishy Monad Tutorial

Haskell on Reddit - Tue, 02/03/2015 - 11:22pm
Categories: Incoming News

Why is hoogle's index so out of date

Haskell on Reddit - Tue, 02/03/2015 - 10:23pm

I am using hoogle a lot, but one think that I find frustrating is that it seems that its index is rather old and it cannot find recently (or not so recently) released stuff. For example, it does not know about the Data.Proxy module from base or that unordered-containers is in the platform now (it still requires to specify+unordered-containers to find it) or about the auto-update package. Why does this happen? Is it because the indexing process has to be initiated manually and nobody has done that recently?

submitted by p0ssibl3
[link] [10 comments]
Categories: Incoming News

LCTES 2015: 2nd Call for Papers

General haskell list - Tue, 02/03/2015 - 10:22pm
############################################################ LCTES 2015 ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems ############################################################ LCTES provides a link between the programming languages and embedded systems engineering communities. Researchers and developers in these areas are addressing many similar problems, but with different backgrounds and approaches. LCTES is intended to expose researchers and developers from either area to relevant work and interesting problems in the other area and provide a forum where they can interact. ## Important Dates Submission deadline: Feb. 15 Notifications by: Apr. 1 Camera-ready deadline: Apr. 11 LCTES 2015 will be held on June 18 and 19 as part of the FCRC 2015 (Federated Computing Research Conference 2015) in Portland, Oregon, USA. This will be the sixteenth conference in the LCTES series. Embedded system design faces many challenges both with respect
Categories: Incoming News

Conal Elliott's Push-Pull FRP?

Haskell on Reddit - Tue, 02/03/2015 - 7:19pm

What ever happened to the ideas from Conal Elliott's Push-Pull Functional Reactive Programming?

If I understand correctly, the Reactive library was the concrete realization of the ideas from the paper. But that project doesn't seem to be active anymore. Did the ideas get pulled into some other Haskell FRP library? (Maybe reactive-banana, which claims to be based on Conal Elliott's ideas? But when I look at reactive-banana's source code, it doesn't seem to be exactly based on the Push-Pull ideas. I may be wrong about that, though.) Or were the ideas discovered to be unworkable for some reason, so they got superceded by other FRP ideas? Or what?

submitted by AdamSpitz
[link] [7 comments]
Categories: Incoming News