[Haskell] Haskell dev role in Strats at Standard Chartered London

2015-06-15 Thread Don Stewart
I'm hiring another Haskell dev to join the Strats team in London.

Details here:

https://donsbot.wordpress.com/2015/06/15/haskell-dev-role-in-strats-at-standard-chartered-london-2/
___
Haskell mailing list
Haskell@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell


[Haskell] VISSOFT 2015 - Call for Papers: New Ideas or Emerging Results and Tool Demos

2015-06-15 Thread Craig Anslow
---
VISSOFT 2015 - Call for Papers: New Ideas or Emerging Results and Tool Demos

3rd IEEE Working Conference on Software Visualization (VISSOFT)
September 27-28, 2015, Bremen, Germany

Paper submission date: June 29, 2015
Notification: July 31, 2015

http://vissoft.info

Software visualization is a broad research area encompassing concepts, methods, 
tools, and techniques that assist in a range of software engineering and 
software development activities. Covered aspects include the development and 
evaluation of approaches for visually analyzing software and software systems, 
including their structure, execution behavior, and evolution.

The VISSOFT IEEE Working Conference on Software Visualization continues the 
history of the ACM SOFTVIS Symposium on Software Visualization and the IEEE 
VISSOFT International Workshop on Visualizing Software for Understanding and 
Analysis. The conference focuses on visualization techniques that target 
aspects of software maintenance and evolution, program comprehension, reverse 
engineering, and reengineering, i.e., how visualization helps professionals to 
understand, analyze, test and evolve software. We aim to gather tool 
developers, experts, users, and researchers from software engineering, 
information visualization, computer graphics, and human-computer interaction to 
discuss theoretical foundations, algorithms, techniques, tools, and 
applications related to software visualization.

Topics of interest include, but are not limited to:
* Innovative visualization and visual analytics techniques for software 
engineering data, such as,
- source code
- static and dynamic dependencies
- software evolution and repositories
- software documentation
- web services
- protocol, log, and performance data
- parallel techniques
- database schemes
- software security and privacy issues
- workflow and business processes
* Visualization to support program comprehension, software testing, and 
debugging
* Interaction techniques and algorithms for software visualization
* Visualization-based techniques in computer science and software engineering 
education
* Integration of software visualization tools and development environments
* Empirical evaluation of software visualization
* Industrial experience on using software visualization

VISSOFT features a New Ideas or Emerging Results (NIER) track and a Tool Demo 
track related to the list of topics suggested above. Papers are solicited that 
present original, unpublished research results and will be rigorously reviewed 
by an international program committee.

The NIER contributions (New Ideas and Emerging Results) describe 
work-in-progress and preliminary exciting results. Authors should include open 
questions and even provocative hypotheses to get early feedback on their 
research ideas or even support through new research collaborations.

Tool contributions describe the design or actual utilization of software 
visualization tools, with a focus on relevant tool construction aspects or the 
use of the tool for gaining new insights. Authors should be prepared to 
demonstrate their tool at the conference. The submission may also contain a 
link to a screencast (video).

All accepted submissions will appear in the conference proceedings and the IEEE 
Digital Library.

-== How to Submit ==-

Both types of papers have to be maximum 5 pages long (including bibliography 
and annexes).
Paper submission date: June 29, 2015 (previously: June 15, 2015)
Notification: July 31, 2015

Submissions must be submitted online via the VISSOFT 2015 EasyChair
conference management system at
https://easychair.org/conferences/?conf=vissoft2015

Please adhere to the formatting instruction published on the ICSME
website:  http://www.icsme.uni-bremen.de/formatting.php


-== Organizing Committee ==-

General Chair:
Jürgen Doellner, Hasso-Plattner-Institut, Germany

Program Co-Chairs:
Fabian Beck, University of Stuttgart, Germany
Alexandre Bergel, University of Chile, Chile

