News aggregator

Functional Jobs: Full-Stack Senior Functional Web Engineer at Front Row Education (Full-time)

Planet Haskell - Tue, 05/05/2015 - 5:30pm
Position

Senior full-stack functional web engineer to join fast-growing education startup that changes how over a million young students learn math.

TL;DR - Why you should join Front Row
  • Our mission is important to us, and we want it to be important to you as well: hundreds of thousands of kids learn math using Front Row every month. Our early results show students improve twice as much while using Front Row than their peers who aren’t using the program.
  • You’ll be one of the first engineers on the team, which means you’ll have an immense impact on our company, product, and culture; you’ll have a ton of autonomy and responsibility; you’ll have equity to match the weight of this role. If you're looking for an opportunity to both grow and do meaningful work, surrounded and supported by like-minded professionals, this is THE place for you.
  • A lot of flexibility: while we all work towards the same goals, you’ll have a lot of autonomy in what you work on. You can work from home up to one day a week, and we have a very flexible unlimited vacation days policy
  • You’ll use the most effective tools in the industry: Haskell, Postgres, Ansible and more. Front Row is one of the very few organizations in the world that use Haskell in production for most of their systems and is an active member of the Haskell community, including the Commercial Haskell Special Interest Group.
  • In addition to doing good, we’re doing really well: in just over a year after launch, we are in more than 20% of all US elementary & middle schools.
The Business

Millions of teachers around the USA are struggling to help 30+ students in their class learn math because every student is in their own place. In a typical fourth grade classroom, there may be students learning to count, students learning to add, students learning to multiply, and students learning how exponents work - and one teacher somehow needs to address all these needs.

Front Row makes that impossible task possible, and as of today, more than a hundred thousand students use Front Row to receive personalized guidance in their learning. Thousands of teachers use Front Row every day to save hours of time and make sure their students are growing at the fastest rate achievable. Front Row active users have been growing over 25% a month for the past 6 months.

Front Row is successfully venture-funded and on the road to profitability.

The Role

As one of our very first engineers, you will be part of a team of developers who take pride in their craft and push each other to continuously get better. You will strive for pragmatism and 80/20 in your work. You will be using tools that make you most effective and give you the most leverage. By working really smart, you will produce more than the average developer ever will, but without the crazy hours.

We love generalists who can quickly bring themselves up to speed with any technology we’re using: you will have the chance to learn a lot, and fast too. You will receive continuous support and mentorship on your journey to achieving mastery. We do however expect you not to need to be hand-held and rely on others for your own growth. You will have full autonomy over your work.

You will work in an effective team that plans, executes and reflects together. Because we’re a small team, everything you create will go into production and be used by students, teachers, parents and school personnel. You will never do unimportant work: every contribution will make a clear and tangible impact on the company’s trajectory. Your personal success will be directly aligned with that of the company.

Most importantly, your work will have purpose: Front Row is a mission-driven company that takes pride in making a significant impact in the lives of hundreds of thousands of students.

Tools
  • Front Row is a polyglot combination of multiple web applications, mobile apps and asset generation tools.
  • Web front-ends are a custom version of Backbone.js + plugins.
  • The backend is a series of Haskell+Yesod-based applications talking to PostgreSQL and 3rd party services. Some Clojure here and there from older codebases on the way out.
  • All test, build and deployment automation relies on Ansible. AWS for hosting.
  • We have mobile apps for both iOS and Android
  • Work is continuously happening to simplify and minimize the codebases. We <3 getting rid of code :)
Must haves
  • You have experience doing full-stack web development.
  • You understand networking and have experience developing distributed systems
  • You have experience with RDBMS
  • You have functional programming experience.
  • Extreme hustle: you’ll be solving a lot of problems you haven’t faced before without the resources and the support of a giant organization. You must thrive on getting creative in order to get things done.
Very nice-to-haves
  • You have existing familiarity with a functional stack (Haskell / Clojure / Scala / OCaml etc)
  • You're comfortable with the Behavior-Driven Development style and Continuous Delivery
  • You have worked at a very small startup before: you thrive on having a lot of responsibility and little oversight
  • You have worked in small and effective Agile/XP teams before
  • You have delivered working software to large numbers of users before
  • You have done system and network administration and are comfortable working in the Linux environment
  • You have implemented deployment strategies for cloud infrastructure
  • You have experience scaling distributed systems and designing large scale web backends
Benefits
  • Competitive salary
  • Generous equity option grants
  • Medical, Dental, and Vision
  • Lunch is on us three times a week, and half-day event every month (trip to Sonoma, BBQ, etc)
  • Equipment budget
  • Flexible work schedule
  • Flexible, untracked vacation day policy
  • Working from downtown SF, super accessible location right by Powell station
Front Row - our mission

