The Greyness of Gold

Steve McMcConnell's Software Project Survival Guide mentions gold plating a project, specifically: "Implement only what is required. Developers, managers, and customers often think of small, easy changes that seem to make the software better. These changes often have much more far-reaching impacts than anticipated by the specific developer who will implement the change. Do not let additional complexity creep into the project through gold-plating."

This may fly in the face of ideas like refactoring (although refactoring is generally an attempt to remove complexity not add it). To put this into context, though, the team that he's talking about is well above the quality curve: "...the average MIS shop would need about 14 calendar months and 110 staff-months to deliver a 100,000 line-of-code MIS system, and it would typically contain about 850 defects when delivered. The NASA SEL [the team in question] would deliver a system of that size with about the same amount of time and effort, but it would contain only about 50 defects."

So when you have a manager talking about not wanting to have a gold plated solution check to see if your project is delivering on the 50 defects/100,000 lines of code first.

Of course, the original point is true too - you can continually seek the perfect solution to a business problem, probably forever, and in doing so add complexity to a system. Business processes aren't always rational so there may not be a good solution to the problem. So continually swapping ways of solving a problem can be an untenable situation.

I know that some people want to refactor code forever and others are happy just to write code and see if it works somehow. There's obviously a balance.

To me saying, "I don't want a gold plated solution" is asking not try to achieve a certain level of quality and certainly most IT shops should be trying to do more not less.

Battle Between Two Towers Continues

"Position Paper: A Comparison of Two Modelling Paradigms in the Semantic Web" which continues some of the themes from "Semantic Web Architecture: Stack or Two Towers?".

"One paradigm is based on notions from standard logics, such as propositional logic, first-order logic, and Description Logics...the Classical paradigm...The other paradigm is based on notions from object-oriented databases... and rule languages...the Datalog paradigm."

"The Semantic Web is a very hostile environment for the unique name assumption. There are many and varied sources of information in the Semantic Web, even in the same area, and these sources are free to coin their own identifiers (IRIs) for anything they choose. For example, there are many providers of FOAF information, each of which may choose to use different identifiers to identify to the same individuals."

"FOAF mailboxes form a unique identifier for members of Person (i.e., mbox is an inverse functional property in FOAF). So, if one information source includes:
mbox(Bill Jones, "mailto:Bill Jones@ex.com") and another includes
mbox(William Jones, "mailto:Bill Jones@ex.com"), then it can be inferred from the two sources that Bill Jones and William Jones identify the same individual. This is not possible in the Datalog paradigm..."

"...mary and john could be the same, and due to the cardinality restriction it is inferred that they are, indeed, the same...here is an easy solution—simply state that these two individuals are different...it is also a good idea in general to explicate
inequalities (and disjointness) where they are known."

"Another way in which to apply a local closed world and/or unique name assumption would be to augment the Classical paradigm with constructs that could provide a Datalog-like flavour for portions of the Semantic Web. For example, there is no conceptual problem in providing constructs that state that certain information sources abide by the unique name assumption or are complete in some way."

"A promising direction for the future is to add epistemic constructs to OWL. An epistemic Description Logic provides a formalism that is mostly open, but that can close certain areas of information as desired."

I wonder if applying ideas like Date's SUMMARIZE operator whether things like COUNT, SUM, etc. could be applied to the Classical model.

Shiny Languages

Reasons Why Your Startup Should Use Ruby On Rails (RoR) "When tempted to adopt the newest “silver bullet” technology that promises immense gains in programmer productivity (which RoR does), understand what the tradeoffs are. To get even keener insight, study a little bit of history and find out what has come before. It’s possible that in your situation RoR is indeed the best choice, but likely not for the reasons above. If you find yourself agreeing with one of the eight reasons above, we really need to talk."

Another related article, "Why Ruby is an acceptable LISP".

And, "SQL On Rails".

Via Javalobby.

Organising Test Cases

One of my recent delvings into test driven code is how to ensure that all classes that implement an interface follow a given contract with the minimal amount of rework per class. In "Organising design-by-contract test code" it suggests creating "...abstract test cases for each of your (work) interfaces. These abstract test cases are specifically geared at testing the contract promoted by the (work) interfaces, and not things like setup, initialization or destruction code...Create concrete subclasses for these abstract test cases, which feed the superclass an instance of an implementation of the (work) interface that is being tested. These concrete classes are responsible for creating mock objects of the dependencies, doing any neccessary initialization, etc."

