Before the time of Google developers were required to learn, remember and never forget the knowledge they needed to perform their work. I might be a bit of a dinosaur in that way, since I’d rather simply know than rely too much on Google. The media has reported cases of student relying more and more on Google (or Bing or anyother web search.) No longer is anyone required to know everything, the web answers all questions.

A fun example is something that actually happens around me sometimes. Since I live and work in Sweden many Operating Systems are in Swedish. Everything is in Swedish, even the error messages. That’s a great feat of the developers to successfully implement I18n, but sometimes other developers can’t find the solution to their problems because they don’t know the English version.

A well known expression in the programming world is RTFM, but this is becoming a relic of an older age, these days a new expression is more valid, STFG.

Unfortunately the expression “Knowledge is power” is still very true. Search engines hold more and more knowledge and thus power. Since it’s all free and open, there is absolutely no problem with that, in fact it’s great. It means everyone can share the knowledge. The real problem is that the people who are supposed to have the knowledge in their brains are become reliant on web search. What happens if the web is not accessible when they need it, or – god forbid – companies like Google and Microsoft start putting a price on that knowledge?

Yes, web search can solve many problems and provide a wealth of knowledge. But don’t just remember the URL to the knowledge you require, remember the actual knowledge instead. Reading news feeds about new techniques in HTML, CSS, JAVA, .NET, Ruby, etc. is great. But you should remember it, quite easy if you experiment with what you’ve read. Doing it stores more in the mind than reading about it.

Go ahead, STFG. Experiment, do, develop, extend and Remember.

Image 1, Common tag line without any style problems.

Looking at the list of tags at the bottom of my posts, I noticed that when the amount of tags gets bigger, strange things happen to the style. When the text width gets too big to fit next to the category tags, it’s naetly moved down. But when it gets even bigger the text gets clipped. Changing the style so the text fits easily solved that problem.

Image 2, Wide tag line without any style problems.

.post .content .under span {
float:    left;
/* Make the span change height to prevent the text from being clipped. */
height:    auto;
margin-right:    15px;
/* Add padding to the left for the image. */
padding-left:    22px;
}

Image 3, Long tag line with wrong background.

But whoops, what’s with the background image? Using CSS Sprites and fluid/elastic layout doesn’t quite seem to work together…
Im my efforts to make this website’s themes more “elastic” I had to find a solution.

Experiments

I first tried to find CSS properties that could be applied directly to the containing SPAN.
Setting float to ‘none’ and display to ‘inline’ will make the text “hanging”. This actually means that each line will receive it’s own “box” with only the first box having a padding and background.

.post .content .under span {
display:    inline;
float:    none;
height:    auto;
margin-right:    15px;
padding-left:    22px;
}

Image 4, Tag line with hanging text.

Unfortunately not floating is not optional and hanging text is not what we want either.
So… how can I get a floating box with a background that ignores the content and stays 16px high?
What property do floats have that can be used and that’s been a thorn in many eyes?

Solution

Overflow! Floats tend to reach outside the containing box making their parent unaware of their size. (The containing box is actually secretly aware of the float’s size, check this by turning on ‘outline’.)

Image 5, Float overflow.

If we create a containing span and make the content a floating block, then the container can contain the background image and won’t be affected by the content’s size.
The content block used to have a background and padding to show an “icon”, so we start by adding a container.

Image 6, Content block with background.

We can then move the background to the container and lock it’s height.

Image 7, Container with background.

Great, this is what we wanted all along! But there’s one final step left.
Since the container doesn’t “contain” the actual content, but the content flows out, we need one more container around the whole. This outer container can be “floating-content-aware”.

Image 8, Final result.

<span class="outer-container">
    <span class="icon-container">
        <div class="content">Lorem impsum, dolor</div>
    </span>
</span>

.outer-container {
    float:    left;
    height:    auto;
    margin:    0;
    overflow:    auto;
    padding:    0;
}
.icon-container {
    background-image:    url(css-sprite.png);
    background-position:    0 16px;
    background-repeat:    no-repeat;
    float:    none;
    height:    16px;
    margin-right:    15px;
    overflow:    visible;
    padding-left:    22px;
}
.content {
    display:    block;
    float:    left;
    padding:    0;
    margin:    0;
}

