paf31

Do you mean PureScript?

I think it really depends what you're trying to do. There's definitely a class of problems where the impact of a runtime type error would be low. But there are plenty of other cases where you want to constrain what you or your users can do at compile time.

> I fail yet to see what advantages PureScript brings compared to Elm.

I think they fit different use cases. Elm is excellent at interactive web apps using FRP. PureScript is a little more general purpose and has a few type system features which Elm currently does not (type classes and rank N polymorphism). Also, PureScript's generated code is a bit simpler and doesn't need a runtime library.

There are a few options, but the most fully-formed is probably purescript-react. I'm also interested to see where the virtual-dom bindings go. The last chapter of the book covers how you might go about writing a library for working with DOM elements in PureScript.

Yes - in fact, that's the approach we encourage for working with immutable arrays: https://github.com/purescript/purescript-arrays

It uses JavaScript's evaluation model - i.e. strict, but you can write lazy code using libraries, such as purescript-lazy.

It has been discussed before: https://github.com/purescript/purescript/issues/396

The reason I have been against the idea so far is that an integer type is easily accomplished using the FFI and user code. Here is one example (not quite what you're asking for, but hopefully instructive): https://github.com/darinmorrison/purescript-int64

Consider a recursive function like factorial:

  fact :: Number -> Number
  fact 0 = 1
  fact n = n * fact (n - 1)

This will build stack frames and fail with a stack overflow for large inputs. We can fix this by using tail recursion and an accumulator:

  fact :: Number -> Number
  fact = go 1
    where
    go acc 0 = acc
    go acc n = go (acc * n) (n - 1)

The PureScript compiler will recognize that every recursive call is in tail position, and will convert the function to a while loop.

If we want to perform side-effects during the recursion, we typically use a monad to track the type of side effect in use. For example, we can use PureScript's Eff monad to trace information to the console:

  fact :: Number -> Eff (trace :: Trace) Number
  fact = go 1
    where
    go acc 0 = do
      trace "Done!"
      return acc
    go acc n = do
      trace "Keep going ..."
      go (acc * n) (n - 1)

In the case of the Eff monad, the PureScript compiler employs some special tricks in the optimizer to enable the tail call optimization, so we're still OK. But this is only possible because Eff is defined in the standard library (at least until we implement custom rewrite rules).

In the general case, the compiler only sees applications to the monadic bind function of the underlying monad. For example, if we use the Writer monad instead:

  fact :: Number -> Writer String Number
  fact = go 1
    where
    go acc 0 = do
      tell "Done!"
      return acc
    go acc n = do
      tell "Keep going ..."
      go (acc * n) (n - 1)
  

which is equivalent after desugaring to the following code:

  fact :: Number -> Writer String Number
  fact = go 1
    where
    go acc 0 = tell "Done!" >>= \_ -> return acc
    go acc n = tell "Keep going ..." >>= \_ -> go (acc * n) (n - 1)

This is an example of "monadic recursion" - a recursive function whose return type uses some monad. In this case, the recursive calls are no longer in tail position, so the compiler cannot apply the tail call optimization. The result is that the compiled JavaScript might blow the stack for large inputs.

The point is that idiomatic Haskell code is often not appropriate in JavaScript because of the different semantics, so it might not be appropriate in PureScript either. The good news is that many Haskell idioms have corresponding PureScript idioms (often using the Eff monad).

Free HTML version is here: https://leanpub.com/purescript/read

(Copied from below) I've written quite a lot of TypeScript, and I generally feel very productive in it, but occasionally I feel like I want more from the type system (type classes, rank-N types, sum types, etc.) and tidier syntax. You might be interested in Bodil Stokke's recent Strange Loop talk, where she discusses why she switched from TypeScript. https://www.youtube.com/watch?v=yIlDBPiMb0o

I've written quite a lot of TypeScript, and I generally feel very productive in it, but occasionally I feel like I want more from the type system (type classes, rank-N types, sum types, etc.) and tidier syntax. You might be interested in Bodil Stokke's recent Strange Loop talk, where she discusses why she switched from TypeScript. https://www.youtube.com/watch?v=yIlDBPiMb0o

I think it's definitely possible to put knowledge of Haskell to use in PureScript, but it's not like Fay, Haste, GHCJS etc. where you can copy code verbatim. I think of PureScript as "an environment in which to write principled JavaScript". That requires that, to a certain extent, you should have JavaScript's semantics in the back of your mind while developing. For that price, you get ease of debugging and some tools which you don't have in many other compile-to-JS languages (an expressive type system, type classes, ability to refactor with confidence etc.)

Of course, one of the best things about AltJS is the interoperability with other languages. PureScript won't be the best tool for every case, but it has a simple FFI. It's possible to write complete front-ends in PureScript, but I'd love to see more examples where PureScript is used alongside something else (I've used TypeScript with PureScript successfully, for example).

"Simple readable JavaScript" as opposed to the sort of output you might expect from compilers for other Haskell-like languages which attempt to preserve Haskell's semantics. Certainly there are cases where using techniques from pure functional programming can lead to poor performance (monadic recursion jumps to mind), but it is perfectly possible to write fast code using PureScript. And if you really need to squeeze out every last bit of performance, you can always write code in JavaScript and use the FFI.

PureScript developer here. Happy to see this here, and happy to answer any questions.

You couldn't pay me enough to work on some stacks.

Also, certain technologies do a good job of convincing potential employees that you know what you're doing and committed to using the best tools available IMO.

Also why not consider remote employees?

My approach is to try to attract strong developers by using the best languages and tools. What technology stack do you use?