This is something I have used in the past, in something like JRDF there's abstract test cases that keep the creation of various objects hidden from the tests themselves.

My preference now is a little different - instead of using inheritance I use composition and I think that better reflects the flexibility of interfaces. Another advantage I've found is that ability to cross cut certain behaviours between these composed objects such as exception handling.

Ruby on Rails Development

"At the end of the day you sit there and realise that you spent the entire day writing 100 lines of code and then deleting 90 of them. :)"

And the perverse thing is, I couldn't think of anything more satisfying than going through that process.

The Rails Development Pattern.

Google TechTalks

Practical Common Lisp and Knowledge Representation and the Semantic Web.

Via Google Techtalks.

Another Spring 2.0 Update

What's new in Spring 2.0? " Previous versions of Spring had IoC container level support for exactly two distinct bean scopes (singleton and prototype). Spring 2.0 improves on this by not only providing a number of additional scopes depending on the environment in which Spring is being deployed (for example, request and session scoped beans in a web environment), but also by providing 'hooks' (for want of a better word) so that Spring users can integrate their own scopes with (hopefully) a minimum of effort.

It should be noted that although the underlying (and internal) implementation for singleton- and prototype-scoped beans has been changed, said change is totally transparent to the end user... no existing configuration needs to change, and no existing configuration will break."

No more Spring Session Components Workarounds. Although, custom bean scopes shouldn't be worked on until RC1.

Ben Hale's Atlanta DevCon 2006 via Atlanta DevCon 2006.

Annotations All Around

Looking around at the talk on JPA, Java Persistence API Overview "Part of JSR-220, it began as a simplification of entity beans and evolved into POJO persistence. Scope expanded from EE environments to include Java SE. The reference implementation is available as part of GlassFish (the implementation donated by Oracle). The query language was expanded. You can use annotations and/or xml configuration, finally, the persistence runtime provider is pluggable.

Entity what's new:

* Created with new operator
* no required interfaces
* Have persistent identity
* May have both persistent and non-persistent state
* If they are Serializable, you can pass between around without the need for DTO's"

Also, lists the named and dynamic queries, object loading, table relationships and transaction handling.

Pretty much every example with JPA (EJB 3.0) consists of annotations, Annotations and the Object Model "Another approach, similar to the way we've used XDoclet or XDocclet 2, is to have the model and its annotations all in one class, which looks a lot like the class above." and another example, Extending EJB 3.0 with Interceptors "EJB 3.0 formalizes interceptors, already available in proprietary products, you can also intercept EJB life cycle events."

Netbeans seems to have taken the lead on some of this stuff including, See some NetBeans 5.5 (beta) features and screenshots.

Dereferencing

More Simpson's references, Lisa's Rival:
"Homer: [sleepy] Must...protect...sugar. Thieves everywhere. The strong
must protect the sweet...the sweet...[snores]
Marge: [walking out] Homer?
Homer: [with a Spanish accent] In America, first you get the sugar, then
you get the power, then you get the women...[snores]"

"Marge: Homer, when are you going to give up this crazy sugar scheme?
Homer: Never, Marge! Never. I can't live the button-down life like
you. I want it all: the terrifying lows, the dizzying highs, the
creamy middles. Sure, I might offend a few of the bluenoses with
my cocky stride and musky odors -- oh, I'll never be the darling
of the so-called "City Fathers" who cluck their tongues, stroke
their beards, and talk about "What's to be done with this Homer
Simpson?""

Logo in Ruby

If It's Not Nailed Down, Steal It "Pattern Matching, S-Expressions, and Domain Specific Languages in Ruby...Pattern matching is a relatively rare language feature found in Standard ML, OCaml0, Haskell, Common Lisp (CLOS), and a handful of others. It’s a form of multiple dispatch, so pattern matching functions run different code when called with different arguments. Pattern Matching lets you do this dispatch based on type, value, and even internal structure of the function’s arguments...Ruby gives us everything we need to represent S-expressions. Ruby list literals are written in enclosing brackets ([...]) and use commas as separators. Symbols are written as barewords proceeded by a colon (:)...Okay, enough talk, let’s implement a simple version of the Logo programming language in Ruby. Remember Logo3? That language with the silly turtle that draws? "