Image 9, Tag line with correct style.

Conclusion

A better solution would have been to use clipping on the background image, but that’s not present in CSS 2.1, CSS 3 or Mozilla’s specifications. Mozilla has an isue on this (113577, please vote!), so I’m hoping this will make it to Firefox 3.5. W3C has nothing on it, so I contacted the “CSS 3, Background and Border” WorkGroup. Let’s hope for the best.

In “Document Management System in Word using WebDAV” I explained why I needed to connect Microsoft Word to a WebDAV repository and in “PHP based authentication for mod_dav” I explained how to set up authorisation for mod_dav using a PHP script. What’s left is accessing the WebDAV repository using Word’s Visual Basic.

Requirements

• Open documents from the remote location.
• Save documents to the remote location.
  • Save new documents to the remote location.
  • Overwrite existing documents on the remote location.
• List documents available for specified MemberID’s.
• Add meta-data to stored documents. (Optional)

Solution

Starting from Office 2000, support for WebDAV is included natively. Although Windows XP and never also have their own support for WebDAV, it’s always better to use Office’s own methods. The only downside to this is that these methods are not available in Word’s Visual Basic.¹

Word Visual Basic WebDAV interface

Accessing WebDAV resources in Word’s Visual Basic can be done by using an ADODB object. Starting from ADODB 2.5 support for WebDAV is available. ADODB might need to be enabled for Word first.

Activate ADODB in Word

Visual Basic Editor (Word 2003)

To activate (or check if it is available) ADODB in Word, you need to start the Visual Basic Editor. The VBE can be found in Tools\Macro (Word XP & 2003²)

Access to ADODB is determined by the project’s references and those are specific for each Word document, so make sure to start your WebDAV macro projekt first (Done by creating a new Macro from Word).

VBE Rreferences (Word 2003)

Open the References from Tools\References and make sure a “Microsoft ActiveX Data Objects 2.x Library” is selected. Versions 2.5 and newer support WebDAV, but make sure the production environment you will be delivering to has the same version.

As soon as the ADODB library is activated the Visual Basic Editor will recognise the ADODB references in the code.

Opening a document from WebDAV

To open a document from WebDAV the ADODB object is not needed, Word uses it’s internal WebDAV library instead.

Documents.Open "http://example.org/dav/document.doc", False, False

Sometime the opened document becomes read-only, this is can have several causes:

• WebDAV supports locks and the file has been locked. Just like normal local access Word puts a lock on the file if opened for writing. Unlike local access the lock on WebDAV can easily be removed by an administrator (or another Word Macro! See “PHP based authentication for mod_dav” to know how even this can be moderated with a PHP script.)
• Word erronously identified the WebDAV as an Exhange or SharePoint resource. Both Microsoft Exchange and Microsoft SharePoint use WebDAV to share documents with Office. The problem is caused by the extra meta-data that is expected.

Save a new document to WebDAV

Documents opened from a WebDAV resource are automatically saved back to their original WebDAV location, unless they are opened as read-only. To save a newly created document to a WebDAV repository, just pass the URL to the normal SaveAs function.

ActiveDocument.SaveAs ("http://example.org/dav/test.doc")

Getting a directory listing from WebDAV

Other actions that interact with the WebDAV repository require the ADODB object. Using ADODB creates an interface for WebDAV that acts like a database, with recordsets and records.

'
' Microsoft Office Visual Basic
' WebDAV Access example
'
' @author Jeffrey Ridout
' @date 2009-04-23
' @version 0.0.1
'

