Monday, November 09, 2009
#
As promised, here's the slide deck for my SharePoint Saturday presentation:
Download Slide Deck
Thanks again for attending!
Wednesday, November 04, 2009
#
Friday, October 23, 2009
#
Hey everyone,
I'm super-excited (and a little nervous) that I was given a speaking slot at SharePoint Saturday Raleigh on Nov. 7th! (Link goes to presentation overview.)
There are quite a few SharePoint heavy-hitters attending (Michael Gannotti, Dan Lewis, and Joshua Carlisle to name a few), so go register today - seats are filling fast!
Cheers,
Adam
Monday, October 19, 2009
#
So we landed on a solution. It's not ideal by any stretch, but it does accomplish the purposes we set out to meet, and it does give us a (small) step in the right direction in terms of moving the client to using Oracle UCM as the sole company-wide content repository.
To recap, here's the skinny on what we're facing:
- There is a mandate in the company to move all "content" to Oracle UCM (a content unification measure)
- There is a significant amount of content in SharePoint (in the form of lists) that needs to make its way into Oracle UCM
- Business users do not want to stop using the SharePoint interface for data entry (not to mention get all the "for-free" stuff that comes with SharePoint, such as alerts, content approval mechanisms, permissions, and workflow).
- It is not feasible to move all of the lists over at once (we have a 3-week scope to move "something" over from SharePoint to UCM)
We came up with two approaches that had varying payoffs and risks.
- The Simple Approach
Seeing how it was very important to keep all of the existing functionality in SharePoint in whatever solution we devised, we first thought of "replicating" list content to the UCM from SharePoint. This approach involved writing a custom workflow that would fire on list item update, and would intelligently call a checkin function in UCM.
This "simple" solution wouldn't come without risks - the first (and most obvious) one being that we'd have duplicated data that needed to stay in sync. After thinking about the implications, we found that this risk wasn't terribly bad. Since no content contribution happens on the UCM-side with this implementation, there's no harm if SharePoint goes down - there just wouldn't be any new data. If the UCM goes down, syncing the data would mean saving the items again (a solution acceptable by the client).
- The UCM-Heavy Approach
This approach was quite a bit more aggressive in terms of planning, execution, and support, but yielded a much bigger step towards migrating the list content from SharePoint to UCM.
The plan was to "switch out" standard SharePoint CrUD (and other) functionality for custom functionality that manipulated UCM content directly. The idea was that all point-foward content would be manipulated directly in Oracle UCM through the SharePoint interface. We felt that if we could nail this approach that we'd set a good proof-of-concept for migrating other content to UCM from SharePoint.
This approach was monstrously invasive. It involved re-writing a lot of stuff that comes for free with SharePoint, and was therefore expensive and risky. However, the payoff of making such a big step towards UCM would be a huge win for the client.
The Accepted Solution
It will probably come as no surprise to many of you that we landed on solution #1. What killed solution #2 was that UCM doesn't have an OOB way to handle broadcasting alerts based on permissions (on the item level) when content was created or updated. Sure, we could write a workflow to sorta-kinda handle it in UCM, but we didn't have the time or budget for it.
Next time, I'll tell you a little about how we're going about implementing solution #1, and what sorts of challenges are cropping up.
Friday, October 16, 2009
#
When trying to generate an ASP.NET proxy class from a physical wsdl on your local file system, you're probably doing something like this:
wsdl.exe MySevice.wsdl /o:Proxy.cs /l:CS
You'd expect a file named Proxy.cs to get created in C# for you. You'd be right, except if you're attempting to generate proxy for a service that uses complex types. If that is the case, you'll get an error that looks a lot like this:
Error: Unable to import binding 'MyBinding' from namespace 'http://www.example.org/MyNameSpace/'.
- Unable to import operation 'MyOperation'.
- The element 'http://mydomain.com:MyComplexType' is missing.
If you would like more help, please type "wsdl /?".
This error is basically saying that you your service is expecting one or more XSD file containing the definitions for those complex types. Here's what your command line should look like:
wsdl.exe MySevice.wsdl MyServiceDefinitions.xsd /o:Proxy.cs /l:CS
If you need to add additional XSD files for other complex type definitions, just add them to the command line like you did for the first one, separated by a space (order doesn't matter).
Wednesday, October 14, 2009
#
I stood up a standard publishing site on a vanilla MOSS instance for some custom workflow development I'm doing. I went to make a list from the Announcement List template (the one that comes OOB), and found that most of the list and library templates that I was accustomed to seeing weren't there at all.
It turns out that by default, the OOB Publishing site definition does not activate the Team Collaboration Lists feature. Go to Site Features and activate it for your publishing site, and they will appear.
Tuesday, October 13, 2009
#
Sorry, already promised out all of my 8 invites, so no begging :)
I agree with my buddy Rob when he says, "I hope that my dreams are not crushed when I actually start to get to use it."
I can't wait to see what kinds of neat things I can do with it! More to come, as I crash into Google Wave...
Tuesday, October 06, 2009
#
I’ve got an interesting challenge a client has asked me help with. We are attempting to move items from multiple custom SharePoint lists to Oracle UCM and continue to manage/review/approve the data through the SharePoint interface.
Moving this list content to OUCM is part of a bigger strategy to centralize all of the “business truth” (content) to OUCM, while keeping SharePoint for collaboration. There are a lot of things to consider, and lots of risks to document.
I'm just now getting to documenting the state of the system, so I'll share some challenges and insights we've come across when we've landed on an approach - should be fun :)
Monday, October 05, 2009
#
I think that the Gang of Four should consider my design pattern recommendations for inclusion in their codified list. And while I have seen ALL of these patterns shipped to production in real life, it doesn't mean that these are by any means the only ones that scream for inclusion. Anyone got any others?
The Duct Tape Pattern
Its versatility is unmatched – any two bits of code from any two systems can co-operate with the use of this simple pattern. Need a piece of data from an XML document to display on your page? No sweat – the Duct Tape Pattern has an implementation that allows you to take data directly from your XML document and slap it straight on the page. Need to update meta data on a user profile? Easy as pie – the Duct Tape Pattern affords you the simplicity of running an in-line SQL update statement right in your button click event handler. Need I say more?
Arguments for Inclusion:
- When the crap hits the fan, this pattern is used more often (and more consistently) than any other recognized design pattern.
- If you’re using this pattern, your code isn’t going to be readable, much less maintainable – it’s guaranteed job security.
The Crayola Pattern
Many people confuse the Crayola Pattern for the Facade Pattern, yet they are very different. While the Facade Pattern attempts to provide a simplified interface to a larger body of code, the Crayola Pattern outright ignores complexity by making wide-sweeping assumptions about the intended usage of the system, thereby making programming against it as simple as coloring with crayons (but you only get to do as many things as you have methods). The Crayola Pattern is especially effective if you reduce the entire system to 8 method calls, but 64 is also an acceptable practice if you include a UseSharpenerOnBack(object) method in your pattern implementation.
Arguments for Inclusion:
- Using this pattern will guarantee those who use it to get code comments such as:
/* we don’t know what this does, but the web server dies when we touch it */
The Clipboard Pattern
This is the pattern by which a programmer takes an existing class, copies it to the clipboard, pastes it to a new code file, renames the class, adds one or more properties/methods, and seals the class. The intent is to make your classes utterly unusable for anything other than the use you originally intended, and utterly bewilder other developers as to why you did it. The maniacal laugh value never ends!
Arguments for inclusion:
- Using this pattern adds a LOT of code overhead, and may very well lead to using the Crayola Pattern, which will inevitably lead to using the Duct Tape pattern, which we all know leads to job security.
- Clipboard Pattern implenters will get to wear out your Ctrl, C, and V keys even faster than your W, S, A, and D keys!
The Shippit Pattern
This is the pattern whereby a programmer copies a block of code from the Internet, pastes it into his code, tweaks it a little, and ships it out to production in one fell swoop. This revolutionary design pattern has been taking the programming world by storm, slashing costs and boosting productivity across many industry verticals.
Arguments for Inclusion:
- Saves literally thousands of dollars in development and testing time by simply not doing them.
- Implementers get to blame someone else for the system not working because they didn't write the code - they simply implemented the Shippit Pattern, and thereby save face when the client can't use the system.
Wednesday, September 16, 2009
#
I've been troublshooting some Application Log issues for a client today, and found multiple instances of Commerce Server error 4116, which all message that goes something like this:
The Commerce Server runtime has detected that more than # instances of the SiteConfigReadOnlyFreeThreaded object have been created. Creating many SiteConfigReadOnlyFreeThreaded instances will negatively affect the performance of the site. Please refer to the Commerce Server documentation for the recommended use of the SiteConfigReadOnlyFreeThreaded object.
After a quick google search for "SiteConfigReadOnlyFree", I came across Tom Shultz's Blog which clearly identified that the warnings were coming from one of two places:
- Your site is configured to use the CommerceDataWarehouseAuthenticationModule (in which case, this problem was resolved in SP1, so it really shouldn't be this problem, seeing how SP2 has been out for a long time now)
- You're creating new instances of Commerce System Context objects, each of which create new SiteConfigReadOnlyFree in memory. This happened to be the case for us.
The correct practice here is to only use the CommerceContext.Current object (as opposed to creating new ones each time), and this will avoid creating new SiteConfigReadOnlyFree objects over and over in memory.