Why have millions of triples? When you can have billions.

Big news, literally, with BigOWLIM. "BigOWLIM is a high-performance semantic repository, implemented in Java and packaged as a Storage and Inference Layer (SAIL) for the Sesame RDF database. BigOWLIM uses the TRREE engine to perform RDFS, OWL DLP, and OWL Horst reasoning, based on forward-chaining of entailment rules. The most expressive language supported is a combination of limited OWL Lite and unconstrained RDFS. BigOWLIM can manage billions of explicit statements on server hardware. A principle limitation of BigOWLIM is the relatively slow delete operation. The upload, reasoning, and the query evaluation proceed fast even against huge ontologies and datasets."

"BigOWLIM successfully passed the threshold of 1 billion (10^9) statements of OWL/RDF – it loaded an 8000-university dataset of the LUBM benchmark and answered the evaluation queries correctly. Evaluation setup and statistics:

BigOWLIM successfully passed the threshold of 1 billion (10^9) statements of OWL/RDF –
it loaded an 8000-university dataset of the LUBM benchmark and answered the evaluation queries correctly. Evaluation setup and statistics:

• Hardware: 2 x Opteron 270, 16GB of RAM, RAID 10; assembly cost < 5000 EURO
  
• OS: Suse 10.0 Linux, x86_64, Kernel 2.6.13-15-smp; 64-bit JDK 1.5 -Xmx12000m
  
• Loading, inference, and storage took 69 hours and 51 min
  
• LUBM(8000,0) contains 1.06 billions of explicit statements
  
  
  
  • The "inferred closure" contains about 786M statements
    
  • BigOWLIM had to manage over 1.85 billions of statements in total
    
  • These figures indicate that, if used as a plain-RDF repository, BigOWLIM can easily handle around 2 billion statements on the same hardware setup
    
  
  
• 92GB RDF/XML files; 95 GB binary storage files
  
• Average Speed: 4 538 statements/sec."

While not available for download, a scaled down version, OWLIM is.

Hot on the heals of recent postings, Scalability of the Semantic Web and performance, triplestores, and going round in circles...

Keep it on the Green

Recently, Martin Fowler updated his Continuous Integration paper, "For most projects, however, the XP guideline of a ten minute build is perfectly within reason. Most of our modern projects achieve this. It's worth putting in concentrated effort to make it happen, because every minute you reduce off the build time is a minute saved for each developer every time they commit. Since CI demands frequent commits, this adds up to a lot of time."

"The commit build is the one that has to be done quickly, as a result it will take a number of shortcuts that will reduce the ability to detect bugs. The trick is to balance the needs of bug finding and speed so that a good commit build is stable enough for other people to work on."

"A simple example of this is a two stage build. The first stage would do the compilation and run tests that are more localized unit tests with the database completely stubbed out. Such tests can run very fast, keeping within the ten minute guideline. However any bugs that involve larger scale interactions, particularly those involving the real database, won't be found. The second stage build runs a different suite of tests that do hit the real database and involve more end-to-end behavior. This suite might take a couple of hours to run."

Breakage patterns for a build is listed in, "Avoiding Continuous Integration Build Breakage Patterns" it includes: "Five O'clock Check-In", "Spoiled Fruit" and "It Is a Small Change".

The overall effect of having a slower build is that tested user visible functionality becomes more difficult over time. Each new high level test increases the build time and understanding what has broken takes longer. Often time is not taken to ensure that your faster atomic/unit/integration tests cover what was missing. So the importance of maintaining a green build when you have worse feedback becomes more important but the cost of maintaining it becomes more expensive.

Some of the discussion that I've had is on this thread on the boost mailing list.

World Wide VB

Two interesting talking points at the moment between Google's AJAX Framework and Continutations. Starting with, Continuations and GUIs, "...Web UIs are drastically constrained, offer a paucity of controls, and enforce a brutally linear control flow; and these are good things. I remember, in the early days, people saying “Once you know how to use one Windows app, you know how to use them all”. Ha ha ha. But you know what? Once you know how to use a browser, you are well on the way to being able to use most Web apps. The best AJAX apps are still very Web-like (as in, the Back button always works); but they’re faster and more responsive and nicer to look at. The worst AJAX apps are like bad Nineties VB."

