- Generics - Haskell.org

gdiff-ig package difficult to use
by Christopher Done 06 Apr '17

06 Apr '17

>From the haddocks API of gdiff-ig it seems that you can’t actually use it for something useful: http://hackage.haskell.org/package/gdiff-ig-0.1.1 The EditScript type is not exported. Thought someone might want to fix it. There is a test suite using the package: http://hackage.haskell.org/package/gdiff-ig-0.1.1/src/examples/Test.hs But it doesn’t actually inspect EditScript, it just uses its equality instance. You can only use it with patch, but in order to get a EditScript you need both values, so there’s no point in doing let p = diff a b in patch p a, you might as well just use b. And EditScript can’t be serialized. Ciao!

1 0

(issue tracker,) deriving multiple instances
by lennart spitzner 28 Jun '16

28 Jun '16

hi, firstly, the "official" syb issue tracker is read-only. My real question is if the code below is not supposed to work, or if there exists a way to make it work. The direct cause of the error is obvious, and I can think of an (ugly) workaround (define different instances in separate modules), but I'd like to know if such usage of Data is considered bad for some reason. code, error and derived instance: > {-# LANGUAGE StandaloneDeriving #-} > {-# LANGUAGE DeriveDataTypeable #-} > {-# LANGUAGE FlexibleInstances #-} > > import Data.Data ( Data ) > > data Foo f = Foo (f Bool) (f Int) > > deriving instance Data (Foo []) > deriving instance Data (Foo Maybe) ghc-7.10.3 error (ghc-8.0.1 shows the same general behaviour, though the internal identifiers are longer): > Main.hs: line 45, column 1: > Multiple declarations of ‘$cr2C’ > Declared at: Main.hs:44:1 > Main.hs:45:1 > Main.hs: line 45, column 1: > Multiple declarations of ‘$tr2D’ > Declared at: Main.hs:44:1 > Main.hs:45:1 > Main.hs: line 45, column 1: > Duplicate type signatures for ‘$tr2D’ > at Main.hs:44:1-31 > Main.hs:45:1-34 > Main.hs: line 45, column 1: > Duplicate type signatures for ‘$cr2C’ > at Main.hs:44:1-31 > Main.hs:45:1-34 ghc -ddump-deriv for a single instance: > Derived instances: > instance Data.Data.Data (Main.Foo []) where > Data.Data.gfoldl k_a45I z_a45J (Main.Foo a1_a45K a2_a45L) > = ((z_a45J Main.Foo `k_a45I` a1_a45K) `k_a45I` a2_a45L) > Data.Data.gunfold k_a45M z_a45N _ > = k_a45M (k_a45M (z_a45N Main.Foo)) > Data.Data.toConstr (Main.Foo _ _) = Main.$cr3ji > Data.Data.dataTypeOf _ = Main.$tr3gf > > Main.$tr3gf :: Data.Data.DataType > Main.$cr3ji :: Data.Data.Constr > Main.$tr3gf = Data.Data.mkDataType "Foo" [Main.$cr3ji] > Main.$cr3ji > = Data.Data.mkConstr Main.$tr3gf "Foo" [] Data.Data.Prefix

1 0

Summer School on Bidirectional Transformations, Oxford, 25-29th July 2016
by Jeremy Gibbons 02 Jun '16

02 Jun '16

