Anyway, I recently had a situation where someone (honestly, in this case it wasn’t me) accidentally deleted the Site Collection for the SSP admin site (/ssp/admin).  Since this was for a SharePoint farm in production I really didn’t want to have to re-create the entire SSP but I couldn’t figure out how to just re-create the site collection itself.  I figured there had to be a site template for the site but since it didn’t show up in the Create Site Collection UI I went and looked on disk.  Sure enough, a site template exists for the SSP Admin site.  It’s called OSRV.

So to create a new SSP admin site, run this command line.

stsadm.exe -o createsite -url http://<server>:<ssp_port>/ssp/admin -owneremail <email address> -ownerlogin <account> -sitetemplate OSRV#0 -title "Shared Services Administration: <your ssp name>"

This might take a little while to complete, but it does eventually finish.

Next you need to edit the SSP to point to the recreated site.

stsadm.exe -o editssp -title "<your ssp name>" -sspadminsite http://<server>:<ssp_port>/ssp/admin

That’s it.  You should be back up and running.

About a year and a half ago I was talking with an associate and he mentioned Iron Python and how it could apply to SharePoint. At the time I was working on other projects but I filed it away as something to play with when I had time. Once I finally got around to it I started to realize just how useful this combination is. I won’t go into the details of what Iron Python is specifically, you can read about it on the site. But essentially you get a powerful scripting language with full access to the SharePoint object model. On top of that, Python has an interactive console so it’s easy to load up an object, poke around its properties, and inspect exactly what each object does.

Here’s a quick example of a Python script enumerating all sites in a site collection and printing out the URL and root web name:

webapp = SPWebApplication.Lookup(Uri("http://mysite"))
for site in webapp.Sites:
    print '%-30s - %s' % (site.Url, site.RootWeb.Title)


Ever need to quickly get the internal name of a particular field?

list = SPSite("http://mysite").RootWeb.Lists["Documents"]
for field in list.Fields:
    print field.InternalName


Okay – these two examples might be fairly simplistic, but the point is Iron Python can be a much quicker and easier way of doing things with the SharePoint object model that you would normally have to write a custom console application for.

Getting Started

First, download Iron Python and install it on your SharePoint server. Next, fire up a console and type “ipy“. This will launch the Iron Python interactive console.

Next, type the following lines:

>>> import clr
>>> clr.AddReference("Microsoft.SharePoint")
>>> from Microsoft.SharePoint import *


Let’s look at what we’ve done. In Python the “import” statement is like the “using” statement in C#. It tells the interpreter that we want to use a particular module. In this case, we’re importing the interface to the .NET Common Language Runtime.

Next, clr.AddReference() is used to tell Iron Python that we want to load the Microsoft.SharePoint assembly. This same approach can be used to load any SharePoint assembly (or any .NET assembly for that matter). Finally, the last line imports all objects in the Microsoft.SharePoint namespace. This only imports objects in the Microsoft.SharePoint namespace. If you want to load objects from another namespace, you’ll need to import those as well.

At this point, you’re ready to go. Try out these lines to explore the object model.

>>> site = SPSite("http://myserver")
>>> for web in site.AllWebs:
. . .     print web.Title



>>> list = site.RootWeb.Lists["Documents"]
>>> list.Title = "Python Documents"
>>> list.Update()
>>> print list.Title


Unit Testing and Debugging

The interactive console can be extremely useful for unit testing your code as well as debugging. Since I’ve started using Iron Python I’ve often kept a console up while working on whatever application I’m building. It’s come in extremely handy when you just want to look up a particular method or see exactly what the format is of a particular piece of data. But another useful aspect is that it can be used to quickly test out the code that you write.

Iron Python can load any .NET assembly. So if you want to test out a method you’ve just written, load it up in the Iron Python interactive console and test it out. Building a real unit testing environment can be difficult in SharePoint because of the long setup and teardown times. This can be a happy compromise between a full on unit testing setup.

Cooking with Gas

One thing I hate is tech sites that show elementary examples and don’t really get into the complexity that is sure to arise once you move past “Hello World”. So I’ve uploaded a sample script that can be used to back up all sites in a given web application. This example combines a number of concepts such as:

• running stsadm commands from python
• importing parts of the .NET framework into your scripts
• functions as objects in python

Download the script here.

Conclusion

I’ve been very impressed by the power of Iron Python and what means for us SharePoint developers. My prediction is that by using scripting tools like Iron Python, developers and administrators will begin to write scripts to automate a number of common SharePoint activities. Personally I’d really like to see some of the following:

• Mass check-in/publish scripts
• Scripts to upload a given web part to every page in a site
• Data/content migration

Reference

• Iron Python website – get the code and learn how to use it
• Python Tutorial – very valuable introduction to the Python language

Download both WSSDW AND MOSSDW.
I ran into a ton of problems when I started because I only downloaded MOSSDW.  The samples don’t work without WSSDW – WSSDWLib.dll to be exact.  So download them both and install them in the same folder. 

You need to “Unblock” the help files (chm) before you can read them.
After downloading the help files, right-click, choose properties, then click Unblock.

Don’t bother trying to delete sample content. 
The tool just doesn’t work very well.  You’ll end up with an error and a bunch of left over content.  The best thing to do is just to create your sample site hierarchy under a single “Test” web and then just delete the Test web manually (or with stsadm) each time.  Note, you may have to use the Manage Site Content and Structure UI in MOSS so that you can delete webs with subwebs.

Creating a publishing page and publishing it is a two step operation.
This just seems weird so maybe I am missing something.  But if you want to create a publishing page, add content to that page, and publish it, you need two XML node actions.  The first node creates the page and adds content.  The second node publishes it.  For example:

<TestPage Name="Page1.aspx" PageLayout="ArticleLeft.aspx" openmode="modifyexisting">
  <TestHtmlFieldValue Name="Page Content" HtmlFile="MOSS_Intro.htm" openmode="modifyexisting"/>
</TestPage>
<TestPage Name="Page1.aspx" openmode="modifyexisting" Status="Published" />

You would assume you could just add the Status=”Published” bit to the first TestPage node.  But what happens is that the status gets set before the TestHtmlFieldValue node is parsed – so this action fails because the page isn’t checked out.  *rolls eyes*

Mixing and matching MOSS tags and WSS tags has some issues.
If you’re going to mix and match MOSS and WSS tags, be sure to use WSS tags to walk your web hierarchy.  The <TestArea> MOSS tag won’t provide context to children such as <Lists>.

Oh… you wanted an explanation?  Okay – here you go.

I could bore you with a bunch of background on Agile and what’s good about it, what the process is, what the core concepts are, etc.  But I won’t.  If I did that we would just go back and forth forever on the benefits/shortcomings of Agile development.  Instead I’ll get right to the point.

You do not know enough about SharePoint to fully spec a solution end-to-end.

Let me repeat that.  YOU (yes you), DO NOT know enough about SharePoint.  I know you think you do.  I know you think you know how everything works, how everything fits together, but you don’t.  And you know what?  Nobody does.

There you go.  Any application you want to build that has any level of complexity just cannot be fully designed up front.  There are too many unknowns at every level in the product.  Too many assumptions need to be made about what should work.  And we all know that there are dozens of unanticipated gotchas waiting around every turn.

SharePoint 2007 is a huge product.  It has a ton of little nooks and crannys each providing great functionality, but also hiding pure WTF, “why did they do it that way”, suprises.  SharePoint is just too big and too new for anybody to know it intimately enough to fully define a solution end-to-end without actually doing some trial and error implementation.  So if you’re doing trial and error implementation anyway, why not include the client and make them short iterations?

Okay – a few more quick benefits to this approach:

1. Don’t have to spend time documenting out of the box functionality that you don’t have control over anyway
2. Wireframes and UI designs are less critical because you can “design” on the fly using the out of the box UI – then identify the gaps where additional design elements or controls are needed
3. End up with less code/customization because once users see it out of the box, they quickly reach a “good enough” point.  You can focus your customizations where where adds real value.
4. The very nature of letting the user touch and feel the solution will change their requirements.  They will realize that certain things are less important than they thought while others are more important.  This is true with any application development but the fact that you can do so much out of the box in SharePoint means you can get to this point very very quickly.

