1. Move the solution to the SharePoint Add-In model or pure client-side code. This is the recommended, sustainable, long-term solution but will require recoding your solution in a different development model than your developers were used to so it will require some ramping.
2. Remove assembly reference from your Sandbox solution. Many Sandboxed solutions don't use any ancillary DLL's but the Visual Studio template for Sandboxed solutions inserts a stub for such a reference. Remove the reference so that the solutions are purely declarative. Steps for this are detailed here.
3. Dave Feldman has a blog post that details a way to remove the reference and assembly from a Sandbox solution without using Visual Studio. This is useful if you no longer have the code. It's definitely a hack but it has been shown to work as a last resort.

   ---

I've been working from home a lot more and have been tweaking my coffee brewing process for a few months now.

Here's some tips that I've gathered from these here interwebs to make a cup of coffee that will keep the keys clicking on your workstation.

1 - Get a coffee grinder. Only grind enough to make the amount of coffee that you're going to drink at that time; meaning one or two cups at a time. I bought this one after a fair amount of research

I bought the Capresso 565.05 Infinity Conical Burr Grinder, Stainless Steel and I'm very happy with it.

2 – Buy an AeroPress or a coffee press. The AeroPress is great if you want to travel and have coffee the same way you do at home. This thing needs the paper filters that are listed on the "frequently sold together" section

3 – Buy gourmet coffees, whole bean, not ground. Coffee has a short shelf life. Air, light, etc., cause the coffee to lose its flavor. Buy good coffee whole bean and get an air-proof container at the Container Store or even Wal Mart. Drink whatever you buy within 2-3 weeks.

Here's a list of good coffees for sale on Amazon.

Here's the one I'm currently drinking and I'm loving it. It's a medium roast. Shout out to Peru!

4 - Finally, here's a primer on coffee beans and roasts. It will help you to vary your tastes from light to dark roasts and everything in between. A relevant quote from the article is

"At lighter roasts, the coffee will exhibit more of its "origin character"—the flavors created by its variety, processing, altitude, soil content, and weather conditions in the location where it was grown.^[9] As the seeds darken to a deep brown, the origin flavors of the bean are eclipsed by the flavors created by the roasting process itself. At darker roasts, the "roast flavor" is so dominant that it can be difficult to distinguish the origin of the beans used in the roast."

https://en.wikipedia.org/wiki/Coffee_roasting#Roasts

5 – I'm boiling the water to 120 degrees, grinding the beans to a coarse grind, and steeping for 3mn, 30 seconds. I find that I like the flavor better than when I go over 4 minutes.

If you think I'm being obsessive, then you don't know enough coffee drinkers that are also techies. Some guys buy their own roasters and get $1k espresso machines. Espresso machine maintenance is too much time for me. The above tips integrate nicely into my daily routine and don't require a ton of extra time, but it is definitely more time consuming that using a Keurig machine. I can't go back to that after grinding my own beans.

Happy caffeinating!

#Remove all accounts
Get-AzureAccount | %{Remove-AzureAccount -Name $_.Id}
Clear-AzureProfile

The comment in the other post also suggests running the Add-AzureAccount cmdlet but I re-registered using the Get-AzurePublishSettingsFile cmdlet and then then importing per the instructions below. They show up on the web page that is rendered when you execute Get-AzurePublishSettings. This solved my problem without having to execute Add-AzureAccount

I’m focusing more on Azure Technologies in order to complement my SharePoint workloads. To this end I’ve been leveraging my MSDN Azure benefit which gives me $150 of Azure credit every month. Some folks I work with don’t think this is enough but I’ve been able to consistently make this last for several months without hitting my limit.

There are some considerations to make this happen.

• You can’t just spin up any old VM. Choose the smallest size you can get away with. I’m partial to A0 size for DC’s, and A3’s for most other workloads.
• Make sure that you choose the “Basic” tier of any of those machine sizes. Basic removes the load-balancing and auto-scaling features. You usually don’t need that for test workloads. See the Azure VM Pricing page for more details.

Finally, like Sticky and Fredro up top, you need to Shut ‘Em Down. Shut down the VM’s as soon as you’re done using them. This will stop using up your credits. Don’t leave a 5 server farm running overnight and expect to be able to pick up in the morning. I know dev’s that have forgotten and then try to open support tickets to get at their data after their allowance has expired, but remember that the MSDN tier only offers subscription support, not technical support. In any case, you’ll need more credits in your account in order to spin those machines back up to get the data.

Solution? Azure Automation. It’s a feature that allows you to use automate common administrative tasks in your Azure account. There is counterpart called Service Management Automation (SMA) that is part of the Windows Server 2012 R2, but I’m including that just for reference. Some of the documentation and blog posts out there will reference SMA but you can apply a lot of the same code since it’s all PowerShell.

Azure Automation allows you to author a PowerShell workflow and publish it as a Runbook, which then can be scheduled.

