Archive

Archive for July, 2012

Changing the Title bar on PuTTY

July 31, 2012 1 comment

If you have ever had to work with PuTTY and you are working with multiple environments, it can be a pain to know which environment you have open.  I struggled with trying to remember the IP address to the servers that I was connecting to on the cloud until I figured out how to set this up.  The following are the steps to get your environments setup so that you can perform the same.

First, perform your standard settings to get connected with the server of your choice.

Next, under the Window node in the tree, click on Behaviour menu item.  There you can specify the Window title you wish to have.  You can see an example below:

Unfortunately, this isn’t all that we need to do, there is still one more step that we need to apply before this will work.  Under the Terminal node, click on the Features menu item.  Here be sure to make sure that you have the “Disable remote-controlled window title changed” checked.  This will ensure that once you connect to your server, the title won’t change from you what you already specified.

Finally, we can now open up as many sessions that we want and know exactly which environment we are working in as shown below:

This has saved me a lot of frustration and confusion and has helped me to organize my desktop.  I would love to be able to launch PuTTY from a .bat file but I haven’t figured out how to create these settings on the fly.  Perhaps I can pass in a saved session that has all my configurations.  This would make my workflow even faster as I wouldn’t have to launch PuTTY and then select the environment to load.

Hope this helps and if you have any tips to make this even better, please let me know…

 

 

Advertisements
Categories: English Tags: , , ,

Writing a BrightScript syntax highlight extension for Visual Studio 2010

July 31, 2012 6 comments

I have recently been involved in a project where we have been required to develop using BrightScript.  BrightScript is the programming language for Roku devices.  Roku is the consumer product and there are also commercial offerings as well that allow you to build your own custom solution without ever needing to use BrightSign’s network.

Since I enjoy using Visual Studio 2010 (soon to be Visual Studio 2012)  for my development, I wanted to have a rich development experience with BrightScript.  Currently we either used NotePad++ or Visual Studio 2010 but without any syntax highlighting.  With NotePad++ it is possible to get syntax highlighting but it wasn’t the best experience.  I decided that I wanted to do some research and see just how difficult it is to write an extension to Visual Studio that would allow me to have syntax highlighting for BrightScript, specifically for “.brs” extensions.

Here is what I currently have for my development environment:

  • Visual Studio 2010 Ultimate SP1
  • Visual Studio 2010 SDK SP1

I don’t believe that you need anything else to do what I have here.  You will also need Visual Studio 2010 Professional or better to be able to do this.

Okay, so let’s get started.  First off, let’s create a project to represent our syntax.  When you launch Visual Studio, click on the Extensibility category and then select, “Editor Classifier”.  I am going to call this project “BrightScriptSyntax”.

When you click OK, Visual Studio will generate several files for you as shown below:

We will examine each of these files as well as introduce a couple others.  Let’s take a look at “BrightScriptSyntax.cs”:

using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Windows.Media;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Classification;
using Microsoft.VisualStudio.Utilities;
using Microsoft.VisualStudio.Language.StandardClassification;
using System.Text.RegularExpressions;