So there you go.  Good luck.  We have a tough fight ahead of us convincing people that SharePoint is different enough to warrant throwing old waterfall methodologies away and trying something new.

Now the bad news: having motivated employees is your responsibility – yours and yours alone. It’s not the responsibility of the HR department or some disconnected “Chief Culture Officer”. It is your responsibility. And it gets worse – if you want to motivate your employees, you have to mean it.

So, before you read any further you need to ask yourself a question: do you feel motivated? Do you want to motivate your employees? Do you want to motivate your employees because you want them to feel the same commitment and passion you do? Or because you want to squeeze a few more hours out of their already long work day?

Motivation is all about communication and vision. It’s about transferring your own motivation and drive to your employees. If you don’t believe in the vision, then no amount of “employee retreats” or “team building exercises” are going to make a difference.

So again, ask yourself if you really feel it. If you don’t, it might be a good idea to step aside so someone who is truly motivated can take the reins. On the other hand, if you are motivated and are looking for some tools to help you transfer that motivation to your team, please keep reading.

Still here? Okay well either you’re lying to yourself, you’re really bored and are reading anyway, or you really do feel enthusiastic and want to pass some of that along. Hopefully it’s the latter, but I’m not going to be picky.

I’ve broken this article into four parts:

1. Being Available
2. Empathize, to a point
3. Commitments
4. General conduct

Part 1 (Being Available) is ready to go now. The other 3 parts will be posted as my time allows.

As I said up front, motivation has a lot to do with transferring your enthusiasm to your employees. But in order to do this effectively you have to be genuine about it. If you aren’t feeling it, you’ll end up doing more harm than good. Employees only need a few “fake” ra ra sessions to start seeing everything you do in that light. So the best thing to do if you aren’t feeling the enthusiasm is to do nothing. Doing nothing is much better than doing something in this case because that something is likely to cause damage that is very difficult to undo.

On the other hand, when you really are feeling it, you want to share it right then and there. When an employee has done great work, praise that work immediately. When the company just landed an awesome new opportunity, tell everyone right then and there.

I’ve always felt that transferring your enthusiasm is much more effective when done in a casual and spontaneous way. When employees see you being enthusiastic in non-orchestrated settings, it comes across as much more genuine. This is why I says be available – walk around a lot – maximize your in person time with your employees. The more time you have with them, the more opportunities you will have to communicate new ideas, be exposed to their great work, and generally check in on how they are doing.

This is such a small and easy thing it’s amazing to me how many people don’t do it. They think that managing people is sitting at their desk, reviewing reports, answering emails, and conducting one on ones. Why should you have to wait two weeks to have your appointed one on one when you can walk over to their desk and do it right now?

A few words on employee praise. Employees want to feel good about the work they are doing. When they feel like they are doing great work, they want to be recognized for that. However, many employees aren’t necessarily into the whole self-promotion thing and thus feel somewhat uncomfortable tooting their own horn. By walking around a lot and being generally available you put yourself in a position to see their great work first hand.

The most effective praise is tied directly to an individual accomplishment. Being able to walk up to someone and say “hey – what you’re doing right now is great” is so much more effective than a disconnected “you’re doing a great job here” comment. I think this is partially because the latter doesn’t really have any insight into what the employee is doing. It fosters comments and thoughts like “he doesn’t really know what I do” or “she has no idea how challenging this is”. When you praise an employee immediately for a specific accomplishment you have witnessed, it tells the employee you know exactly what they’re doing, have seen the great work, and think it’s great. It’s a much more genuine form of praise. And being genuine is what it’s all about.

Another extremely valuable insight you gain from walking around and being available is the pulse of the organization. Are people heads down working with little or no communication? Not necessarily a healthy organization. Are they whispering in groups? Lookout for turnover. Are they happy and joking around but generally focused? Hooray for you! This is the kind of insight that is impossible to discern from reports, company meetings, etc. These insights require your intuition as a manager who knows his or her organization and knows when it’s running smooth on all 8 cylinders.