This linked to: Continuations, cont’d "...there’s no need to drive a continuation bulldozer through your webapp, when a little REST garden spade will work quite nicely (and won’t tear up your lawn in the process). Don suggests that there may be other, more legitimate use cases for continuations outside of web applications, and I have no reason to disagree, but I would like to look at them pretty carefully."

The seed of the continued continuations conversation was, "Will Continuations continue?".

The Google Web Toolkit gets a reasonable overview, "GWT: Googles plain Java AJAX tools". This seems to be a similar approach taken by DWR 2.0 (out since late April) - using Java to write Javascript. DWR 2.0 also supports Jetty's AJAX continuations.

Update: So GWT is not like DWR. With DWR you still create your HTML and Javascript pages directly. With GWT you use widgets and lay them out like Swing - there's no direct access to the Javascript or layout. There is some criticism that this approach is at the wrong level of abstraction. One of the potential advantages is the ability to test drive the Java code and then deploy the Javascript - and hope that there are no bugs in only the Javascript version.

More Gore

A few years ago I tried to imagine what would have happened if Al Gore hadn't won the 2000 election. Well now that we're half way through his second term you can only wonder what kind of problems would've occurred if he hadn't turned solving global warming into the Apollo project of the 21st century. Although his critiques have labeled it a quagmire I guess it's better than half the world becoming so.

Update: In the comments Paul pointed to an introduction to Saturday Night Live introduction by president Gore (the direct link didn't work but this one did).

Update 2: Lawrence Lessig links to two adverts that are surely directed by Paul Verhoeven (from Robocop or Starship Troopers).

New Style, Old Style

In keeping with the new theme I'll continue to make outlandish claims (like the impending global acceptance of the Semantic Web?) and I was going to go with Google Adwords but instead to the 20 odd people who read this they will receive :Cuecats in the mail.

At the moment the list of blogs consists of the people who have linked to me.

Ten Times

What's the Secret Sauce in Ruby on Rails? links to Crossing borders: What's the secret sauce in Ruby on Rails? "Debates about Rails in the Java community have been intense and show no sign of dying down any time soon. Rails proponents boast of incredible productivity, with some claims of 10 to 1 over Java development. As a Java programmer, your knee-jerk response is to dismiss any wild productivity claims because you've likely heard them before and been disappointed. Java advocates increasingly insist that Ruby on Rails is a toy that can't scale, produces bad code, and won't work beyond the simplest applications. But as Rails praise keeps popping up -- often from credible sources -- a more prudent course might be to understand what Rails does well and to bring those ideas back to the Java platform. In this article, I'll explore the core features -- the secret sauce -- that are the essence of Rails's great productivity."

If Ruby is up to 10 times more productive that makes it about as productive as Python, Tcl and Perl, see "An Empirical Comparison of Seven Programming Languages".

Free the Worker

Open letter to CEOs, COOs, CIOs and CFOs across the corporate world "No amount of posters, incentive programs, PowerPoint presentations or slogans on websites will affect the hearts and minds of your employees...many of your managers act betrayed when their employees tell them they want to leave the company. This is an absolute double standard and should be stopped immediately...Explain how your business works and why it is so exciting for you to run. Make them into better businesspeople so that they can grow their opportunities and net worth. And for God's sake share the profits...Don't ask for your employees' input if you are not going to listen to it...I have witnessed people playing video games at their desk until their manager leaves "just so they won't think that I am slacker." Huh? It is not a badge of honor to work 18 hours a day."

Also, Open letter to employees across the corporate world "If you want your life to grow in a positive direction, surround yourself with people who are eager to learn, problem-solve and support each other. I don't mean you can never complain - just don't get stuck whining all the time...Don't think of your job as a paycheck, think of it as a learning opportunity...You choose to be in your current situation, otherwise you would have changed it. So don't give away your power. If you are miserable, follow the advice above and move yourself to a better place."

From, Links for 2006-05-11 [del.icio.us].

Simpsons Ruby Mixin

Homerpalooza "I used to be with it, but then they changed what "it" was. Now, what I'm with isn't it, and what's "it" seems weird and scary to me."

Why Aren't My Assertions Counted? "The problem typically comes when you put assertions in your library modules. This isn't hard. All you have to do is put include Test::Unit::Assertions in your module or helper class and then you can include calls to assert, assert_equal and all the other assert methods. It works, except that your assertions aren't counted.

The reason why is that the method add_assertion does the counting. This is automatically called by all the assert methods. When they call the add_assertion method of TestCase, the count shows up in your test results no problem. But the add_assertion method of the Assertions module is just a no op. This is why they don't affect the assertion count. The solution is to add a functional add_assertion method back to your helper module/class that ties back to your test case."

When the language has the []= operator and it can be overloaded is somewhat scary. But when you fix what seems like a bug by changing the behaviour of the underlying class it seems crazy. I'd like to be able to say with certainty that the lack of interfaces is a mistake (or not) just like people seem to consider checked exceptions. Or that the ability to abitrarily add behaviour to existing objects is going to destroy open source and make code unmaintainable.

Why do you need new languages? Everyone knows programming languages attained perfection in 1995. It's a scientific fact.

RDF2GO

RDF2GO is an abstraction over triple (and quad) stores. It allows developers to program against rdf2go interfaces and choose or change the implementation later easily.

A common API for Jena and YARS. Includes a comparison with JRDF.

RDFHibernate

Re: How will the semantic web emerge - OO languages:

"> For certain ontologies, java beans are a reasonable model. For
> others, though, with extremely flexible type systems, involving
> type relations outside those that map directly onto the java type
> system, its not so clear. Say it were possible for some instance to
> be a foaf:Person from one ontology and a deo:God from another
> ontology and a comic:Superhero from yet another, and there were no
> subclass relationships among these. Heck, perhaps deo:God and
> comic:Superhero both subclass from et:Nonhuman . While this isn't
> absurd by any means, it does make denoting the instance's type in a
> java bean complicated at best (I anticipate lots of interfaces ;-) ).

