Original Source: The RSA Animate: ‘DRIVE – The Surprising Truth About What Motivates Us’

I first heard of the concept of Convex Leadership during a TEDTalk by R.A. Mashelkar, when he was speaking at TEDIndia in 2009. His talk discussed breakthrough designs for ultra low cost products being developed in India. Borrowing the concept, Gandhian engineering, from Tata Motors, his discussion expanded on the concept of frugality and challenging conventional wisdom in technological innovations, engineering and new product development. Getting more, from less, for more….. meaning Getting more service, from less resources, for more people. Amazing concept for the manufacturing and production world; especially for a world of depleting resources and a population that can’t afford luxurious overpriced designs.

Going back to the concept of convex leadership, the talk by Mashelkar brought up the idea of how leaders can transform the views and perceptions of those around them to focus and act as one; this type of leadership is needed to take advantage of concepts like Gandhian Engineering. Mashelkar further discusses how he came up with the concept:

“Principal Bhave took us out into the sun to demonstrate to us as to how to find the focal length of a convex lens. He had a piece of paper here, a convex lens here and he moved it up and down and there was a point when there was a sharp focus and a bright spot on the paper. He showed the distance between paper and the lens and said that this distance was the focal length. But then the paper started burning. For some reason, he then turned to me, and said, Mashelkar, if you focus your energies like this, you can burn anything in the world.”

If you think carefully about this story, it tells you about the new model for the society and for the nation. What is the experiment? You have the lens. And what does the lens do? It takes the parallel rays of the sun and then lets them converge. And what is the property of parallel lines? Parallel lines never meet. Parallel rays never meet but the lens actually makes them meet. The “convex lens” brings things together to focus and work together – leadership that brings people together.

Lets bring this back to the world of technology for a minute. Many frameworks and methodologies exist on leadership and project management, but when it comes down to leadership, it really comes down to basics – team leadership means focusing the team on obtaining a goal. As a company, the same concept can be applied – focusing the company on common goals; focusing everyones energy on obtaining the same strategic goals is key to obtaining success. Leaders that are able to display the attributes of convex leadership will be able to focus their teams of employees towards achieving the objectives laid out by the company; in some cases this may be in the form of helping employees obtain their own objectives (SMART goals from performance reviews) which thereby result in moving a step forward towards reaching the overall company objectives. In the end, the ability to lead people and converge the parallel lines that represent individual goals, is the true measure of a good leader.

The challenging part is finding those individuals that can lead by using a convex leadership style within a company; these leaders are the ones who understand the true motivators that get people to work in the morning; the difference between intrinsic and extrinsic motivators, Herzberg’s motivation-hygiene theory and are able to build the culture and team that have chemistry to work together.

So, the question I pose is, do you have a leader that is able to motivate and focus you? Or are you that leader?

Article source: http://www.robbiemadan.com/2012/01/04/the-art-of-leadership

The underlining issue for the disconnect is that Lync requires SRTP encryption by default which the Windows Live network does not support.

Assuming that your federation is working to the Windows Live network, we have to insure that the Lync users have Public A/V connectivity:

Set-CsExternalAccessPolicy Global -EnablePublicCloudAudioVideoAccess $true

The second step is to change the Lync encryption requirement fromt required to supported. The Lync client will still try to negotiate an encrypted session first, but if that fails it will allow the unencrypted session with the Windows Live network to take place:

Set-CsMediaConfiguration Global -EncryptionLevel SupportEncryption

