I started programming on the [MarkLogic](http://www.marklogic.com/) platform in 2010.  It was a very new experience for me.  I don't program in it these days, but I still think back on the experiences I had with MarkLogic and in general believe that they made me a better programmer.  Here's how.



## First Functional Language
MarkLogic is a proprietary platform that uses the XQuery language.  This is MarkLogic-flavor XQuery, augmenting the vanilla.  There are first-level functions.  There are sequences.  There are no side effects.  There is no state outside of function scope.

This language proved to require a new way of thinking.  I came from coding Java at the time.  I was without my `StringBuilder` class.  I remember the first time I tried to build up a string dynamically in code.  There is no such thing as throwing substrings in a builder or a buffer and building it up (no side effects).  Of course, there is a way to build a dynamic string; it is just different.  I became a lot more comfortable with recursive methods for solving problems.

As a side note, the language isn't 100% functional.  For instance, there actually are side effects.  For example, the [`map`](https://docs.marklogic.com/map) api sets values on preexisting maps and returns the same map.  And the terrible [`xmdp:set`](https://docs.marklogic.com/xdmp:set) will bypass all of the functional sauce and set whatever whenever and is to be avoided.

## First NoSql Store
MarkLogic has its own database built in.  It's a document store.  It was the first place I implemented real NoSQL work and pushed it to production.  Here, I learned document design.  I practiced optimizing for reads or writes depending on the use case.  The experience helped me think beyond well-formed tables and embrace the messier data that is more true to life.  I was thinking more in terms of search engines and less in terms of spreadsheets.

Coding in MarkLogic utilizes XQuery which encompasses XPath.  Given that much X technology, the data format was almost assuredly going to be XML.  And so it is.  Every document stored in MarkLogic is XML.  I became a lot better at tree traversal as a result.

## Lack of Libraries
The MarkLogic ecosystem at the time was really lacking.  I don't follow its current state, but it's probably safe to say that there is less going on here than in the world of Node or Ruby.  You won't find a MarkLogic package manager a la `npm` or `gem`.  You probably won't even find a library to reuse.  There are literally just a handful of libraries that are shared widely in my experience, and these are lower-level utility libraries of the flavor of UnderscoreJs.

This meant that if I needed code, I was going to write it.  So, I wrote a lot of code.  I learned to produce everything I needed and not rely on any 3rd party code.

This was the same when it came to utilities on the platform.  For instance, there was not a unit test library at the time I started into XQuery.  There was a framework that was written in Java that would exercise XQuery code, but that didn't fit my environment needs very well and felt odd, so we wrote our own unit testing framework a la Junit or Jasmine, called [XqTest](https://github.com/irinc/xqtest).  We finally open sourced it (also rare for the MarkLogic ecosystem), but by then several similar frameworks had been created.

## Lack of Help
MarkLogic is a proprietary system.  There aren't many people using it, but those that do license it from the MarkLogic company.  They also pay for support.  Most of the expertise I encountered in MarkLogic was either a visiting consultant from MarkLogic, an engineer I met at the one MarkLogic conference, MarkLogic world, or a fellow in-house engineer.

This means that when you go to StackOverflow, there is a woeful lack of good solutions for common problems.  So, I learned to do a lot of debugging by myself and just keep on keeping on until I figured out the problem.  We had to write almost all of our code, so I was mostly reading my own code, which is easier.  Google wasn't a lot of help, and that's pretty odd in this age of programming.  Upside was that once I wrote the web article about the subject, I was the first-page [result](http://rockycode.com/blog/tech/marklogic/).

## Playing Ops
MarkLogic has its own web server as well, built into the monolith MarkLogic server product.  It was a new beast for the ops guys I worked with.  I was as new to it as them, thus I got to play ops a lot more than I would have on our older, more traditional systems.  I got to help keep the thing running.

I also got to help keep the apps tuned.  It turns out that MarkLogic can be either really performant or really *not* performant.  Often, I wrote the "not" way, and I had to help optimize (of course, via our in-house performance monitoring tools).

## The Experience
I was excited to learn MarkLogic at the time.  It was something new.  I enjoy that.  New code, new team, new thinking.  It was a high-profile product.  It was really a good experience.

I felt like I became very productive on the platform and was able to produce quality and quantity code.  In the end, I chose to not do more more MarkLogic.  I was doing more heavy client-side apps.  The XML just became a stumbling block where Json is king.  The functional paradigm is cool.  I really like it.  But I really don't like the XQuery language.  Its api is not very expressive, and its syntax requires a ton of typing.  MarkLogic is growing in its acceptance and use, but not at a huge pace.  It still seems like a niche product, used mostly in the publishing and defense industries.  It didn't seem like a great investment to keep spending my golden dev years on the platform.

 But for all the pros and cons of the platform and all the ups and downs of the experience, I feel like one of the net effects was that I became a better programmer in new, interesting ways.  For that, I'm grateful.  I'm glad I did it, and I'm glad to move on.  There are, after all, soooo many cool things to try in this age of software development.

MarkLogic was a very new experience for me.  I don't program in it these days, but it helped me become a better programmer.

How MarkLogic Made Me a Better Programmer

When ordering a sequence of items in XQuery, sometimes it's desirable to be able to decide the order based on a parameter value (something dynamic).  XQuery doesn't look extremely elegant when it comes to this feature, but depending on exactly what you want, you should be able to get the job done.


## Static sort

In XQuery, an a FLWOR statement can be ordered (the "O" in FLWOR).  Here are some taffy f

```
let $items := 
  <taffies>
    <taffy><quantity>13</quantity><flavor>Root Beer</flavor></taffy>
    <taffy><quantity>5</quantity><flavor>Black Licorice</flavor></taffy>
    <taffy><quantity>133</quantity><flavor>Cotton Candy</flavor></taffy>
  </taffies>
for $i in $items/taffy
order by xs:integer($i/quantity)
return $i
```

Note that if you want to sort by something besides the natural order of string values (in this case, an `xs:integer`), you need to cast the value.

## Dynamic ascending or descending

Ascending order means lowest values will be listed first, and the higher values will be listed later.  Descending means just the opposite.  By default, XQuery order by clauses are sorted in ascending order.

Let's say that you have just _one_ sort commparator (in this case, quantity) that you care to sort by.  But there's some toggle in your logic or UI or somewhere that determines whether things should be sorted in ascending or descending order.  A [nice markmail thread from Michael Blakely](http://markmail.org/thread/rpc3unlqlj72loah#query:+page:1+mid:k3zprjr4civlrkfg+state:results) reveals a nice solution.  For our example, it would look something like:


```
let $ascending := fn:false()
let $items := 
  <taffies>
    <taffy><quantity>13</quantity><flavor>Root Beer</flavor></taffy>
    <taffy><quantity>5</quantity><flavor>Black Licorice</flavor></taffy>
    <taffy><quantity>133</quantity><flavor>Cotton Candy</flavor></taffy>
  </taffies>
for $i in $items/taffy
order by
  if ($ascending) then xs:integer($i/quantity) else () ascending,
  if ($ascending) then () else xs:integer($i/quantity) descending
return $i
```

The syntax is a little odd in order for us to get the result we want.  There are two `if` expressions.  They are separated by commas, so it is pretty much just a primary, then secondary sort.  The conditional is the same on each ("if is ascending");  But then notice that was just a way to get the syntax to work, because it's really an if-else.  

## Multiple Sort Values

The next case is slightly more complicated, but I initially tried the Michael Blakely approach.  This case introduced another parameter:  Sometimes I wanted to sort by quantity, but other times I instead wanted to sort by the name of the flavor.  So, I came out with something like this:

```
let $ascending := fn:false()
let $sortby := "flavor"
let $items := 
  <taffies>
    <taffy><quantity>13</quantity><flavor>Root Beer</flavor></taffy>
    <taffy><quantity>5</quantity><flavor>Black Licorice</flavor></taffy>
    <taffy><quantity>133</quantity><flavor>Cotton Candy</flavor></taffy>
  </taffies>
for $i in $items/taffy
order by
  if ($ascending and $sortby eq "quantity") then xs:integer($i/quantity) else () ascending,
  if ($ascending and $sortby eq "quantity") then () else xs:integer($i/quantity) descending
  if ($ascending and $sortby eq "flavor") then $i/flavor else () ascending,
  if ($ascending and $sortby eq "flavor") then () else $i/flavor descending
return $i
```

El problemo is that because these are essentially just a list of secondary sorts and each `if` conditional has an `else` with an actual sort value, I'm not really sorting by just one thing.  This scenario has `$sortby` set to "flavor", but it's really still sorting by quantity descending primarily, then flavor descending secondarily.  Blast.

## Fully-dynamic order by clause -- and everything else

At this point, I was contemplating doing the full smash and just evaluating a dynamically-built string describing my desired query:

```
let $ascending := fn:false()
let $sortby := "flavor"
let $items := 
  <taffies>
    <taffy><quantity>13</quantity><flavor>Root Beer</flavor></taffy>
    <taffy><quantity>5</quantity><flavor>Black Licorice</flavor></taffy>
    <taffy><quantity>133</quantity><flavor>Cotton Candy</flavor></taffy>
  </taffies>
return xdmp:value(fn:concat("for $i in $items/taffy ",
"order by $i/", $sortby, 
if ($ascending) then
  " ascending "
else
  " descending ",
"return $i"))
```

I guess that's all right.  I try to avoid string->query conversions just for safety and code complexity, but perhaps I call `xdmp:value` safe enough here, since it's just executing XQuery within the context of the current expression, because I could call this _less_ complex than the previous (albeit not what we want) scenario.  

So, what did I end up with?

## Sort by dynamic value first

Again, all I wanted to was to sort by a single value based on a parameter, and have ascending/descending be another variable parameter.  If you don't care to get a descending sort, then dynamic order by is actually not too bad.  So, get that out of the way and then decide if you like the order or not.  If not, it must be backward, so reverse it:

```
let $ascending := fn:false()
let $sortby := "flavor"
let $items := 
  <taffies>
    <taffy><quantity>13</quantity><flavor>Root Beer</flavor></taffy>
    <taffy><quantity>5</quantity><flavor>Black Licorice</flavor></taffy>
    <taffy><quantity>133</quantity><flavor>Cotton Candy</flavor></taffy>
  </taffies>
let $sorted := 
  for $i in $items/taffy
  order by
    if ($sortby eq "quantity") then 
      xs:integer($i/quantity)
    else if ($sortby eq "flavor") then 
      $i/flavor
    else 
      ()
  return $i
return if ($ascending) then
  $sorted
else
  fn:reverse($sorted)
```

Thanks for the suggestion, Tommy.  It's simple.  Maybe not super-efficient for large datasets.  But, it gets the job done.  

Any other awesome ways you've found to get dynamic order by clauses in your XQuery statements?

When ordering a sequence of items in XQuery, sometimes it's desirable to be able to decide the order based on a parameter value (something dynamic).  XQuery

XQuery Dynamic Order By

Unit testing is a required part of a healthy software development lifecycle and a balanced breakfast.  But test-driven development is a rockin' part of an *awesome* development lifecycle.  What's the difference?  If you don't test-drive the dev of your MarkLogic XQuery, you may never come back to test again.  Test-driven XQuery development will ease your headaches, put you into the plush seat of a developer with confidence, and rocket you down the road to making all your wildest dreams come true.  Kachow!



Ok, it may be slightly <em>more</em> magical than that.  But, I don't want to get your hopes up.  Seriously, though, if TDD is fun in, say Java Land (and it still is in MarkLogic land with "the Swede"), then it's a required portion of fun in MarkLogic Land?  Why?  While you might imagine yourself going back and adding tests to your Java project and sometimes you do, if you imagine it and then attempt it in your XQuery project, I believe the likelihood that you shrivel in shame and tears under your desk is much higher than in some other environments.

I the difficulty of the test after development approach is higher in MarkLogic XQuery because of what I've called "camouflaged dependencies" -- essentially, access to the http request and respond and to the database.  

You can get access to request fields or headers or anything else dealing with the web context in which the code is executed at any place in your code.  This doesn't mean you have to code like this, but the language doesn't necessarily help you enforce your discipline.  This is where testing before you write the code will help.  Make you functions functional -- pass in parameters and make them the only data access.  

You can read the database natively in MarkLogic XQuery.  That means that you can be retrieving data anywhere in your code.  There is an extreme lack of ceremony in making a connection to the database -- it's always there;  they're connected.  This is both refreshing and a shiny nail strip upon which to puncture the tires of your test-driven sports coupe e're you drive it off the lot.  Resist the temptation to read from the database or write to the database save in very determined and specific parts of your app -- parts that you will not actually unit test [gasp] because they'll be doing nothing but saving xmls at given database uris, and MarkLogic already has internal testing for that.

So, respect what you might call your dependencies -- the network and the database -- and be thrilled with the adventure of testing the business logic that you write yourself and need to verify.  And test it first to help keep you on the strait and narrow.  Otherwise, you're "discipline" will crumble under deadlines and in the end it will "just work" -- until it doesn't -- and you won't know why.



Note:
Below are the slides to support a presentation given at an in-house development conference.  It is an evolution of a talk previously given on <a href="">unit testing XQuery on MarkLogic</a> with streamlined principles and skills section and a not-included coding portion surrounding the use of XqTest, our XQuery unit test framework, and its integration in our environment.  Tonight, as I say my prayers, I will continue to hope that someday XqTest will be released from its prison and "the Swede" will see the light of day!

<div style="width:425px" id="__ss_9651897"> <strong style="display:block;margin:12px 0 4px"><a href="https://www.slideshare.net/rockycode/testdriven-development-on-marklogic" title="Test-driven Development on MarkLogic" target="_blank" rel="noopener noreferrer">Test-driven Development on MarkLogic</a></strong> <iframe src="https://www.slideshare.net/slideshow/embed_code/9651897" width="425" height="355" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe> <div style="padding:5px 0 12px"> View more <a href="https://www.slideshare.net/" target="_blank" rel="noopener noreferrer">presentations</a> from <a href="https://www.slideshare.net/rockycode" target="_blank" rel="noopener noreferrer">rockycode</a> </div> </div>

Unit testing is a required part of a healthy software development lifecycle and a balanced breakfast.  But test-driven development is a rockin' part of an *

Test-driven Development on MarkLogic

I've seen a number of different ways that internationalized strings get put into Javascript code.  Of all of them, I kind of like just bundling the resource bundle of key value pairs in Javascript files themselves, one for each language or something close to that.  But, in a recent project, there were a few other constraints, so we did it another way.



The Situation
-------------

* We're using MarkLogic on the backend -- our data is stored in xml.  Our server-side code is XQuery.
* Some of these strings are needed on the server side as well, so storing them all on the client in .js files wasn't going to cut it.
* We wanted to get all of the strings into the same place to make the list more manageable to update and maintain.

So, now there are two parts to getting internationalized strings available in the front-end code: The data transform on the backend and the strings made available on the front-end.

The Backend Transform
---------------------

The resource bundle data looks like this:

```xml
<resource-bundle xml:lang="spa">
  <resource key="my.key.name">
    <value>Translated String</value>
  </resource>

</resource-bundle>
```

The transform a la:

```
declare function get-lang-dict($bundle-collection as xs:string, $lang as xs:string?, $keys as xs:string*) as xs:string* {
  let $eng :=
    if (fn:exists($keys)) then
      get-resource-bundle($bundle-collection, "eng")/resource[@key = $keys]
    else
      get-resource-bundle($bundle-collection, "eng")/resource
  let $translations :=
    if (fn:exists($keys)) then
      get-resource-bundle($bundle-collection, $lang)/resource[@key = $keys]
    else
      get-resource-bundle($bundle-collection, $lang)/resource
  let $max := fn:count($translations)
  for $translation at $i in $translations
  let $engTxt := $eng[@key eq $translation/@key]/value/text()
  let $key := if (fn:exists($engTxt)) then
    json:escape(fn:normalize-space(fn:string($engTxt[1])))
  else
    fn:string($translation/@key)
  return fn:concat("'", $key, "': '", json:escape(xdmp:quote($translation/value/text())), "'",
    if ($i eq $max) then () else ",")
};

declare function get-resource-bundle($bundle-collection as xs:string, $lang as xs:string) as element()* {
  fn:collection($resource-collection-uri)/resource-bundle[@xml:lang eq $lang]
};
```

Now we have our xml transformed into a sequence of xs:string, each a json object where the English text is the key and the language text is the value, like this:

```json
{ "English String": "Translated String" }
```

The XQuery expression that renders the html page includes a call to populate the Javascript "lang" object with the json:

```
declare function lang-dictionary($lang as xs:string?) as element(script) {
  <script type="text/javascript">
    jQuery(document).ready(function(){{
      lang.dict("{$lang}", {{
        {get-lang-dict("bundle-collection", "spa", ("keys", "if", "any"))}
      }});
    }});
  </script>
};
```

Note that if you provide a pre-known set of i18n string $keys to the get-lang-dict() function, it will only add those resources to the dictionary.  Otherwsie, all the resources in your bundle are added.

Front-end Usage
---------------

The lang object that stores the dictionary of translated strings is like so:

```javascript
var lang = (function () {

  var current_dict = "eng";
  var dicts = {};

  var is_array = function (obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  };
  var set_lang = function (lang_code) {
    current_dict = lang_code;
  };
  var dict = function (lang_code, dict) {
    dicts[lang_code] = dict;
    set_lang(lang_code);
  };
  var get_translation = function (key, number) {
    var isPlural = number != undefined && number != 1;
    var dict = dicts[current_dict];
    var entry = dict == undefined ? undefined : dict[key];
    var val = null;
    if (is_array(entry)) {
      val = isPlural && entry[1] != undefined ? entry[1] : entry[0];
    } else {
      val = entry;
    }
    return val == null ? key : val;
  };

  return {
    dict: dict,
    _: get_translation,
    get_current_lang: function () {
      return current_dict;
    }
  };

})();
```

And when you want to grab a string from the language dictionary, just call:

```javascript
lang._("English String")
```

Plurals
-------

Note that the lang object implementation also allows for storage of a plural form of the translated word.  In practice, it was decided not to store our resource bundles in a parallel format.  Still, you provided data to the lang.dict() populating function that looked like this:

```json
{ "Result": ["Resultado", "Resultados"] }
```

And then got the translation like this:

```javascript
lang._("Result", results.length)
```

If it had a plural form, it would use it, falling back to the singular (1st) form.

Thoughts
-----------

So, what are the pros and cons here?  The main design issue that I felt created a bit of give and take was the keying of the strings by the English word.  The pro: If the string doesn't exist, the intelligible English string is shown in its place.  The con: It's less reliable and more brittle because you have to be able to control and escape properly the text that appears in the key.  What alternate solutions might you create?

Update: "RequireJs"
-----------------------
Or if you're using some sweet new Javascript tech, check out `this article on i18n in RequireJs <http://rockycode.com/blog/i18n-strings-requirejs/>`_.

I've seen a number of different ways that internationalized strings get put into Javascript code.  Of all of them, I kind of like just bundling the resource

I18n Strings in Javascript

If you've created an internationalized website lately, you've probably implemented some sort of language chooser widget in your site ui to allow your users to indicate which language they would like to see content displayed in.  What I often forget is that the user may have already made this indication previous to visiting your site, and you might be like to think about respecting their previously indicated preference.



Within the browser, a user can store their preferred language.  The w3c has a [nice browser list](http://www.w3.org/International/questions/qa-lang-priorities#changing) to give some terse instructions on how to set your language in your browser.

Your app might read the browser preference differently, but at least one component is consistent.  Your browser is going to pass an [HTTP header](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html) called "Accept-Language" to your app.  In a recent app, I read this using XQuery:

```
xdmp:get-request-header("Accept-Language")
```
That's going to return a string something like this one, which is mine:

```
en-US,en;q=0.8
```

This is a comma-delimited list of 2-letter [language codes <http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>`_ and 2-letter `locale codes](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2), informally "language-locale".

The "q=#" describes the quality of the language.  The higher, the quality, the more preferred.  Notice that in my header, "en-US", American English, does not have a "q=" attribute.  The lack of "q=" indicates a default, actually the highest preference, of 1.0.

There's also a Content-Language header, that I suppose you could use if you were making a differentiation for what language the actual content was using compared to the site chrome.  But, as far as I can tell, this is used less.  Even less by myself.  (Never.)

Here's a full XQuery implementation for MarkLogic that will read the header and parse out the preferred language.  In my implementation, I don't care about the locale, so I'm paying attention only to the language code.  The regex used is an adjustment of [this original php regex](http://www.thefutureoftheweb.com/blog/use-accept-language-header):

```
xquery version "1.0-ml";

declare option xdmp:mapping "false";

declare function local:get-browser-lang() as xs:string? {
  let $header := xdmp:get-request-header("Accept-Language")
  return if (fn:exists($header)) then
    local:get-top-hit-lang($header)
  else
    ()
};

declare private function local:get-top-hit-lang($header as xs:string) as xs:string? {
  let $langs :=
    for $entry in fn:tokenize(local:parse-header($header), ",")
    let $data := fn:tokenize($entry, "q=")
    let $quality := $data[2]
    order by
      if (fn:exists($quality) and fn:string-length($quality) gt 0) then
        xs:float($quality)
      else
        xs:float(1.0)
      descending
    return $data[1]
  return $langs[1]
};

declare private function local:parse-header($header as xs:string) as xs:string {
  let $regex := "(([a-z]{1,8})(-[a-z]{1,8})?)\s*(;\s*q\s*=\s*(1|0\.[0-9]+))?"
  let $flags := "i"
  let $format := "$2q=$5"
  return fn:replace(fn:lower-case($header), $regex, $format)
};

local:get-browser-lang()
```

This implementation just takes the top language, no matter what.  You might want to check to see if your site actually supports the language before picking from the browser preference.  While you're looping through the list of acceptable languages in get-top-hit-lang(), you could add a where clause to check for support.

Do you find that the sites you visit respect this header?

Update
---------

Here's an updated version of the code that respects secondary language selections as well (not just first choice):

```
xquery version "1.0-ml";

declare option xdmp:mapping "false";

declare function local:get-browser-lang() as xs:string? {
  let $header := xdmp:get-request-header("Accept-Language")
  return if (fn:exists($header)) then
    local:get-top-supported-lang(local:get-browser-langs($header), ("en", "es", "it"))
  else
    ()
};

declare function local:get-top-supported-lang($ordered-langs as xs:string*, $translations as xs:string*) as xs:string? {
  if (fn:empty($ordered-langs)) then
    ()
  else
    let $lang := $ordered-langs[1]
    return if ($lang = $translations) then
      $lang
    else
      local:get-top-supported-lang(fn:subsequence($ordered-langs, 2), $translations)
};

declare private function local:get-browser-langs($header as xs:string) as xs:string* {
  let $langs :=
    for $entry in fn:tokenize(local:parse-header($header), ",")
    let $data := fn:tokenize($entry, "q=")
    let $quality := $data[2]
    order by
      if (fn:exists($quality) and fn:string-length($quality) gt 0) then
  xs:float($quality)
      else
  xs:float(1.0)
      descending
    return $data[1]
  return $langs
};

declare private function local:parse-header($header as xs:string) as xs:string {
  let $regex := "(([a-z]{1,8})(-[a-z]{1,8})?)\s*(;\s*q\s*=\s*(1|0\.[0-9]+))?"
  let $flags := "i"
  let $format := "$2q=$5"
  return fn:replace(fn:lower-case($header), $regex, $format)
};

local:get-browser-lang()
```

If you've created an internationalized website lately, you've probably implemented some sort of language chooser widget in your site ui to allow your users

XQuery Browser Language Detection

I just returned from the MarkLogic Users Conference in San Francisco.  I had a good time.  I think the conference was worthwhile.  I'd go again, and I'd recommend it as a regular ritual for those that create on the MarkLogic platform.



Venue
-----

San Francisco was very fun.  About half the tech conferences out there are probably in this city, so there's nothing unique to the MLUC here.  The conference was held at The Palace hotel.  It is indeed quite grand.  The staff was very nice and accomodating.  The most impressive was the dining area just inside the front entry -- very cool.

Keynotes
--------

My favorite keynote was probably that given by Robert Sutton as he talked about great leaders and inventive teams.  It was definitely the most big-picture and general item talk, and it was probably the most inspiring.  Really, it had the potential to also be the most life-altering.  My second favorite was probably by Jason Monberg as a part of the next generation of unstructured data talk -- great moon landing analogy.

Surprisingly and unfortunately, I thought the intro keynote by the new CEO, Ken Bado, was a little stiff.  The content was fine, but the delivery came across and rehearsed and too teleprompter-supported, especially where he was trying to connect with his new customers.  But, no problem.  He seemed to loosen up and get in his groove as the talk went on, as I'm sure his tenure as the new MarkLogic CEO will progress as well.  I was impressed when he helped a fellow on-stage executive get past a little brain cramp of his own.

Customer-Serving
----------------

What better measure of a company than the degree to which they serve their customers?  Over and over again, the MarkLogic employees that I heard on stage or in front of a podium seemed very accomodating -- even begging -- for user feedback and requests.  They reiterated over and over that they were there to serve us.  The symbiotic relationship was reiterated many times.  I can't speak too much to MarkLogic corporation's relationship with our corporation, because I don't work at that level.  But, they sure seemed responsive at the conference.  

Some reasons might be obvious and self-serving for them as they are creating a product in large part to make a profit and serve their customers.  And most in the audience were indeed their customers.  And sure, a lot of their responsiveness and assistance is experienced through their professional services and the accompanying expensive consulting fees.  But, anyone can do that.  And businesses need to be profitable to survive.

From what I heard in talks and in conversations with MarkLogic employees, I perceived a real attitude and way of doing business that backed up what they were saying.  I felt that when they asked for desirable features from their customers for future products that they would actually implement them.  I felt that when they asked for feedback on what parts of the product were slow or clunky that they really meant it and that they cared about their craft enough to fix it.  I felt that when they asked what we were working on and how it was going that they really wanted to know about our success.  When Joe Dalton, their CMO, spoke I really had the impression that they are sincere about building not just profits, but a better company with values of substance.

Techie Hardware
---------------

.. raw:: html

  The most interesting slidedeck I saw was by John Snelson as he spoke about upcoming transaction mechanisms in MarkLogic Server 5.0.  It was presented in <s>Keynote</s> what I think was <a href="http://prezi.com/">Prezi</a> on a Macbook.  But, his hardware was the exception at the conference.  I found the lack of Apple products among the conference attendees and MarkLogic employees very refreshing.  Interesting code can be written on hardware that performs better, doesn't have the same pop appeal, but costs a lot less.  MarkLogic and their employees definitely don't seem to be Apple fanboys and don't pretend to need the sleek hardware to drive up their coolness factor, which seems to be a general them in many other places.  If I had to guess, MarkLogic gets most of their employee hardware from HP.

The Peeps
---------

I was constantly being very impressed with the caliber of people that were gathered at this conference.  I could characterize literally everyone I met as very smart and very kind.  What better could be said of a group?  Of course, there are always exceptions.  Who knows, many would probably think me an exception on both counts in some circles :) but I was impressed with those I met -- both attendees and employees.  Dare I go too over the top, even the sponsors were impressive. :)

There was a lot of access to MarkLogic employees here, from execs, to other management, to engineers and designers.  And those that I asked in informal conversation always gave good feedback about their company.  The top talent, back to even their original founder and architect were available for talks, formal and informal, which is probably unique compared with other tech conferences.  This company is relatively young, and its user base is relatively small.  That creates challenges, but it also creates opportunities.

Tech Conversations
------------------

Last year, I actually chose not to go to the MLUC.  I looked at the session list, and it looked to me like a marketing conference, where the provider tried to drum up more and continued business.  When some of my coworkers returned they reported that it did indeed feel like a lot of business hype.  So, this year, it was with a little bit of trepidation that I decided to go to this conference.  But, I was pleasantly surprised.  There were many super-smart engineers at the conference, and they shared some really cool stuff.  I felt like I got all the technical conversation I wanted.  

The hands-on opportunities were there, but they felt a little awkward.  They were in the form of self-paced, printed lab worksheets, where you could walk yourself through any number of things ranging from setting up your MarkLogic dev environment in Eclipse to using different libraries or doing some performace tuning.  To me, they felt awkward because I didn't really feel like going to another room and reading some piece of paper to myself whilst other developer-related talks were happening that I couldn't get later or elsewhere.

I was very encouraged to hear from CEO Ken Bado that he felt they had neglected the developer community, but that they realized that the dev community was the lifeblood of their platform and that they were going to improve drastically.  It'll be interesting to see how that materializes, but I was at least refreshed to hear the confession.

In all, I felt that the technical conversations that I had consisted of the most worthwhile part of the conference.  There was a lot of sharing of best practices.  There were a ton of tools and frameworks brought to my attention that I didn't know about before.  And all that generally made me question the way I had been doing things, which I think is a good thing.

Speaking
--------

I was invited to give a talk on unit testing XQuery on MarkLogic as a part of the conference.  Considering the caliber of the attendees and other talks, I felt very honored to be there.  My track manager, Dale Kim, was very helpful and provided good feedback during preparation and the day of my talk.  I felt like it went well, but could have been improved.  It seemed to be well-received.  I look forward to more feedback.  It was hard to decide how to approach a subject that I deal with on a technical level every day but that I presented to a mixed audience of developers and business types.  In conflict with [my own tech conference advice <http://rockycode.com/blog/ideal-tech-conferences/>`_, I added my own deck of `psychedelic slides](http://rockycode.com/blog/unit-testing-xquery-marklogic/) to the world.

Travel
------

TSA.  Egh.  My favorite [tweet](http://twitter.com/#!/flyingtweets/status/64994809328308225) of the day from @mikewhitmore: "Bin Ladin is dead! Can I travel with more than a 3 oz toothpaste now?" 

Airplanes were definitely not made for tall people.

I just returned from the MarkLogic Users Conference in San Francisco.  I had a good time.  I think the conference was worthwhile.  I'd go again, and I'd rec

MarkLogic Users Conference 2011 Impressions 

Unit testing is a required part of a healthy software development lifecycle.  Business logic in MarkLogic Xquery needs the same insurance of superb testing as any other language.  

Principles: Come learn the motivation for unit testing and how test-driven development can increase your productivity writing solid Xquery code in an Agile-coding environment.  

Skills: We'll code Xquery examples to learn general skills including the TDD workflow, how to isolate your code for unit testability, and how to test one thing at a time.  In each case, we'll address how to apply these skills specifically to development in the MarkLogic environment.

Tools: We'll also introduce you to in-house-developed tooling for creating unit tests and running them.  This tooling provides an all-Xquery method of creating test functions, annotating them as such so they're runnable in the test runner, isolating certain modules to test, and viewing clear test results.

With a few principles, skills, and tools for unit testing, you can go forward with increased confidence that the Xquery code you write on MarkLogic is more awesome than ever.



This slide deck is from a presentation at the MarkLogic Users Conference 2011.  

<div style="width:510px" id="__ss_7778485"> <strong style="display:block;margin:12px 0 4px"><a href="https://www.slideshare.net/rockycode/unit-testing-xquery-on-marklogic" title="Unit Testing XQuery on MarkLogic">Unit Testing XQuery on MarkLogic</a></strong> <iframe src="https://www.slideshare.net/slideshow/embed_code/7778485" width="510" height="426" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe> <div style="padding:5px 0 12px"> View more <a href="https://www.slideshare.net/">presentations</a> from <a href="https://www.slideshare.net/rockycode">rockycode</a> </div> </div>

More prose to follow and support these slides soon.

Unit testing is a required part of a healthy software development lifecycle.  Business logic in MarkLogic Xquery needs the same insurance of superb testing

Unit Testing XQuery on MarkLogic

Have you ever needed to know the location of the actual file that houses the code that's currently executing?  Well, if you have then you're not alone.  I have been there myself.  The answer might not be as interesting as some of life's deeper mysteries unveiled, but I was excited about it nonetheless.

This information seems especially useful in cases where an absolute path to the code is required but you want to avoid hard-coding context information into your app.  Your app really shouldn't care where it is deployed to afterall.  My love for Django increased when I discovered os.path.dirname(__file__).  Here's an equivalent goody in MarkLogic.



If I have the following directory structure:

```
code
  cutlass
   test
    unit.xqy
```

And I want to find the context of my unit.xqy from within the unit.xqy code as it's executing, I can call this:

```
fn:concat(xdmp:modules-root(), fn:substring(xdmp:get-request-path(), 2))
```

What's happening?

* xdmp:modules-root() points to the Modules DB (which happens to be where the code is running).  This also works if you're running modules on the filesystem.
* xdmp:get-request-path() is giving you path from your domain root
* The substring is to strip the / (slash) prepended to the request path, because the modules-root also ends with a slash

Finally, that line of code yields the full path to the context of execution, boom!:

```
/code/cutlass/test/
```
As a side note to the above solution, I was thinking from [this MarkMail thread](http://markmail.org/search/?q=marklogic:%20get%20uri%20of%20current%20file#query:marklogic%3A%20get%20uri%20of%20current%20file+page:1+mid:mdj6xdqyf3lajez6+state:results) that this would work:

```
 resolve-uri(".", xdmp:get-request-path())
```

But this is all I ever got:

```
/test/
```
Anyone know what I was doing wrong?

Well, it's good to know where you came from, why you are here, and where you are going -- in many contexts, I guess. :)

Have you ever needed to know the location of the actual file that houses the code that's currently executing?  Well, if you have then you're not alone.  I h

Execution Context in MarkLogic

How do you log into a MarkLogic application to run as a user besides the default app server user?  Use xdmp:login(), baby!  User/role management can be awesome -- when it's done and coded.  For now, let's sing out a few important things to remember about xdmp:login() and all its hidden secrets.



My voice is my passport...
--------------------------

I was debugging some xdmp:login() goodness and realized that sometimes the SEC-PRIV exception wasn't thrown.  It seems that if the xdmp:login() doesn't recognize the username as a user known to the system, it won't login.  Thus, if I code this beauty:

```
xdmp:login("asdf")

```
It won't even try.  It just doesn't do anything, assuming "asdf" really isn't a known user in your app.

Session Masquerade
------------------

Make sure that you realize, as I failed to scrutinize in my quick glance at the [xdmp:login() API](http://developer.marklogic.com/pubs/4.2/apidocs/AppServerBuiltins.html#xdmp:login), that by default xdmp:login() logs in as the specified user for the entire session.  The last (optional) parameter, $set-session is true by default.  What will stop the masquerade?  Only session timeout or a call to xdmp:logout().  Don't want to have to rip the mask off your user every time?  Try:

```
xdmp:login($username, (), fn:false())
```

But, if session logins are what you're craving, you may run into the same issue I did... On a dark dreary night I crept to the monitor, brought up my code and began pressing the keys... typity, typity.  The branches of the tree outside scraped across the moonlit window.  Breathing more quickly now, I focused back at the flickering monitor.  I did an xdmp:login() to a user that didn't have the xdmp-login execute privilege.  It worked.  But then to my horror, the second time it failed.  But, why?  Thinking that I might have to beat back the horrors of the night at any time with a flashlight, I stumbled to my feet.  Then, I realized that I was now permanently (at least for the duration of the session) an unprivileged peon and could not enjoy the warmth that privilege had once bought me.  After this realization, my nocturnal hallucination suddenly seemed less harrowing, less threatening, and I committed my code and went to sleep.

Obviously not wanting to relive such an experience, just realize that you'll need more logic around when to xdmp:login() and, in this case more importantly, when to not login.

And now a word about amps
-------------------------

Another experience to not forget (and also, thankfully, not embellish to such great, un-useful lengths) is that amps on the filesystem act a little bit differently than everywhere else.  That is, when I was trying to define xdmp-login privileges for the function that performed the password-less xdmp:login(), I couldn't seem to get them to take on the filesystem.  That is because my deployment mechanism doesn't apply amps to the filesystem.  If you want that goodness, make sure you do something as sweet as this:

```
xdmp:amp($namespace, $localname, $module-uri, xs:unsignedLong(0))
```

Where the "0" represents the filesystem instead of a deployed Modules database.

... verify me.

How do you log into a MarkLogic application to run as a user besides the default app server user?  Use xdmp:login(), baby!  User/role management can be awes

Xdmp:Login Love

When a person looks at an Xquery module import, ... um, sorry... he usually gets distracted by something else before he can get to the semicolon at the end of the statement.  They're seriously long!  Few are the files in which one-line imports adhere to an 80 character width limit.  Read on for my other Martin Luther-spirited grievances.



Length
------

Ridiculously long.  Example that speaks for itself:

```
import module namespace translate = "http://aprilandjake.com/audience/modules/content/translate" at "/modules/content/translate.xqy";
```

Ok, some of the blame here lies with me for picking a ridiculous namespace.  But it seems conventional to stick the domain on the front in proper URL fashion.  And then, I'm mirroring the path from app server root as the rest of the namespace, which takes me to repetition:

Repetition
----------

Doesn't it seem like we have the same data listed here twice.  From what I'm getting from the [W3C Xquery Spec](http://www.w3.org/TR/xquery/#id-module-import):

The URILiterals that follow the at keyword are optional location hints, and can be interpreted or disregarded in an implementation-defined way.

The implementation I'm operating in is MarkLogic.  As far as I can tell, then url after the "at" is required in this implementation.  Can anyone fulfill a boyish dream of mine and tell me otherwise?  Please!

So, I thought I was pretty cool creating a Live Template in IntelliJ to throw down this nasty import for my current project and save me a few keystrokes:

```
import module namespace $NAME$ = "http://aprilandjake.com/audience$PATH$" at "$PATH$.xqy";
```

So, then I could type the path from app server root to the library module file once and it would be duplicated, but now I get bitten by paths:

Paths
-----

It seems like most of the Xquery code that I see uses absolute paths after the "at" in the import, as in:

```
import module namespace myns = "http://super.long/namespace/of/modules/death" at "/modules/death.xqy";
```

Note the leading slash.  So, I have done this in most of my code.  Remember, it helps my live template work as well (less typing overall).  Well, it seems that I may need to change my standard here, because the leading slash limits me, as I see it, in my code reuse.  Paraphrasing from the [MarkLogic Documentation](http://docs.marklogic.com/4.2doc/docapp.xqy#display.xqy?fname=http://pubs/4.2doc/xml/dev_guide/import_modules.xml%2329407):

Paths in imports are resolved as follows:

1. Starts with "/", look under Modules subdir in MarkLogic install
2. Starts with "/", look under App Server root
3. Doesn't start with "/", look relative to location of referencing module
4. Contains scheme/network location (eg, "http://"), throw exception

So, everything's all well and good using leading "/" in the "at" expression until you want to reference the same code from multiple locations (really only a problem in local filesystem development thus far).  For Example:  

- App Server 1 - This app server's root is pointed to its own code.  Absolute paths work fine. Bam!
- App Server 2 - This app server's root is different.  It has its own code and also has a maven dependency declared on the code that's currently being run on App Server 1.  App Server 1 code is a module that I've packaged up and sent to the maven repo, but developing locally, I don't have a compile or package phase for running my app, so I create a symlink with the same name as the artifactId to where the code is that I want to reference.  To get my import statements that link App Server 2 to App Server 1 code to work, I have to add the artifactId at the front of the absolute path.  But, now the problem is the code within App Server 1, where it links to itself.  Because it uses the leading "/" (absolute), MarkLogic tries to resolve it under App Server root, which in this case is a different App Server entirely.  

So, am I stuck using relative paths at least inside of the App Server 1 code?

Dreams
------

All I want in an import statement is to declare to my language that I want to use code that is stored elsewhere.  Can't we do that in fewer than 80 chars?  And couldn't there be a really cool convention (over configuration), for developers like me whose fingers tire from writing ranting blog posts, that, for example, could derive a path to the .xqy file from the namespace that follows said convention?  Finally, I can't help but think that there has to be an easier way for me to find and run bits of code from places besides my App Server root, even in local filesystem dev mode.

Help me, Obi-wan Kenobi, you're my only hope.

When a person looks at an Xquery module import, ... um, sorry... he usually gets distracted by something else before he can get to the semicolon at the end

Xquery Imports on MarkLogic

Sometimes you want to ensure that your xml document matches a given schema (xsd).  Xquery on MarkLogic gives you a few tools to do this.  If you want to validate your xml against an xsd, read on fair reader.



First of all, you need an xsd schema to show the database what you expect your data to look like.  From the w3schools xsd example , [here's a sweet schema](http://www.w3schools.com/schema/schema_howto.asp):

```xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
	targetNamespace="http://www.w3schools.com"
	xmlns="http://www.w3schools.com"
	elementFormDefault="qualified">

	<xs:element name="note">
	  <xs:complexType>
		<xs:sequence>
		  <xs:element name="to" type="xs:string"/>
		  <xs:element name="from" type="xs:string"/>
		  <xs:element name="heading" type="xs:string"/>
		  <xs:element name="body" type="xs:string"/>
		</xs:sequence>
	  </xs:complexType>
	</xs:element>

	</xs:schema>
```

First, save the xsd in the Schemas database.  If you want to webdav in, connect to port 8902 and create a directory structure that matches the xsd target namespace:

```
http://  >  www.w3schools.com 
```
	
And drop your schema in there.

If you want to verify the location of your xsds, run a little cmd in CQ against the Schemas db:

```
fn:base-uri(/xs:schema)
	
```
Next, let's get us a document to validate (again, from w3schools' example):

```xml
<note>
  <to>April</to>
  <from>Jake</from>
  <heading>Reminder</heading>
  <body>Don't forget me this weekend!</body>
</note>
```
	
And finally to validate.  There are two modes, strict (default) and lax.  I've been using strict, because lax really is.  And a little more CQ action:

```
	import module namespace functx = "http://www.functx.com" at "/MarkLogic/functx/functx-1.0-nodoc-2007-01.xqy";
	let $document := 
		<note>
		  <to>April</to>
		  <from>Jake</from>
		  <heading>Reminder</heading>
		  <body>Don't forget me this weekend!</body>
		</note>
	let $doc-to-validate := functx:change-element-ns-deep( $document, "http://www.w3schools.com", "awesome" )
	return validate strict { $doc-to-validate }
```
	
To explain, we pull in our doc, we attach a namespace to it (since we didn't already specify one), and validate away.  If your doc fails validation against the schema, prepare to see the first error encountered.  In another experiment, I was getting beauties like these:

- validate strict { $doc-to-validate } -- Missing element declaration: Expected declaration for node ...
- validate strict { $doc-to-validate } -- Missing required attribute: Found () but required (@type & @uuid? ...
- validate strict { $doc-to-validate } -- Invalid node type: @type lexical value "asdf" invalid for expected type ...

Beauties, eh?

The one-at-a-time error reported stinketh a bit to me.  With a function whose job it is to provide a picture of how well (or not) a document matches a schema, I think it would be more fitting to provide a report (perhaps in beautiful xml) of what all the issues are that were found.  

Cheers!  And a happy new year filled with valid documents.

Sometimes you want to ensure that your xml document matches a given schema (xsd).  Xquery on MarkLogic gives you a few tools to do this.  If you want to val

XSD Validation in MarkLogic

Recently, we've been working on writing an API using xquery.  We have wanted to make the API as solid as possible, since we're putting the brunt of the complexity of our system into this module of code.  What might typing our parameters and return types give us?  We are hoping for safety and readability.  



Safety-wise, we're a little perplexed on how safe typing really is.  In the past, it's helped fail fast, providing feedback on data anomalies or bad conditions during test.  But, if you haven't tested a particular condition that would trigger an error, you're going to have to wait until runtime to then get the app to blow up in your face.  A compile-time check would be really nice here.

Readability, I think, is vastly improved by typing parameters and return types.  I'm very thankful that the built-in functions of MarkLogic, the Xquery implementation I use most often, are so annotated.  I also dig the occurrence indicators a la regex that provide terse, elegant meaning.

In trying to get to the point of increased safety and readability, I've also reached the point of increased confusion.  We setup an example of what we thought would error out, but instead it still didn't work, but gave us something unexpected.  Here's the example:

```
xquery version "1.0-ml";

declare namespace aw = "awesome";

declare function aw:foo($in as xs:string) as xs:string? {
  ()
};

declare function aw:foo2($in as xs:string) {
  "sweetness"
};

aw:foo2(aw:foo("something"))
```

The function foo2() is supposed to requires a string and return "sweetness".  We pass into foo2() the result of foo(), which is always an empty sequence, so we would have expected the call to foo2() to blow some serious xml chunks.  Instead, the return value of the whole expression is also empty sequence.  Will someone please explain why this is, because foo2() is hardcoded to return "sweetness".  Is it that foo2() is never called?  And if so, why does that seem to happen silently?  Doesn't that seem dangerous?  The mysteries mount.  

If I change the xquery version itself on this code to read:

```
xquery version "1.0";
```
	
Now we're back into vanilla Xquery land without the MarkLogic flavor.  Now, I get what seems to be a more expected response.  Calling this code now yields this lovely:

```
[1.0] XDMP-AS: (err:XPTY0004) $in as xs:string -- Invalid coercion: () as xs:string
Stack trace:

line 9:
7: };
8: 
9: declare function aw:foo2($in as xs:string) {
10: "sweetness"
11: };

aw:foo2(())


line 13:
11: };
12: 
13: aw:foo2(aw:foo("something"))
14: 
15:
```

So, is this a bug in the MarkLogic implementation of type checking, coercion or something else?  Beats me, but for now this is something that makes me a little more unsure of the code I write in Xquery/MarkLogic.  Help me Obi-wan, you're my only hope.
	

**Update - Mystery Solved**

Kelly Stirman of MarkLogic was kind enough to comment on my consternation (see his post below).  I took his advice, saw the coercion error that I was observing when running in vanilla 1.0 xquery, and the universe came back into alignment.

So, it turns out that my function foo2() was indeed never called.  From the [MarkLogic Docs](http://docs.marklogic.com/4.2doc/docapp.xqy#display.xqy?fname=http://pubs/4.2doc/xml/xquery/enhanced.xml%2355459) describing function mapping:

One consequence of function mapping, which can be **surprising** the first time you see it, is that if the value passed for a parameter is the empty sequence, it could result in the function being called 0 times (that is, in the function never runs and results in the empty sequence. For example, if you entered the empty sequence as the parameter to the above function call, it returns empty, as follows:

```
xquery version "1.0-ml";

declare function local:print-word ($word as xs:string) { $word };

local:print-word( () )
(: 
   evaluates the print-word function zero times, resulting 
   in the empty sequence
:)
```
The `local:print-word` function is never called in this case, because it is iterating over the empty sequence, which causes zero invocations of the function. If your function calls are fed by code that can return the empty sequence (an XPath expression, for example), then you might see this behavior.

And boy was I surprised. :)  

So, what was the fix?  It was to disable function mapping that MarkLogic-flavored Xquery adds as an extension to the language:

```
xquery version "1.0-ml";

declare namespace aw = "awesome";

declare namespace xdmp = "http://marklogic.com/xdmp";

declare option xdmp:mapping "false"; 

declare function aw:foo($in as xs:string) as xs:string? {
  ()
};

declare function aw:foo2($in as xs:string) {
  "else"
};

aw:foo2(aw:foo("something"))
```

This yielded:

```
[1.0-ml] XDMP-AS: (err:XPTY0004) $in as xs:string -- Invalid coercion: () as xs:string
```

And I felt much better knowing what was happening in the code.

The behavior of not calling a function when passed an empty sequence when function mapping is on does not seem very intuitive to me, but it does seem to fit in with the logic of function mapping if it treats for the sequence as the variable iterated on in the for a FLWOR.  Recently, I've created a hotkey for turning off function mapping for other reasons, and now here's another one.  I have obviously not leveled up sufficiently to handle this function mapping beast with any dexterity.  

Thanks, Kelly, for letting our souls rest easier over the holidays. :)

Recently, we've been working on writing an API using xquery.  We have wanted to make the API as solid as possible, since we're putting the brunt of the comp

Unexpected Results in MarkLogic Xquery Type Coercion

The spectre of webdav has again appeared before me.  This time's it's on Windows.  My last experience on webdav was in the dojo of Linux.  Now, my Linuxy nun chucks aren't quite as deadly.  I must tame this beast.  Here's a Windows-webdav must.



Disable Internet Exporer 8's automatic proxy
--------------------------------------------

If you don't do this, you will find that webdav on Windows 7 is extremely slow.  So slow, in fact, that it crashed Windows Explorer several times as I tried connecting to webdav and got the dreaded "(Not Responding)" text multiple times.

To disable, open up IE, and pull this action:

1. Tools menu > Internet Options > Connections tab > LAN Settings button

2. Uncheck "Automatically detect settings" box

This should noticeably improve your speed.


Other Troubled-shots
--------------------

I tried a few other things that may/not help you in your quest for webdav'ery on Windows:

* Allow for [basic authentication via webdav](http://support.microsoft.com/kb/841215).

* Use the [Oxygen](http://www.oxygenxml.com/download.html) webdav interface.  It's faster that the Windows Explorer method (with auto proxy still enabled), but limited in its function.  You can't copy folders of things out of or into webdav.


Make a webdav connection
------------------------

Now that you hopefully have your enemies to progress subdued, it's time to just make the connection.  The favored Windows 7 method is adding a network place:

1. Start menu > Computer 

2. Right click in main window area > Add a network location

3. Next > Next > Enter URL > Enter descriptive name > [enter credentials] > Finish

Now your connection should be saved for the next time you log into your computer and are ready to face the perils of webdav once more.

The spectre of webdav has again appeared before me.  This time's it's on Windows.  My last experience on webdav was in the dojo of Linux.  Now, my Linuxy nu

WebDAV on Windows 7

My first xquery experience has been on the MarkLogic platform.  The project that we just released was written entirely in xquery and on that platform.  As our site continues to gains popularity, we continue to realize how little about xquery we knew or know.  Sometimes and in some places, the site is just really not that performant.  "But I thought MarkLogic/xquery is super-scalable," some exclaim indignantly.  If you do it right, an Oracle relational database can be made to scale.  Done wrong, a MarkLogic database can be made to not scale at all.  There's a lot to be said about knowledge of the platform, the language, and how to wrestle it to do your bidding.  Here are a few optimization ditties that I've collected as of late that might help in your future xquery dev.



* Flatten your query - This means push your where clause into the xpath at the beginning of your FLOWR statement, limiting the amount of work you have to do once you're inside the for statement.

* Limit your data set - Do whatever it takes.  You just want to get to the smallest set of data possible in the most direct way.  For us, that has meant putting the most specific predicate first or keeping active datasets in a collection (king of AoP-like, not affecting persisted XML data)

* Query once, reference later - This comes pretty naturally in a, say, Oracle world, because it takes so much work to get down to the persistence layer and retrieve the data.  In xquery, the data sits so much closer to your app layer, giving you plenty of easy access.  Just think of it as taking another needless roundtrip to the database every time you want to run a little xpath action.

* Favor xdmp:estimate() - If you can, use xdmp:estimate() because it's faster.  And, it's accurate if counting at fragment boundaries (doc roots).

* Beware calculations - "select count (id)" might work snappy quick in sql, but do the same thing in xquery, and depending on your xpath or where clause, it's gonna work as slow as snot.  The biggest difference?  Probably that documents may need read into memory in their entirety for even a simple result like a count.  Lots of times, it might be good to design for pre-calculations, that happen before the calculation is actually even needed.  For instance, you could put all id's for docs in a certain state inside of a single doc, which is much cheaper to query than many.

* Know your indexes - I'm definitely still learning this one:  which ones are being used implicitly w/o being setup by an admin.  Here's a pearl that we just picked up: Range indexes will significantly increase the performance of your order by clauses that use those indexed elements/attributes (including fn:distinct-values()).

* Limit logging - By nature, file i/o can be expensive.  If you want to keep it in, but turn it off, protect it with a conditional (it's a lazy calculation and hopefully a cheap one too).

* Beware the double slash - This is a given, even for the xquery newb.  This is tree traversal galore.  Then again, don't be afraid to use it, when helpful, for data sets that are always guaranteed to be known and small.

* Utilize search functions - MarkLogic, for instance, has many performance optimizations built into its search capability.  Sometimes it will be more performant to use a search function as opposed to raw xpath.  For example, if an element personId is supplant deep in the bowels of an xml document, requiring xpath muscle to get in, find docs with a particular personId, and return the set, you could do something simple like cts:search(/doc,cts:element-word-query(xs:QName("personId"), $personId)) that could be legions faster.

Those are some dev tips, here are your tools, really quickly:

* Known and love [CQ](http://developer.marklogic.com/code/cq) and its profiler

* xdmp:query-trace() and  xdmp:query-meters()

* Some code to generate large amounts of data for you to test on

Finally:

* There are a few more tips in the Priscilla Walmsley [XQuery](http://www.amazon.com/XQuery-Priscilla-Walmsley/dp/0596006349/ref=sr_1_1?ie=UTF8&s=books&qid=1278002233&sr=8-1) book, chapter 15.

- Performance guide available at [developer.marklogic.org](http://developer.marklogic.com/docs).

Happy coding.  And remember, it's always possible to write bad, unperformant code.

My first xquery experience has been on the MarkLogic platform.  The project that we just released was written entirely in xquery and on that platform.  As o

Xquery Optimization Tips

Mark Logic Server seems to be the latest, greatest in content serve-up.  At least it is generating a lot of excitement at the LDS Church, where it's being used for new content-centric apps/sites.  Being caught in the wave of awesome, I was interested in getting it running in my favorite dev environment: Ubunutu-flavored Linux.

It wasn't bad at all.  In fact, it was accomplished in almost as few steps as installing Apache or Tomcat.  Except, after this installation, full XML xquery'age is now possible!  Here are the steps, slightly elongated by the fact that all Mark Logic-supported Unix systems are rpm-based.



Here are the steps, ya'll:

```bash
# Get the package
wget http://developer.marklogic.com/download/binaries/4.0/MarkLogic-4.0-5.i686.rpm
    
# Get the rpm -> deb converter
sudo apt-get install alien
    
# Convert the package
sudo alien MarkLogic-4.0.5.i686.rpm
    
# Install the package
sudo dpkg -i MarkLogic-4.0.6.i686.deb
    
# Supposedly, this dir is also important
sudo mkdir /var/lock/subsys
    
# Try to start the server -- most likely this will fail
sudo /etc/init.d/MarkLogic start
    
# Here, I got this error:
#   MarkLogic: /opt/MarkLogic/bin/MarkLogic: error while loading shared
#   libraries: libbteuclid.so.6.0.1: cannot open shared object file: No such file or directory
    
# If needed, the the latest, unstable shared library (at own risk)
wget http://ftp.us.debian.org/debian/pool/main/l/lsb/lsb-base_3.2-22_all.deb
    
# Install the shared lib
sudo dpkg -i lsb-base_3.2-22_all.deb
    
# Start for real this time
sudo /etc/init.d/MarkLogic start
    
# Access your server and download a license key
firefox http://localhost:8001 &
```


You can also look for newer packages [here](http://developer.marklogic.com/download/).

Here's the [lsb-base page](http://packages.debian.org/unstable/lsb-base) for further investigation of this shared library awesomeness.

Mark Logic Server seems to be the latest, greatest in content serve-up.  At least it is generating a lot of excitement at the LDS Church, where it's being u