It's an unfortunate reality that students from less affluent families perform worse in school than students from wealthier families. Part of this reason has to do with home environment and absentee parents, but much of it has to do with inferior resources and less experienced teachers. The worst part of this problem is that if a student falls behind in any grade, they will forever be behind in every grade.

That's the core problem Front Row solves - it doesn't let students fall behind. And if they fall behind, Front Row helps catch them up really quickly because Front Row arms teachers with the resources and knowledge to develop their students individually. Now, the probability of falling behind in any given grade is irrelevant, because it will never compound. The student who would have been the most at risk will instead be up to speed, and therefore far more motivated.

Get information on how to apply for this position.

Categories: Offsite Blogs

Significant changes in -Wall for GHC 7.10

haskell-cafe - Tue, 05/05/2015 - 3:54pm
I noticed some significant changes to the flags included with -Wall in GHC 7.10. Many flags that were previously included in -Wall are now not included. These include: -fwarn-type-defaults -fwarn-name-shadowing -fwarn-missing-signatures -fwarn-hi-shadowing -fwarn-orphans -fwarn-unused-do-bind -fwarn-trustworthy-safe I can't find any mention in the release notes of this change in behavior. I was wondering what the rationale is for these changes? Any link to relevant discussion would be appreciated if it exists. Also, what opinion do people have? I previously kept my code -Wall clean, but sometimes that would be a pain. For instance I would munge local names so they wouldn't trigger -fwarn-name-shadowing, and I would add signatures to integers so they wouldn't trigger -fwarn-type-defaults. In fact, I only noticed this change in behavior in 7.10 because I was considering dumping -Wall, and when I looked at the 7.10 manual I saw that it does not enable -fwarn-name-shadowing. (I still use 7.8 but Googl
Categories: Offsite Discussion

Language.Perl? (static analysis of Perl code,in Haskell)

haskell-cafe - Tue, 05/05/2015 - 2:59pm
I am investigating options for analyzing, and refactoring, legacy Perl code. Ideally, the tools would be in a high-level language like Haskell. I found [Pugs][1] and (related) [Language.Perl5][2] but both appear dead. Is there something for Perl that would provide what [hack][4] provides for PHP, and [typescript][5] for JS? (Perhaps I should write a Perl to PHP compiler.) Yes, I know that [Perl is not parseable][3]. - J.W. [1]: http://hackage.haskell.org/package/Pugs [2]: http://hackage.haskell.org/package/HsPerl5 [3]: http://www.perlmonks.org/?node_id=800599 [4]: http://hacklang.org/ [5]: http://www.typescriptlang.org/
Categories: Offsite Discussion

finding things on haskell.org

haskell-cafe - Tue, 05/05/2015 - 2:07pm
The only search feature I'm aware of on the haskell website is the haskell wiki, which is a self-contained little corner. For example, the wiki says nothing about minGHC. To find out what the website has on the subject, I used a Google query: site:haskell.org minghc. Is there thought of a comprehensive site-search facility that can find anything, including stuff that hasn't been wiki-ized? Doug
Categories: Offsite Discussion

Arer there standard functions `left :: Either a b -> Maybe a` and `right :: Either a b -> Maybe b` somewhere?

Haskell on Reddit - Tue, 05/05/2015 - 1:07pm

The implementation is easy:

left = either Just (const Nothing) right = either (const Nothing) Just

But I was expecting to find this in a standard library, but didn't turn anything up in hoogle.

submitted by peterjoel
[link] [19 comments]
Categories: Incoming News

Extensible states

haskell-cafe - Tue, 05/05/2015 - 10:40am
Hi, Anyone used some of the extensible record packages to create a kind of extensible state monad? I mean something that besides having "get", "gets" and "put" would have some kind of "add" and "gets": add :: a -> State () gets :: State (Maybe a) or add :: LabelName -> a -> State () gets :: LabelName -> State (Maybe a) So that I can extend the state without using additional monad transformers. Monad transformers are very hard for beginners and scramble error messages I did the first option for MFlow, hplayground and Transient packages (setSData and getSData). But my solution uses a map indexed by type and this requires a lookup for each access. I would like to know if there is an alternative with no lookups. I´m not obsessed with speed but In some applications the speed may be important.... Anyone?
Categories: Offsite Discussion

Three Complementary Approaches to Bidirectional Programming

Haskell on Reddit - Tue, 05/05/2015 - 10:27am

Just stumbled across a cool paper titled Three Complementary Approaches to Bidirectional Programming

The idea is to define higher-order that takes forward transformation functions and returns the corresponding inverse functions (i.e backward transformation).

I think you will enjoy it!

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

Theory Lunch (Institute of Cybernetics, Tallinn): A concrete piece of evidence for incompleteness

Planet Haskell - Tue, 05/05/2015 - 10:23am

On Thursday, the 25th of March 2015, Venanzio Capretta gave a Theory Lunch talk about Goodstein’s theorem. Later, on the 9th of March, Wolfgang Jeltsch talked about ordinal numbers, which are at the base of Goodstein’s proof. Here, I am writing down a small recollection of their arguments.

Given a base , consider the base- writing of the nonnegative integer

where each is an integer between and . The Cantor base- writing of is obtained by iteratively applying the base- writing to the exponents as well, until the only values appearing are integers between and . For example, for and , we have

and also

Given a nonnegative integer , consider the Goodstein sequence defined for by putting , and by constructing from as follows:

  1. Take the Cantor base- representation of .
  2. Convert each into , getting a new number.
  3. If the value obtained at the previous point is positive, then subtract from it.
    (This is called the woodworm’s trick.)

Goodstein’s theorem. Whatever the initial value , the Goodstein sequence ultimately reaches the value in finitely many steps.

Goodstein’s proof relies on the use of ordinal arithmetic. Recall the definition: an ordinal number is an equivalence class of well-ordered sets modulo order isomorphisms, i.e., order-preserving bijections.Observe that such order isomorphism between well-ordered sets, if it exists, is unique: if and are well-ordered sets, and are two distinct order isomorphisms, then either or has a minimum , which cannot correspond to any element of .

An interval in a well-ordered set is a subset of the form .

Fact 1. Given any two well-ordered sets, either they are order-isomorphic, or one of them is order-isomorphic to an initial interval of the other.

In particular, every ordinal is order-isomorphic to the interval .

All ordinal numbers can be obtained via von Neumann’s classification:

  • The zero ordinal is , which is trivially well-ordered as it has no nonempty subsets.
  • A successor ordinal is an ordinal of the form , with every object in being smaller than in .
    For instance, can be seen as .
  • A limit ordinal is a nonzero ordinal which is not a successor. Such ordinal must be the least upper bound of the collection of all the ordinals below it.
    For instance, the smallest transfinite ordinal is the limit of the collection of the finite ordinals.

Observe that, with this convention, each ordinal is an element of every ordinal strictly greater than itself.

Fact 2. Every set of ordinal numbers is well-ordered with respect to the relation: if and only if .

Operations between ordinal numbers are defined as follows: (up to order isomorphisms)

  • is a copy of followed by a copy of , with every object in being strictly smaller than any object in .
    If and are finite ordinals, then has the intuitive meaning. On the other hand, , as a copy of followed by a copy of is order-isomorphic to : but is strictly larger than , as the latter is an initial interval of the former.
  • is a stack of copies of , with each object in each layer being strictly smaller than any object of any layer above.
    If and are finite ordinals, then has the intuitive meaning. On the other hand, is a stack of copies of , which is order-isomorphic to : but is a stack of copies of , which is order-isomorphic to .
  • is if , if is the successor of , and the least upper bound of the ordinals of the form with if is a limit ordinal.
    If and are finite ordinals, then has the intuitive meaning. On the other hand, is the least upper bound of all the ordinals of the form where is a finite ordinal, which is precisely : but .

Proof of Goodstein’s theorem: To each integer value we associate an ordinal number by replacing each (which, let’s not forget, is the base is written in) with . For example, if , then

and (which, incidentally, equals ) so that

We notice that, in our example, , but : why is it so?, and is it just a case, or is there a rule behind this?

At each step where , consider the writing . Three cases are possible:

  1. .
    Then , as , and .
  2. and .
    Then for a transfinite ordinal , and .
  3. and .
    Then for some , and is a number whose th digit in base is zero: correspondingly, the rightmost term in will be replaced by a smaller ordinal in .

It is then clear that the sequence is strictly decreasing. But the collection of all ordinals not larger than is a well-ordered set, and every nonincreasing sequence in a well-ordered set is ultimately constant: hence, there must be a value such that . But the only way it can be so is when : in turn, the only option for to be zero, is that is zero as well. This proves the theorem.

So why is it that Goodstein’s theorem is not provable in the first order Peano arithmetics? The intuitive reason, is that the exponentiations can be arbitrarily many, which requires having available all the ordinals up to

, times , times:

this, however, is impossible if induction only allows finitely many steps, as it is the case for first-order Peano arithmetics. A full discussion of a counterexample, however, would greatly exceed the scope of this post.


Categories: Offsite Blogs

Functional Jobs: Sr. Software Engineer at McGraw-Hill Education (Full-time)

Planet Haskell - Tue, 05/05/2015 - 9:42am