You can also apply these commands to a specific policy that you have created. After these commands are entered on the server, wait a few minutes and then sign out and back in to the Lync client. You can verify that change has taken place by looking at the PC to PC AV Encryption in Lync (hold down CTRL and right click the tray icon and select “Configuration Information”. The setting should display “AV Encryption Supported”.

If the encryption level is not changed there will be an error logged on the Front-End server when an A/V call is trying to be established:

Start-Line: SIP/2.0 488 Not Acceptable Here
ms-client-diagnostics: 52017;reason="Encryption levels do not match"

The whole process was pretty simple to implement, however it was a good exercise that helped me better understand how LightSwitch separates concerns. It was this knowledge and understanding that helped me implement a solution for another email challenge.

The challenge I have is this; I want functionality that will let me send an email on demand, via a button on a screen, and I don’t want to code some fancy WCF service or custom extension to do the job.

Here is the thing – you can’t call server code from the client. It is in the server code that the email processing occurs. Why? Because the client and common projects are Silverlight based projects and I can’t add the necessary System.Net reference to those projects – otherwise I would have used the System.Net.Mail namespace directly from the client.

But hey, the Server project is a .Net 4 class library project, and I can add the System.Net reference to that project. That is why the actual email processing has to occur in the Server project. Following me so far?

So, here is what I did…

In the Solution Explorer of my LightSwitch project, I switched to File View so that I can get at the Server project…

Knowing that I need to use an external (SMTP) email service to actually send out the email, I decided to store some static information that my email processing can use to process the email; such as stuff for the email service authentication. To do this, I opened the Server project settings.

Next, I added some Application scoped configuration settings…

…come on, you didn’t actually think that I would post my own credentials did ya…I learned from that mistake already

I made sure to save the updates.

Next, a folder is created within the Server project, and named the folder “UserCode”. Within that folder I created a new Class file and named it “EmailHelper.vb”.

This is the code I added to this file…

Imports System.Net
Imports System.Net.Mail

Namespace LightSwitchApplication
    Public Class MailHelper

        Private Property SMTPServer As String = My.Settings.SMTPServer
        Private Property SMTPUserId As String = My.Settings.SMTPUserID
        Private Property SMTPPassword As String = My.Settings.SMTPPassword
        Private Property SMTPPort As Integer = My.Settings.SMTPPort

        Private Property MailFrom As String
        Private Property MailFromName As String
        Private Property MailTo As String
        Private Property MailToName As String
        Private Property MailSubject As String
        Private Property MailBody As String

        Sub New(ByVal SendFrom As String,
                ByVal SendFromName As String, _
                ByVal SendTo As String, _
                ByVal SendToName As String, _
                ByVal Subject As String, _
                ByVal Body As String)
            _MailFrom = SendFrom
            _MailFromName = SendFromName
            _MailTo = SendTo
            _MailToName = SendToName
            _MailSubject = Subject
            _MailBody = Body
        End Sub

        Public Sub SendMail()

            Dim SMTPUserAddress = New MailAddress(_SMTPUserId)

            Dim mail As New MailMessage
            Dim mailFrom As New Mail.MailAddress(_MailFrom, _MailFromName)
            Dim mailTo As New Mail.MailAddress(_MailTo, _MailToName)

            With mail
                .From = mailFrom
                .To.Add(mailTo)
                .Subject = _MailSubject
                .Body = _MailBody
            End With

            Dim smtp As New SmtpClient(_SMTPServer, _SMTPPort)
            smtp.EnableSsl = True

            smtp.Credentials = New NetworkCredential(SMTPUserAddress.Address, _SMTPPassword)
            smtp.Send(mail)
        End Sub

    End Class
End Namespace

So, this class contains some pretty simple code. Instantiating the class requires a bunch of parameters that are later used by the SendMail() method. The SendMail() methid is where the mail message gets created, configured, and sent using the a SmtpClient. As you can see, some class properties are defaulted to the values that are stored in the App.Config file of the Server project (which were added earlier).

Next, I go back into the logical view of the solution.

In the logical view, a new table is created. The table name is “ProxyEmail”, and it looks like this…

Now, with this table, I have essentially created a “Model” that I can use in my workaround. Remember, my challenge is to do all this with native LightSwitch features and functionality. I don’t want to create a fancy-smancy WCF service or custom extension for this. I just want to get the job done. By creating this entity, I have, in essence, created a business object that I am going to use to do what I want to do.

Here is the fun part! I can’t call the Server code directly from any screens, however I know that my “entity” can access the server code via its dependencies. For example, my ProxyEmail entity has a method called ProxyEmails_Inserted(), which runs on the server when an entity as added to the table (add to the collection of ProxyEmail entities).

So, I add some code to this method…

…and here is the code if you want…

 Private Sub ProxyEmails_Inserted(entity As ProxyEmail)
            ' Write your code here.
            Dim sSubject = "Test Email."
            Dim carRtn = Environment.NewLine  Environment.NewLine

            Dim sMessage = "The following email has come from a button on LightSwitch..."  carRtn
            sMessage += "Testing 1, 2, 3!!"

            ' Create the MailHelper class created in the Server project.
            Dim mailHelper As New MailHelper(entity.SenderEmailAddress, _
                                             entity.RecipientName, _
                                             entity.RecipientEmailAddress, _
                                             entity.RecipientName, _
                                             sSubject, _
                                             sMessage)

            ' Let 'er rip!
            mailHelper.SendMail()
        End Sub

So, this is pretty much the same as the last post. Right, but here is how this similar stuff is used to create a feature that will allow you to send an email on demand, rather than relying only on updates to entities.

I create a new Screen and, using the New Data Screen template, name it “SendAnEmail”, but don’t assign any screen data to it…

In the screen designer for the new SendAnEmail screen, I click Add Data Item… and create a Method with a name of “SendMyEmailOnDemand”…

Back in the screen designer, I expand the Screen Command Bar, and drag and drop the SendMyEmailOnCommand method to the command bar.

I right click the newly added button, and select to Edit Execute Code.

I edit the method to this…

…and here is the actual code you can use…

        Private Sub SendEmailOnCommand_Execute()
            Dim newEmail = DataWorkspace.ApplicationData.ProxyEmails.AddNew()
            With newEmail
                .RecipientEmailAddress = "paulspatterson@hotmail.com"
                .RecipientName = "Paul Patterson"
                .SenderEmailAddress = "paul@selectsystems.ca"
                .SenderName = "Paul Patterson (Select Systems)"
            End With

            DataWorkspace.ApplicationData.SaveChanges()
            newEmail.Delete()
            DataWorkspace.ApplicationData.SaveChanges()
        End Sub

What this is doing is simply creating a new ProxyEmail entity, settings it’s properties, the committing the insert to the system. The SaveChanges after the setting the properties will cause the ProxyEmails collection to fire that ProxyEmails_Inserted() method that was wired up earlier, which then sends the email from the server code. After that, the newly added entity is deleted because I don’t need it any more.

So, I F5 to test it…

… and I click the Send Email On Demand button. Then I go and check my email, and presto…

Yes!

This may not be the super cool software code monkey way of doing things, but who cares! It does the job, and I did in no time at all.

Hope you find it useful!

Cheers

Article source: http://www.paulspatterson.com/technology/lightswitch/microsoft-lightswitch-sending-emails-from-the-client/

Employees periodic assessment is an important and tedious repetitive process for the HR department. As a leader in Software Development, Quercus Solutions decided to computerise its employees assessment process. I was charged with implementing a simple, affordable, and extensible solution using a non code InfoPath Form and a declarative SharePoint Designer 2010 Workflow.

Process Description and Security Constraints

Quercus Employees assessment process involves four parties, the employee himself, his coach, the HR department, and the company manager. One big concern is to keep the assessment data completely private and secure.

The assessment  process consists of multiple stages.  The following flowchart shows these stages.

Assessment Process

To start an assessment, the HR manager should create a new assessment Form. He/she, then, fills a view of the  form that includes some basic parameters such as: employee name, coach name, etc. We plan, in a future release,  to automate this step using a SharePoint employees External List and a Timer Job. When a Form is created, no body Should be given access to it, except the HR Manager.

The second stage starts when the HR manager decides that the process of assessment is ready to go. At this moment an alert is sent  to the coach. It should give him a link to the assessment Form that he should fill. As a part of filling the assessment form, he should decide about a meeting date with the employee to discuss the assessment.

At this second stage,  the coach should be the only person that have write access to the Form. The HR and the company manager should only have read access. Neither the employee himself, nor any other person should be able to access the Form at all.

The third stage starts when the coach signals that he is finished with the assessment. The coach can edit and modify the assessment as many times as he wishes, however, he can’t modify it once he marks it as ready for the next stage.  An alert is, then, sent to the employee to ask him to revise the assessment and to inform him of the meeting date.  The body of the alert should include a link to the assessment Form. The employee should  be able to navigate to the Form and read his coach assessment. He can enter his comments and specify his future goals for the next period.

While doing so, the employee should not have any write access to the part of the Form containing his coach assessment. However, he should have write access to the part of the Form including his comments and his goals. Any other involved party, even the coach, should have, only, read access to the Form. You may wonder why we don’t permit the coach to modify his assessment? This is because we don’t want him to change the Form while the employee is viewing it. Any other person except those involved in the process should not be capable of accessing the Form by any means. In particular, he or she must not have the permission to download the form to his/here computer and open it with an XML editor

The fourth and final stage starts after the employee completes his review. In this stage the coach and the employee meet  together  to discuss the assessment. The coach should be able to change his assessment in case he have new evidence resulting from the meeting. He, also,  should  be able to terminate the assessment process. No other party could be able to modify the Form. Non involved parties, should not, even, be able to access the Form.

Once the coach marks the assessment as completed, no other person except the HR manager and the company manager could  be able to access the Form. This is true even for the coach and the employee.

Outlines of the Solution

The solution is based upon a non code InfoPath Form published to a SharePoint InfoPath Form Library. The Form is accessed with InfoPath  client filler; i.e., the form is not web enabled. The design justification of this choice is the  need to use InfoPath User Rules combined with InfoPath  Views to control access to the different parts of the form. As User Rules are not supported in InfoPath web Forms, we  excluded it in the first implementation. The other rational is that all Quercus employees have InfoPath filler installed on their computer. At the end of this article I will devote a section on how to use InfoPath Web Forms instead of InfoPath filler.

The solution uses also a declarative workflow developed with SharePoint Designer 2010 to alert the involved parties and control the  process flow. It also sets SharePoint items permissions on the Form Library using a workflow Impersonation Step.

In Part 2 of this article I will explain the implementation in details.

About the Survey

 The survey covers 650 individual members of the AIIM community between January 28,2011, and February 14, 2011. Survey Participants represent organizations of all sizes. Larger organizations over 5,000 employees represent 35%, with mid-sized organizations of 500 to 5,000 employees at 41%. Small-to-mid sized organizations with 10 to 500 employees constitute 24%. Organizations of less than 10 employees (26) are not included in the report.

 The findings concerning SharePoint are classified in three headings; Adoption, Maturity and Governance, and Strategies.

 Adoption

• 58% of respondents are already using SharePoint, rising to 70% of the largest organizations.
• SharePoint 2010 version has attracted 13% of respondents as first time SharePoint users
• Only 20%  have no interest in SharePoint.
  

Maturity and Governance

•   27% admit that valuable content is being stored in SharePoint across the organization but there is no real guidance on what/how to store .
•   18% have stable and well-governed systems.
•   only 5% of users would consider their SharePoint implementation to be fully optimized and integrated with other applications and repositories.

Strategies

• 11% of respondents have SharePoint as first document or content management suite.
• 49% are planning to integrate SharePoint with their existing – or new – ECM or records management suites.
• 24%  have not yet formulated any plans to integrate SharePoint with their existing ECM/DM/RM systems
• 4% are phasing out existing systems in favour of SharePoint

For a full version of the report go to http://www.aiim.org/

According to Gartner, “Citizen developers will be building at least a quarter of new business applications by 2014…”.  That, according to the report titled “Citizen Developers Are Poised to Grow”.

Represented by about 6 million information workers, these “latent” application developers make up that same Microsoft Visual Studio LightSwitch target market.

Very interesting, indeed!

Article source: http://www.paulspatterson.com/technology/lightswitch/microsoft-lightswitch-championing-the-citizen-developer/

ASP.NET MVC is still a fairly new framework – the majority of ASP.NET projects use Web Forms and they have been successfully serving client’s needs for years, but the rise of MVC fills a much needed hole for ASP.NET.

ASP.NET has many strengths and weaknesses:

Strengths:

• Mature technology
• Rapid Application Development
• Designer support in Visual Studio
• Familiar feel to windows forms development

Weaknesses:

• Tightly coupled logic between presentation and code-behind files
• Hard to unit test

ASP.NET Web Forms has some major problems in scalability and the ViewState/PostBack model. The ASP.NET MVC framework was initially developed as a alternative form for building web applications. The core part of the framework uses the Model-View-Controller pattern and implements many best practices and object oriented methods; most importantly it allows for loose coupling and efficient use of unit testing.

Strengths:

• RESTful architecture (I’ll be discussing this one next!)
• Doesn’t compromise performance and flexibility
• No ViewState and PostBack model
• Clear separation of code and presentation
• Ability to map URLs logically and dynamically

Weaknesses:

• Not event driven

That all being said, which one should you use? My opinion is that both Web Forms and ASP.NET MVC have their places. But ASP.NET MVC has the leg up because it makes me a better developer. Lets face it, a framework should be written with concept of using best practices and also encourage developers to use best practices. But Web Forms doesn’t inherently support any best practices; separation of concerns, loose coupling and testability have to implemented by the developers. ASP.NET MVC implements all these best practices in the framework itself. Separation of concerns makes it easier to manage complexity and make changes on certain isolated parts of the application. Loose coupling is incorporated into the MVC framework itself, enabling developers to swap even the core component of the frameworks with custom replacements to change the behavior of the framework without effecting other components. This makes amazing flexibility and makes working with the best-practice of loose coupling easy. Testability is also relatively easy with the MVC, this best-practice is emphasized by Microsoft since unit-testing is been getting a lot of attention lately.

Responsibility for the overall quality of the application lies with the developers. They have to use the best-practices and make sound decisions when developing, whatever framework they use. Working with the MVC won’t guarantee success, it just makes it easier to be successful.

Article source: http://www.robbiemadan.com/2011/12/18/asp-net-mvc-vs-web-forms-another-opinion

The objective of this series of articles is to examine SharePoint capabilities and limitations  in the context of Enterprise Content Management, including Web Content Management. 

In Part 1 I am going to discuss the notion of IA and its implications for Content Management Systems. Also, I will discuss the concept of SharePoint Governance and its relation to IA.

For the empirical purpose of this article I am going to adopt a very simple and clear definition of IA as:

“The organization of information into coherent structures that optimize its usefulness and enable its efficient navigation and retrieval (search). This usually requires the categorization of information using hierarchical or network artefacts.”

The above definition implies that developing an IA includes the following essential undertakings:

• Delineating the information to be managed, its boundaries and stockholders,
• Identifying the structures that should be used to store information,
• Conceiving an appropriate classification spectrum.  
• Describing the user interface that will be used to expose the information to users.
• Defining the functional and performance requirements of information search (retrieval).

The subsequent articles should clarify theses activities in the context of SharePoint implementation.

It is widely agreed that having a solid IA is a predominant factor in building successful Enterprise Content Management system, particularly if the content is highly unstructured and diversified.

A lot of organizations are using- or at least willing to use- SharePoint to implement their Web Content Management and/or Document Management systems. Usually they have serious questions about the capabilities of SharePoint to support such implementation and about its cost effectiveness. We are going to argue that the cost of a SharePoint implementation can be reduced substantially if the organization has developed an appropriate IA, and that the lack of an IA is a big factor  in raising SharePoint Implementation Costs.

Another important question is related to the synchronization between SharePoint implementation and IA development; should we proceed sequentially starting with the IA or could we proceed in parallel?

Throughout this series of articles I will argue for the following:

• The development of an IA cannot be accomplished by SharePoint Architects or developers whatever the size of the SharePoint implementation is going to be (departmental or enterprise wide).
• The development of the IA must be done by experienced specialized professionals, in collaboration with SharePoint specialists and with complete user involvement.
• All professionals involved in a SharePoint project should have a minimal understanding of how SharePoint store, classify, search and expose information.
• Potential users should be exposed to SharePoint main concepts (content types, managed meta data, sites, lists, libraries) before being actively involved.

 SharePoint Governance

SharePoint experiences showed that the implementation and management of SharePoint is far from being a trivial undertaking. This is mostly attributed to the richness of SharePoint, its immense capabilities and its misunderstood limitations.

Some organizations are using a cowboy approach to implementing SharePoint without any proper planning or even understanding of its basic functionalities and boundaries. Not surprisingly they end up with poorly functional systems with humble user adoption. The other side of the story tells us that successful SharePoint implementations are, usually, based on careful planning and solid IA.

The term “SharePoint Governance”  has emerged recently to tackle the challenges posed by SharePoint  implementation and management. SharePoint Governance means simply that SharePoint should be implemented and managed according to a proper plan that specifies cleary the needs of the organization, its infrastructure, and which is consistent with its culture. I wish here to emphasize that SharePoint is mainly a Content Management technology that needs a proper IA planning and governance.

After some digging around we were left with the alternative of purchasing a 3^rd party web part or launching VS 2010 and creating our own. Neither option was very appealing, so we came up with an alternative out of the box solution, with a little configuration thrown in.

Here is how it looks:

The solution is actually pretty simple. The main challenge is how to get all of the content from multiple SiteCollections to appear in one view. Well… SharePoint Search already does that quite well doesn’t it?

So, first we create a new search scope targeted directly at Blog posts.

If we log into Central Administrator and click through to the Search Administration screen:

The Content Source we need is already there, in fact it’s the default content source that crawls and indexes all content on our local site:

Next click into Scopes and create a new scope. Let’s call it blogposts. Everything else can be left as is.

Now we have a scope created we need to define the rules that will target our Intranet blog posts.

Click Add Rule and make it a web address rule. Our MySites are all under something like  http://intranet/personal so that’s the web address we used. The behaviour of the rule is to Include any item under the web address. We will restrict it with more rules next.

The next rule will restrict the content to a particular Content Type. SharePoint 2010 blogs use the Post content type. We will also set the behaviour of the rule to Require which eliminates all but Posts. Highlight the scope and choose Edit Properties and Rules:

From here click New Rule:

Enter the Rule details.

Finally we need to add a rule to eliminate the default blog post that SharePoint creates for everyone when you first use your blog site as in the example below:

To do that we just add another rule like so:

This time we set the Behaviour to Exclude. This will remove any blogs that have “Welcome to your Blog!” in the title.

When creating these rules, you may find the ContentType and Title property do not appear in the Property drop down. If that is the case then go to the Metadata Properties link on the left hand side menu:

And find the 2 properties, ContentType and Title. When you edit them make sure the option to Allow this property to be used in Scope is turned on.

With that our scope is ready. Next kick off a full crawl of the content source and wait for the scopes to be updated on the front end site.

To confirm the Scope is working ok, we can take a look at the Scopes page again, and this time we should see how many items have been picked up. If all is well this should match the number of real blog posts.

So, our scope is ready. Now what do we do with it?

It’s pretty simple actually… just go to the page we want to place the blog rollup and edit the page:

From the Ribbon, choose Insert – Web Part

Scroll the categories selector to Search and choose the Search Core Results web part. Click Add.

You will now have an empty Search web part on the page.

Choose Edit Web Part from the web part dropdown arrow. We get the following screen.

Open up Location Properties and change the location to Local Search Results. Set the scope to the Scope we created earlier – blogposts.

Next open up the Display Properties panel.

Change the default sorting to Modified and set the Results Per Page to 10 say. Also specify what character limits you want in the summary and title URL.

Now the important piece, open up the Results Query Options and set the Fixed Keyword Query to ContentType:Post. This tells the search engine to automatically bring back results where the Metadata property ContentType is Post (i.e. blogs).

Eh voila, all our recent blog posts appear:

But, it looks a bit crap doesn’t it? We don’t want it looking like a search result; we want it to look a little bit nicer, like this:

To do that requires one more change. Edit the Web Part again, and open the Display Properties panel. Uncheck the Use Location Visualization property. This will enable the XSL Editor Button.

Now personally I don’t like to edit the XSL in the web Text Editor. I copy it all into NotePad++ and go from there.

Always save a backup of the XSL, it is very, very easy to go wrong with it and you could end up having to start the web part from scratch.

The template that shows the search results is called Results.

The first thing is to remove the Icons that search shows:

I just removed the img tags:

Next we want to remove the ugly green URL at the bottom of every result. That is located further down the XSL:

Removing the <XSL:Choose> to </XSL:Choose> gets rid of the URL.

Save the XSL changes back to the web part and apply the changes. Save the page and refresh. This time we should have a nicer looking results web part like so:

And that’s it. An out of the box solution to provide rolling, cross site collection blog entries on our homepage.