Sub AccessWebDAV()
    Dim files() As String                  ' String array to hold friendly filenames.
    Dim davDir As New ADODB.Record         ' Record for the directory
    Dim davFile As New ADODB.Record        ' Record for the file
    Dim davFiles As New ADODB.Recordset    ' Recordset for the directory's filelist
    Dim isDir As Boolean
    Dim index As Integer

    ' For debugging purposes jump to the error display on any error
    On Error GoTo showErr

    ' Open the root folder as a ADODB.Record to retrieve a list of it's contents.
    ' To open a folder, pass an empty string as the filename and the full URL as the path.
    ' URL= tells ADODB to use the WebDAV interface.
    ' adModeReadWrite: This could be adModeReadOnly, it might matter in a multi-threaded environment
    ' adDelayFetchStream: ADODB sometimes pre-fetches the content of files, this is not needed.
    davDir.Open "", _
                "URL=http://example.org/dav", _
                adModeReadWrite, _
                adFailIfNotExists, _
                adDelayFetchStream, _
                "username", _
                "password"
    Set davFiles = davDir.GetChildren()          ' Get the list of files as a ADODB.Recordset

    index = 0
    ' The WebDAV directory Recordset uses a 'current' index and has no counter,
    ' so use EOF to check if there are more files.
    Do While Not davFiles.EOF
        davFile.Open davFiles, , adModeReadWrite
        ' File properties are Record.Fields, all standard DAV fields are called "Dav:<property>".
        ' ADODB adds it's own fields that supply the same information, called "RESOURCE_<property>".
        isDir = davFile.Fields("RESOURCE_ISCOLLECTION").Value                     ' RESOURCE_ISCOLLECTION is a boolean specifiying if the file is a directory.

        If Not isDir Then ' If the file is not a directory it's a normal file and we can add it to the list.
            ReDim Preserve files(0 To 1, 0 To index)                              ' The number of files is unknown, so "ReDim Preserve" resizes the array without losing the data.
            files(0, index) = davFile.Fields("RESOURCE_PARSENAME").Value          ' RESOURCE_PARSENAME contains the filename.
            files(1, index) = davFile.Fields("RESOURCE_ABSOLUTEPARSENAME").Value  ' RESOURCE_ABSOLUTEPARSENAME contains the full URL.
            index = index + 1
        End If

        davFile.Close       ' Always remember to Close the file!
        davFiles.MoveNext   ' Move the index to the next Record.
    Loop
    Set davFiles = Nothing  ' Always unset the object pointer!
    davDir.Close            ' Close the Record for the directory, not closing it can leak memory and could also lock the directory.
    Set davDir = Nothing

    ' Do something with files here...

    GoTo noErr
showErr:
    Call MsgBox(Err.Number & ": " & Err.Description, vbOKOnly, "Error")

noErr:
    ' No errors
End Sub

Getting and setting meta-data

Exchange and SharePoint use custom properties to perform extra actions and change file attributes. Custom properties in WebDAV normally have their own namespace, but I haven’t figured out how to specify those with ADODB yet.³ Some examples contain the namespace as part of the property, so I’ve adopted this.

Adding properties for the document’s title, subject, author, etc. makes it possible to display those properties without having to open the document. Whenever the document is saved to WebDAV a Macro function should be triggered to update these properties.

'...
' Define some constants containing property namespaces in the head of the Macro.

' Constants
Public Const OFFICE_URN  As String = "urn:schemas-microsoft-com:office:office"
Public Const EXAMPLE_URN As String = "http://example.org/dav/props/"

' Inside the function, the custom properties can be retrieved and added quite easy.
'...
    ' Get custom properties.
    prop1 = davFile.Fields(OFFICE_URN & "author").Value
    prop2 = davFile.Fields(EXAMPLE_URN & "doc_title").Value
    prop3 = davFile.Fields(EXAMPLE_URN & "doc_subject").Value
    prop4 = davFile.Fields("non-existing-property").Value      ' Non existing properties return an empty string.

    ' Set custom properties.
    davFile.Fields(OFFICE_URN & "author") = "user"
    davFile.Fields(EXAMPLE_URN & "doc_title") = "Document title"
    davFile.Fields(EXAMPLE_URN & "doc_subject") = "Document subject"
    davFile.Fields.Update  ' Fields.Update commits the changes to Fields to WebDAV.
'...

Putting it all together

Here is the code where all previous techniques are put together. Normally opening, saving and listing would be done in different functions preferably triggered by events, put this will serve as an example.

'
' Microsoft Office Visual Basic
' WebDAV Access example
'
' @author Jeffrey Ridout
' @date 2009-04-23
' @version 0.0.2
'

' Constants
Public Const OFFICE_URN As String = "urn:schemas-microsoft-com:office:office/"
Public Const SPK_URN As String = "http://schemas.spk.no/dav/props/"