Apologies if you have seen this before, but the early registration deadline (June 10th) is fast approaching for SSBX in Oxford. Please pass this on to anyone who may be interested (and consider coming yourself!). * SUMMER SCHOOL ON BIDIRECTIONAL TRANSFORMATIONS Lady Margaret Hall, Oxford, UK 25th to 29th July 2016 http://www.cs.ox.ac.uk/projects/tlcbx/ssbx/ TOPIC Bidirectional transformations (BX) are means of maintaining consistency between multiple information sources: when one source is edited, the others may need updating to restore consistency. BX have applications in databases, user interface design, model-driven development, and many other domains. This summer school is one of the closing activities on the "Theory of Least Change for BX" project at Oxford and Edinburgh (http://www.cs.ox.ac.uk/projects/tlcbx/) It brings together leading researchers in BX, spanning theory and practice, for a week of lectures in beautiful Oxford. It will be aimed at doctoral students in computer science, but will also be suitable for strong master's students and for researchers. LECTURERS Anthony Anjorin, University of Paderborn, DE "Bx with Triple Graph Grammars" Martin Hofmann, Ludwig-Maximilians-Universitaet Muenchen, DE "Modular Edit Lenses" Zhenjiang Hu, National Institute of Informatics, JP "Principles and Practice of Putback-based Bidirectional Programming in BiGUL" Mike Johnson, Macquarie University, AU "Mathematical Foundations of Bidirectional Transformations" Richard Paige, University of York, UK "Engineering Bidirectional Transformations" The TLCBX team, Universities of Edinburgh and Oxford, UK will introduce, say a bit about TLCBX results, and conclude VENUE The school will take place at Lady Margaret Hall (http://www.lmh.ox.ac.uk/) in leafy North Oxford, right next to the University Parks and the River Cherwell and a short walk from the City Centre. LMH is one of the constituent colleges of the University of Oxford; it was founded in 1878 as the first women's college in Oxford. Our lectures will take place in the splendid Simpkins Lee Theatre in the Pipe Partridge Building, completed in 2010. REGISTRATION The Summer School is financially partially supported by EPSRC. There is an early registration fee of £200 (or £150 for students) if booked before the early registration deadline of 10th June, rising to £250 (or £200 for students) after that point. The registration fee includes lunches, coffee breaks, and a banquet one evening. We have reserved bed-and-breakfast accommodation in college, at £62.50 per night in an ensuite room; there are also a few standard rooms available at £58 per night, but please contact Karen.Barnes(a)cs.ox.ac.uk in advance if you would like to reserve one of them. Those rooms will be released after the early registration deadline, after which point there will be no guarantee of accommodation. Space is limited; there is room for 40 students. FURTHER INFORMATION More information, including the registration link, is on the summer school webpage: http://www.cs.ox.ac.uk/projects/tlcbx/ssbx/ For questions about registration or administrative matters, please contact Karen.Barnes(a)cs.ox.ac.uk. For questions about academic matters, please contact any of the organizers: Faris Abou-Saleh, James Cheney, Jeremy Gibbons, James McKinna, Perdita Stevens * Jeremy.Gibbons(a)cs.ox.ac.uk Oxford University Department of Computer Science, Wolfson Building, Parks Road, Oxford OX1 3QD, UK. +44 1865 283521 http://www.cs.ox.ac.uk/people/jeremy.gibbons/

1 0

SIGPLAN John C Reynolds Doctoral Dissertation Award
by Jeremy Gibbons 22 Nov '15

22 Nov '15

Dear All, I would like to draw your attention to the SIGPLAN John C. Reynolds Doctoral Dissertation Award. If you are (or will be) a 2015 PhD graduate with a great thesis or a supervisor of such a graduate can I suggest you consider applying? Obtaining such an award makes a person stand out when applying for positions. The nomination process is straightforward and nominations are due on the 5th of January. Details of the award can be found at http://www.sigplan.org/Awards/Dissertation/ . If you have any questions, please contact Susan Eisenbach (CC'd). Cheers, Jeremy Jeremy.Gibbons(a)cs.ox.ac.uk Oxford University Department of Computer Science, Wolfson Building, Parks Road, Oxford OX1 3QD, UK. +44 1865 283521 http://www.cs.ox.ac.uk/people/jeremy.gibbons/

1 0

syb-0.5.1 test failure with ghc-7.10
by Jens Petersen 19 Sep '15

19 Sep '15

Hi, Any plans to fix the syb-0.5.1 testsuite failing with ghc-7.10? https://code.google.com/p/scrapyourboilerplate/issues/detail?id=26 Also how about about enabling the issue tracker on github? https://github.com/dreixel/syb Thanks, Jens

3 3

PEPM 2015: First call for papers
by Jeremy Gibbons 17 Jul '14

