News aggregator

Monte Carlo Analysis in Haskell

Haskell on Reddit - Mon, 03/31/2014 - 4:13pm
Categories: Incoming News

Functional Jobs: Infrastructure Engineer at Zeta Project Germany GmbH (Full-time)

Planet Haskell - Mon, 03/31/2014 - 12:14pm

About us

We are an early-stage product company. At Zeta everyone has a voice and we expect you to change our world. If you like coming up with creative solutions then this is definitely the place for you.

We’ve built a team of passionately experienced, curious engineers and designers who are dedicated, hardworking and wholeheartedly embrace technical and design challenges of all types.

We are located in Berlin Mitte and are looking for talented individuals who share our passion.

Job Description

This position is for someone to work in the Infrastructure team, to contribute to the evolution of our software platform.

The team is responsible for developing and supporting the company's core systems and infrastructure, which is predominately written in Haskell.

You will work directly with other teams within the company, including client, backend, and QA engineers, ensuring that the infrastructure runs correctly, reliably and at scale.

The ability to educate others on the best use of the software resources the team provides is crucial, as is the ability to use feedback to continually improve our tooling and processes.

Initially we would like you to own our Jenkins setup and drive best practices for the automation of various teams' Continuous Integration and Deployment workflows, with future work planned to improve problem areas such as development workflow, monitoring, alerting, provisioning, and performance.

Skills & Requirements

  • Practical experience using various Amazon Web Services
  • Comfortable with admin tasks, like partitioning and formatting filesystems, Debian packaging, debugging live processes, and general Linux best practices
  • Working knowledge of Cassandra, Redis, or similar databases
  • Proactive with the ability to own and oversee projects
  • Extensive familiarity with Jenkins and Continuous Integration, for technologies such as Objective-C, C++ and Haskell
  • Good programmer with experience programming Ruby, Python, Erlang or other languages
  • Experience with various Configuration Management technologies like Ansible, Chef, Puppet, etc.
  • Interested in learning Haskell
  • Experience working as a Linux System Administrator

Get information on how to apply for this position.

Categories: Offsite Blogs

Can someone give me an example of how/when/why currying/uncurrying might be useful?

Haskell on Reddit - Mon, 03/31/2014 - 12:07pm

This is what I understand so far:

  • Uncurried functions take arguments simultaneously

    uncurriedFunction :: (a,b) -> c

  • Curried functions take arguments one at a time

    curriedFunction :: a -> b -> c

So currying, or a curried function, allows for partial application. With a curried function, we can give one argument to a function that requires more than one, right?

Beyond that, I'm having a hard time understand how the built-in functions, curry and uncurry, are useful, or why/when they would be used.

I have read through the sections of "Learn You a Haskell" that are relative to this topic, but I'm still struggling to really wrap my mind around it.

Thanks in advance.

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

I'm trying to learn about free monads, but I get confused in the first paragraphs of /u/Tekmo's tutorial :/

Haskell on Reddit - Mon, 03/31/2014 - 11:52am

Why Free Monads Matter

In the tutorial, Gabriel defines a new data type, Toy:

data Toy b next = Output b next | Bell next | Done

After showing that different programs have different types, we are introduced to the Fix datatype:

data Fix f = Fix (f (Fix f))

Then we are shown that different programs can have the same type:

Fix (Output 'A' (Fix Done)) :: Fix (Toy Char) Fix (Bell (Fix (Output 'A' (Fix Done)))) :: Fix (Toy Char)

Now, this is the part where I become confused.

First, what's the intuition behind the Fix definition? It it supposed to be read as "the fixed point of an f is an f followed by a fixed point of f"?

I'm also not sure that I really follow the types and kinds; for example, the type of Done is Toy b next, and the kind of that type (sorry for the weak wording) is * -> * -> *. However, the kind of Fix is (* -> *) -> *, so how is Fix Done properly typed?

Sorry if this is very basic, but my brain seems unable to properly connect the dots.

UPDATE:

Okay, so I read your comments and the Fix datatype makes more sense. Now to another question: is Fix integral to free monads? I found another tutorial where the author used a subset of Joy to show free monads and he also used the scheme of having an extra type variable that points to the next instruction. Is that required for free monads or do they just need an extra type variable (i.e. have kind * -> *) so that they can have a Functor instance?

submitted by gnuvince
[link] [11 comments]
Categories: Incoming News

Alejandro Cabrera: Migrating to Static, Self-Hosted Blog

Planet Haskell - Mon, 03/31/2014 - 9:50am
Hello, readers.

Soon, I'll be moving away from the Blogger platform to a statically hosted blog. I've been playing with hakyll for some time now, and am pleased with it's support for syntax highlighting, markup formats, RSS/Atom generation, and packaged Warp.

It'll be great to develop my blog with emacs, leveraging git for backup and rsync for deployment.

Expect:

* Less latency
* A home-grown design
* More code samples, with pretty highlighting

With possibly:

* More frequent posts

Stay tuned. I'll be releasing the new blog by the end of the week!
Categories: Offsite Blogs

Daniil Frumin: ANN: hastache 0.6

Planet Haskell - Mon, 03/31/2014 - 1:49am
Announcing: hastache 0.6

Hastache is a Haskell implementation of the mustache templating system.

Quick start cabal update cabal install hastache

A simple example:

import Text.Hastache import Text.Hastache.Context import qualified Data.Text.Lazy.IO as TL main = hastacheStr defaultConfig (encodeStr template) (mkStrContext context) >>= TL.putStrLn template = "Hello, {{name}}!\n\nYou have {{unread}} unread messages." context "name" = MuVariable "Haskell" context "unread" = MuVariable (100 :: Int)

Read Mustache documentation for template syntax; consult README for more details.

Whats’s new in 0.6?

The interface of the library has been switched from ByteString to (lazy) Text. That means, for example, that the type of hastcheStr function is now the following:

hastacheStr :: MonadIO m => MuConfig m -> Text -> MuContext m -> m Text

The generic context generation (mkGenericContext) now supports functions of the types Text -> Text and Text -> m Text, as well as types with multiple constructors. That is, given a Haskell datastructure

data A = A { str :: String } | B { num :: Int }

it is possible to write a template like this:

{{#A}} A : {{str}} {{/A}} {{#B}} B : {{num}} {{/B}}

Please take a look at the multiple constructors example if you are interested.

Additionally, a couple of new MuVar instances has been added.

Links Acknowledgments

Special thanks to Mark Lentczner, Alexander Voikov and others who reported issues, tested the library and provided feedback.


Tagged: haskell, hastache
Categories: Offsite Blogs

Learning Haskell

del.icio.us/haskell - Mon, 03/31/2014 - 12:02am
Categories: Offsite Blogs

real world yi-editor usage?

Haskell on Reddit - Sun, 03/30/2014 - 11:34pm

just curious if anyone here is actively using yi. for me it would be a vim replacement, but it still seems as if its missing quite a bit. AFAIK, vertical splits for one..

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

Yet another 2048 clone

Haskell on Reddit - Sun, 03/30/2014 - 6:01pm

https://github.com/mitchellwrosen/hs2048-free

Based this on https://github.com/badamson/2048.hs, but I used a free monad to model the game actions. You might have some fun writing an AI, see Main.hs for a couple examples.

submitted by MitchellSalad
[link] [15 comments]
Categories: Incoming News