So, because all the Prolog papers I was reviewing were referencing Programming in Prolog by W. F. Clocksin and C. S. Mellish I bought an older (and cheap) edition to re-read. I was surprised how good the book is for learning to program in Prolog.

You can use the wonderful Learn Prolog Now! as a free introduction text, but Clocksin and Mellish chapters on grammar rules, debugging and laying out programs makes the book priceless.

And if you want to use prolog for ‘practical matters’ I strongly recommend Jan Wielemaker Ph. D. disertation: Logic programming for knowledge-intensive interactive applications. You’ll find a good overview about using Prolog outside the logic course: Web, multi-threaded, RDFs, literate programming, interfacing with object-oriented systems and interfacing with C for creating data storages.

Finally, If you come from the functional programming world, download Scrap Your Boilerplate—Prologically! a Prolog version of the Scrap Your Boilerplate set of papers. It is a great addition for learning Prolog if your background is functional.

I suppose the emergence of Ruby and the renewed interest in Smalltalk and lisp-based languages like Clojure made DSL an interesting topic for blog posts.

But I must admit that maybe we need to explain what DSL means… or why a good API design is always needed, because:

// describe the optimization problem
LinearObjectiveFunction f = new LinearObjectiveFunction(new double[] {-2,1}, -5);
Collection constraints = new ArrayList();
constraints.add(new LinearConstraint(new double[] {1,2}, Relationship.LEQ, 6));
constraints.add(new LinearConstraint(new double[] {3,2}, Relationship.LEQ, 12));
constraints.add(new LinearConstraint(new double[] {0,1}, Relationship.GEQ, 0));

// create and run the solver
RealPointValuePair solution = new SimplexSolver().optimize(f, constraints, GoalType.MINIMIZE, false);

// get the solution
double x = solution.getPoint()[0];
double y = solution.getPoint()[1];
double min = solution.getValue();

…is not a good API Ben.

• IIS memory leaks when coding ASP pages because it was a threaded server.
• Huge MS SQL server code in the database because developers came from C/S backgrounds.
• Low level dll development interfacing with .asp pages through COM because .asp was not fast enough.
• Registering manually the COM/VB code each time we had to deploy a new release.
• Sacking MS consutants trying to sell you DNA.

I have no idea about Ruby on Rails, but you can botch a MS stack pretty easily.

Also, why do you want to make the Ruby on Rails comunity angry? I have no doubt they’re rabid fanboys, but I know who you are, so don’t be child and stop nagging the children.

I’ve been getting back to knowledge based applications again and again and Jan’s thesys looks good enough to invest some time reading the 257 pdf file. 

Additionally, the swi-prolog site has an interesting page with some additional publications.

 To avoid loss of face, a Chinese employee will not say that he only understood half of what his expat colleague tells him. This leads to misunderstandings, and ultimately to a lot of time lost.

We encountered a lot of these problems working with the outsourcing team that made all our 3D models. The same mistakes would be made over and over again because the modeling team didn’t understand the comments we made on their work, package names would have spelling errors in them, etc.

Towards the end of the project, these problems gradually became smaller, as Chinese artists started to understand English better and expatriates became more proficient in the Chinese language. More bilingual support, both at Spicy Horse and at the outsourcing studio, would have helped a lot in the beginning, though.
 

Globally, the experience is positive.

Software should be able to apply per user customization properties between common members of users’ groups. These communities should be discovered by the application using existing relationships among the users. The relationship should be an integral part of the application, set by the users (via internal application messaging, internal address book, subscription to mailing lists/interest groups…) or the application administrators (hierarchical definitions, ACLs…). From the set of communities the application should extract  customization properties and recommend the common ones to the rest of the community.

Two documents have been useful:

1. Social networks that matter: Twitter under the microscope
   is an introductory paper about choosing the right metric for identifying communities in Twitter, but easily applicable to other social networks.  Conclusion for Twitter: Number of followers is not a good metric, @friends are.

2. Discovering Communities in Linear Time: a Physics Approach is a much more interesting paper. It proposes using Kirchhoff’s laws to find communities in linear time (without the need of edge cutting). The algorithm has some drawbacks (Usha Nandini Raghavan, Reka Albert, Soundar Kumara propose an alternative), but the approach is interesting because allows to identify communities without identifying hierarchical structures.

For more social network papers, HP Labs has an interesting set of them.

Oh! I also work for an HP company, but I have no relationship to the HP Labs papers.

Qitab is the final name of the project ITA will use to publish its lisp code.

The first project in Qitab is POIU a replacement for ASDF that will compile each of your ASDF systems in parallel.

Also, ITA published XCVB, a compillation tool for SBCL. Zach wrote a post about it in May.

ITA is known in lisp world for being a proud user of lisp in software development world, and contributing to existing lisp projects (from SBCL to slime). They’re also vocal about lisp use in today’s most complex problems (low fare search engine is one of their business) so they’re widely respected.

They will be publishing generally purpose libraries and utilities. No Airline Industry code will be published.

Additional information will be found in the devel and announce mailing lists.

Update: ITA has changed the project name, more information in the following post.

Basically code reuse and inheritance are not orthogonal, so I never know if my class hierarchy should be designed to maximize code reuse, or if I should limit my code reuse not to interfere with the class hierarchy. There’s no simple rule, and it isn’t trivial to make the right decision. As the paper summarizes:

[...]multiple inheritance uses the notion of a class in two competing roles: the generator of instances and the unit of code reuse

Schärli, Ducasse, Nierstrasz and Black describe the pitfalls of inheritance (single, multiple and through mixins) as a code reuse tool in their paper (check chapter 2) with such clarity I recommend any OOP programmer to read the paper.

Unfortunately they do not consider delegation in the mix, so there is some room for improvement. Their only reference is at the end of chapter 7:

Delegation (also known as “object-based inheritance”) is another form of composition that side-steps many of the problems related to class-based inheritance [24]

Have in mind this paper is not about reusability problems with inheritance, but about traits, their proposed solution to these problems. If you’re interested in traits you’ll find a good discussion in Reddit’s thread OO Programming: why “traits” rule and mixins and multiple inheritance suck.