17 Jul '14

[Note - the submission deadline is earlier than usual, and is FIRM to allow time to apply for a visa.] ----------------------------- C A L L F O R P A P E R S ----------------------------- ======= PEPM 2015 =========== ACM SIGPLAN 2015 WORKSHOP ON PARTIAL EVALUATION AND PROGRAM MANIPULATION Tue-Wed, January 13-14, 2015, Mumbai, India, co-located with POPL'15 http://conf.researchr.org/home/pepm2015 Sponsored by ACM SIGPLAN SCOPE The PEPM Symposium/Workshop series aims at bringing together researchers and practitioners working in the areas of program manipulation, partial evaluation, and program generation. PEPM focuses on techniques, theory, tools, and applications of analysis and manipulation of programs. The 2015 PEPM workshop will be based on a broad interpretation of semantics-based program manipulation and continue last years' successful effort to expand the scope of PEPM significantly beyond the traditionally covered areas of partial evaluation and specialization and include practical applications of program transformations such as refactoring tools, and practical implementation techniques such as rule-based transformation systems. In addition, the scope of PEPM covers manipulation and transformations of program and system representations such as structural and semantic models that occur in the context of model-driven development. In order to reach out to practitioners, a separate category of tool demonstration papers will be solicited. Topics of interest for PEPM'15 include, but are not limited to: * Program and model manipulation techniques such as: supercompilation, partial evaluation, fusion, on-the-fly program adaptation, active libraries, program inversion, slicing, symbolic execution, refactoring, decompilation, and obfuscation. * Program analysis techniques that are used to drive program/model manipulation such as: abstract interpretation, termination checking, binding-time analysis, constraint solving, type systems, automated testing and test case generation. * Techniques that treat programs/models as data objects including metaprogramming, generative programming, embedded domain-specific languages, program synthesis by sketching and inductive programming, staged computation, and model-driven program generation and transformation. * Application of the above techniques including case studies of program manipulation in real-world (industrial, open-source) projects and software development processes, descriptions of robust tools capable of effectively handling realistic applications, benchmarking. Examples of application domains include legacy program understanding and transformation, DSL implementations, visual languages and end-user programming, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, resource-limited computation, and security. To maintain the dynamic and interactive nature of PEPM, we will continue the category of `short papers' for tool demonstrations and for presentations of exciting if not fully polished research, and of interesting academic, industrial and open-source applications that are new or unfamiliar. Student participants with accepted papers can apply for a SIGPLAN PAC grant to help cover travel expenses and other support. PAC also offers other support, such as for child-care expenses during the meeting or for travel costs for companions of SIGPLAN members with physical disabilities, as well as for travel from locations outside of North America and Europe. For details on the PAC programme, see its web page at: http://www.sigplan.org/PAC.htm. All accepted papers, short papers included, will appear in formal proceedings published by ACM Press. Accepted papers will be included in the ACM Digital Library. Following the practice of recent PEPMs, A special issue for Science of Computer Programming is planned with recommended papers from PEPM'15. PEPM has also established a Best Paper award. The winner will be announced at the workshop. SUBMISSION CATEGORIES AND GUIDELINES Regular Research Papers must not exceed 12 pages in ACM Proceedings style (including appendix). Tool demonstration papers and short papers must not exceed 6 pages in ACM Proceedings style (including appendix). At least one author of each accepted contribution must attend the workshop and present the work. In the case of tool demonstration papers, a live demonstration of the described tool is expected. Suggested topics, evaluation criteria, and writing guidelines for both research tool demonstration papers will be made available on the PEPM'15 Web-site soon. Papers should be submitted electronically via the workshop web site. Authors using LaTeX to prepare their submissions should use the new improved SIGPLAN proceedings style (sigplanconf.cls, 9pt template) available at: http://www.sigplan.org/Resources/Author. IMPORTANT DATES Abstract submission: Tue, September 9, 2014 Paper submission: Fri, September 12, 2014 (*FIRM*) Author notification: Mon, October 13, 2014 Workshop: Tue, January 13 and Wed, January 14, 2015 Note: The paper submission deadline is firm. Because the VISA application to India can take a long time, all the schedule is set earlier than previous years. The above schedule is tight: we have absolutely no time to wait for late submissions and we will have no deadline extension. So, please plan ahead. INVITED SPEAKERS to be announced PROGRAM CHAIRS Kenichi Asai (Ochanomizu University, Japan) Kostis Sagonas (Uppsala University, Sweden / NTUA, Greece) PROGRAM COMMITTEE Andreas Abel (Chalmers and Gothenburg University, Sweden) Elvira Albert (Complutense University of Madrid, Spain) Malgorzata Biernacka (University of Wroclaw, Poland) Matthias Blume (Google, USA) Cristiano Calcagno (Facebook, UK) Jacques Carette (McMaster University, Canada) Jeremy Gibbons (University of Oxford, UK) Nao Hirokawa (Japan Advanced Institute of Science and Technology, Japan) Atsushi Igarashi (Kyoto University, Japan) Andrei Klimov (Russian Academy of Sciences, Russia) Michael Leuschel (University of Dusseldorf, Germany) Sam Lindley (University of Edinburgh, UK) Michal Moskal (Microsoft Research, USA) Keiko Nakata (Tallinn University of Technology, Estonia) Jeremy Siek (Indiana University, USA) Peter Thiemann (University of Freiburg, Germany) Janis Voigtlaender (University of Bonn, Germany) Kwangkeun Yi (Seoul National University, South Korea) Tetsuo Yokoyama (Nanzan University, Japan) Jeremy.Gibbons(a)cs.ox.ac.uk Oxford University Department of Computer Science, Wolfson Building, Parks Road, Oxford OX1 3QD, UK. +44 1865 283521 http://www.cs.ox.ac.uk/people/jeremy.gibbons/

