Tag Archives: Code & Technology

Print me up Scotty!

3D printing just got to a new level with the worlds smallest 3D printed objects (go read this and watch the video, I’ll be waiting here).

3D printing is a subject I have been discussing often with friends and I even mentioned it in a previous post, here (in French), about IP and piracy. This is a revolution I cannot wait to see because this is gonna be huge on so many levels!

And the music/movie download issues will be nothing compared to the IP mayhem this is gonna bring, just imagine when anyone will be able to print a Panton chair or a Starck lemon squeezer.

And just think about what will be possible with copyleft designs, we might even have a Justin Bieber of design (tho I am not really looking forward for this one)!

And we will be able to download items we buy from Amazon.

This is the beginning of teleportation too! As soon as someone develop a good enough scanner (can TSA’s full body scanners be of any use here? or this may be?) we will be able to scan and send items through the Internet to our friends’ 3D printers.

This is gonna be so awesome! And just imagine when we will be able to print biological structures :D

Image Credits: Vienna University of Technology

XML schemas compatibility

Photo by psd

This is the fourth installment of this series about managing backward compatibility in software development. Here I talk about what makes an XML Schema backward incompatible.

I specifically address W3C XML Schemas but general principles applies regardless of the schema language you use.

But first, why bother about XML Schemas compatiblility?

Actually, in enterprise applications, XML is often used either to specify configuration files or interchange formats. With the rise of WebServices and RESTFull applications on the Internet there is also an increase in the use of XML.

Thus, making sure that existing configuration files still work with your new software or, more importantly,  that other applications can still communicate with yours can really make a difference.

So, what makes a schema incompatible?

  • Changing an element or attribute type to a more restricted type (like adding constraints on a xs:string)
  • Changing the order of a sequence in a complex element
  • Removing or renaming an element or attribute from a complex type
  • Adding a mandatory element or attribute to a complex type without providing a default

Removing complex or simple types will also make it incompatible if:

  • Your schema is included or imported by other schemas or
  • You do not replace them by compatible anonymous types (compatible meaning equivalent or less strict, e.g. if one defines a simple type JavaClass, which is a xs:string with a constraint, and replaces it with xs:string).

Then, how to preserve backward compatibility?

If some elements of the schema are becoming obsolete, do not remove them. Instead, mark them as deprecated in the schema documentation and, if applicable, remove their mapping to the object model (that way you will not have to maintain the code equivalent of the deprecated elements).

The best strategy I came across so far is using namespacing: If a given schema must be refactored, create a new one, changing its namespace (a good practice is to include the major version of the schema in the namespace).

You then have two options:

  1. provide an XSL stylesheet that enables the migration of XML documents from the old schema the new one
  2. provide support code to be able to read both document structures

Of course, the second solution is the most desirable from the operational point of view (and the first one is not always applicable). However, the trade-off is that it is more expensive from the development point of view. Once again, choosing between who is going to do the work (the guy who develops or the guy who installs your application) is a matter of project management.

A software architect is like the conductor of a band…

On a recent post, reacting to a post from Shane Patterson, Ted Neward gave us what I think is actually the most accurate analogy, so far, concerning the job of a software architect:

At the risk of offering up yet another of those tortured metaphors, let me proffer my own architect analogy: an architect is not like a construction architect, but more like the conductor of a band or symphony. Yes, the band could play without him, but at the end of the day, the band plays better with one guy coordinating the whole thing. The larger the band, the more necessary a conductor becomes. Sometimes the conductor is the same thing as the composer (and perhaps that’s the most accurate analogous way to view this), in which case it’s his “vision” of how the music in his head should come out in real life, and his job is to lead the performers into contributing towards that vision. Each performer has their own skills, freedom to interpret, and so on, but within the larger vision of the work.

I think the actual point here lies in the last part: the actual job of an architect is leading a team towards a vision.

To me neither “architect” nor “engineer” is well suited. Both terms have a “one guy do all” feeling associated with it, like Frank Gehry or Scotty. However, neither Franck nor Scotty can actually do anything useful without a (collaborating) team and an actual direction (e.g. “to boldly go where no man has gone before”).

Nevertheless, I don’t find “conductor” to be well suited either, because conductors are often considered arrogant superstars and not all software architects I know are like that.

Or it may just be that I am more arrogant than they are…

Google Friend Connect Launched