' Module variables
Public isCancelled As Boolean  ' Used by dlgOpenFileDAV
Public fileURL As String       ' Used by dlgOpenFileDAV

Sub OpenWebDAVFile()
    Dim files() As String                  ' Dynamic Multidimensional String array to hold file properties.
    Dim davDir As New ADODB.Record         ' Record for the directory
    Dim davFile As New ADODB.Record        ' Record for the file
    Dim davFiles As New ADODB.Recordset    ' Recordset for the directory's filelist
    Dim isDir As Boolean
    Dim index As Integer
    Dim dlg As Object

    ' For debugging purposes jump to the error display on any error
    On Error GoTo showErr

    ' Open the root folder as a ADODB.Record to retrieve a list of it's contents.
    ' To open a folder, pass an empty string as the filename and the full URL as the path.
    ' URL= tells ADODB to use the WebDAV interface.
    ' adModeReadWrite: This could be adModeReadOnly, it might matter in a multi-threaded environment
    ' adDelayFetchStream: ADODB sometimes pre-fetches the content of files, this is not needed.
    davDir.Open "", _
                "URL=http://example.org/dav", _
                adModeReadWrite, _
                adFailIfNotExists, _
                adDelayFetchStream, _
                "username", _
                "password"
    Set davFiles = davDir.GetChildren()          ' Get the list of files as a ADODB.Recordset

    index = 0
    ' The WebDAV directory Recordset uses a 'current' index and has no counter,
    ' so use EOF to check if there are more files.
    Do While Not davFiles.EOF
        davFile.Open davFiles, , adModeReadWrite
        ' File properties are Record.Fields, all standard DAV fields are called "Dav:<property>".
        ' ADODB adds it's own fields that supply the same information, called "RESOURCE_<property>".
        isDir = davFile.Fields("RESOURCE_ISCOLLECTION").Value                     ' RESOURCE_ISCOLLECTION is a boolean specifiying if the file is a directory.

        If Not isDir Then ' If the file is not a directory it's a normal file and we can add it to the list.
            ReDim Preserve files(0 To 4, 0 To index)                              ' The number of files is unknown, so "ReDim Preserve" resizes the array without losing the data.
            files(0, index) = davFile.Fields("RESOURCE_PARSENAME").Value          ' RESOURCE_PARSENAME contains the filename.
            files(1, index) = davFile.Fields("RESOURCE_ABSOLUTEPARSENAME").Value  ' RESOURCE_ABSOLUTEPARSENAME contains the full URL.
            files(2, index) = davFile.Fields(SPK_URN & "doc-title").Value         ' Custom property: title
            files(3, index) = davFile.Fields(SPK_URN & "doc-subject").Value       ' Custom property: subject
            files(4, index) = davFile.Fields(OFFICE_URN & "author").Value         ' Custom property: author
            index = index + 1
        End If
        davFile.Close       ' Always remember to Close the file!
        davFiles.MoveNext   ' Move the index to the next Record.
    Loop
    Set davFiles = Nothing  ' Always unset the object pointer!
    davDir.Close            ' Close the Record for the directory, not closing it can leak memory and could also lock the directory.
    Set davDir = Nothing

    ' See Image 3 and Listing 4 for the OpenFileDAV dialog.
    dlgOpenFileDAV.listDocuments.Clear     ' Clear the ListBox since dlgOpenFileDAV is reusable.
    For I = 0 To index - 1
        With dlgOpenFileDAV.listDocuments
            .AddItem files(0, I), I        ' Add a new row to the ListBox.
            .List(I, 1) = files(1, I)      ' The ListBox has 4 columns, 2nd column is hidden and contains the full URL.
            .List(I, 2) = files(2, I)      ' 3d column contains the title.
            .List(I, 3) = files(3, I)      ' 4th column contains the subject.
            .List(I, 4) = files(4, I)      ' 5th column contains the author.
        End With
    Next I

    isCancelled = True
    fileURL = ""
    dlgOpenFileDAV.Show
    If (isCancelled = False) Then
        If (fileURL <> "") Then
            Documents.Open fileURL, False, False  ' To open the file from the WebDAV repository, simple pass the URL.
        End If
    End If

    GoTo noErr
showErr:
    Call MsgBox(Err.Number & ": " & Err.Description, vbOKOnly, "Error")