1 0

Request for code review: Generics for tuple/newtype introspection
by Anthony Clayden 21 Dec '13

21 Dec '13

(Jeremy's announcements and the occasional spam is meagre fare. I'm showing this list some love ;-) I asked a question on the cafe, starting here: http://www.haskell.org/pipermail/haskell-cafe/2013-October/111133.html and got some very helpful answers. Thank you. Only after that did I realise that I'd asked the wrong questions. I now have something that works (using Generics), but the types are scary (especially the instance constraints). John did warn me: "The types look bigger [than Data/Typeable], but the functions are probably simpler to grok. And once you start using generics the types get much easier to read." I'm looking for a little clarification of what value of "easier" I should expect. What am I trying to do? * As input have a tuple of newtypes: someTuple = (FooD 7, FooD2 True, FooD3 'X') (Think of it as a row in a databse table.) * As output I want a list of tuples of newtypes, each tuple describing an element: [(AttrAttr FooT. AttrBasedOn Int), (AttrAttr FooT2, AttrBasedOn Bool), (AttrAttr FooT3, AttrBasedOn Char)] (Think of this as the column specs for the database table. AttrAttr and AttrBasedOn are newtypes.) * The input tuple could have zero, one, two or more elements. * The elements could be newtypes or data with a single constructor and single based-on type. * Note that the tuples of the output also match this pattern. So I want to recurse inside the constructors, but only to a controlled depth. At first, I tried doing this with Data's gunfold. But in: newtype BarT = BarD alpha deriving (Data, ...) `alpha` is required to be in Data (and so through all its sub-constructors), and that's too stringent a constraint on the users of my package. Also some (base/abstract) types aren't in Data, especially TypeRep: newtype AttrBasedOn = AttrBasedOn TypeRep deriving (Data, ...) Then I turned to deriving Generic, which only requires Typeable of the based-on types. I've tried to follow the pattern in Generic.Deriving.Base and Generic.Deriving.ConNames. (Those are great examples! Pity that they don't seem to be pointed to from the wiki.) But I don't want to descend uniformly through the structures. So is the following appropriate?: {-# LANGUAGE KindSignatures, DataKinds, MultiParamTypeClasses, TypeFamilies, RankNTypes, FlexibleInstances, UndecidableInstances, PolyKinds, FlexibleContexts, FunctionalDependencies, OverlappingInstances, ScopedTypeVariables, NoMonomorphismRestriction, TupleSections, TypeOperators, DeriveDataTypeable, DeriveGeneric, DefaultSignatures #-} module TupleAttrGeneric where import Data.Typeable import GHC.Generics -- wrapper function tupToAttribs :: (Generic a, Rep a ~ (M1 D t1 (M1 C t3 t4)), BodyToAttribs t4 ) => a -> [(AttrAttrib, AttrBasedOn)] tupToAttribs x = map (\(xa, xd, xb) -> (AttrAttrib xa, AttrBasedOn xb)) $ bodyToAttribs body where (M1 (M1 body)) = from x -- worker class/method class BodyToAttribs f where bodyToAttribs :: f a -> [(TypeRep, String, TypeRep)] -- instance for empty tuple `()` instance BodyToAttribs U1 where bodyToAttribs _ = [] -- instance for a newtype element instance (Typeable t1, Generic t1, Rep t1 ~ (M1 D t1' (M1 C t3' (M1 S t4' (K1 t5' t6')))), Constructor t3', Typeable t6' ) => BodyToAttribs (M1 S t (K1 r t1)) where bodyToAttribs (M1 (K1 x)) = [(typeOf x, conName from2, typeOf xb)] where (M1 from2) = from x (M1 (M1 (K1 xb))) = undefined `asTypeOf` from2 -- instance for the products of elements instance (BodyToAttribs f, BodyToAttribs g) => BodyToAttribs (f :*: g) where bodyToAttribs (_ :: (f :*: g) a) = bodyToAttribs (undefined :: f a) ++ bodyToAttribs (undefined :: g a) Questions: * These pile-ups of types (M1 D ... (M1 C ... (...))) seem hairy. Is that the best way to control the depth of recursion? * The suggestion from John Lato (see gist from his message http://www.haskell.org/pipermail/haskell-cafe/2013-October/111139.html ) uses a different style for the class types, avoiding the mysterious unbound typevar class GConName a where getConName :: a -> String -- cp: class ... f where ... :: f a -> String Are there places where one or other is more suitable? (I did try John's style at first, but the constraints got uglier.) * The explicit data constructors in the pattern matching are a bit temperamental w.r.t. undefined values. (Specifically, my instance for (:*:) was crashing.) Should I use dummy `_` patterns throughout? (Then the type annotations are monsters!) Thank you AntC