NIER/Tool Co-Chairs:
Craig Anslow, Middlesex University, UK
Johan Fabry, University of Chile, Chile

NIER/Tool Program Committee:

Bilal Alsallakh TU Vienna, Austria
Jennifer Baldwin Swinburne University,Australia
Ivan Beschastnikh University of British Columbia, Canada
Usman Bhatti INRIA Lille / Synectique, France
Michael Burch University of Stuttgart, Germany
Andrei Chis Bern University, Switzerland
Neville Churcher University of Canterbury, New Zealand
Marcus Denker INRIA Lille, France
Coen De Roover Vrije Universiteit Brussel, Belgium
Jens Dietrich Massey University, New Zealand
Bogdan Dit Boise State University, US
Matthias Frisch Magdeburg University, Germany
Maria-Elena Froese University of Victoria, Canada
Michael Homer Victoria University of Wellington, New Zealand
James A. Jones University of California, Irvine, US
Adrian Kuhn AirBNB, US
Jannik Laval Ecole Des Mines de Douai, France
Paul Leger Universidad Catolica Del Norte, Chile
Andrea 

RE: overlapping instances in 7.10.1

2015-06-15 Thread Sergei Meshveliani
On Mon, 2015-06-15 at 09:29 +, Simon Peyton Jones wrote: 
 |  This is why I think that  ghc-7.8.3  treats the OI notion in a more
 |  natural way than ghc-7.10.1 does.
 |  May be, ghc-7.10.1 has a better technical tool for this, but  ghc-
 |  7.8.3 corresponds to a natural notion of OI.
 |  
 |  Can GHC return to a natural OI notion?
 |  Or am I missing something?
 
 Well it all depends what you mean by natural. To me it is profoundly 
 un-natural to deliberately have the same type-class constraint solved in two 
 different ways in the same program!
 
 To require this would prevent cross-module specialisation. If I have  
   f :: C a = a - a
 in one module, and I specialise it to
   f_spec :: [Int] - [Int]
 in one module, I want to be free to re-use that specialisation in other 
 modules.  But under your natural story, I cannot do that, because (C [Int]) 
 might be resolved differently there.
 
 I'd be interested in what others think.  I've started
   https://ghc.haskell.org/trac/ghc/ticket/10526
 to collect these points.
 
 Meanwhile, Sergei, it's clear how to fix docon, so you are no longer stuck.



I hope DoCon is not stuck -- because it relies (so far) on  ghc-7.8.3.

But I need to understand the subject of  overlapping instances  (OI).


--
I am writing this _here_ because to clicking at
 https://ghc.haskell.org/trac/ghc/ticket/10526

my browser responds   Problem occurred while loading the URL   
  https://ghc.haskell.org/trac/ghc/ticket/10526
  SSL handshake failed: A TLS fatal alert has been received.

Then, I start searching from   https://ghc.haskell.org/trac/ghc/
and cannot find #10526
Also I had earlier a certain difficulty with registering to this bug
tracker, and suspect that registration was not fully successful, so that
I doubt that I can write there.

May I, please, discuss the subject here?
---


The report of  7.10.1-errReport-may23-2015.zip
shows that 7.8.3 and 7.10.1  treat OI differently,
But this report is rather complex.

Instead consider the following simple example.


module A where
class Size a where size :: a - Int