McGraw-Hill Education is a digital learning company that draws on its more than 100 years of educational expertise to offer solutions which improve learning outcomes around the world. McGraw-Hill Education is the adaptive education technology leader with the vision for creating a highly personalized learning experience that prepares students of all ages for the world that awaits. The Company has offices across North America, India, China, Europe, the Middle East and South America, and makes its learning solutions available in more than 65 languages. For additional information, visit www.mheducation.com.

This Senior Software Engineer position will be joining the new adaptive learning engineering team at McGraw-Hill Education's new and growing Research & Development center in Boston's Innovation District.

We make software that helps college students study smarter, earn better grades, and retain more knowledge.

The LearnSmart adaptive engine powers the products in our LearnSmart Advantage suite — LearnSmart, SmartBook, LearnSmart Achieve, LearnSmart Prep, and LearnSmart Labs. These products provide a personalized learning path that continuously adapts course content based on a student’s current knowledge and confidence level.

On our team, you'll get to: Move textbooks and learning into the digital era Create software used by millions of students Advance the state of the art in adaptive learning technology Make a real difference in education

Our team's products are built with Flow, a functional language in the ML family. Flow lets us write code once and deliver it to students on multiple platforms and device types. Other languages in our development ecosystem include especially JavaScript, but also C++, SWF (Flash), and Haxe.

If you're interested in functional languages like Scala, Swift, Erlang, Clojure, F#, Lisp, Haskell, and OCaml, then you'll enjoy learning Flow. We don't require that you have previous experience with functional programming, only enthusiasm for learning it. But if you have do some experience with functional languages, so much the better! (On-the-job experience is best, but coursework, personal projects, and open-source contributions count too.)

Required Experience:

Have a solid grasp of CS fundamentals (languages, algorithms, and data structures) Be comfortable moving between multiple programming languages Be comfortable with modern software practices: version control (Git), test-driven development, continuous integration, and Agile methodologies.

Get information on how to apply for this position.

Categories: Offsite Blogs

FFI nested structs - malloc - free

haskell-cafe - Tue, 05/05/2015 - 4:42am
FFI Gurus, I created a c2hs FFI of a nested C structure, where struct A has a pointer to a struct B. To do so, I used a malloc, but I am unsure if the memory will be freed when the resulting Ptr is freed. The example at this link uses the same technique, so it will serve as an example. https://github.com/ifesdjeen/haskell-ffi-tutorial/blob/master/src/Example.hsc Line 48 and 51 do the malloc and assign the pointer in the struct, from inside a Storable poke implementation. But, there is no explicit free, nor a finalizer. Will the memory be freed when the Ptr of the Storable is freed? If it is, it implies that some magic keeps track of mallocs inside a poke, and creates finalizers. Or, this example leaks. If it leaks, how do I create a finalizer from inside a poke implementation? Mike
Categories: Offsite Discussion

notepad++ && haskell -> is there a template?

Haskell on Reddit - Tue, 05/05/2015 - 2:03am

Hi, I'm searching for a template plugin or something like that which structures my haskell code in npp, so that all my '=' are on the same level like that: func :: a -> a func a | a == True = 1 | a == False = 2

also it would be nice to have a possibility to fold functions/modules etc.

Is there a way to do all this in notepad++.

Bonus question: is it possible to get some syntax-style/look like you can get with emacs (-> are replaced by real arrows etc.?)

Thx for your help

submitted by baxbear
[link] [2 comments]
Categories: Incoming News

Philip Wadler: Bright Club: Computability

Planet Haskell - Mon, 05/04/2015 - 11:19pm
<iframe allowfullscreen="allowfullscreen" class="YOUTUBE-iframe-video" data-thumbnail-src="https://i.ytimg.com/vi/GnpcMCW0RUA/0.jpg" frameborder="0" height="266" src="https://www.youtube.com/embed/GnpcMCW0RUA?feature=player_embedded" width="320"></iframe>A brief introduction to the hilarious subject of computability theory. Performed as part of Bright Club at The Stand in Edinburgh, on Tuesday 28 April 2015.
Categories: Offsite Blogs

[Jobs] Galois is hiring

haskell-cafe - Mon, 05/04/2015 - 10:16pm
Hello, Galois is hiring! We're looking for researchers, principal investigators, software engineers, and project leads with expertise in functional programming, formal methods, computer security, control systems, or networking. Positions are available at both our Portland OR and Arlington VA offices. For more information on the application process and the available positions, please visit out web site: http://corp.galois.com/careers -Iavor _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe< at >haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Categories: Offsite Discussion

What was your next step after you gave up and washed your hands of any hope of ever binding that massive C++ library you have to use for work to Haskell?

Haskell on Reddit - Mon, 05/04/2015 - 9:59pm

I suspect you moved on to F# or Lua. Maybe you just embraced the new improved C++14. I'd like to hear from you so I know what my options are.

submitted by rdfox
[link] [39 comments]
Categories: Incoming News