4 7

Bumping regular-extras upper bound on QuickCheck
by Adam Bergmark 10 Dec '13

10 Dec '13

Hi, regular-extras doesn't allow QuickCheck 2.5 and 2.6, could someone bump it, please? I verified that it compiles with 2.6. Regards, Adam Bergmark

2 2

ACM SIGPLAN Workshop on Data-Centric Programming (at POPL) - talk proposal deadline extended to 22nd Nov
by Jeremy.Gibbons＠cs.ox.ac.uk 20 Nov '13

20 Nov '13

ACM SIGPLAN Workshop on Data-Centric Programming 2014 ----------------------------------------------------- DEADLINE EXTENDED TO FRIDAY NOVEMBER 22 - CONTRIBUTIONS ARE 2 PAGES Please consider submitting to this great workshop Colocated with POPL, January 25, 2014 | San Diego, USA http://research.microsoft.com/DCP2014 Submission: November 22, 2013 Notification: December 4, 2013 We're very pleased to announce DCP 2014, an exciting workshop which builds on the success of the Data-Driven Functional Programming (DDFP) workshop at POPL 2013. This workshop is for anyone who loves the application of functional programming (and indeed other programming paradigms as well) to data-rich domains. Please consider submitting to the workshop - whatever your flavor of data, whatever your flavor of data-centric programming. We want this to be a great event that opens up opportunities at the intersection of data and programming. Functional programming techniques are increasingly important in data-centric programming: languages like Haskell, Scala, and C# draw heavily on a range of functional techniques and find application in numerous data-driven domains; paradigms like map/reduce and its extensions lie at the core of modern scalable data processing; and "information-rich" languages like Ur, F#, and Gosu use meta-programming to integrate type-safe queries, web-based APIs, and scalable data sources - along with associated semantically-rich metadata - into the programming language. In principle, the expressiveness, strong typing, and core functional paradigm of these languages make them an ideal choice for expressing robust and scalable data-centric programming. On the other end, the web of data is growing at an enormous pace, with few dedicated software applications capable of dealing efficiently in information-rich spaces. Reasons for that include one (or more) of the following research issues: lack of integrated development environments (IDEs, such as Visual Studio and Eclipse), poor programming language support, lack of standard testbeds and/or benchmarks, inadequate training, and perhaps the need for curriculum revision. Properly addressing these issues requires interdisciplinary skills, and the collaboration between academia and industry. Many challenges remain. Workshop Goals -------------- This workshop invites submissions that explore the gap between today's data management challenges, particularly the ones related to dealing with large amounts of semantically rich data, and the lack of adequate tools. We are looking for contributions that discuss, promote and further advance the programming of semantically-rich data including the development of new languages, extension of existing ones, and the inclusion of semantic-enabled capabilities into existing IDEs. In this forum, we will discuss, promote, and advance the use of data-centric programming in information-rich data spaces - including the development of new programming and data-manipulation systems as well as the extension of existing ones. By devising methods for handling data from the programming level, we can promote the research and development of better data-centric programming technologies as a whole, as well as facilitate the shift towards both principled and effective data-centric computing. Talk Proposals -------------- We want DCP to be as informal and interactive as possible. The program will thus involve a combination of invited talks, contributed talks about work in progress, and open-ended discussion sessions. There will be no published proceedings, but participants will be invited to submit working documents, talk slides, etc. to be posted on the workshop website. We invite proposals for talks in any area related to the connection between programming and data, including, but not limited to: * Formal systems that capture the essential theoretical elements of data-centric programming * Experimental systems that demonstrate novel data-centric programming techniques * Technology that demonstrates correctness, scalability, productivity, robustness, or maintainability of data-centric programs * Schema evolution, schema-type mapping, query languages, probabilistic programming, network-connected programming, or semi-structured data * Programming-related aspects of knowledge representation techniques including database theory, ontology techniques, and linked data * Impact of specific application areas (e.g. e-science, e-gov, sensors) on information-rich application design * Data exploration and visualization * Evaluation of data quality * Plugins and IDEs for information-rich application development * Cleaning and provenance of data, services, and processes Talks about work in progress are particularly encouraged. If you have any questions about the relevance of a particular topic, please contact the PC chairs at the address dcp.2014(a)lambda-calcul.us . We solicit proposals for contributed talks. Proposals should be at most 2 pages, in either plain text or PDF format. We plan to allocate 30-minute talk slots; but proposals for shorter or longer talks will also be considered. Speakers may also submit supplementary material (e.g. a full paper, talk slides) if they desire, which PC members are free (but not expected) to read. Organization ------------ Program Chairs Jeremy Gibbons, University of Oxford, United Kingdom Evelyne Viegas, Microsoft Research, United States Program Committee Soren Auer, University of Bonn, Germany Nate Foster, Cornell University, United States Juliana Freire, Polytechnic Institute of New York University, United States Erik Meijer, Applied Duality, United States Steffen Staab, University of Koblenz, Germany Don Syme, Microsoft Research Cambridge, United Kingdom Hadley Wickham, Rice University, United States