There is some risk here and you need to be aware of it. Employees should not see your presence as a signal to get back to work. “Uh oh, here comes the boss. If he sees us talking he’s gonna be pissed!” To a certain extent there will always be an element of that – it’s inevitable. But there are some things you can do to minimize this.

1. Don’t publicly call people out when you see behavior you think should be addressed. Of course if you see something that is clearly wrong or unethical you must address it immediately. But for minor things like surfing the web, joking around the water cooler with colleagues, etc, let it slide. If you pick up a pattern and think it needs to be addressed, talk to people in private later. It is important to disassociate any criticism from your presence in the office. It is also important to avoid giving employees who are performing well the impression that they’re in the same boat with the slackers.
2. Join in the conversation. Not all manager/employee conversation needs to be about work. If you join in a non-work related conversation, or better yet initiate one yourself, you come off as non-threatening.

Two quick pointes about item number two above. Like everything else we’ve talked about you must be genuine. Don’t try to be something you’re not. If you try and join in on a conversation that you have absolutely no background in, you’re going to come across phony. We’ve all seen The Office and it’s painful. You don’t want to be Steve Carrell in your own office. This can be tough when there is a significant age difference between you and your employees (oh please no stories about how it was in your day).

The second point is this. Keep it short and sweet. This is both for your sake and your employees. On your hand, you don’t want to foster a culture that regularly takes one hour digressions into the geo-political state of various 3rd world countries and the parallels between that and modern capitalist trends that will eventually result in our ultimate and utter demise.

And for your employees, remember that you are still their manager and to a certain extent they will feel compelled to participate with you in these discussions. They will feel obligated to laugh at your jokes, agree with your opinions, and continue the conversation until you indicate that it’s finished. From their point of view, there’s nothing worse than to have what used to be an interesting conversation crushed by some old guy who doesn’t “get it”, and then have that drag on for 20 agonizing minutes of hell. So like many things, this is a balancing act. Participate enough so as to be non-threatening, but don’t go overboard.

The funny thing about this is that too little of this will make people get back to work when they see you coming because they think you don’t want them socializing. Too much will have the same effect but because they want to avoid a 30 minute conversation about something they don’t care about .

So in summary, making yourself regularly and informally available to your employees is an extremely powerful tool for motivation. By maximizing your face time with your employees you ensure that you will have as many opportunities as possible to genuinely transfer your own enthusiasm. You put yourself in a position to regularly and naturally praise them for their accomplishments, and you gain valuable insights into the overall temperament of your organization.

And all of this can be achieved by simply getting up off your ass, putting away those damn reports, and walking around saying “how’s it going?”

This code sample uses the Prototype Javascript library. When you see Ajax.Request, that’s using prototype’s Ajax framework. The great thing about prototype is that everything is cross-browser compatible.

First we need some code that formats a simple SOAP envelope. SOAP is the required protocol for communicating with the SharePoint web service.

var Soap = {
  createEnvelope: function(action, ns, parameters)
  {
    var soap = '<?xml version="1.0" encoding="utf-8"?>
        <soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
        <soap12:Body>';
    soap += '<' + action + ' xmlns="' + ns + '">';
    soap += Soap.__parseParameters(parameters);
    soap += '</' + action + '></soap12:Body></soap12:Envelope>';
    return soap;
  },

  __parseParameters: function(parameters)
  {
    var params = "";
    if (typeof parameters == 'object')
    {
      // check if we were provided an array or an object
      if (typeof parameters.push == 'function')
      {
        for (var i = 0, length = parameters.length; i < length; i += 2)
        {
          params += "<" + parameters[i] + ">" + parameters[i+1] +
              "</" + parameters[i] + ">";
        }
      }
      else
      {
        $H(parameters).each(
          function(pair)
          {
            params += "<" + pair.key + ">" + pair.value + "</" + pair.key + ">";
          });
      }
    }
    return params;
  }
}

Okay, so now we can make a SOAP envelope as simple as this:

var mySoap = Soap.createEnvelope(
  "MyAction",
  "http://schemas.microsoft.com/sharepoint/soap/",
  { param1: "value", param2: "value" });