noErr:
    ' No errors
End Sub

Image 3 shows the UserForm used as the custom “Open File” dialog. Image 4 shows the ListBox properties. The ListBox currently only should support selecting 1 file, has 5 columns. Note that the 2nd column has a width of “0 pt” in order to hide it. BoundColunm is set to 2, which results in the Value of the ListBox being the value of the hidden column of the selected row (The file’s full URL).

Image 2: Open WebDAV File dialog

Image 5: ListBox properties

Private Sub btnCancel_Click()
    davTest.isCancelled = True
    Hide
End Sub

Private Sub btnOk_Click()
    davTest.isCancelled = False
    davTest.fileURL = listDocuments.Value
    Hide
End Sub

Private Sub listDocuments_Change()
    If listDocuments.Value >= 0 Then
        btnOk.Enabled = True
    End If
End Sub

Private Sub UserForm_Initialize()
    If (listDocuments.ListCount > 0) Then
        listDocuments.Clear
    End If
    btnOk.Enabled = False
    davTest.isCancelled = True
End Sub

Conclusion

Creating your own WebDAV based repository access in Microsoft Word is possible and after some research and experimenting quite easy. Combine this with a PHP CMS and mod_dav with PHP authentication and authorisation and you’ve got a fully functional Document Management System.

Example

• Download: VBA-WebDAV.doc

All code in this post is licensed under Creative Commons Attribution Share Alike.

1. Office’s own WebDAV support might be available in VBA, but I have not found any documentation on it.
2. Office 2007 might have hidden it better but ALT+F11 still works.
3. If you find out, let me know!

To be able to create a Document Management System in Word using WebDAV on Apache webserver, I did some research on mod_dav, an Apache module to provide WebDAV support. It appears that the authaurisation part of mod_dav is limited to “allow all” / “deny all”, which did not quite suite my needs. The solution needed more fine-grained authorisation on a per-directory level. Another problem was that the authentication and authorisation data was in a database.

Issues

1. Mod_dav does not have a fine-grained authorisation system on a per-directory level.
2. Directory structure is known but unstable.
3. Authorisation data is held in a database and requires complex SQL.

Solution

Fine-grained authorisation

I started by looking at mod_auth and mod_auth_dbd (in combination with mod_dbd), but the SQL useable by mod_dbd only received the username and password as parameters, not the requested URI. What mod_auth module could possibly be used? The solution to this was quite unexpected: mod_auth_script.

Mod_auth_script allows CGI or PHP scripts to handle the authorisation. By looking at the REQUEST_URI the script can easily decide to simulate authorisation by invalidating the authorisation.

I created a PHP script that at first would log the REQUEST_URI and allow access for any username and password. All that is left now is to handle authorisation based on the directory structure and fetch the real authorisation from the database.

<Location /dav>
	Options			+Indexes
	Dav				On
	AuthType		Basic
	AuthName		"PHP based authentication for mod_dav"
	AuthScriptFile	/any_full_path_your_apache_can_get_to/.auth.php
	Require			valid-user
</Location>

<?php
/**
 * PHP based authentication for mod_dav
 * @author Jeffrey Ridout
 * @link http://blog.itwarlocks.com
 * @license http://creativecommons.org/licenses/by-sa/3.0
 * @date 2009-04-27
 * @version 0.0.1
 */

/**
 * $_SERVER['REQUEST_URI'] contains the location accessed by the WebDAV client.
 * Using parse_url enables easy access to all URL parts.
 */
$requestURI = parse_url($_SERVER['REQUEST_URI']);

/**
 * Accessing some pages directly, like a page containing phpinfo(), will result in several
 * calls to .auth.php. These do not need to be logged.
 */
if ($requestURI['path'] != $_SERVER['SCRIPT_NAME']) {
	$logFile = fopen('auth.log', 'a');
	fwrite($logFile, "${_SERVER['PHP_AUTH_USER']}:${_SERVER['PHP_AUTH_PW']}@${requestURI['path']}\n");
	fclose($logFile);
}

/**
 * At this stage we always allow access.
 * mod_auth_script catches custom headers to define the result to mod_auth.
 * auth-script:allow|deny|prompt Defines the authentication result.
 */