1 0

Call for Talk Proposals: Data-Centric Programming, San Diego, Jan 2014
by Jeremy.Gibbons＠cs.ox.ac.uk 13 Oct '13

13 Oct '13

ACM SIGPLAN Workshop on Data-Centric Programming 2014 ----------------------------------------------------- Colocated with POPL, January 25, 2014 | San Diego, USA http://research.microsoft.com/DCP2014 Submission: November 18, 2013 Notification: December 2, 2013 We're very pleased to announce DCP 2014, an exciting workshop which builds on the success of the Data-Driven Functional Programming (DDFP) workshop at POPL 2013. This workshop is for anyone who loves the application of functional programming (and indeed other programming paradigms as well) to data-rich domains. Please consider submitting to the workshop - whatever your flavor of data, whatever your flavor of data-centric programming. We want this to be a great event that opens up opportunities at the intersection of data and programming. Functional programming techniques are increasingly important in data-centric programming: languages like Haskell, Scala, and C# draw heavily on a range of functional techniques and find application in numerous data-driven domains; paradigms like map/reduce and its extensions lie at the core of modern scalable data processing; and "information-rich" languages like Ur, F#, and Gosu use meta-programming to integrate type-safe queries, web-based APIs, and scalable data sources - along with associated semantically-rich metadata - into the programming language. In principle, the expressiveness, strong typing, and core functional paradigm of these languages make them an ideal choice for expressing robust and scalable data-centric programming. On the other end, the web of data is growing at an enormous pace, with few dedicated software applications capable of dealing efficiently in information-rich spaces. Reasons for that include one (or more) of the following research issues: lack of integrated development environments (IDEs, such as Visual Studio and Eclipse), poor programming language support, lack of standard testbeds and/or benchmarks, inadequate training, and perhaps the need for curriculum revision. Properly addressing these issues requires interdisciplinary skills, and the collaboration between academia and industry. Many challenges remain. Workshop Goals -------------- This workshop invites submissions that explore the gap between today's data management challenges, particularly the ones related to dealing with large amounts of semantically rich data, and the lack of adequate tools. We are looking for contributions that discuss, promote and further advance the programming of semantically-rich data including the development of new languages, extension of existing ones, and the inclusion of semantic-enabled capabilities into existing IDEs. In this forum, we will discuss, promote, and advance the use of data-centric programming in information-rich data spaces - including the development of new programming and data-manipulation systems as well as the extension of existing ones. By devising methods for handling data from the programming level, we can promote the research and development of better data-centric programming technologies as a whole, as well as facilitate the shift towards both principled and effective data-centric computing. Talk Proposals -------------- We want DCP to be as informal and interactive as possible. The program will thus involve a combination of invited talks, contributed talks about work in progress, and open-ended discussion sessions. There will be no published proceedings, but participants will be invited to submit working documents, talk slides, etc. to be posted on the workshop website. We invite proposals for talks in any area related to the connection between programming and data, including, but not limited to: * Formal systems that capture the essential theoretical elements of data-centric programming * Experimental systems that demonstrate novel data-centric programming techniques * Technology that demonstrates correctness, scalability, productivity, robustness, or maintainability of data-centric programs * Schema evolution, schema-type mapping, query languages, probabilistic programming, network-connected programming, or semi-structured data * Programming-related aspects of knowledge representation techniques including database theory, ontology techniques, and linked data * Impact of specific application areas (e.g. e-science, e-gov, sensors) on information-rich application design * Data exploration and visualization * Evaluation of data quality * Plugins and IDEs for information-rich application development * Cleaning and provenance of data, services, and processes Talks about work in progress are particularly encouraged. If you have any questions about the relevance of a particular topic, please contact the PC chairs at the address dcp.2014(a)lambda-calcul.us . We solicit proposals for contributed talks. Proposals should be at most 2 pages, in either plain text or PDF format. We plan to allocate 30-minute talk slots; but proposals for shorter or longer talks will also be considered. Speakers may also submit supplementary material (e.g. a full paper, talk slides) if they desire, which PC members are free (but not expected) to read. Organization ------------ Program Chairs Jeremy Gibbons, University of Oxford, United Kingdom Evelyne Viegas, Microsoft Research, United States Program Committee (others to be confirmed) Soren Auer, University of Leipzig, Germany Nate Foster, Cornell University, United States Juliana Freire, Polytechnic Institute of New York University, United States Erik Meijer, Applied Duality, United States Steffen Staab, University of Koblenz, Germany Don Syme, Microsoft Research Cambridge, United Kingdom

1 0