namespace BrightScriptSyntax
{

#region Provider definition
/// <summary>
/// This class causes a classifier to be added to the set of classifiers. Since
/// the content type is set to "text", this classifier applies to all text files
/// </summary>
[Export(typeof(IClassifierProvider))]
[ContentType("brs")]
internal class BrightScriptProvider : IClassifierProvider
{
/// <summary>
/// Import the classification registry to be used for getting a reference
/// to the custom classification type later.
/// </summary>
[Import]
internal IClassificationTypeRegistryService ClassificationRegistry = null;

public IClassifier GetClassifier(ITextBuffer buffer)
{
return buffer.Properties.GetOrCreateSingletonProperty<BrightScript>(delegate { return new BrightScript(ClassificationRegistry); });
}
}
#endregion //provider def

#region Classifier
/// <summary>
/// Classifier that classifies all text as an instance of the OrinaryClassifierType
/// </summary>
class BrightScript : IClassifier
{
BrightScriptLanguage _brightScriptLanguage;
IClassificationType _classificationType;
IClassificationType _whiteSpaceType;
IClassificationType _keywordType;
IClassificationType _commentType;
IClassificationType _stringType;
IClassificationType _identifierType;
IClassificationType _numericType;

internal BrightScript(IClassificationTypeRegistryService registry)
{
_brightScriptLanguage = new BrightScriptLanguage();
_classificationType = registry.GetClassificationType("BrightScript");
_whiteSpaceType = registry.GetClassificationType(
              PredefinedClassificationTypeNames.WhiteSpace);
_keywordType = registry.GetClassificationType(
              PredefinedClassificationTypeNames.Keyword);
_commentType = registry.GetClassificationType(
              PredefinedClassificationTypeNames.Comment);
_stringType = registry.GetClassificationType(
              PredefinedClassificationTypeNames.String);
_identifierType = registry.GetClassificationType(
              PredefinedClassificationTypeNames.Operator);
_numericType = registry.GetClassificationType("BrightScriptNumeric");
}

/// <summary>
/// This method scans the given SnapshotSpan for potential matches for this
        /// classification.
/// In this instance, it classifies everything and returns each span as a
        /// new ClassificationSpan.
/// </summary>
/// <param name="trackingSpan">The span currently being classified</param>
/// <returns>A list of ClassificationSpans that represent spans identified
        /// to be of this classification</returns>
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
//create a list to hold the results
List<ClassificationSpan> classifications = new List<ClassificationSpan>();
string current = span.GetText();
bool commentFound = false;
// Note:  Comments should go to the end of the line.
foreach (var item in _brightScriptLanguage.Comments)
{
Regex reg = new Regex(item, RegexOptions.IgnoreCase);
var matches = reg.Matches(current);
for (int i = 0; i < matches.Count; i++)
{
commentFound = true;
Match m = matches[i];
Span new_span = new Span(span.Start.Position + m.Index,
                      current.Length - m.Index);
SnapshotSpan new_snapshot = new SnapshotSpan(span.Snapshot,
                      new_span);
var newText = new_snapshot.GetText();
classifications.Add(new ClassificationSpan(new_snapshot,
                      _commentType));
}
}
if (commentFound)
return classifications;
Classify(classifications, current, span, _brightScriptLanguage.Custom,
              _classificationType);
Classify(classifications, current, span, _brightScriptLanguage.Quoted,
              _stringType);
Classify(classifications, current, span, _brightScriptLanguage.KeyWords,
              _keywordType);
Classify(classifications, current, span, _brightScriptLanguage.IdentifierTypes,
              _identifierType);
Classify(classifications, current, span, _brightScriptLanguage.Numeric,
              _numericType);
return classifications;
}
private void Classify(List<ClassificationSpan> classifications, string current,
          SnapshotSpan span, List<string> matchList, IClassificationType classificationType)
{
foreach (var item in matchList)
{
Regex reg = new Regex(item, RegexOptions.IgnoreCase);
var matches = reg.Matches(current);
for (int i = 0; i < matches.Count; i++)
{
Match m = matches[i];
Span new_span = new Span(span.Start.Position + m.Index, m.Length);
SnapshotSpan new_snapshot = new SnapshotSpan(span.Snapshot, new_span);
var newText = new_snapshot.GetText();
classifications.Add(new ClassificationSpan(new_snapshot,
                      classificationType));
}
}
}

#pragma warning disable 67
// This event gets raised if a non-text change would affect the classification
        // in some way, for example typing /* would cause the classification to
        // change in C# without directly affecting the span.
public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;
#pragma warning restore 67
}
#endregion //Classifier
}

This file differs slightly from what was originally generated by the Project Template. First, note that the ContentType is set to “brs”. This is the extension for which I want the syntax highlighting to work. I don’t want my syntax highlighter to affect all text files as is the default behavior.

The BrightScriptProvider class is has not been changed.

The next portion is where all of our work is going to be constrained from a development perspective. The BrightScript class is our classifier. It is this class that tell Visual Studio how to go about providing syntax highlighting for our BrightScript language. I want to point out that I did cheat a little and I included the following assembly to help make my development a little easier and more consistent with what Visual Studio already does with languages like C#. If you look at the screenshot below, you will see the project reference that I included:

As you can see, you will need to include the Microsoft.VisualStudio.Language.StandardClassification assembly.

It is this assembly that we get the bulk of our syntax formats. You will observe that I provide two custom formats and fall back on using the standard formats from Visual Studio.

Next, we will look at the GetClassificationSpans method. This method is the engine for performing our syntax highlighting. I keep a collection of ClassificationSpan objects that will tell Visual Studio how to classify the text it encounters. I start off by first trying to find comments in BrightScript. The rule is simple: if a comment is found, then take the rest of the current line and make it part of the comment. This is a basic single line comment rule. I have a custom class called, “BrightScriptLanguage” that represents the keywords and language of BrightScript. I loop through each keyword that is defined as a comment and create a new ClassificationSpan with the correct span information as well as indicated for it to use the comment classification type.

After I finish the loop, I then check to see if I previously found a comment. If this is true, then I return with the current list of ClassificationSpan objects. Otherwise, I then perform similar checks against Custom, Quoted (strings), Keywords, IdentifierTypes, and Numeric language types. We will look at the language definition very soon.

Finally, you will see the helper method that I wrote that is almost exactly like that of the comment check but does not assume the whole line when a match is found.

At the end of this class is a public EventHandler that is provided to us for free by the Project Template.

Let’s take a look at the “BrightScriptLanguage”:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.VisualStudio.Text.Classification;

namespace BrightScriptSyntax
{
class BrightScriptLanguage
{
#region Member Variables

private List<string> _comments = new List<string>();
private List<string> _quoted = new List<string>();
private List<string> _numeric = new List<string>();
private List<string> _keyWords = new List<string>();
private List<string> _identiferTypes = new List<string>();
private List<string> _custom = new List<string>();

#endregion

#region Properties

public List<string> Comments
{
get { return _comments; }
}
public List<string> Quoted
{
get { return _quoted; }
}
public List<string> Numeric
{
get { return _numeric; }
}
public List<string> KeyWords
{
get { return _keyWords; }
}
public List<string> IdentifierTypes
{
get { return _identiferTypes; }
}
public List<string> Custom
{
get { return _custom; }
}

#endregion

#region ctor

public BrightScriptLanguage()
{
Initialize();
}

#endregion

#region Methods

private void Initialize()
{
_custom.Add(@"\breturn\b");

_comments.Add("\'");
_comments.Add(@"\brem\b");

_quoted.Add(@"([""'])(?:\\\1|.)*?\1");

_numeric.Add(@"\b\d+\b");
_numeric.Add(@"\>");
_numeric.Add(@"\<");
_numeric.Add(@"\<\>");
_numeric.Add(@"\=");
_numeric.Add(@"\=\=");

_keyWords.Add(@"\bpos\b");
_keyWords.Add(@"\band\b");
_keyWords.Add(@"\bprint\b");
_keyWords.Add(@"\bline_num\b");
_keyWords.Add(@"\bor\b");
_keyWords.Add(@"\bgoto\b");
_keyWords.Add(@"\bnext\b");
_keyWords.Add(@"\bnot\b");
_keyWords.Add(@"\bstep\b");
_keyWords.Add(@"\bdim\b");
_keyWords.Add(@"\bthen\b");
_keyWords.Add(@"\bstop\b");
_keyWords.Add(@"\belse\b");
_keyWords.Add(@"\bto\b");
_keyWords.Add(@"\btab\b");
_keyWords.Add(@"\bobjfun\b");
_keyWords.Add(@"\btype\b");
_keyWords.Add(@"\brnd\b");
_keyWords.Add(@"\btrue\b");
_keyWords.Add(@"\bfalse\b");
_keyWords.Add(@"\bcreateobject\b");
_keyWords.Add(@"\bend while\b");
_keyWords.Add(@"\bexit while\b");
_keyWords.Add(@"\bwhile\b");
_keyWords.Add(@"\bend sub\b");
_keyWords.Add(@"\bsub\b");
_keyWords.Add(@"\bend for\b");
_keyWords.Add(@"\bfor each\b");
_keyWords.Add(@"\bfor\b");
_keyWords.Add(@"\bexit\b");
_keyWords.Add(@"\bendif\b");
_keyWords.Add(@"\bif\b");
_keyWords.Add(@"\bend function\b");
_keyWords.Add(@"\bfunction\b");
_keyWords.Add(@"\bas\b");
// Types
_identiferTypes.Add(@"\bvoid\b");
_identiferTypes.Add(@"\bboolean\b");
_identiferTypes.Add(@"\binteger\b");
_identiferTypes.Add(@"\bfloat\b");
_identiferTypes.Add(@"\bdouble\b");
_identiferTypes.Add(@"\bstring\b");
_identiferTypes.Add(@"\bobject\b");
_identiferTypes.Add(@"\binterface\b");
_identiferTypes.Add(@"\binvalid\b");
}

#endregion
     };
}

This class basically provides the meta-data necessary for me to use regular expression to determine whether or not we have a match. It is pretty much explanatory but I wanted to show you my simple regular expression solution for parsing the text.

Let’s move on to the “BrightScriptSyntaxType.cs” file:

using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Text.Classification;
using Microsoft.VisualStudio.Utilities;

namespace BrightScriptSyntax
{
internal static class BrightScriptClassificationDefinition
{
/// <summary>
/// Defines the "BrightScript" classification type.
/// </summary>
[Export(typeof(ClassificationTypeDefinition))]
[Name("BrightScript")]
internal static ClassificationTypeDefinition BrightScriptType = null;

[Export(typeof(ClassificationTypeDefinition))]
[Name("BrightScriptNumeric")]
internal static ClassificationTypeDefinition BrightScriptNumericType = null;

[Export]
[Name("brs")]
[BaseDefinition("text")]
internal static ContentTypeDefinition BrightScriptContentDefinition = null;

[Export]
[FileExtension(".brs")]
[ContentType("brs")]
internal static FileExtensionToContentTypeDefinition
          BrightScriptFileExtensionDefinition = null;
}
}

This class uses MEF by exporting the required information necessary for this extension. First off, we see our two custom classification types: “BrightScript” and “BrightScriptNumeric”. Next we see our entries for satisfying the file extension requirement. This is two-part in that we need a ContentTypeDefinition as well as a FileExtensionToContentTypeDefinition entry. We use the ContentTypeDefinition to define the name and base definition of our content type. Next we use the “.brs” file extension as well as reference the “brs” content type.

The final file that wee need to take a look at is the, “BrightScriptSyntaxFormat.cs” file:

using System.ComponentModel.Composition;
using System.Windows.Media;
using Microsoft.VisualStudio.Text.Classification;
using Microsoft.VisualStudio.Utilities;

namespace BrightScriptSyntax
{
#region Format definition
/// <summary>
/// Defines an editor format for the BrightScript type that has a purple background
/// and is underlined.
/// </summary>
[Export(typeof(EditorFormatDefinition))]
[ClassificationType(ClassificationTypeNames = "BrightScript")]
[Name("BrightScript")]
[UserVisible(true)] //this should be visible to the end user
[Order(Before = Priority.Default)] //set the priority to be after the default classifiers
internal sealed class BrightScriptFormat : ClassificationFormatDefinition
{
/// <summary>
/// Defines the visual format for the "BrightScript" classification type
/// </summary>
public BrightScriptFormat()
{
this.DisplayName = "BrightScript"; //human readable version of the name
this.ForegroundColor = Colors.OrangeRed;
}
}
#endregion //Format definition

#region Format definition
/// <summary>
/// Defines an editor format for the BrightScript type that has a purple background
/// and is underlined.
/// </summary>
[Export(typeof(EditorFormatDefinition))]
[ClassificationType(ClassificationTypeNames = "BrightScriptNumeric")]
[Name("BrightScriptNumeric")]
[UserVisible(true)] //this should be visible to the end user
[Order(Before = Priority.Default)] //set the priority to be after the default classifiers
internal sealed class BrightScriptNumericFormat : ClassificationFormatDefinition
{
/// <summary>
/// Defines the visual format for the "BrightScript" classification type
/// </summary>
public BrightScriptNumericFormat()
{
this.DisplayName = "BrightScriptNumeric"; //human readable version of the name
this.ForegroundColor = Colors.Goldenrod;
}
}
#endregion //Format definition
}

It is this file that defines the custom formats we want for “BrightScript” and “BrightScriptNumeric”. Most of these attributes are already provided by the Project Template. The only custom thing that I am performing here is setting the ForegroundColor to the corresponding value for each format.

Before we can upload this extension, we need to be sure that we have all of our information correct in the “vsixmanifest” file as shown below:

Just fill in the information that best describes your extension.  I also provided an icon and an image preview so that when developers search for my extension, they can see a sample of what it does.

Finally, I uploaded the extension with the Visual Studio Extension Gallery as shown below:

That’s all there is to it! I hope this helps anyone else who has wondered or wanted to write a custom Visual Studio Extension

Here is a link to the project.

Intoducing Micorosoft’s Roslyn compiler as a service

I had a great time Tuesday night speaking at the Charlotte Enterprise Developers Guild.  Thanks to all who came out to the presentation!

Here are the slides and sample code:

Slides and Sample code

Hope you enjoy…

 

Microsoft Silverlight 5 Data and Services Cookbook

I wanted to continue on reviewing books related to Silverlight 5 and development.  Microsoft Silverlight 5 Data and Services Cookbook states that it has over 100 practical recipes for creating rich, data-driven, business applications in Silverlight 5.  As with my last review, I will go over each chapter and add any gut reactions towards the content it provides.

The book is broken down into 13 chapters as well as an appendix.  On the whole, the book has a lot of content to absorb.  It is broken down into a collection of tips and tricks and common scenarios for using Silverlight in building line of business applications.  I like the concept and idea behind the approach to this book but I find that a lot of corners were cut in getting the book out the door.  I wish that the book had a better quality of code snippets as well as accompanying images as the code samples lack syntax highlighting of any sort and the images are very poor in quality.

Chapter 1 is all about learning the nuts and bolts of Silverlight 5.  This chapter is necessary if you have never written a Silverlight application and need to understand what is required in order to get started using Visual Studio 2010.

Chapter 2 jumps right into covering Data Binding.  This is also a core concept to any XAML technology and I like that they cover it soon so as to get you exposed to the whole data binding programming paradigm.  You are exposed to the classical non-data binding approach and then launch into the concept of a DataContext and how the data binding mechanism works.  We exposed how to create bindings both in XAML as well as in code which is sometimes necessary.  Binding to other elements, and collections is also discussed.  Next, is introduced the interface, INotifyPropertyChanged.  This is by far one of the most important aspects of XAML programming as it facilitates two-way data binding.  We finally come to one of the first instances of a new feature of Silverlight 5, debugging data binding expression.  This is one of the coolest features of Silverlight 5 and makes developing in Silverlight 5 a joy.

Chapter 3 takes our knowledge that we learned from data binding and goes into some advanced topics.  Namely, we are presented with converters, data templates, validating.  Converters are required in most line of business applications as your data binding alone will not satisfy all of your business logic and requirements.  We are also presented TargetNullValue, StringFormat, and FallbackValue as alternatives for using converters.  Another important part of any line of business application is validating user input.  We are presented with NotifyOnValidationError and ValidatesOnExceptions.  In the UI, we are introduced the ValidationSummary control that will automatically receive any BindingValidationError events.  This is nice in that we can present all errors in one concerted location and effort back to the user.  Data Annotations are presented as a means for providing validation rules on your domain objects.  INotifyDataErrorInfo and IDataErrorInfo interfaces are introduced to show how you can validate user input without throwing exceptions.  We finally move away from validation and review data templates.  This is an important concept with any XAML technology and we find good examples of usage here.  With Silverlight 5, we get the ability to use implicit templates and this is covered as well.  For scenarios where we need to binding something different than our current element in the visual tree, we are presented with Ancestor RelativeSource binding now available in Silverlight 5.  Another powerful feature of Silverlight 5 is the ability to create custom markup extensions.  Finally, as with INotifyPropertyChanged works on a single object, we are presented with the INotifyCollectionChanged interface for dealing with change aware collections.

Chapter 4 is completed dedicated to the Data Grid.  The one aspect that I was curious about was how they demonstrated binding combo boxes to the a column in the data grid.  The sample was very primitive and would not be something you would really be able to use in most data driven scenarios.  I am hoping that as we move to MVVM, we will see better scenarios on this.

Chapter 5 is about Isolated Storage.  This chapter does a good job on covering Isolated Storage and the limitations of Silverlight applications and their security sandbox.  I also liked that they also showed how you could use the Sterling database.

Chapter 6 covers MVVM.  The chapters covers the basics of MVVM as well as introducing MVVM Light and MEF as tools to use with MVVM.  I would have like an introduction on Prism and Caliburn.Micro as well as these are two important frameworks and libraries.  With Caliburn.Micro, they could have provided a nice introduction to architecting rich user interfaces without explicit data binding in your XAML.

Chapter 7 covers services.  Most all line of business applications will require data and since you cannot create a direct connection to the database in Silveright, you will need to access a service.  You presented with services such as ASMX, WCF, REST, and RSS.  I also liked that they also had a section on socket communication in Silverlight as well.  The one complaint I have is that I wished they would have also introduced SignalR as section as this is gaining a lot of popularity in the .NET community.

Chapter 8 takes what we were introduced in the previous chapter and focuses strictly on WCF and ASMX services.  We are exposed with using services that expose data, using Bing as a service.  We get presented with performance tuning by using binary XML.  We also cover a personal favorite of mine, the infamous, “Server Not Found” exception and how to provide more information to the Silverlight client.  Integrating with ASP.NET Authentication is also covered.  Finally, we are presented with uploading files using WCF.

Chapter 9 takes us one step further in our discovery with ASMX and WCF.  Mainly, we cover duplex communication, data encryption, message-based security, using Windows Identity Foundation and, finally, using a ChannelFactory with Silverlight.  Most of these sections are very high level and don’t go any further than a quick sample.  It at least points you in the right direction for further investigation.

Chapter 10 talks about using REST and WCF Data Services.  With REST we cover both XML and JSON formats.  Another sections discusses the limitations to the Silverlight browser stack.  We are then presented with the ClientHttp stack and how we can use the common REST verbs.  Next, we are presented with using WCF Data Services.  We also get presented with Flickr and Twitter and how to use their REST services.

Chapter 11 is dedicated to presenting WCF RIA Services.  While I am not a big fan of WCF RIA Services this chapter does a good job at showing you what you can do with WCF RIA Services.  It walks you through using the class library, getting your data, using a LoadBehavior, server-side queries, sorting, filtering, paging, and finally persisting your data and dealing with transactions and concurrency.

Chapter 12 continues on the WCF RIA Services and shows us some advanced features.  We are shown how to get a user’s identity either by Windows authentication or a custom means.  Next, we are presented with using Windows Identity Foundation and WCF RIA Services.    We then move from authentication to authorization in our services.  We also review how WCF RIA Services supports data annotations and validating user input.  Finally, we are presented with exposing our data via OData endpoints as well as SOAP or a JSON/REST endpoint.

Chapter 13 introduces Windows Phone 7.  This chapter walks you through the WP7 architecture from a developer’s perspective and then concentrates on getting data to the device.  A lot of the same patterns presented in the previous chapters are applicable.  Using push notifications with the cloud is demonstrated.  Local storage using a SQL CE database is presented.  Finally, a sample on using background transfer service is covered for uploading and downloading files in the background.

Appendix.  The appendix walks you through how to find any of the dependencies mentioned in the book.

If you are looking for a book that covers a lot of scenarios in Silverlight concerning data and services than this seems like a good reference for you to have.  At times, I feel that the samples were overly verbose and cluttered but I believe this is more to be the fault of poor publishing.  It would have been nice to have a better rendering of the code snippets and a better quality of the sample images throughout the book.  All in all, I found the book to be a good reference and it will definitely go in my toolbox as a go to book when I am working on a particular scenario.

When it comes to browser compatibility, this is my favorite tool…

One of my biggest frustrations with developing web applications is the need to deal with old and clunky browsers. I find that one of my least favorite exercises is being forced to support browsers that aren’t what I would call modern. Well, I tried several tools to help me in this process and found that two different ones became my favorite.

One of the pains with working with these different browsers is that you either need to manually install every type you need or you need older machines that still have the version running for you.

I looked at Expression Web 4 Super Preview and found that although the interface was nice and did allow me to see some differences, it was 100% accurate as to what I would see in the real browser.  I found this interesting and frustrating at the same time.  It also only allowed me to test the various versions of Internet Explorer.

Here is a screen shot of Expression Web 4 Super Preview:

 

I do like the interface and what it tries to offer but I found that it wasn’t the best choice as far as rendering accuracy.

Which now leads me to my new best friend!  I discovered a service that allows you to use your desktop applications anywhere.  I now use Spoon.net as my first line of defense when it comes to testing across multiple versions of IE or whatever browser you may need.  Here is a screen show of their page:

Here is a screen show of what I am currently using just like above but now with the ability to run IE 7 and IE 8 side by side without performing any installations manually:

 

You can configure your own applications that you wish to access.  Here is a screen shot of some of the browsers that are provided:

 

I can launch both IE7 and IE8 side by side.  I also have IE9 as my main browser so this gives me the ability to test all three versions that I care about.

Here is what IE7 looks like when launched:

 

As you can see, this is just what you would expect from IE7.  Now let’s see IE8:

 

 

Again, no surprises here.  What I really like about this service is that I can access it from any computer and perform my testing as I need without the need to configure my computer.

It does cost a little but it is well worth the price to know that your web applications will look sharp across any browser version and more.  This service allows you to have more than just browsers to access from anywhere.

Hope this helps…

 

Intoducing Micorosoft’s Roslyn compiler as a service

I will be speaking for the Charlotte Enterprise Developers Guild on Tuesday, July 24.

Here is my presentation summary:

Taking a look at Microsoft’s Roslyn compiler as a service. If you ever wanted to build your eval engine in .NET, now is the time. We will take a look at building your own Read-Evaluate-Print-Loop (REPL) engine. We will also see how can we use Roslyn to support buidling your templating engine.

Looking forward to seeing you there!