yes. My RDFHibernate library [1] works with interfaces that map onto
an RDF database using dynamic proxies."

It's listed under Java Distributed Data Acquisition and Control but does not seem available - except for the Subversion repository.

Henry Story just announced a new project which also has Hibernate overtones, Sommer "Sommer is a very simple library for mapping Plain Old Java Objects (POJOs) to RDF graphs and back. Sommer stands for Semantic Object (Metadata) Mapper. In German it also means "summer", the season opposite to winter, when animals no longer hibernate. In French a "somme" is both the sum of things as well as a little rest."

Mustang for Intel Macs

Bit behind the times. Available Now: Java SE 6.0 Release 1 Developer Preview 1 (Intel) "We have just released Java SE 6.0 Release 1 Developer Preview 1 and it is currently only available for Intel-based Macintosh computers. We will be releasing a DP in the near future for PPC also. We just wanted to get 1.6 out as fast as possible. It is available at the usual location of http://connect.apple.com. Please give us you feedback."

Via, Mac Java Community.

You couldn't possibly be

Research May 2006: Which Emerging Technologies Make Sense For Your Company? "And we're still a decade away from the Semantic Web, according to Charles Abrams, a research director at Gartner. So how can 8 percent say they've adopted it? Abrams suggests that they may be using some XML-based specifications that involve semantics. Or maybe, says Parkinson, "They don't know what they are talking about.""

The graph shows 8% deployed, 10% testing and 25% evaluating/tracking. This makes it about as popular as Linux on the desktop and Grid Computing.

Relations in my Language

A good interview with Ted Neward (from chapter 8) about the differences and benefits of LINQ and why it's not SQL in your language.

The New OO

So now that Ruby is officially the next new thing it's time for the next level of books. Bruce Tate's From Java to Ruby or From Java To Ruby "Java to Ruby is packed with interviews of Ruby customers and developers, so you can see what types of projects are likely to succeed, and which ones are likely to fail. Ruby and Rails may be the answer, but first, you need to be sure you're asking the right question. By addressing risk and fitness of purpose, Java to Ruby makes sure you're asking the right questions first."

Continuations in JVM/CLR