Very nice. It took me a while to realize that array literals aren't supported, but once I did that I was able to write concatMap and watch it being evaluated.

A couple of points:

- If there is a syntax error, the box just turns red. It would be nice to see what the issue is.

- You could probably make it clearer that it's possible to execute arbitrary expressions, by editing the map term, for example.

Presumably this doesn't prevent a developer from creating another "pattern class" subclassing some superclass in another package, thereby breaking existing pattern matches?

Added to my calendar :)

A week in Mexico starting tomorrow :P

DICOM Grid http://dicomgrid.com/ - Phoenix, AZ or REMOTE

DICOM Grid, a SaaS start-up in the healthcare technology field, is looking for a JavaScript/TypeScript developer to maintain and enhance DICOM Grid’s front-end medical image sharing and reading web application. You will report to the Director of Dev Ops.

Familiarity with modern front-end web development is essential.

The ideal candidate would be able to work independently with minimal supervision, and be enthusiastic about keeping up-to-date with the latest web technologies.

The team is distributed with team members working remotely in Phoenix, Los Angeles, Boston, and New York.

Required:

* HTML5, CSS, JavaScript

* JQuery, Underscore

* Working knowledge of Linux

Familiarity with any of the following would be a big plus:

* TypeScript

* Handlebars, Backbone

* Scala, Java

* Functional programming techniques

* Linear algebra

* DICOM, HL7

Position Responsibilities

* Plan, evaluate, implement, test and document new features and bug fixes for the DICOM Grid web application.

* Work with other development team members to integrate with backend services.

* Work with DevOps to deploy code into our production and UAT environments.

* Work with customers and professional services to gather requirements.

* Conform to company standard operating procedures.

What qualifies you to join?

* A combination of a college degree in CS, Math, Physics, or related, relevant work experience, and/or a strong open source portfolio

* General interest in the healthcare field

* Strong communication and interpersonal skills

* Meticulous attention to detail with strong organization skills

* Base salary and stock options depend on experience; health insurance, paid holidays and vacation are part of the package.

Send your resume, cover letter and/or links to your StackOverflow, GitHub profiles, etc. to pfreeman+hn@dicomgrid.com.

For bonus points, include a solution to the following short task, including code in JavaScript or the frontend language of your choice: write a function which identities the largest common set (not list) of words appearing as prefixes of two input strings. For example, the largest common prefix set of the strings "His dog and the cat" and "The dog and his ball" is { "the", "dog", "and", "his" }

No recruiters please.

> With minor advertising and effort, I have more inbound work requests than I can personally take on.

I'm very much interested in moving more towards contract-based employment, so I would love to hear more about the mechanics of getting off the ground, and any recommendations for advertising my services etc.

Los Angeles, Remote or local, Contract

Stack: Haskell, C#, F#, Java, Scala, Javascript, TypeScript

GitHub: http://github.com/paf31, http://github.com/purescript

Specialties: Domain specific languages (DSLs), Compiler implementation, Framework implementation, Statistics, Geometry

Resume/Blog: http://functorial.com

Contact: my username at cantab dot net

Experienced developer with a strong background in Mathematics looking for small to medium projects (approx. 20 hrs/week). I enjoy writing reliable code in strongly typed functional languages, or using the techniques of strongly-typed functional programming in other languages. Contact me if you're interested in using those techniques to write verifiably correct code.

SEEKING WORK - Los Angeles (remote or local)

Experienced developer with a strong background in Mathematics looking for small to medium projects (approx. 20 hrs/week). Keywords: C#, F#, Java, Scala, Haskell, Javascript, TypeScript

Specialties: Domain specific languages (DSLs), Compiler implementation, Framework implementation, Statistics, Geometry

I enjoy writing reliable code in strongly typed functional languages, or using the techniques of strongly-typed functional programming in other languages.

GitHub: http://github.com/paf31, http://github.com/purescript

Website/Resume/Blog: http://functorial.com

Contact: my username at cantab dot net

Attend a Haskell mini-conference! http://www.haskell.org/haskellwiki/BayHac2014

Los Angeles, remote preferred, Contract | Part Time

Stack: Haskell, C#, F#, Scala, Java, TypeScript, Javascript

Resume: http://functorial.com

Contact: my username at cantab dot net

I am looking for something challenging which would allow me to use my skills in functional programming (with a strong preference for Haskell). Short to medium term contract/part time projects are preferred. I am most interested in language/compiler design, but given the freedom to use the right tools, I would be happy working on a wide variety of projects.

SEEKING WORK - Los Angeles (remote or local)

Experienced developer looking for small to medium projects. I have strong experience with the following: C#, F#, Java, Scala, Haskell, Javascript, TypeScript. My main speciality at the moment is the development of reliable Javascript applications using strongly-typed source languages. I can work across the full stack if necessary.

I also have extensive experience with: domain specific language design, compiler implementation, framework implementation.

GitHub: http://github.com/paf31, http://github.com/purescript (I am the original author of this project)

Website/Resume/Blog: http://functorial.com

Contact: my username at cantab dot net

There are a few interesting projects in the contrib organization on GitHub:

https://github.com/purescript-contrib

I also like inquire.js:

https://github.com/concordusapps/inquire.js

Also, some slides and examples from a talk I recently gave, with a few (what I think are cool) examples of functional approaches to common JS problems:

https://github.com/paf31/lambdaconf

And a little game (needs some more work):

https://github.com/paf31/purescript-croco http://functorial.com/purescript-croco/html/

I use Cats IDE on a relatively large project and find it very good.