Google just released a preview of their new Google Friend Connect service.

Google Friend Connect lets you grow traffic by easily adding social features to your website. With just a few snippets of code, you get more people engaging more deeply with your site.

This is not a social network by itself, this is something that enables you to turn your own web site into a social network. I can’t wait to try it myself on this blog and build my own social network…

Database schemas compatibility

by gnizrThis is the third post about software compatibility, the previous ones were talking about project management and bugs and this one deals with database schemas compatibility (I will deal with stored procedures in the chapters about code compatibility).

First of all, what does backward compatibility means when talking about the database?

  1. Being able to retain data stored in one schema into a new one.
  2. Preserving compatibility with external systems (like report engines) that may be accessing the database directly.

Point #1 is achieved through migration tools that update the database schema, in some cases such tools may be very tricky.

Point #2 is a bigger challenge. Changes that may break the database compatibility are:

  1. Removing a table or changing its name.
  2. Removing a column, changing its type (including its precision or length) or changing its name.
  3. Changing the semantic of a column (e.g. changing the valid values).
  4. Adding foreign keys.

In case #1 and #2, if such changes cannot be avoided, a good enough solution is to implement database views that mockup the old tables based on the new ones.

The thing is that for #2 you will need to rename the actual table which will force an update of the foreign keys in other tables and surely more code update than what was initially expected. Leaving an unused column in the table may be a better solution. As usual, this is a trade-off that should be discussed at the project level.

Point #3 is more tricky because it really depends on the change and the usage of the column. Most of the time transforming a “change” into a “remove and add new” will enable to refer to #2. Triggers can then be used to update the old column or it can just be left unused.

Point #4 is a problem when there are scripts that delete entries in a table. If all of a sudden there is a new foreign key that depends on this table then the script will fail, thus breaking the compatibility. I actually have no technical solution for this one. I think that only documentation can be given, but if any of you has an idea please share it with us :)

Nevertheless, one should recall to never do any incompatible change without a good enough reason.

About bugs and software compatibility

This is my second post about backward compatibility in software, the first one was dealing with the project management aspect of software compatibility, this one talks about bugs and how, sometimes, correcting a bug can break compatibility.

First of all, coming back to my previous post on the subject, deciding whether or not to break the backward compatibility of an application is a project management matter. The decision that correcting a bug will break compatibility must not be left solely to the developer, sometimes the company may decide that compatibility should be preserved even when it comes to bugs.

Raymond Chen, a well-known developer at Microsoft, has some good examples on his blog, The Old New Thing, to illustrate this. Raymond actually gives us a good insight at Microsoft policy concerning backward compatibility of its OS.

This post, from Joel Spolsky (another well-known ex-employee of MS) gives another good example with this leap-year-bug deliberately created for Excel/1-2-3 compatibility.

So, to make it short, when you correct a bug, incompatibilities can appear because:

  • Either the bug as been detected and a workaround as been put in place. This workaround will have to be removed once the bug is corrected.
  • Or this was not initially considered a bug and the behavior is going to unexpectedly change.

As an example, if an interface exchanges strings representing date and time and you later discover that the time zone is omitted from the format. If someone developed a parser for this date and time but never expected a time zone information, then the application will break. This is a semantic incompatibility, but one that is brought by a bug fix.

In the case where your management decided that bug for bug compatibility was not necessary, the incompatibility and its potential impacts should be documented in the migration release notes.

In the case where you have to maintain the bug to maintain the compatibility, I recommend you subscribe to Raymond Chen’s blog or stop writing bugs.

Fun with timezones

Take 10 minutes and think about the following:

  • I am French, born in NYC the 24th of April at 3pm. What is my birth date on my passport?
  • If was living in Thailand and wanted to open a bank account what birth date should I give (Hint: Thailand does not use the Gregorian calendar) ?
  • I want a job to be scheduled for execution every Sundays at 2:30am
  • I am in Durban (Australia) and I want to see all operations made in London yesterday.

If you don’t see any challenge you’d better not be coding for an application with geographically distributed users ;)

Need Lifting?

Lift has ended now.

I will not comment on the various speakers and themes (although I really liked Kevin Warwick’s and I have been left with a question) others have done that and they are much more gifted than I am in that area.

I just wanted to say a big “thank you” to the Lift team, the organization was great and this was an enjoyable experience.

Thank you all for your work, see you next year.