While waiting for my plane and thinking about a what a VHDL/Verilog killer would look like, I had a very (un!)original idea: describe what is to be done in English, and let the killer do the code derivation.
Here is an example of a description of how I want my blob detection (a computer vision application) be done on incoming images:
blob detection, image processing
This description is enough for a human to write the code, but not so for a computer, that has no understanding of any of these words.
Now my question is, is there anyone working on this?
To start working on this, here is what I want to do (in my spare time):
I like to hear your reasons on why it is or is not possible!
Hi all :)
I'm thinking about extending Wikipedia with a new page: Structured BNF. Is anyone interested in helping in changing content or lecturing it before I publish it? I would appreciate any comment, even if you think that this is not a thing to place in Wiki.
In Î»-calculus, all functions are unary, and n-ary functions are encoded through currying. But knowing the arity of a function can be useful for optimization â€” a curried function starts computing only after applying it to at least N arguments, and this N can be useful to know.
Below I explain the details.
Applications of arity:
But function arity is a tricky concept in Î»-calculus. For instance, id should be unary, Haskell's ($) is binary, but ($) is defined as equal to id:
($) :: (a -> b) -> a -> b
So, a notion of arity seems tricky, and one of my colleague keeps repeating it's a bad idea.
Today, while reading a paper using CBPV (Hammer et al. 2014), I got a hunch that the call-by-push-value (CBPV) lambda calculus seems to allow for a natural notion of arity. But Googling does not find this spelled out anywhere, maybe because CBPV seems typically used in theoretical contexts. I'm
So, why should CBPV help?
(1) It distinguishes values (A) and computations (C): Computations are either functions (A -> C) which take values and return computations, or base computations F A which wrap values in a "return" expression:
C ::= A -> C | F A
So, the return type of a function is wrapped by the F constructor. In particular, this distinguishes A1 -> A2 -> F A3 (a binary function) from A1 -> F (U (A2 -> F A3)), a unary function returning another unary function.
(2) Moreover, we also distinguish partial and full applications: since a full application produces a result of type F A, we need to use the elimination form for F.
Thus, after conversion to CBPV, we can distinguish syntactically between partial and full applications.
Liu, Y. A., and Teitelbaum, T. Caching intermediate results for program improvement. In Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (New York, NY, USA, 1995), PEPM â€™95, ACM, pp. 190â€“201.
I would normally post this to G+, but I'm in a 3 day vacation weekend behind the great firewall, so here goes. Pursuing a CLOS submission on hackernews this morning, I came across an awesome quote in the comments section:
Many would find this very controversial, but it is increasingly true for younger programmers (and I've gotten into this habit myself). It has serious implications on programming language design: efficient feedback loops are much more important as design occurs more by doing than being done up front, functionality should be discoverable at least by searching. What else?
I am currently searching for anything that calls itself a "Database Programming Language", and in particular any reviews or helpful comparisons.
The purpose is something of a long term hobby project, non-commercial but also non-academic. I'm most interested in languages that have at least some prospect of finding users with real problems to solve and real data to manage, but I'm also interested in more esoteric ideas for their future prospects.
My list currently includes (no particular order) : Datalog, DBPL/Tycoon, Dataphor/D4, Tutorial D, Business System 12, Rel Project, Kleisli, Xduce, Links, Cduce. I would be interested to add to the list.
It would be helpful to know of any confirmed deaths. In particular, it's impossible to Google for Links. Does it live?
I'm working my way (slowly) through the C2 Wiki -- bit of a mixed blessing -- and I know about the DBPL conference and the DBLP bibliography site (confusing). Other resources would be appreciated too.
Call for Scholarship Applications: Programming Languages Mentoring Workshop - a POPL workshop (Deadline: September 19!)
CALL FOR SCHOLARSHIP APPLICATIONS (Deadline September 19!)
ACM SIGPLAN Programming Languages Mentoring Workshop, Mumbai, India
Wednesday, January 14, 2015
Co-located with POPL 2015
PLMW web page: http://plmw15.iisc-seal.net/
After the resounding success of the first three Programming Languages
The purpose of this mentoring workshop is to encourage graduate students
So far, we have the following speakers confirmed to speak at the
- Adam Chlipala (MIT)
We especially encourage women and underrepresented minority students to
This workshop is part of the activities surrounding POPL, the Symposium
A number of sponsors (listed below) have generously donated scholarship
Students attending this year will get one year free student membership
The workshop registration is open to all. Students with alternative
APPLICATION for PLMW scholarship:
The scholarship application can be accessed from the workshop web site
The reason for this early pre-registration has to do with obtaining
A kickstarter project. Abstract:
Programming as the basis of a magic system seems like a great idea, though I think the challenges would be in balancing (resource consumption of the spell must be restricted!).
A couple of weeks ago (the database LtU seems corrupted so I can't find the link) I posted about my theory of data parallel computing. I make a bunch of claims (not necessarily in that paper) why my idea can lead to more efficient software than some other parallel programming systems, and I was wondering why.
At some level, my Integrative Model for Parallelism is based on dataflow, as an Intermediate Representation, to be exact. And I think one reason dataflow approaches can be efficient is that the dataflow graph is a representation of the program in the program. By building up a dataflow graph, the program reconstructs a limited version of itself that can then be analyzed by a higher level tool than either the compiler or a traditional runtime.
My question to this esteemed audience: surely I'm not the first one to observe this. Is there a formalism, or at least a vocabulary to describe this phenomenon?
(Background info: I know that dataflow is a 1980, early 90s at best, phenomenon, but it's been in resurgence, with OpenMP tasks (OMP v3 and later), Intel TBB & CnC, and dedicated linear algebra software such as SuperMatrix and Quark. In all these cases the C/Fortran program creates a task graph out of ordinary function pointers and submits it to some scheduler which can be defined on a fairly high level, in a library itself written in C.)
Portland, Oregon, USA
Sponsored by ACM SIGPLAN
The ACM SIGPLAN conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH) embraces all aspects of software construction and delivery to make it the premier conference at the intersection of programming, languages, and software engineering. SPLASH is now inviting calls for participation.
** REGISTRATION **
** CONFERENCE PROGRAM **
** KEYNOTE Speakers **
** OOPSLA Research Papers**
** Onward! Research Papers **
** Onward! Essays **
** Dynamic Languages Symposium (DLS) **
** Wavefront **
** Panels **
** SPLASH-E **
** Artifacts **
** Workshops **
** Tutorials **
** Demos **
** Posters **
** Doctoral Symposium **
** Student Research Competition **
** Co-located Events **
ACM SIGAdaâ€™s Annual International Conference High Integrity Language Technology (HILT)
Multicore Parallel Programming Course:
** Location **
** Organization **
SPLASH General Chair: Andrew Black (Portland State University)
Apparently, Microsoft applied for a patent on "safe" transitive immutability for object types. I use "safe" to summarize a useful feature: even though object constructors can set fields of an immutable object, the mutable reference to this cannot escape the constructor and become visible to other code. I say "transitive" because contained objects are immutable even though their types would be mutable.
Active forum topics
New forum topics