header('auth-script:allow');

/* EOF */
?>

Directory structure

The sub-directories are named according to a strict rule, but they are unknown to exist at design-time. Therefore the script needs to analyse the destination location and extract the key to be used for authorisation.¹

/<Day>/<Month>/<Year>/<MemberID>
	<Day>:		00 - 31
	<Month>:		00 - 12
	<Year>:		00 - 99
	<MemberID>:	DDMMYY#####

Directory structure

This directory structure allows for a quite straight forward check to get the MemberID.²

<?php
/**
 * PHP based authentication for mod_dav
 * @author Jeffrey Ridout
 * @link http://blog.itwarlocks.com
 * @license http://creativecommons.org/licenses/by-sa/3.0
 * @date 2009-04-27
 * @version 0.0.2
 */

/**
 * $_SERVER['REQUEST_URI'] contains the location accessed by the WebDAV client.
 * Using parse_url enables easy access to all URL parts.
 */
$requestURI = parse_url($_SERVER['REQUEST_URI']);

/**
 * Accessing some pages directly, like a page containing phpinfo(), will result in several
 * calls to .auth.php. These do not need to be logged.
 */
if ($requestURI['path'] != $_SERVER['SCRIPT_NAME']) {
	$logFile = fopen('auth.log', 'a');
	fwrite($logFile, "${_SERVER['PHP_AUTH_USER']}:${_SERVER['PHP_AUTH_PW']}@${requestURI['path']}\n");
	fclose($logFile);
}

/**
 * At stage 2 we can simulate a real authorisation lookup by using a simple array.
 * mod_auth_script catches custom headers to define the result to mod_auth.
 * auth-script:allow|deny|prompt Defines the authentication result.
 */
$blocked = array (
	'01010154321',
	'31037912345'
);

/**
 * The directory name to search for might be in the path or destination filename.
 * .../blocked-dir
 * or
 * .../blocked-dir/
 * or
 * .../blocked-dir/...
 */
$path = dirname($requestURI['path']);
$dir = basename($path);
$match = basename($rURL['path']);
if (preg_match('#$\d{11}^#', $dir)) {
	$match = $dir;
}
if (!in_array($match, $blocked)) {
	header('auth-script:allow');
} else {
	/* Simulate authorisation by denying access.
	 * Normal authentication would return auth-script:prompt
	 */
	header('auth-script:deny');
}

/* EOF */
?>

Authorisation data

The data that determines the authorisation can come from different sources; files, LDAP, RADIUS, database, …

In my case the authorisation result was retrieved from complex SQL using a stored procedure in a Sybase Database.

Whatever you use as your source of authentication/authorisation, remember that request can be asynchrounous and parallel. For a file base method that means never locking the file and opening it as “read-only”, for an external connection based method, it means using persistent connections.

Conclusion

Just because mod-dav and mod_auth don’t support your exact needs, doesn’t mean there is no solution. Using mod_auth_script to create your own tailored flexible solution works perfectly. As an added bonus this adds a new processing layer to PHP by allowing PHP to be executed at a much earlier stage. Using a PHP script to authorise also allows authorisation of non-existing destination URLs or destinations which access is based on complex business logic.

All code in this post is licensed under Creative Commons Attribution Share Alike.

1. You may notice that year only has 2 digits. so no, it’s not Y2K safe…
2. MemberID in this case is the Norwegian version of a social security number.

A customer I’m currently doing maintenance on their major application for, had an issue come up a couple of weeks ago where not all employees were to access all data any longer. The company deals with other companies and their employees, called members. The issue that came up caused a company wide policy to come in effect that meant that only specific users were to allow members or family of members to be accessed for a certain client company.

The application in question was easily modified since it already had support for authentication, so only authorisation for that specific company had to be added. (No we weren’t allowed to create a generic solution that would allow a reusable authorisation for multiple client companies. But discussing their policies is a whole different matter.)

Case definition

The users use the main application to create letters to be sent to client companies and members using Word. the application sends information about the specific company or member to Word using DDE and macros in the used templates fill in most of that information into the prewritten text. Another macro allows the user to save the document in a predefined location on a Windows Active Directory share. Yet another macro allows the user to get a list of all the documents stored for a specific company or member.