Simple enough. Now let’s call a SharePoint web service. We’ll use the Lists web service and create a new list item. The UpdateListItems method allows us to pass in some XML defining the items to create. So first I’m going to build that XML.

var batch = '
  <Batch OnError="Continue">
    <Method ID="1" Cmd="New">
      <Field Name="ID">New</Field>
      <Field Name="Title">Hello World</Field>
    </Method>
  </Batch>';

Next we’ll call the web service using the Ajax.Request object:

// build parameter object
var parameters =
{
  listName: "My List",
  updates: batch       // xml created earlier
}

// create soap envelope
var soap = Soap.createEnvelope(
  "UpdateListItems",
  "http://schemas.microsoft.com/sharepoint/soap/",
  parameters);

// call web service
new Ajax.Request(
  "http://myserver/mysite/_vti_bin/lists.asmx",
  {
    method: "post",
    contentType: "application/soap+xml",
    postBody: soap,
    onSuccess: function(transoprt) { alert("Success: " + transport.responseText); },
    onFailure: function(transport) { alert("Error: " + transport.responseText); }
  });

If all goes according to plan, I should have a new list item with the title of “Hello World” in the list called “My List”.

A couple of points about the javascript above:

1. It’s certainly not the greatest Javascript in the world. I plan to clean it up and hopefully release a Javascript library for working with all of SharePoint’s web services.
2. The user’s browser must already be authenticated for this to work. Prototype doesn’t have a way to pass credentials to the web service so make sure you run this from a machine joined to the same domain as the sharepoint site. Ideally this is running within a sharepoint site so that should take care of the authentication problem.
3. FireFox has an issue because it doesn’t pass domain credentials automatically. This makes debugging hard from your workstation, but if it’s running on a SharePoint site where the user has already authenticated, it works fine.
4. I cheat in the example above and break strings onto multiple lines. That’s for the purpose of formatting only. If you copy and paste this code directly it won’t work.

You can download the code here: wsswebservice.js.

At first I got what I expected – much of Excel’s basic functionality while feeling a little less responsive than a desktop app. I mean, for a web app they’ve done a remarkably good job, but it’s still not the same as a rich desktop application. But then I discovered two excellent features that I didn’t expect.

The first came after I had been working on a spreadsheet for a while and realized that I had it so screwed up I wanted to go back to the beginning. I was just about to close and re-open the spreadsheet when I noticed the “Revisions” tab at the top. I clicked on this and – hey what do you know – just about every change I made was automatically saved as a revision. I flipped through the revisions, found the place I wanted, and overwrote my f’d up version with a clean version. Now that’s something you don’t get in Excel.

The next thing that happened (which prompted me to write this blog post) is that I was making a change when all of a sudden I lost my internet connection (damn netgear wireless crap). Now I’m thinking “ugh – lots of rework” but all of a sudden Google pops up a little box that says “uh hey – you don’t have connection. you want to work offline or try and reconnect?”. Wow – ok, let’s see how this works. I reboot my router, get my connection back, click the “try and reconnect” option, and I’m back and running. No lost data – nothing. Everything is exactly as if I had never lost connection in the first place. Now that’s slick!

So I’m not sure if I’m completely sold on giving up Excel but I have to say that if Google keeps going the way they are going with innovative features and solid design, I might just be tempted.

Look, marketing is important – critically important to the success of your company. But if your blog is going to be a marketing tool, it’s got to be targeted at your potential customers. Your customers don’t care that you really liked some Joel on Software post. Your customers don’t care that you’re putting the finishing touches on some feature or that you contributed to some open source project over the weekend. Your customers want to read things they care about – not things you care about.

The key to a successful blog for a software company is one that truly provides value and connects with your customer base. If you are passionate about the subject of your software, then you have a good chance of writing a compelling blog which adds value on top of the software you sell. If you’re not that passionate, or if you suck at writing, a better approach would be to try and aggregate news articles or other industry/subject related blog postings.

At the end of the day, look at everything you do through the eyes of your customer. Is it valuable to them? If not, then you should stop and put that valuable time into something else.