Can the CLR "go dynamic"? Absolutely... and arguably, already is "Continuations are not impossible to support, however they are currently more or less impossible to support given the current lack of access to the underlying stack frames in the managed environment--you'd need some support from the runtimes (either the JVM or the CLR) to make it work. Such runtime support would not be too difficult to add, however, as both environments already have rich and powerful stack-walking mechanisms (because both environments use the thread stack as bookkeeping tools, among other things, and need to be able to crawl through those stack markers for a variety of reasons, such as security checks), and it would not be hard to create a runtime-level mechanism that allowed code to "take a snapshot" of the stack--and its related object graph--from a certain point to a certain point, and save off that state to some arbitrary location. In many respects, it would be similar to serializing an object, I believe."

A list of new features from include: invokedynamic, hotswapping, tail calls and continuations.

Leading the Way

Semantic Breakthrough "McDonald Bradley's Parmelee agrees, saying that defining terms in an ontology is not very different from what developers do in the database world. "The same logic that goes into an ER [entity relationship] diagram or a multidimensional database allows you to distinguish between objects and relationships in an ontology," she says. "We are conducting lab experiments associated with a large data integration project in which we use the Oracle Spatial RDF capabilities of Oracle Database 10g for storing data in RDF format. This format preserves the true graph-based representation of the ontology model, rather than trying to fit a graph-based structure into a standard relational mold.""

""Oracle is leading the marketplace by embedding Semantic Web capabilities into its database, enabling computers to aggregate data and make inferences about data relationships," he says. "Oracle is in a great position here since the companies that benefit the most from the Semantic Web are large, distributed, global operations, where Oracle is already the database vendor of choice.""

Better searching, Web Services, grid computing, and enterprise integration are all mentioned as applications.

Via, Semantic Mainstream.

Protected is Evil

I thought I'd blogged about this before but apparently not.

So I'm a fan of both Alan Holub's articles about "Getters and Setters being Evil" and "Why extends is evil". These articles reminded me of an early book by Peter Coad called, "Java Design: Building Better Apps and Applets" which introduced this idea of composition over inheritance. Certainly a predecessor to the whole IoC bandwagon.

In fact, re-reading Holub's article it's interesting in the summary he writes: "As much as 80 percent of your code should be written entirely in terms of interfaces, not concrete base classes. The Gang of Four Design Patterns book, in fact, is largely about how to replace implementation inheritance with interface inheritance."

Likewise, Arthur Riel's, "Object-Oriented Design Heuristics" doesn't ban inheritance but offers the few cases where it is should be used.

Tony Morris (a fellow mouse) has written, "Why extends is not evil". Where he talks about interface inheritance and makes a pretty good point: "The only keyword that is exclusively associated with concrete inheritance is the protected keyword. The use of this keyword should be avoided indiscriminately."

Order Dependent SPARQL

Here is an example of what I consider something that can be improved in SPARQL. Using something like FOAF, you have one person that has a nick name and another that has 2 nick names and an email address.

Performing the following query:

SELECT ?name ?alias
WHERE { ?x foaf:name ?name .
OPTIONAL { ?x foaf:nick ?alias }
OPTIONAL { ?x foaf:mbox ?alias }
}

It returns 3 results - Person 1's nick name and Person 2's two nick names.

However if you did this:

SELECT ?name ?alias
WHERE { ?x foaf:name ?name .
OPTIONAL { ?x foaf:mbox ?alias }
OPTIONAL { ?x foaf:nick ?alias }
}

You get a different result - 2 results. Person 1's nick name and Person 2's email address.

Now if you use an operation that is both associative and commutative (like minimum union or disjunction even) you always get 4 results (Person 1's nick name, Person 2's 2 nick names and email address).

This is just a practical example derived from, "A relational algebra for SPARQL".

For those concerned about commercial implementations, it's true that there's no available implementation of minimum union. But it is expressable in SQL (see section 6.7).

4 Killer Applications of the Semantic Web

XML and Web Services Reference Guide "We start with a discussion of Google Base, Google's attempt at a semantic search engine, which
enables you to add information in such a way that it can be searched intelligently, with queries such as "engineering job in New York, more than $40,000 a year." From there, we move on to a discussion of Microformats, or standard representations of information you put on the web every day, such as addresses, events, and reviews. Next, you need a way to easily publish that information, so we look at StructuredBlogging, a plug-in that enables you to easily add structured data to your blog. Finally, we'll look at Live Clipboard, handy little technique that enables you to move structured information such as events and contacts from one place to another with the same ease you currently have in moving a chart from your spreadsheet to your word processor."

Also, Amazon and SPARQL.