The problem was that everyone had full access to the shared location. So even though the information was protected through authentication and authorisation in the main application, the resulting letters containing vital information were still completely open.

Solution

There are actually several solutions, but I’m only going to blog about my favourite solution, since it involved quite some interesting techniques. This solution uses WebDAV instead of an Active Directory share.

Requirements

1. Access to the documents needs to be authenticated
2. Access to the documents needs to be authorised
3. Authentication and authorisation data needs to be retrieved from a database (Sybase in this case)
4. The location needs to be accessible from Word
5. The location needs to be accessible from MainApp (pseudo name for the customer’s main application)

Implementation

The MainApp already happened to be multi-tiered using an Apache webserver to provide services to the client. Since Exchange and SharePoint use the WebDAV protocol and mod_dav is available for Apache, I decided to try WebDAV. Since Office 2000, support for WebDAV (or “Web Folders”) has been present in Word, so there should be a way to access it through Word’s Visual Basic.

Implemenation articles:

• PHP based authentication for mod_dav
• Accessing WebDAV in Microsoft Word Visual Basic

What is “Extensible”?

Extensible is defined in Wikipedia as:

In software engineering, extensibility (sometimes confused with forward compatibility) is a system design principle where the implementation takes into consideration future growth. It is a systemic measure of the ability to extend a system and the level of effort required to implement the extension. Extensions can be through the addition of new functionality or through modification of existing functionality. The central theme is to provide for change while minimizing impact to existing system functions.

Although forward compatibility and extensibility are similar, they are not the same. A forward compatible system can accept data from a future version of itself and pick out the “known” part of the data. An example is a text-only word processor ignoring picture data from a future version. An extensible system is one that can be upgraded to fully handle the new data in the newer input format. An example is the above mentioned word processor that can be upgraded to handle picture data.

In systems architecture, extensibility means the system is designed to include hooks and mechanisms for expanding/enhancing the system with new capabilities without having to make major changes to the system infrastructure. A good architecture provides the design principles to ensure this—a roadmap for that portion of the road yet to be built. Note that this usually means that capabilities and mechanisms must be built into the final delivery which will not be used in that delivery and, indeed, may never be used. These excess capabilities are not frills, but are necessary for maintainability and for avoiding early obsolescence.

Extensibility can also mean that a software system’s behavior is modifiable at runtime, without recompiling or changing the original source code. For example, a software system may have a public Application Programming Interface that allows its behavior to be extended or modified by people who don’t have access to the original source code.

Although usually applied to engineered systems involving software, it can be applied to any type of engineering. Houses can be built with future extensions in mind. The Prince Edward Viaduct located in Toronto, Ontario, Canada was built to accommodate a future subway line.

Though the application to software is relatively new, the word has been a rare but valid part of English for a long time. The Oxford English Dictionary cites examples going back to the 17th century.

For me extensibility means, thinking ahead without planning the future. In the classic waterfall model, this would mean analysing all possible future feature enhancements and adapting the architecture to be extendable. This method always misses the target though and causes more problems and frustration along the road. My philosophy is that using development principles like Agile, Scrum, RUP etc. will not make the actual software extensible, but it will make the code much more flexible. Agile is used to be able to quickly adapt to changing needs (required feature priority, etc.) during development, but one thing that’s normally not mentioned is the timeframe.

If the development process is based around being agile, adapting to change and delivering production quality parts, does it matter if these changes come tomorrow, next week or next year? Of course not. The biggest issue with creating software that is future-proof is often not the actual architecture, but the code and the organisation around it. If code is well documented and the project around it is fine-tuned for quick change, then the code will become easier to maintain and adapt, thus becoming extensible. Often when we’re asked to make changes in (older) system the biggest problem is understanding the architecture and code in order to be able to make the changes. I’ve often heard of and seen systems that were extremely hard to maintain, so badly even that noone was allowed to touch the code and a complete new product was being developed instead. If those nightmare systems had been made using Agile/Scrum/RUP, then this probably would not have been the case. I say “probably” since there are people out there that implement Agile just for the sake of it without truly understanding it, this delivering even worse maintainable products.

What it comes down to is this: It’s not the code that makes a product extensible, it’s the process that creates it that does.