instance {-# OVERLAPPING #-}
 Size [a] where  size = length

f :: Size a = a - Int
f = size

g :: [Maybe Int] - Int
g = size


module Main where
import A

instance {-# OVERLAPPING #-}
 Size [Maybe a] where  size _ = -1

mbs = []  :: [Maybe Int]

main = putStr (shows (f mbs) \n) -- I   -1
   -- putStr (shows (g mbs) \n)  -- II   0


Making and running in  ghc-7.10.1 :

  ghc --make -XFlexibleInstances Main
  ./Main

It prints  -1  for the line (I) for main,
and0   for the line (II).

To compare to  ghc-7.8.3,  comment out the pragma and add
-XOverlappingInstances  to the  ghc  call.

And this yields the same results  -1 and  -0  respectively.

Please, how to change (a bit) the above simple example in order to see
the difference between 7.8.3 and 7.10.1
?

Thanks,

--
Sergei 


___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users


Re: ANNOUNCE: GHC 7.10.2 Release Candidate 1

2015-06-15 Thread Austin Seipp
Not in particular - I guess we didn't get everything we precisely
needed for the RC.

I've filed a ticket: #10530

On Sun, Jun 14, 2015 at 10:25 PM, Andrés Sicard-Ramírez
a...@eafit.edu.co wrote:
 On 14 June 2015 at 19:16, Austin Seipp aus...@well-typed.com wrote:
 We are pleased to announce the first release candidate for GHC 7.10.2:

 Since transformers is a GHC-include library, is there any particular
 reason why GHC 7.10.2 RC1 didn't include the latest version of the
 transformers library, i.e. transformers-0.4.3.0?

 --
 Andrés




-- 
Regards,

Austin Seipp, Haskell Consultant
Well-Typed LLP, http://www.well-typed.com/
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users


Re: ANNOUNCE: GHC 7.10.2 Release Candidate 1

2015-06-15 Thread Jens Petersen
On 15 June 2015 at 09:16, Austin Seipp aus...@well-typed.com wrote:
 We are pleased to announce the first release candidate for GHC 7.10.2:

Thank you

I did a 'quick' build of it for Fedora 22 in my Copr repo:

https://copr.fedoraproject.org/coprs/petersen/ghc-7.10.2

I will try to update it to a 'perf' build soon.

Cheers, Jens
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users


Re: ANNOUNCE: GHC 7.10.2 Release Candidate 1

2015-06-15 Thread Austin Seipp
Yes, as noted on the ticket, I've bumped the priority and we'll be
looking into this - and hopefully have a fix in time for 7.10.2. There
are some similar tickets where we get large explosions of terms, so it
may be in the same ballpark.

On Sun, Jun 14, 2015 at 11:18 PM, Rob Everest rober...@cse.unsw.edu.au wrote:
  We plan to make the 7.10.2 final release at the end of this coming week -
 so please test as much as possible; bugs are much cheaper if we find them
 before the release!


 Could I possibly draw attention to #10491? It's a regression in the
 simplifier that is causing considerable pain for Accelerate, namely a
 compile time of many hours for a 300 line module. It would be unfortunate if
 this couldn't be resolved for the 7.10.2 release.



-- 
Regards,

Austin Seipp, Haskell Consultant
Well-Typed LLP, http://www.well-typed.com/
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users


Re: ANNOUNCE: GHC 7.10.2 Release Candidate 1

2015-06-15 Thread Miëtek Bak
Thanks.  GHC 7.10.2-rc1 can now be installed with Halcyon:

halcyon install --ghc-version=7.10.2-rc1 --cabal-version=1.22.4.0

Supported platforms include:

- Amazon Linux 2014.09
- Arch Linux
- CentOS 6, 7
- Debian 6, 7, 8
- Gentoo Linux
- openSUSE 13.2
- OS X 10.8, 10.9, 10.10
- Red Hat Enterprise Linux 6, 7
- Slackware 14.1
- SUSE Linux Enterprise Server 12
- Ubuntu 12.04 LTS, 14.04 LTS, 14.10, 15.04
- Fedora 20, 21


-- 
Miëtek
https://mietek.io




On 2015-06-15, at 01:16, Austin Seipp aus...@well-typed.com wrote:

 We are pleased to announce the first release candidate for GHC 7.10.2:
 
https://downloads.haskell.org/~ghc/7.10.2-rc1
https://downloads.haskell.org/~ghc/7.10.2-rc1/docs/html/
 
 This includes the source tarball and bindists for Windows, Mac OS X,
 and Debian Linux. FreeBSD and Solaris binaries will follow soon. These
 binaries and tarballs have an accompanying SHA256SUMS file signed by
 my GPG key id (0x3B58D86F).
 
 We plan to make the 7.10.2 final release at the end of this coming
 week - so please test as much as possible; bugs are much cheaper if we
 find them before the release!
 
 -- 
 Regards,
 
 Austin Seipp, Haskell Consultant
 Well-Typed LLP, http://www.well-typed.com/
 ___
 ghc-devs mailing list
 ghc-d...@haskell.org
 http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs



smime.p7s
Description: S/MIME cryptographic signature
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users


RE: overlapping instances in 7.10.1

2015-06-15 Thread Sergei Meshveliani
On Mon, 2015-06-15 at 09:29 +, Simon Peyton Jones wrote:
 |  This is why I think that  ghc-7.8.3  treats the OI notion in a more
 |  natural way than ghc-7.10.1 does.
 |  May be, ghc-7.10.1 has a better technical tool for this, but  ghc-
 |  7.8.3 corresponds to a natural notion of OI.
 |  
 |  Can GHC return to a natural OI notion?
 |  Or am I missing something?
 
 Well it all depends what you mean by natural. To me it is profoundly 
 un-natural to deliberately have the same type-class constraint solved in 
 two different ways in the same program!
 
 To require this would prevent cross-module specialisation. If I have  
   f :: C a = a - a
 in one module, and I specialise it to
   f_spec :: [Int] - [Int]
 in one module, I want to be free to re-use that specialisation in other 
 modules. 
  But under your natural story, I cannot do that, because (C [Int]) might be 
 resolved differently there.


Now, I give a simple (and a very contrived) example illustrating of how
overlapping instances  (OI)
are used in DoCon.
Also this example is made after the sample that Simon has given in his
recent letter:

 GHC generally assumes that if it generates   
(the instance) 
 (C T) in one place, then it can use that anywhere in the program that
 (C T) is needed.  That is, there is only one (C T) dictionary.

 But suppose you have overlapping instance in different modules; say

 module A where instance C [a]
 module B where import A; instance C [Maybe a]

 If you use (C [Maybe Int]) in A, then of course we won’t see the 
 instance in B.  So you’ll get a different dictionary than if you 
 compute C [Maybe Int] in module B.
 
 In short, overlapping instances are OK, but it’s best to put them in 
 the same module as the instances they overlap. 


My example:


module A where
class Att a where att :: a - (Int , Maybe Int)

instance {-# OVERLAPPING #-}
 Att [a] where  att xs = (length (reverse xs) , Nothing)

f :: [Maybe Int] - (Int , Maybe Int)
f = att

-
module Main where
import A

instance {-# OVERLAPPING #-}
 Att [Maybe a] where  att mbs = (length mbs , Just 1)

mbs = []  :: [Maybe Int]

main = putStr (shows (f mbs) \n)  -- (I)   (0 , Nothing)
   -- putStr (shows (att mbs) \n) -- (II)  (0,  Just 1)
--

Att  stands for the class C of Simon's letter.
It means  certain attributes of a value, and also of its type.
The value  Nothing  for the second part of (att a) means that the second
component of attributes is not definitely known for this particular
instance. 
length (reverse xs)  imitates a non-optimal method for computing  att
in the instance for  a = [a].  This instance is very general, so that
the first component of attributes is evaluated in-efficiently (but
correct), the second component has a correct value, but highly
indefinite (few information derived).

The function  f  uses the instance  Att [Maybe Int],  
and it is satisfied with the generic instance given in  A.hs.
Because a) at this stage of the project there is not enough
functionality to implement a better special method  b) for this
particular case in this module the generic instance is sufficient. 

Main.hs  defines a special instance of Att for  [Maybe a].
This instance in more special than the one defined in  A.hs.
And the value  (att mbs)  has the first component evaluated more
efficiently than for the generic  (Att [a])  instance.  But the value is
the same.
The second component even has a different value in the result. But it is
considered as correct
(this is similar to the situation of: 
generally the speed is  2  s  8,  
and in this the special case it is  3).

The call  (att mbs)   in `main' uses a different dictionary for  Att
than the call  A.f (mbs).
Right?

Both  ghc-7.8.3  
(with -XFlexibleInstnce -XOverlappingInstances  in the call)
and   ghc-7.10.1  
(with -XFlexibleInstnce  in the call)

give the same results in 'main':
(0, Nothing)  for the line (I)   
and
(0, Just 1)   for the line (II).

And I thought that everything is set naturally in this program.


Simon, you would state that
  as  A.f and  (Main.att mbs)  use the instances of  Att  for the 
  same type  [Maybe Int],
  overlapping instances are OK, but it’s best to put them in the same 
   module as the instances they overlap. 

I do not understand the grammar of the phrase in quotes, either it has a
typo or this is too difficult English for me.
Anyway: does this mean for this particular example, that it is highly
desirable to set the two above instance declarations in the same module
?

1) What if they are in different modules, like in the above example.
   What unnatural may happen -- for example?

2) At least  ghc-7.8.3  and  ghc-7.10.1  do the same in this example. 
   May be, you can change this example a bit to make  ghc-7.8.3 and  
   ghc-7.10.1 diverse, so that my 

[Haskell] Summer School on Generic and Effectful Programming (2nd call for participation)

2015-06-15 Thread Maciej Pirog
Call for Participation

  SUMMER SCHOOL ON GENERIC AND EFFECTFUL PROGRAMMING

   St Anne's College, Oxford, 6th to 10th July 2015
 http://www.cs.ox.ac.uk/projects/utgp/school/

TOPIC

Generic programming is a technique that exploits the inherent
structure that exists in data, to automatically produce efficient and
flexible algorithms that can be adapted to suit different needs. The
goal of this school is to explore datatype-generic programming and
related topics from a variety of different angles, emphasizing in
particular the interplay of generics and effects.

This summer school is the closing activity of the EPSRC-funded project
Unifying Theories of Generic Programming at Oxford University.


LECTURERS

Six lecturers from the Programming Languages community, each an
acknowledged expert in their specialism, will cover various aspects of
generic and effectful programming. Each will give about four hours'
lectures, distributed throughout the week.

  Edwin Brady (University of St Andrews)
  Embedded Domain-Specific Languages in Idris

  Fritz Henglein (University of Copenhagen)
  Worst-case Efficient Generic Functional Programming on Bulk Data

  Andres Löh (Well-Typed)
  Applying Type-level and Generic Programming in Haskell

  Conor McBride (University of Strathclyde)
  Datatypes of Datatypes

  Don Syme (Microsoft Research)
  Compile-time Meta-programming for the Information-rich World

  Tarmo Uustalu (Tallinn University of Technology)
  Containers for Effects and Contexts


PREREQUISITES

The school is aimed at doctoral students in programming languages and
related areas; however, researchers and practitioners will be very
welcome, as will strong masters students with the support of a
supervisor. It will be assumed that participants have a good
understanding of typed functional programming, as in Haskell, O'Caml,
or F#.


DATES

Registration deadline: 21st June 2015
School:6th July (9am) to 10th July 2015 (lunchtime)


COSTS

Costs will be kept low, thanks to support from EPSRC. There will be a
nominal registration fee of £135, and BB accommodation in college
will be £75 (ensuite) or £48 (shared bathroom) per night. We can
accept at most 50 participants; places will be allocated on a
first-come, first-served basis.


FURTHER INFORMATION

Further information, including instructions on how to register, is
available at the website:

  http://www.cs.ox.ac.uk/projects/utgp/school/


___
Haskell mailing list
Haskell@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell