Peter Selinger. A brief survey of quantum programming languages.
In Proceedings of the 7th International Symposium on Functional and Logic Programming, Nara, Japan. Springer LNCS 2998, pp. 1-6, 2004.

A brief but useful survey of quantum programming languages (six pages), that I think wasn't mentioned here before.

Section 2.1 describes the common target hardware models (the quantum circuit model, QRAM, and quantum Turing Machines).

Section 2.2 is about imperative quantum languages (e.g., QCL), and section 2.3 discusses functional quantum languages.

Interesting draft paper on the History of Haskell by Simon Peyton Jones, Phil Wadler, Paul Hudak, and John Hughes.

This paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact.

This paper is aimed at History of Programming Languages - HOPL III to be held in June 2007.

In 1978, the first History of Programming Language Conference (HOPL) described the development of 13 computer programming languages, the people who participated in that work, and the context in which it was undertaken. In 1993, HOPL-II contained 14 papers on the genesis and evolution of programming languages. It is time for HOPL-III, to be held with FCRC 2007 in San Diego. Each HOPL-III paper should detail the early history or evolution of a specific programming language. Preliminary ideas about each language should have been documented by 1996 and each language should have been in use by 1998.

Overview

Web development incorporates all areas of creating a Web site for the World Wide Web. This includes Web design (graphic design, XHTML, CSS, usability and semantics), programming, content management, marketing, testing and deployment. The term can also specifically be used to refer to the "back end", that is, programming and server administration.

ref: Wikipedia: Web Development

• I Monster Lance: Outsourcing Freelance
• Programming IT Services,
• Custom Web Design, PHP Programmers,
• IT Freelancers,
• Computer Programming Work,
• , Freelance Website. . .
  read more:

The first 10 Prolog Programming Contests took place in Ithaca (1994), Portland (1995), Bonn (1996), Leuven (1997), Manchester (1998), Las Cruces (1999), Paphos (2001), Copenhagen (2002), Mumbay (2003) and Saint-Malo (2004). The contest organisers have written this book, containing the (slightly reworked) questions and an answer (in Prolog of course) for each question... The book is now also freely downloadable on this page.

For your enjoyment...

O'Reilly has published Computer Science & Perl Programming - Best of The Perl Journal. This is a compilation of articles originally published in The Perl Journal. Chapter 57, 'Spidering an FTP Site', is an article I wrote for The Perl Journal which describes how to recursively upload/download files and directories to/from an FTP site.

Lately I've been working on ‘Den’ and other things relating to the E programming language.

A Core Calculus for Scala Type Checking, is a new paper by the Scala team.

Abstract. We present a minimal core calculus that captures interesting constructs of the Scala programming language: nested classes, abstract types, mixin composition, and path dependent types. We show that the problems of type assignment and subtyping in this calculus are decidable.

The paper revolves around the question of decidability of type checking in Scala. The following quote summarizes the background of this question.

Scala’s approach to component modeling is based on three programming language constructs: modular mixin composition, abstract type members, and explicit self-types. All three have been studied in the vObj calculus. A key concept of the vObj calculus, path-dependent types, is also present in Scala. However, some other constructions of vObj do not correspond to Scala language constructs. In particular, vObj has first-class classes which can be passed around as values, but Scala has not.
First-class classes were essential in establishing an encoding of F<: in vObj, which led to a proof of undecidability of vObj by reduction to the same property in F<:. However, since Scala lacks first-class classes, the undecidability result for the calculus does not imply that type checking for the programming language is undecidable.

Ehud: Given current interest in Scala and its more or less unique (don't want to raise controversy here) position as being both a functional and an OO language, furthermore being much more than a toy language, would it be a good idea to give Scala a place in the Spotlight section?

Event-Based Programming without Inversion of Control. Philipp Haller and Martin Odersky.

Scala is different from other concurrent languages in that it contains no language support for concurrency beyond the standard thread model offered by the host environment. Instead of specialized language constructs we rely on Scala's general abstraction capabilities to define higher-level concurrency models. In such a way, we were able to define all essential operations of Erlang's actor-based process model in the Scala library.

However, since Scala is implemented on the Java VM, we inherited some of the deficiencies of the host environment when it comes to concurrency, namely low maximum number of threads and high context-switch overhead. In this paper we have shown how to turn this weakness into a strength. By defining a new event-based model for actors, we could increase dramatically their efficiency and scalability. At the same time, we kept to a large extent the programming model of thread-based actors, which would not have been possible if we had switched to a traditional event-based architecture, because the latter causes an inversion of control.

(There's not really a proper abstract. The above is from the conclusion.)

I enjoyed this paper. It's a quick read and a nice demonstration of some of Scala's cool features. It's also a good example of using exceptions as delimited control operators, and in fact the one substantial restriction is imposed by the lack of the more powerful operators. They use Scala's type system to reduce the burden of this restriction, however, since they're able to state that a particular statement never returns normally (and thus must not be followed by more statements).

Those interested in the language/library boundary will also find it interesting for this reason:

The techniques presented in this paper are a good showcase of the increased flexibility offered by library-based designs. It allowed us to quickly address problems with the previous thread-based actor model by developing a parallel class hierarchy for event-based actors. Today, the two approaches exist side by side. Thread-based actors are still useful since they allow returning from a receive operation. Event-based actors are more restrictive in the programming style they allow, but they are also more efficient.

They have some fairly impressive empirical scalability results as well.

I started the project with two goals in mind: Getting more experience developing real-world Web applications and promoting Chef Moz, a corner of the Open Directory Project devoted to restaurant listings and reviews. Chef Moz offers its entire database under an open license, but no one appears to be doing anything with it.

I'm beginning to understand why. There are a lot of obstacles to overcome when dealing with 134 megabytes of XML data that isn't well-formed, contains hundreds of illegal characters, and isn't in the UTF-8 character set as described in the documentation. (I was so desperate at one point I turned to Perl, which is my language of last resort.)

I'm hoping the project becomes a useful consumer-friendly interface to Chef Moz, which is designed more for project contributors than hungry diners, as shown in this before and after view. At a minimum, it should give me plenty of fodder for programming articles here on Workbench (and future books).
read more:

Design and programming activity as a profession is better performed with mathematics and applied logic concepts as first-class tools in the hands (heads) of practitioners.

There are a significant number of factors to take care of in order to improve design and programming skills that last. Two of those are: essential mathematics and, first-order logic (also known as first-order predicate calculus). If you are serious about a design and programming career, you know that already.

This is another trait of the current youthful state of mainstream software development industry where many, many people delude themselves into thinking that formalism means tons and tons of paperwork or (not kidding) a dress code wearing mandatory suit and tie. Then, some of them will say: 'we are formal here'.

Regardless of what people are wearing, good and needed formalism in our industry is the kind of formalism related to useful software specifications, that is to say, class interface design and programming by contract.

In other words: 'Talent Mandatory, Suit Optional' as stated in Quinn Emanuel’s philosophy towards law.

Bertrand Meyer in his book, Object-Oriented Software Construction-2nd Edition, page 400, in a section entitled 'The expressive power of assertions' said:

'Including a full specification language into the language of this book would have completely changed its nature. The language is meant to be simple, easy to learn, applicable to all areas of software construction, and implementable efficiently (with a final run-time performance similar to that of Fortran and C, and a fast compilation process).

Instead, the assertion mechanism is an engineering tradeoff: it includes enough formal elements to have a substantial effect on software quality; but stops at the point of diminishing return — the threshold beyond which the benefits of more formality might start being offset by the decrease of learnability, simplicity and efficiency.

Determining that threshold is clearly a matter of personal judgment. I have been surprised that, for the software community at large, the threshold has not moved since the first edition of this book. Our field needs more formality, but the profession has not realized it yet.'

Assertion-first design, also known as test-driven development represents a powerful and reasonable tool at the hands of more and more designers and programmers, hoping the level of mathematic formalism in software development increase in a positive way.

Socially Responsive, Environmentally Friendly Logic
by Samson Abramsky

We consider the following questions: What kind of logic has a natural semantics in
multi-player (rather than 2-player) games? How can we express branching quantifiers, and
other partial-information constructs, with a properly compositional syntax and semantics?
We develop a logic in answer to these questions, with a formal semantics based on multiple
concurrent strategies, formalized as closure operators on Kahn-Plotkin concrete domains.
Partial information constraints are represented as co-closure operators. We address the
syntactic issues by treating syntactic constituents, including quantifiers, as arrows in a
category, with arities and co-arities. This enables a fully compositional account of a wide
range of features in a multi-agent, concurrent setting, including IF-style quantifiers.

This paper seems to unify multiple interesting directions - logic, game semantics, concurrent constraint programming (and concurrent programming in general).

At the same time it remains very accessible, without overwhelming amount of math, so can be hopefully useful not only for academics. I, for one, was waiting for exactly this kind of paper for two years (and my interest is very practical).

Multiplayer Curry-Howard correspondence, anyone? Or Curry-Howard for web services?

Registration is now open for the 9th Annual ICFP Programming Contest. The ICFP contest is an event that traditionally raises interest in the LtU community.

A more detailed announcement found in the forum mentions that this year's theme is 'computational archaeolinguistics.' Intriguing.

If, and only if, MDA proponents articulate a new kind of general-purpose source code at a higher level of abstraction such as we never ever need to see again third generation programming languages source code.

If you need to see it again, then MDA is just CASE fallacy resurrected.

A book that is sub-titled 'Everything you need to learn JavaScript from scratch' is obviously not aimed at experienced JavaScript developers. However I don't think Simply JavaScript is suitable for absolute beginners either, since it contains programming examples that aren't all that easy for someone without at least some programming or scripting experience to wrap their head around.

The authors, Kevin Yank and Cameron Adams, get off to a great start by explaining the three layers the Web is built on (presentation, content, and behaviour) and how CSS, HTML, and JavaScript should be used for each separate layer. When a JavaScript book starts by talking about unobtrusive scripting and even mentions that perhaps JavaScript isn't always the best way of solving a problem, you can be reasonably sure that it's been written by someone who knows about modern Web development.

Since this book is not aimed at JavaScript experts, there is a whole chapter devoted to explaining the basics of programming with JavaScript. Variables, statements, conditions and loops, functions, and objects are all talked about in an easy-to-understand way, accompanied by plenty of code examples and illustrative figures.

After the first two introductory chapters, the authors dive into some actual programming for the next several chapters. The DOM, events, animation, form scripting, finding and debugging errors, and Ajax are all discussed in one chapter each. The final chapter takes a look ahead at the future of JavaScript.

Throughout the book, the Core JavaScript library is used to make some common DOM scripting tasks easier. I hadn't heard of Core before, but it seems to do the job and is very lightweight. It's so small that the entire source is included in the book.

Overall I think the authors do a great job of explaining JavaScript. The examples and code are easy to follow and explained well, and the book is written in a friendly and inviting tone. I picked up a few tips and tricks from reading this book, which for me makes it worth the time it took to read it.

Revisiting the sub-title of this book, I think the audience that will get the most out of it falls somewhere in between the novice and expert levels. To me it seems best suited for designers or developers with a decent knowledge of HTML and CSS and some familiarity with JavaScript. If that describes you, I can recommend Simply JavaScript.

As with all SitePoint books, there are sample chapters you can download to find out if the book is right for you.

Simply JavaScript

Authors: Kevin Yank, Cameron Adams

ISBN-10: 0980285801

ISBN-13: 978-0980285802

Add 456 Berea Street to your Technorati favorites.

Posted in JavaScript, Reviews.

In preparation to write some papers about software design techniques, I am planning to illustrate those techniques with a variety of examples. As part of the effort I will document my thoughts while doing reflective practicum, identifying and documenting patterns of thought while programming solutions to several kinds of problems; including implementation of simple algorithms like insertion sort, selection sort, bubble sort and more complex ones. By now, let’s see the code so far.

Consider the following main function:

#include <iostream>#include <vector>#include <iterator>using namespace std;void main(){  sort( sort_by_selection<vector<int> >() );  sort( sort_by_insertion<vector<int> >() );  sort( sort_by_bubble<vector<int> >()    );}

template<typename T>void sort(T sort_algorithm){  int v[]={100,80,70,70,60,50,40,40,20,10,-1,-2};  vector<int> V(v,v+sizeof(v)/sizeof(int));  ostream_iterator<int> out(cout,' ');  copy(V.begin(),V.end(),out);  sort_algorithm(V);  cout << endl;  copy(V.begin(),V.end(),out);  cout << endl;}

template<typename T>class sort_by_selection{public:  void operator()(T& v)  {    T::size_type length=v.size();    if(length<2) return;    for(int k=0;k<length;++k)    {      int min=k;      for(int j=k+1;j<length;++j)        if(v[j] < v[min])          min=j;      T::value_type t=v[k];      v[k]=v[min];      v[min]=t;    }  }};template<typename T>class sort_by_insertion{public:  void operator()(T& v)  {    T::size_type length=v.size();    for(int k=1;k<length;++k)    {      T::value_type key=v[k];      int j=k-1;      while(j>=0 && key < v[j])      {        v[j+1]=v[j];        --j;      }      v[j+1]=key;    }  }};template<typename T>class sort_by_bubble{public:  void operator()(T& v)  {    T::size_type length=v.size();    for(int k=0; k<length-1; ++k)    {      for(int j=length-1; j>k; --j)      {        if( v[j] < v[j-1] )        {          T::value_type t=v[j-1];          v[j-1]=v[j];          v[j]=t;        }      }    }  }};

CLPython is an implementation of the Python programming language in Common Lisp. It is developed by Willem Broekema with support from Franz Inc. CLPython is released under the LLGPL.

You might enjoy browsing the source code.