A fellow MSoftie published a runbook to the gallery that shuts down all your machines every night. You can look at the Runbook here.

In order to get this to work, you have to create an Azure AD account that can be used by Azure Automation to log into your account. You don’t want to use your Microsoft (Hotmail, Live, Outlook.com) account since they won’t work with Azure Automation. The overview of the this process is to

• Create an Azure account in your subscription,
• Grant it co-administrator rights to manage your subscription resources
• Create an Automation Credential asset that uses that account

John Levy has posted detailed instructions on the Azure Blog. Follow those steps first.

The next step is to actually create the Runbook. We have a template on the Azure Portal. Select New > App Services > Automation > Runbook

Now select “From Gallery”. You’ll get a dialog listing all the Runbook templates we offer. Select VM Lifecycle Management > Azure Automation Workflow to schedule stopping of all Azure Virtual Machines.

Give your Runbook a name and associate it with the Automation account you created above.

The Runbook will be imported into your account. Once it is finished, click “Edit Runbook” to see the code. The comments will tell you the final steps. You’ll need to add your Automation credential to the script and reference your Azure Subscription.

You can test the script by clicking on “test”. Be aware that you may get an error regarding the credential. In the script above you’re asked to enter it in the format “account@MySubscription.OnMicrosoft.com” but I got it to work by simply using the “Account” portion and excluding everything to from and to the right of the “@”, inclusive. So that line would look like

$Cred = Get-AutomationPSCredential –Name “Account”

Now that you have this completed, publish the Runbook and create a schedule for it to run every night. Choose midnight or some other time that is appropriate for your work habits. This will save you credits and you’ll never have to worry about forgetting to shut down your machines again. Be aware that the machines will forcefully shut down so if you need the machines to stay up then disable the schedule. Also remember to save your work since it’s tantamount to somebody just switching off a physical server.

I’ve had to dig up some PS scripts from my SP2007 days and I thought I’d share. Here’s a script that will crawl all Web Apps in a farm and will output metadata into an xml file for import into your favorite tool, like Excel.

The script will list web apps, site collections, webs, SPusers with full control privileges, content database names and sizes for each. Run it on any SP2007 web front end.

This is useful if you don’t have any other 3rd party migration or assessment tools installed in your environment.

#SiteMap.ps1
#Mario Brandan, Regional Architect, Microsoft
#Script targets a SharePoint 2007 farm and will output a structured SiteMap.xml file that
#will list all web apps, site collections and webs, along with webs owners for webs that 
#have broken inheritance as well as those that inherit permissions.

#Run this locally on any front end
#Ensure the account has at least "Full Read" permissions on ever Web Application policy in
#Central administration.

#v3
#Added Db Size, Name for Site Collection node
#Added DisplayName, and Email attributes for FullControlUser node

clear-host

#Sp2k7 way of loading assembly
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint.Portal")

#this doesn't work in the SP2k7 farm, probably because get-variable isn't there.
#$invocation = (Get-Variable MyInvocation).Value
#$path = Split-Path $invocation.MyCommand.Path 
#$filePath = "{0}\SiteMap.xml" -f $path

#Hard code the output file path
$filePath = "C:\dev\SiteMap.xml"
#Create the output file in xml format.
$xtw = New-Object System.Xml.XmlTextWriter($filePath, $null)

#Vars to be used in finding Full Control users
$groupNameWildcard = "Owners"
$existingRole = "Full Control"

#Make it readable
$xtw.Formatting = 'Indented'
$xtw.Indentation = 1
$xtw.IndentChar = "`t"

$xtw.WriteStartDocument()
#xsl
#$xtw.WriteProcessingInstruction("xml-stylesheet", "type='text/xsl' href='style.xsl'")

$farm = [Microsoft.SharePoint.Administration.SPFarm]::Local;

$xtw.WriteStartElement("Farm")
$xtw.WriteAttributeString("FarmVersion", $farm.Version.ToString())

$websvcs = $farm.Services | where -FilterScript {$_.GetType() -eq [Microsoft.SharePoint.Administration.SPWebService]}

Write-Host "Crawling all Web Apps and creating site map..."

foreach ($websvc in $websvcs) {
    foreach ($webapp in $websvc.WebApplications) {
        $xtw.WriteStartElement("WebApplication")
        $xtw.WriteAttributeString("WebAppName", $webApp.Name)
        $xtw.WriteAttributeString("WebAppAppPool", $webApp.ApplicationPool.Name)
        foreach ($site in $webApp.Sites){
            $xtw.WriteStartElement("SiteCollection")
            $xtw.WriteAttributeString("SiteCollectionUrl", $site.ServerRelativeUrl)
            $xtw.WriteAttributeString("SiteCollectionOwner", $site.Owner)
            #Get the Content Database.
            #Can't call $site.ContentDatabase directly due to non CLS-compliant type.
            #Retrieve the handle to the property using reflection instead.
            $cdbProperty = [Microsoft.SharePoint.Administration.SPContentDatabase].GetProperty("DisplayName")
            $xtw.WriteAttributeString("ContentDb", $cdbProperty.GetValue($site.ContentDatabase, $null))
            
            $cdbProperty = [Microsoft.SharePoint.Administration.SPContentDatabase].GetProperty("DiskSizeRequired")
            $xtw.WriteAttributeString("ContentDbSizeGb", ($cdbProperty.GetValue($site.ContentDatabase, $null))/1024/1024/1024)
            foreach($web in $site.AllWebs){
                Write-Progress -Activity "Crawling..." -Status $web.url
                $xtw.WriteStartElement("Web")
                $xtw.WriteAttributeString("WebUrl", $web.Url)
                
                if ($web.HasUniquePerm -and $web.AssociatedOwnerGroup -ne $null){
                    $xtw.WriteAttributeString("HasUniquePermissions", "True")
                    $fullControlRoleDef = $web.RoleDefinitions["Full Control"]
                    foreach($roleAssignment in $web.RoleAssignments){
                        if($roleAssignment.RoleDefinitionBindings.Contains($fullControlRoleDef)){
                            $principal = $roleAssignment.Member
                            if ($principal.GetType() -eq [Microsoft.SharePoint.SpGroup]){
                                foreach($fullControlUser in $principal.Users){
                                    $xtw.WriteStartElement("FullControlUser")
                                    $xtw.WriteAttributeString("Name", $fullControlUser.Name)
                                    $xtw.WriteAttributeString("LoginName", $fullControlUser.LoginName)
                                    $xtw.WriteAttributeString("Email", $fullControlUser.Email)
                                    $xtw.WriteEndElement()
                                }#foreach FullControlUser
                            }#if the principal is an SpGroup
                            else{
                                #the principal is a user
                                $fullControlUser = $principal.Member
                                $xtw.WriteStartElement("FullControlUser")
                                $xtw.WriteAttributeString("LoginName", $fullControlUser.LoginName)
                                $xtw.WriteAttributeString("Email", $fullControlUser.DistributionGroupEmail)
                                $xtw.WriteEndElement()
                            }#else                            
                        }#if Full Control principal
                    }#foreach RoleAssignment
                }#if uniquePermissions
                else{
                    $xtw.WriteAttributeString("HasUniquePermissions", "False")
                }
                $xtw.WriteEndElement()#Web
            }
            $xtw.WriteEndElement() #Site
        }
        $xtw.WriteEndElement() #WebApp
    }
}
$xtw.WriteEndElement()
$xtw.WriteEndDocument()
$xtw.Flush()
$xtw.Close()
#$msg = "Site Map created at {0}" -f $filePath
$msg = "Site Map created at " + $filePath
write-host $msg
write-host "Import into an Excel PivotTable for analysis"

Yesterday Julie White announced that we will have a new unified event in Chicago in 2015 that will replace several of our trade shows from the past. Most notably for my community of peers, the SharePoint Conference and TechEd.

This is bittersweet. I’ve always had a great time at the SharePoint Conference and have enjoyed immensely the time spent learning, meeting, mentoring and getting mentored by the SharePoint community. The change underscores the changing times and the fact that the future is now. Cloud isn’t something that’s going to happen; it’s happening now. Those of us that grew up racking servers in datacenters have already been dealing with cloud deployments for at least several years. Now the big tradeshows are changing, appropriately, to reflect the changing technology.

On the plus side, I’m excited about the future of the platform. The product “SharePoint” is evolving and may not remain “SharePoint” for much longer. I have no insight into the product group’s plans but if you look at the history of standalone products like FAST and CMS being integrated into the larger SharePoint product, then you can see that what is past is prologue. I have customers that today won’t even think of the cloud, but a year ago NONE of my customers even considered the cloud.

When I came into the workforce the mainframe guys were on their way out and I was the scrappy kid converting all of their green-bar printed COBOL code into Win16/32 applications. They complained that they didn’t want to learn new technologies. Now I’m the same position and I don’t want to make the same mistake they made.

I imagine the new conference will focus on the API’s and services that can cross products. Since hosted servers in customer datacenters are becoming less and less common those of us that were infrastructure guys are encouraged to dust off some of the coding skills that we invariably acquired during our career. There’s a new wave of demand for devs coming, just like there was a huge wave of demand for SharePoint folks over the last 10 years. Time to ride a new wave!

I’ll be sure to be in Chicago for the 2015 kickoff to this new event, whatever we decide to call it. Cloudapalooza? OfficeChella?

Paul Thurrott gives us his analysis on his post R.I.P., TechEd

Now I can select between the two subscriptions by using Select-AzureSubscription and then verifying by issuing Get-AzureSubscription –Current

There is the concept of a default subscription in PowerShell. To change the default subscription just issue

Select-AzureSubscription -SubscriptionName "[SubscriptionName]" –Default

To view all subscription names just issue

Get-AzureSubscription | select SubscriptionName