UK StudentZine Blog

Life as an Intern (Colin Davies)

ukstudentzine — Tue, 17 Nov 2009 17:46:12 GMT

My name is Colin Davies and I am currently on placement at Microsoft as a Marketing Project Manager. Around now a lot of you will be thinking about getting applications in for either placements or grad roles so I have been asked by the lovely editor of this newsletter to give you a little insight of what I am doing at Microsoft and what you could expect to be doing if you got a job at Microsoft.

I work in the Server department marketing software that allows data to come alive. My main focus is on a product called SQL Server, it is a database tool that turns data into information and allows you to manage that information in order to make use of it. One of the most recent projects I finished was working with another member in my team to organise an event for the people who already use SQL to demonstrate the new features they can expect from the next release. With 600 people invited to the event the responsibility that came with helping to organise the event was no intern admin job, I was a fully-fledged member of the team!

My long term project for the year is to reduce the leakage and increase the return on investment of marketing spends. The first part of this is to have a set procedure of how marketing generated leads are dealt with by our sales force. However in investigating the current process and the frustrations this provides varying stakeholders it has proved not to be an easy task. Challenges are good though; with the support of the team I have around me here at Microsoft I’m sure we’ll get there in the end.

One great thing we get at Microsoft is to have access to a lot of new technology. Windows 7 is one of them. We’ve been using it during the Beta stage but in case you haven’t upgraded yet have a look at the following website, with your .ac.uk email address you can get it for 90% discount, that’s only £30!

http://www.ultimatesteal.co.uk/student11

Good luck with the rest of your degree and I hope the applications go well whether they are for internships or grad roles.

Take it easy, Colin

Silverlight – Gadgets, Web Slices and more! (Part 1)

ukstudentzine — Tue, 17 Nov 2009 17:45:01 GMT

There’s a lot of cool things you can do with Silverlight. This new series will introduce you to some of them, including parameters, OutOfBrowser, Gadgets and more. In this part, we’ll be discussing passing parameters in to an application to inform the application of where it is running – be it browser, OutOfBrowser, WebSlice or Gadget! So let’s get started:

Create a new Silverlight application:

After this screen, you will be asked if you want to host this in a new Web Site – host is in a new ASP.NET web project and click OK:

Now we have a project to work with, we need to add our basic framework to allow the application to know where it’s being run from. The way we do this is with parameters that are passed from HTML to the Silverlight application.

Let’s start with the Silverlight code. First, we need to allow our project to get the Parameters from the HTML file. Open up your App.xaml.cs file and go to the Application_Startup function. Before the line “this.RootVisual = new MainPage();”, add the following code so that your Application_Startup function looks like this:

private void Application_Startup(object sender, StartupEventArgs e)

{

if (e.InitParams != null)

{

foreach (var item in e.InitParams)

{

this.Resources.Add(item.Key, item.Value);

}

this.RootVisual = new MainPage();

}

Now we have the code to read the parameters from the HTML page and add them to our Silverlight resources dictionary, we need to add some code to make sure the MainPage has fully loaded before trying to read the parameters. The way we do this, is to add an event handler to the MainPage, so that when it has fully loaded, it calls our loaded function. Add the following lines of code so that your MainPage() function looks like the following:

public MainPage()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

}

Add the following function also, for the event handler:

void MainPage_Loaded(object sender, RoutedEventArgs e)

{

throw new NotImplementedException();

}

Now that we have the parameters being added to the global dictionary, we can start to use them in our code. So, for this project, we’re going to use an environment key that will allow us to get some information about the environment the Silverlight application is running from.

Let’s go to our MainPage.xaml and add a simple button:

<UserControl x:Class="StudentZine.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480">

</Grid>

</UserControl>

For this project, we’ll just change the button to display the text of whatever environment we’re in. In the MainPage.xaml, in the MainPage_Loaded function, delete the current line of code for the not implemented exception and add the following code:

void MainPage_Loaded(object sender, RoutedEventArgs e)

{

string Environment = App.Current.Resources["environment"].ToString();

string ButtonText = "";

switch (Environment)

{

case "Gadget":

ButtonText = "Gadget";

break;

case "WebSlice":

ButtonText = "WebSlice";

break;

default:

ButtonText = "Browser";

break;

}

if (App.Current.IsRunningOutOfBrowser)

ButtonText = "Out Of Browser";

ClickMe.Content = ButtonText;

}

So let’s break this down – the Environment string is storing the value of the “environment” key in our global dictionary. This is the string that will be passed in through the parameters. We then have a select case, where it checks if it has a Gadget or WebSlice value. If so, it sets it to the appropriate value. Otherwise, it assumes it’s in the web browser. The last line of code checks if the application is installed and running out of browser.

On this note, to add OutOfBrowser functionality, right click the Silverlight project and go to properties. Check Enable Running Out Of Browser:

That’s it for our Silverlight code! Now we just need to add some html pages to our web project. For this part of the series, we’ll be covering simply passing in some parameters using the HTML page we already have. So let’s have a look at that code. Open the TestPage.aspx file and add the following line to your Silverlight object code:

So your code should now look like:

</a>

</object><iframe id="_sl_historyFrame" style="visibility:hidden;height:0px;width:0px;border:0px"></iframe></div>

And that’s all there is to passing in parameters to a Silverlight application! Next time, we’ll be looking at adding to this project to create an IE8 Web Slice using the same Silverlight code as the Browser piece, as well as fleshing out the application to be something a little more interesting!

Azure Applications (Explained)

ukstudentzine — Mon, 28 Sep 2009 14:34:14 GMT

What is Windows Azure?

Windows Azure is a cloud computing platform. It allows the deployment of cloud based applications that are managed at Microsoft datacenters.

How do I get Azure?

In order to start building Azure applications, you need to have Visual Studio 2008 or higher to install the SDK and tools.

Windows Azure SDK and tools: http://go.microsoft.com/fwlink/?LinkId=128752

In order for Azure to install correctly, you may need to enable IIS 7.0 ASP.NET application development components – you will receive an error if you have it disabled. To enable it, go to Control Panel -> Programs -> Programs and Features - > Turn Windows Features On or Off.

Enable Windows Communication Foundation HTTP Activation.

Enable IIS -> WWWS -> ASP.NET and CGI.

Building Your First Azure Application

Now you have the runtime and fabric installed, we can build our first application! To begin with, create a new Cloud Service project:

Next, you’ll get a screen asking you about Web and Worker roles. These are the types of applications you can create with Windows Azure. Web roles act as your web user interface (ASP.NET) and the worker role is a console application that deals with intensive background processing. For our demo, go ahead and add a Web Role and a Worker Role.

Now we have our Azure solution, we can start building the application. One great thing about the Windows Azure Platform Kit is that is comes with a solution that allows you to immediately make use of Tables, Queues and Blobs. Add the StorageClient solution (found with the Platform Kit) to your project.

Now that we have our solution setup, we need to configure the ServiceConfiguration.cscfg and the ServiceDefinition.csdef. Open the ServiceConfiguration.cscfg and change it to look like the following:

<?xml version="1.0"?>

</ConfigurationSettings>

</Role>

</ConfigurationSettings>

</Role>

</ServiceConfiguration>

If you were accepted on to the CTP for Windows Azure and have an account, you can replace the AccountName and AccountSharedKey with your own details and deploy it to your Azure account. After you have configured the ServiceConfiguration.cscfg, you need to configure the ServiceDefinition.csdef to look like the following:

<?xml version="1.0" encoding="utf-8"?>

</InputEndpoints>

</ConfigurationSettings>

</WebRole>

</ConfigurationSettings>

</WorkerRole>

</ServiceDefinition>

Configuration is out of the way! Now what about the application? We’re going to create a simple application that allows you to enter some text on the WebRole ASP.NET page, adds that to the queue and then the worker role is going to process the information from that queue and output it to the development fabric! Sounds easy, right? So let’s begin!

Creating the ASP.NET page

Open the default.aspx pagein the StudentZineWebRole solution. Add an <asp:TextBox> control and an <asp:Button> control. Label these txtMessage and btnSubmit.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="StudentZineWebRole._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

</head>

<body>

<div>

<asp:TextBox ID="txtMessage" runat="server" />

<asp:Button ID="btnSubmit" runat="server" Text="Submit" />

</div>

</form>

</body>

</html>

Now we’ve added our controls, we need to add some logic to take the submitted data and add that to the queue. Open up the Default.aspx.cs file. First, we need to add our StorageClient using namespace. To do this, right-click References -> Add Reference...

Add this line of code to your using namespace directive:

using Microsoft.Samples.ServiceHosting.StorageClient;

On the design page, double-click the button control. This will bring up the code behind with a function called btnSubmit_Click(). In that function, add the following line so that the function looks like the following:

protected void btnSubmit_Click(object sender, EventArgs e)

{

StorageAccountInfo account = StorageAccountInfo.GetDefaultQueueStorageAccountFromConfiguration();

}

This initializes the account information and uses the configuration information you provided previously. Now, you need to create the queue. This is a simple if statement to check if the queue is already there:

QueueStorage service = QueueStorage.Create(account);

MessageQueue queue = service.GetQueue("messages");

if (!queue.DoesQueueExist())

{

queue.CreateQueue();

}

Now that we have a queue, we need to add things to it. To do this, add the following lines of code within the same function:

Message msg = new Message(txtMessage.Text);

queue.PutMessage(msg);

txtMessage.Text = string.Empty;

This takes the information from the Textbox control and puts this on to the queue. It then empties the Textbox control text. Your completed function should now look like this:

protected void btnSubmit_Click(object sender, EventArgs e)

{

StorageAccountInfo account = StorageAccountInfo.GetDefaultQueueStorageAccountFromConfiguration();

QueueStorage service = QueueStorage.Create(account);

MessageQueue queue = service.GetQueue("messages");

if (!queue.DoesQueueExist())

{

queue.CreateQueue();

}

Message msg = new Message(txtMessage.Text);

queue.PutMessage(msg);

txtMessage.Text = string.Empty;

}

Now that we have a queue and the ability to add items to that queue, we need to process them and report them to the development fabric. In the StudentZineWorkerRole solution, open up WorkerRole.cs and add the StorageClient reference in the same way you did for the WebRole.

For the WorkerRole, you’ll notice two functions. Start() and GetHealthStatus(). Start() works like the Main() function in normal console applications and GetHealthStatus() returns the current state of the WorkerRole. For this demonstration, you can delete all the code within the Start() function, so that it looks like the following:

public override void Start()

{

}

Similar to the WebRole, we need initialize our storage account. Add the following line to the Start() function:

StorageAccountInfo account = StorageAccountInfo.GetDefaultQueueStorageAccountFromConfiguration();

Now we need to add some code to reference the queue we created in the WebRole:

QueueStorage service = QueueStorage.Create(account);

MessageQueue queue = service.GetQueue("messages");

As you can see, it’s pulling the same queue, “messages”, that was created by our WebRole. Now that we have that, we need to pull the messages from the queue. We do this by creating an infinite loop to check the queue. Once we have a message in the queue, we pull that from the queue, report it and then delete it from the queue. Remember, queues work in a FIFO prioritisation!

while (true)

{

Thread.Sleep(10000);

if (queue.DoesQueueExist())

{

Message msg = queue.GetMessage();

if (msg != null)

{

RoleManager.WriteToLog("Information",

string.Format("Message '{0}' processed.", msg.ContentAsString()));

queue.DeleteMessage(msg);

}

So now, you’re completed WorkerRole Start() function should look like the following:

public override void Start()

{

StorageAccountInfo account = StorageAccountInfo.GetDefaultQueueStorageAccountFromConfiguration();

QueueStorage service = QueueStorage.Create(account);

MessageQueue queue = service.GetQueue("messages");

while (true)

{

Thread.Sleep(10000);

if (queue.DoesQueueExist())

{

Message msg = queue.GetMessage();

if (msg != null)

{

RoleManager.WriteToLog("Information",

string.Format("Message '{0}' processed.", msg.ContentAsString()));

queue.DeleteMessage(msg);

}

And that’s all there is to it! A fully working WebRole and WorkerRole communicating with a queue!

Life as an Intern (Samantha Mills)

ukstudentzine — Mon, 28 Sep 2009 13:46:00 GMT

Let’s set the scene... 2nd year of University; more interested in a buzzing social life than rolling out tones of coursework, plus exams which actually count for something for the first time since A Levels – the previous year or 2 of a lazy, carefree existence is now simply a fond memory.

Sound Familiar?

For many people that’s enough to deal with but, for others, being lumbered with searching, and applying for, a job that will interest them for a year, with an employer that will look good on your CV is a harsh reality.

So as you can imagine; when, after months of trailing the internet, endless career emails, and the filling-in of a huge amount of dreary application forms, I landed a placement year at Microsoft, I was thrilled!

I work on marketing and events within the Public Sector team – we are the ones who promote to Health, Education and Government (including Mi5 and all the exciting smaller Govt. sections).

The majority of my role requires me to deal with event logistics, organisation and feedback – from small internal events, to assisting large conferences with thousands of people. I am involved with the whole process – from booking the venue and catering, and dealing with registrations; to meeting and greeting attendees on the day and analysing feedback.

I am given a lot of responsibility – which at times can be incredibly daunting – however, Microsoft has ensured that I can deal with the majority of things thrown at me right from the beginning. The previous interns were a fantastic resource – teaching us everything we needed to know about our roles - managers and team members are very understanding, and there is a huge network of people who are willing to help and answer as many questions as you can think of!

Another part of my role is to coordinate internal communications. I put together a monthly newsletter which is sent to the whole of the UK PS team.
Sourcing and reading about all of the information has helped me a lot in my role. Public Sector companies are very different to the enterprise-based businesses that most people are used to, and meant that I’ve been put in contact with a lot of different people. Microsoft can be a very easy place to get your name and ideas heard if you make the effort J

As well as this, the majority of managers will be happy for the intern(s) in their team to get experience in a different area – for example any techies wanting marketing experience can get the chance to be involved with events or PR by shadowing one of the marketing teams, and lending a hand on tasks that they find interesting.

This year is an extremely exciting time to be involved with Microsoft’s marketing strategies. As well as the usual buzz surrounding new, unusual, futuristic technologies; the launch of Windows 7 and Office 2010 (amongst others) means that there are even more events and activities being put in motion. Windows 7 promotions are increasingly becoming a bigger and bigger part of my role.

I honestly can’t believe that I have been working at Microsoft for just over 2 months now – the time has literally flown by. I feel that I’ve learnt so much already, and the scope for me to grab even more of the skills I need is tremendous. The moral of the story? Grab every opportunity you can with both hands and don’t give up on placement hunting – chances are you’ll end up with a job that you will really enjoy!

Pushing Paint applications into Web 2.0 using Silverlight

ukstudentzine — Thu, 09 Apr 2009 15:51:00 GMT

Paint applications on the desktop has been developing for a long time however there are few available on the internet, even less that offer the same control that you would find on a desktop paint application, even one as simple as Paint. Let me show you how you can make your own online paint application in Silverlight.

One of the reasons this hasn’t been done before in Silverlight is the way it renders graphics and shapes. It uses Vectors; which are great if you want to create shapes that look good at any resolution or zoom level but not so good for us. Why? Well you can’t say what colour is at point [5, 5] for example if we load in an image and then draw a shape on top. Or what if we want to draw a pen line, well we could use the Ink tools but they are all separate and distinct and in the end we can’t bring them all together in a saveable image. Thus we need to create our own pixel based graphics library that incorporates the required functionality.

Luckily most of the hard work was figured out for us by Joe Stegman who incorporated a PNG encoder to link between the Silverlight Image control and a pixel level graphics array of bytes accessible via Get and Setpixel functions.

We need to increase the functionality of this, so I went through the GDI+ graphics library and copied most of the function signatures for the ones that would be useful (or easy to implement) and then added a few additional ones that would help the applications performance and scalability, below is the class diagram for the finished graphics library.

As you can see we have quite the selection of Methods, quite a few of them we don’t actually require for this project however I thought it would be useful if the graphics library was used elsewhere.

Now let’s talk about how the graphics library actually works and what goes on under the hood. The image data is stored in a byte array. Each screen pixel requires 4 bytes (representing A, R,G,B) and then a parity byte at the end of each row, thus for an image of size [w, h] the required bytes are (w * 4 + 1) * h. Set and Get Pixel process the coordinates and read / write from a position in the byte array.

Some modifications were made to the PNG encoding library, such as altering the way it copies arrays to use System.Array.Copy() to increase speed, as we will constantly be updating as fast as possible every millisecond counts!

One of the first functions we needed to create was a DrawLine() function; the default signature of which being DrawLine(Color color, int x1, int y1, int x2, int y2) this function would effectively walk the line in both horizontal and then vertical 1 pixel increments and plot the resulting pixel using Bresenham's algorithm, this gave a fast and effective algorithm however it lacks anti-aliasing though for this implementation that is acceptable. To improve performance we bypass SetPixel and set the bytes directly otherwise we would constantly have to recalculate the colour values. Once we have a line drawing function in place others come naturally, such as DrawRectangle() etc.

public void DrawLine(Color color, int x1, int y1, int x2, int y2)

{

byte red = color.R;

byte green = color.G;

byte blue = color.B;

byte alpha = color.A;

int start;

// Uses Bresenham's algorithm to draw a line

// Work out the start, end and step points

double startX = x1;

int endX = x2;

double yStep = (y2 - y1) / (endX - startX);

double yPos = y1;

if (endX < startX)

{

startX = x2;

endX = x1;

yStep = (y1 - y2) / (endX - startX);

yPos = y2;

}

// First we traverse the x plane

for (int x = (int)startX; x < endX; x++)

{

start = _rowLength * (int)yPos + x * 4 + 1;

if (x < Width && yPos < Height && x > 0 && yPos > 0)

{

// Set the buffer directly for increased speed

_buffer[start] = red;

_buffer[start + 1] = green;

_buffer[start + 2] = blue;

_buffer[start + 3] = alpha;

}

yPos += yStep;

}

// Secondly we traverse the y plane

double startY = y1;

int endY = y2;

double xStep = (x2 - x1) / (endY - startY);

double xPos = x1;

if (endY < startY)

{

startY = y2;

endY = y1;

xStep = (x1 - x2) / (endY - startY);

xPos = x2;

}

for (int y = (int)startY; y < endY; y++)

{

start = _rowLength * y + (int)xPos * 4 + 1;

if (xPos < Width && y < Height && xPos > 0 && y > 0)

{

// Set the buffer directly for increased speed

_buffer[start] = red;

_buffer[start + 1] = green;

_buffer[start + 2] = blue;

_buffer[start + 3] = alpha;

}

xPos += xStep;

}

Drawing an ellipse is slightly more complex, for this I used a modified version of the ellipse rendering code found on Wikipedia. It creates lines connecting 72 splines around the ellipse at the key positions; I choose 72 as an arbitrary number that provides a high level of detail.

private Point[] GetEllipsePoints(int x, int y, int width, int height)

{

// Iterate through 72 points

int steps = 72;

double angle = Math.PI / 4;

double centerX = (double)width / 2;

double centerY = (double)height / 2;

// Store for the keypoints around the Ellipse

List<Point> points = new List<Point>();

// Angle is given by Degree Value

double beta = -angle * (Math.PI / 180); //(Math.PI/180) converts Degree Value into Radians

double sinbeta = Math.Sin(beta);

double cosbeta = Math.Cos(beta);

for (double i = 0; i < 360; i += 360 / (double)steps)

{

double alpha = i * (Math.PI / 180);

double sinalpha = Math.Sin(alpha);

double cosalpha = Math.Cos(alpha);

double X = x + centerX + (centerX * cosalpha * cosbeta - centerY * sinalpha * sinbeta);

double Y = y + centerY + (centerX * cosalpha * sinbeta + centerY * sinalpha * cosbeta);

points.Add(new Point(X, Y));

}

return points.ToArray();

}

Bucket fill proved interesting, from a starting point it would iterate through till an area enclosed by the same original colour was filled. This was achieved by first creating a copy of the buffer store, though in the form of a 2D colour grid, and then using a queue to process each item. The first item in the queue is the original point pasted to the function. The queues iteration loop would check the four surrounding pixels to see if they are the same as the origin pixel colour and if so, would change its colour and add the position to the queue if the square hadn’t already been processed. Once the queue is empty the bucket fill is complete.

public void BucketFill(Color color, int x, int y)

{

// Store the colour of the origin pixel

Color OriginPixelColour = GetPixel(x, y);

// First to make things easier we need to create a backup of the graphic

Color[,] _backupGrid = CreateColourGrid();

bool[,] ProgressGrid = new bool[Width, Height];

// Create a queue of all the points we need to check through

Queue<Point> ProgressQueue = new Queue<Point>();

// Set the initial queue item to the origin

ProgressQueue.Enqueue(new Point(x, y));

ProgressGrid[x, y] = true;

// Iterate through the queue till there are no items

{

// Dequeue the item

Point QueueItem = ProgressQueue.Dequeue();

int X = (int)QueueItem.X;

int Y = (int)QueueItem.Y;

// Change the colour

SetPixel(X, Y, color);

// Now go through the different directions

if (Y >= 1 && !ProgressGrid[X, Y - 1] && _backupGrid[X, Y - 1] == OriginPixelColour)

{

ProgressGrid[X, Y - 1] = true;

ProgressQueue.Enqueue(new Point(X, Y - 1));

}

if (Y < Height - 1 && !ProgressGrid[X, Y + 1] && _backupGrid[X, Y + 1] == OriginPixelColour)

{

ProgressGrid[X, Y + 1] = true;

ProgressQueue.Enqueue(new Point(X, Y + 1));

}

if (X >= 1 && !ProgressGrid[X - 1, Y ] && _backupGrid[X - 1, Y] == OriginPixelColour)

{

ProgressGrid[X - 1, Y] = true;

ProgressQueue.Enqueue(new Point(X - 1, Y));

}

if (X < Width- 1 && !ProgressGrid[X + 1, Y] && _backupGrid[X + 1, Y] == OriginPixelColour)

{

ProgressGrid[X + 1, Y] = true;

ProgressQueue.Enqueue(new Point(X + 1, Y));

}

while (ProgressQueue.Count != 0);

}

Initialisation for the image was moved to the constructor method to improve perceived performance as there would not be a slight lag the first time the image is drawn to.

public Bitmap(int width, int height)

{

this.Width = width;

this.Height = height;

// Initalise everything

_rowLength = _width * 4 + 1;

_buffer = new byte[_rowLength * _height];

_init = true;

}

Other functions such as DrawImage() just transfer the bytes from a previously defined Bitmap to the current object, due to their simplicity I thought it would be best to carry on and not go into much detail about them.

So now we have a fully functional dynamically generated Bitmap class. Moving on we must now go ahead and implement the front end this plugs into. To simplify things the window will be split into several Grids, one to house the main paint window, status bar, tool bar and menu. For the moment we will concentrate on the main window and implement that.

In the main windows code we need to declare two bitmaps using the library we just created and then one using Silverlights graphics library.

public Bitmap(int width, int height)

{

this.Width = width;

this.Height = height;

// Initalise everything

_rowLength = _width * 4 + 1;

_buffer = new byte[_rowLength * _height];

_init = true;

}

_Frontbuffer is where the main drawing will take place before it is drawn to the screen; _Backbuffer is used to hold temporary graphics information for certain operations and brushes.

The image itself will consist of an Image control ‘DrawSurface’ surrounded by 3 Rectangles for the different shadows to give the image a 3d relief effect ‘DrawSurfaceShadowRight’, ‘DrawSurfaceShadowBottom’ and ‘DrawSurfaceShadowCorner’.

The shadow fill of the rectangles is created by a LinearGradientBrush going from Gray to LightSteelBlue (the paint windows background colour). The positions of the Shadows are based on the dimensions of the internal drawable bitmap _FrontBuffer although offset northeast by 5 pixels to give the effect the canvas is hovering. We package this up as a function that we call whenever the dimensions of _FrontBuffer changes.

private void SetupShadows()

{

// Set the dimensions and margins

DrawSurfaceShadowRight.Height = _Frontbuffer.Height - 5;

DrawSurfaceShadowRight.Margin = new Thickness(30 + _Frontbuffer.Width, 35, 0, 0);

DrawSurfaceShadowBottom.Width = _Frontbuffer.Width - 5;

DrawSurfaceShadowBottom.Margin = new Thickness(35, 30 + _Frontbuffer.Height, 0, 0);

DrawSurfaceShadowCorner.Margin = new Thickness(30 + _Frontbuffer.Width, 30 + _Frontbuffer.Height, 0, 0);

// Set up the gradient colours and offsets

GradientStopCollection _GSC = new GradientStopCollection() {

new GradientStop() { Color = Colors.Gray, Offset = 0 },

new GradientStop() { Color = Color.FromArgb(255, 176, 196, 222), Offset = 1 } };

// Set the right, bottom and corner gradients

DrawSurfaceShadowBottom.Fill = new LinearGradientBrush(_GSC, 90);

DrawSurfaceShadowRight.Fill = new LinearGradientBrush(_GSC, 0);

DrawSurfaceShadowCorner.Fill = new LinearGradientBrush(_GSC, 45);

}

Different tools in Silverpaint are used by storing the ID for the tool which is in the form of a string eg. Pen, Line, BucketFill etc. The type of tool is checked on various mouse events on the Drawable surface depending on how they effect it.

The source code for SilverPaint is available for download at SilverPaints page on MSDN.

Mix Conference 2009

ukstudentzine — Thu, 09 Apr 2009 15:50:00 GMT

The Mix Conference held each year in Las Vegas is a showcase for Microsoft’s vision of internet technologies and this year was no exception. It bridges the gap between Web professionals and industry leaders in a way that allows them to explore the future of the web together.

This year it was held between the 18^th and 20^th of March. For those not able to attend the conference videos on demand of various sessions have been made available to download and view on the Mix Website. http://visitmix.com/

There was a lot to talk about this year at the initial Keynote, held by Scott Guthrie and Bill Buxton. Formost on the agenda was the forthcoming Version of Silverlight 3, now available for download in Beta 1. To continue the ‘next generation web’ experience Internet Explorer 8 was finalised and demonstrated; providing a faster, easier and more secure web browsing experience.

If you want to try out the Beta of Silverlight 3 then pop over to MSDN and download the Visual Studio Tools

Getting to grips with Dreamspark

ukstudentzine — Thu, 09 Apr 2009 15:49:00 GMT

What is DreamSpark?

DreamSpark is Microsoft’s way of giving free software to students. Students can simply log on and enjoy the free Microsoft products available to download. Products available on DreamSpark include Expression Studio 2, Virtual PC, Visual Studio and more.

Why DreamSpark?

DreamSpark has just undergone a funky new makeover to help promote some of the new products and bonus features added. These include:

· Live@edu integration

· Updated versions of existing products with added languages now available

· XNA 3.0

· Availability to schools (campaign launched in Feb 09) and

· Microsoft Robotics Developer Studio

Simply visit www.dreamspark.com , follow the 3 simple steps and download the free products of your choice today!

Microsoft Surface - Real world meets software engineering

ukstudentzine — Thu, 26 Feb 2009 17:47:00 GMT

Warren Rieutort-Louis, third year at CUED and a Microsoft Student Partner in Cambridge, explores the power of software engineering and the design process through a new touch technology that hopes to revolutionise the way we interact with out environment...

Read the article here

Dreamspark

ukstudentzine — Tue, 17 Feb 2009 18:27:00 GMT

Students love free stuff, fact. Dreamspark was launched by Microsoft to do just that. Free downloads of Visual Studio and other cool Microsoft products such as Windows Server were already available for students. However, Microsoft decided this wasn’t enough and in January the new Dreamspark was launched to students around the world.

Now Microsoft offers a new, improved and exciting range of products for free, including:

· Live@edu which has been added to the package, with 24 new countries added to the platform

· Generic Web Server support

· XNA 3.0

· Plus, MS Robotics Studio is due to be added shortly

The forthcoming addition of Microsoft Robotics Studio has caused must excitement and interest from students and enthusiasts across the globe. Stay connected for more information about this addition.

For more information check out www.Dreamspark.com to receive your free tools today.

Making bigger bets with smaller stakes.

ukstudentzine — Tue, 17 Feb 2009 17:42:00 GMT

Keeping Lionhead Innovative.

Adam Jethro Langridge

How do you make something big and innovative?

That's a particularly interesting question in the computer games industry. It is easy to see its significance once you peruse your local Computer Game store. When I look around a game shop, I tend to look for something exciting and interesting that offers me something that I haven't experienced before. If I'm lucky I'll find something that hasn't existed before. For most people, especially those that don't play games (which is a lot), I think this may be the case too. They just don't know it yet - the amazing game that will interest them still hasn't been made.

For an entertainment medium that is still in relative infancy, computer games already make a lot of money and often have large teams working on a single title. This opens up the game developer to two opposing forces; On the one hand, there is a great deal of opportunity to innovate- to find new ways to entertain new people. On the other hand, a large financial commitment to any project means that mistakes can be costly. As a result, big budget titles display a tendency to be risk averse, which at its worst can mean the latest release you've been looking forward to turns out to be the same game you played last year, but bigger. However, there are a handful of developers that are the exception to the rule. They manage to make big games, with big imaginations. This article shares my insight on how just one of them does it - Lionhead.

Lionhead Studios has been making computer games for over 10 years. Founded by Peter Molyneux and a handpicked team of crack commandos in July 1997 Lionhead has grown from 15 people making Black & White to become a fully fledged Microsoft Game Studio with over 100 full time developers. On its way, Lionhead has made the Movies, Black & White 2 and of Course Fable 1 (as it is now known).

Lionhead's heritage goes back to Bullfrog Productions, which was itself responsible for some genre defining hits, most notably the birth of the 'God Game' in Populous.

During this time, Peter Molyneux and Lionhead have built a reputation for innovation and ambition in every title that has been released. Most recently in Fable II, some interesting innovations include mechanics called 'Ambient Orbs', the 'Breadcrumb Trail' and 'One Button Combat', each of which weren't previously seen in computer games, but managed to help Fable II shine. However, with every innovation is an element of risk. Some ideas simply don't work. If you're unlucky they end up in the finished product - making your game less fun and less successful. If you're really unlucky, commitment to a bad idea can wreck a title's development completely. I have heard stories of games that languish unfinished and unreleased because of a particularly unfortunate turn in its design - they just never recovered. Of course, these are an extreme case, but even bad ideas that don't wreck a game can still be costly if mishandled. Why is this?

Size does matter.

Computer Game development teams have grown over the last 20 years from a lone bedroom programmer doing everything, to teams of more than 100 people. These new teams have dedicated people corresponding to many different disciplines. Broadly, teams are made up of Artists, Animators, Designers, Musicians, Programmers and Testers. Each of these disciplines has their own specialities. For example in the case of artists you will find people who focus on one specific element of computer game art such as characters, concepts, environments, textures, and more. This means that because a single game feature often involves a team of people to coordinate, working on the wrong idea wastes a lot of time. Due to the complexity of many modern games, these mistakes can introduce knock-ons to other areas.

The big question is how do you invest in big ideas, without taking equally big risks? Some ideas seem great on paper, but unless you've played them, you sometimes never know. But what if you try them out in the game and the idea fails? You've wasted all that time and work, and the deadline is that much closer now! I'm sure you've already guessed the answer to this question - and that is what Lionhead has a culture of doing - Prototyping.

Show - Don't Tell.

A prototype is usually a standalone piece of technology that is made with the sole purpose of proving (or disproving) an idea. This idea could be anything - some rendering technology to showcase an art style, a control scheme, some networking design, even the way you make something. The great thing about prototypes is that because they only care about one thing, they don't need to bother with everything else. This means that they can take less time and use less people to put together than a full implementation. If it fails, you've lost one or two peoples work (but really you've saved a lot more people from making the same mistake). If it succeeds - you've got a proven idea ready to put into your game and some experience of doing it already.

This all sounds great, but is it actually done? Prototyping is done by lots of people in lots of areas of Lionhead. Lionhead even has a small department dedicated to identifying risky opportunities and prototyping them - called the Research and Development team. Let's use a case study to demonstrate how Prototyping has helped Lionhead make innovative games. In this case, let's look at Fable II's One Button Combat system.

What button combat?

This feature was triggered by Peter Molyneux, who wondered if we could have cinematic action without the complications of most control schemes - in this case, just one button. The sentence that encapsulated the idea was something like "When you press this button, the hero does the coolest and most exciting thing that he can at the time." This could mean attacking, defending or leaping off of a wall!

Straight away this idea presented risk, because this was counter to previous conventions - one button blocked, another attacked. So much so that I don't remember anything else that worked in this way in a computer game before.

Three options were open to Fable II's development. The first was to put it in the game and see if it worked. This idea seemed very risky for two reasons; combat is one of Fable's cornerstones and couldn't afford to be broken. Also, no-one had any clue as to whether or not it was a good idea - unless you get your hands on it and play, you'll never know. The second option was to ignore it, losing that opportunity. The third option was a prototype. This meant the Fable II's main development could continue. If this paid off, it would be a nice extra. If it failed, then nothing would be lost to the game's development.

As speed was critical, we decided to make the prototype outside of Fable II's codebase, which was still under heavy development. The prototype was called FistiCuffs, and focussed on unarmed combat only - a street fight. It wasn't much to look at, it didn't have any textures, and the characters didn't have any fancy animation coding techniques that prevented their feet slipping. These things weren't important, what was critical to this idea was how it felt. As it turned out, the prototype proved to be successful in proving this idea. Happily, some more ideas came along from this prototype as well. The nice thing about having a working prototype of this nature is that for very little extra effort, you can try out other ideas too. No matter how silly they seem, if they have a reasonable chance of success, they are worth trying because they are so cheap to explore.

This example goes to show that with a sound prototype and good backing (in this case Peter), new ideas can find their way into big games, even as core mechanics.

What could this mean to you? Well, if you find yourself wanting to try out a wacky idea for a larger project, but you're scared of breaking everyone else's work. Perhaps you find yourself having trouble getting consensus on a feature. Don't be afraid to Prototype it first. If you decide to do so, remember the following:

· Prototypes don't need to show everything- just focus on what you're trying to demonstrate.

· Prototypes don't need to do everything properly. If you can show an idea in 2d, even if it's for a 3d project, then do that.

· Prototypes do need to show what's important. Make sure you have a very clear idea of what you're trying to prove. If you can't say it in a single sentence, you probably don't know what it is. Try writing it down. For example, "This Prototype needs to show whether or not a single button control scheme can be fun and rewarding in a combat game."

· Know your audience. Often, a prototype will be a tool to demonstrate an idea in order to get buy in from more people. Weigh up any things that are easy to do, but boost the message of the prototype, such as sound effects in a game play prototype.

· Re-Use code and assets. Don't re-invent the wheel, if something already does what you need it to, use that and build on it. Keep your own useful code handy.

· Let the work speak for itself. As a previous title mentioned, show, don't tell. Simply by trying this idea out, it should be pretty self-evident whether this idea is a 'goer'. If people aren't buying in to the idea after being shown, then it probably isn't that great an idea. Don't get upset, you've just saved yourself the pain of working on it in the larger project and finding this out too late!

Next time you're looking through the shelves at your local computer game shop, think what ideas and prototypes these games would have looked at or dismissed. Perhaps you’ll have ideas of what prototypes you would like to try to make these games better - you'll be on the way to making your own groundbreaking blockbuster (or little gem). Have fun.

Lionhead is currently searching out the brightest, most imaginative and nicest graduates that are around to become the games developers of the future. If you've a clever brain full of big ideas, are currently finishing your degree, and like programming- follow this link:

http://www.lionhead.com/Graduates.aspx

F# ...Functional programming in the .Net world - Kevin Pfister

ukstudentzine — Tue, 17 Feb 2009 17:37:00 GMT

F# was developed as an experimental programming language by Microsoft Research to provide a combination of many sought after features in other programming languages.

The problem with most programming languages is that they usually have to give up on functionality to achieve it elsewhere; C# for example gave up on a slight performance overhead while gaining the benefits of managed code.

The goal for F# was to create a type-inferred functional programming language that provides type safety, succinctness, expressivity, scripting while still maintaining performance relative to a well-supported modern runtime system.

F# is a fully supported .NET language and you can download the CTP from the Microsoft download site. Developed as a pragmatically oriented variant of ML with a core that shares many of the language fundamentals as OCaml, F# can still run near the speed of C++.

The first port of call for anyone wanting to know more about F# would be its developer section on MSDN, I’m now going to go through and explain more technically about F# and how to program in it.

Once you have downloaded and installed the CTP for F# you can now go into visual studio and create a new project in the language.

As F# is based on OCaml it means it has the ability to cross compile OCaml source code, however this also means it can create a syntax that isn’t as elegant as we would hope for, thus we can use the #light directive at the being of our source to simplify the syntax.

The next big thing about F# is Type Inference, if we were to make a function in C# we would have to say what the argument types were and what the return type was, F# however makes these determinations at the compiler stage using the function signature. If we were to make the following declaration of a function in F# that doubles a number given to it.

let doublenum x = x * 2

This would cause the F# to believe the return value would be an int... why? Well the return value is the last executable statement, in this case ‘x * 2’ F# also knows that there is only 1 argument to the function ‘x’. The reason however why it will return an int is because the last statement contains *, although * can be applied to byte, uint64, double etc. F# will default it to a signed 32bit integer for our convenience.

Now we can override the way that F# does this to make some interesting effects by applying type annotation to one or more arguments. We can do this by declaring what type they are, for example.

let concat (x: string) y = x + y

We have stated that x is of type string, this then infers that y must also be a string as + only works when both variables are strings.

Now what if we want to return more than one result? This can be achieved by wrapping the values you want to return in brackets at the end of the function, as shown in the following example.

let wordCount text =

let words = String.split [' '] text

let wordSet = Set.of_list words

let nWords = words.Length

let nDups = words.Length - wordSet.Count

(nWords,nDups)

This function returns the number of words in text (nWords) and the number of duplicate words (nDups).

So now you know how to make functions in F#, let’s move into GUI. As F# utilises .Net we can use System.Windows.Forms and from that we can make Windows Forms to display things on. Below shows how easy it is to make a new window in F#. ( Remember you have to reference System.Windows.Forms as part of the project as well)

open System.Windows.Forms;;

let form = new Form(Visible=true,TopMost=true,Text="Hello GUI World");;

Now if you want to add a control to the form you have to add it to the Forms Control property, below is an example of adding a RichTextBox to the form we just made.

let textB = new RichTextBox(Dock=DockStyle.Fill, Text="Hello GUI World");;

form.Controls.Add(textB);;

So in all F# is a very powerful and interesting language which is great if you are moving from the functional world of ML, OCaml etc.

If you want to try out some more samples you can download F# samples at code.msdn which shows a selection of slightly more complex examples for those wanting a challenge.

Visualising media search better (Part 2) - Kevin Pfister

ukstudentzine — Tue, 17 Feb 2009 17:31:00 GMT

The way Image search results look now hasn’t really changed much in the last few years, I ask the simple question ...why? In this article I want to try something that hasn’t been done before; combining Deep Zoom and Live Image Search. I call it DeepSearch ...Sounds awesome!

In the last article we used a pseudo 3D effect in Silverlight to show one way of visualising Images we have searched for.

However just showing the images was a bit bland, even with a 3d effect. We needed to actually be able to manipulate the images better, and so people I give you DeepSearch!

This has only been made possible by the changes made to the MultiScaleImage control (Deep Zoom to us common people) within Silverlight Version 2 which allows us to dynamically generate our own MultiScaleTileSource. In the ye olde days the MultiScaleImage control would link to an external XML file via the Source property; however we can override this via the abstract class MultiScaleTileSource which has a method GetTileLayers() that we can override.

protected abstract void GetTileLayers(

int tileLevel,

int tilePositionX,

int tilePositionY,

IList<Object> tileImageLayerSources

)

Where this gets interesting now for us is creating the Dynamic tiles that we are going to supply to the MultiScaleImage control. Silverlight 2 doesn’t contain really anything in the way of pixel based bitmap manipulation client side, so what we need to do is push all that code over to the server. Mike Ormond and Mike Taulty have both done great blog posts that explain this problem and a way to get round it. I will be using the same type of methods they suggest. We will remote the requests to server side code so using an ASP.Net ashx handle so that we can use System.Drawing to enable us to have the bitmap manipulation we so desperately need, the only problem as both the Mike’s so rightly point out is the problem with the lack of caching causing server side congestion which will cause our code some problems later. Now to start off with I used most of the code base downloadable from Mike Taulty’s blog entry to speed things up a bit... here’s it running with quite a lot of changes made to the Silverlight front end. (One of the ideas of how it could have looked)

Some of you may notice that in Mikes DeepZoom image only showed the number whereas mine also shows the text searched for; in this case Layer. All that had to be done was simply link send the search text to the ashx handler along with the rest of the deep zoom configurations.

string source =

string.Format(

"http://localhost:62586/ClientBin/handler.ashx?" +

"tileLevel={0}&tilePositionX={1}&tilePositionY={2}&tileSize={3}" +

"&imageWidth={4}&imageHeight={5}&imageQuery={6}",

tileLevel, tilePositionX, tilePositionY, tileSize,

imageWidth, imageHeight, QueryString);

Having the bitmaps being generated server side also has a benefit to us as well; we will also be processing the search results server side as well due to Silverlight using a subset of System.Xml and also is a simple way to negate Silverlight’s Cross-Domain problem.

To use the Live Search API’s as part of our project we need to download the Live Search SDK and then acquire an AppID; for more information on the Live Search SDK you can visit the site.

There is a great example as part of the Live Search SDK which shows how to perform a Live Image Search and display the results; we only need to alter the context as it has been designed to run from a console rather than a web service... easy enough you would think.

However there is a big problem that we will have to overcome, the example I mentioned above will just search for a set of images and display the links to the results. If we plug this into the Server code; based on the code example Mike T provides then every time we want to change the depth or viewport we would have to perform the same search again and download the same set of images; thus we need to implement a simple image caching system on the server.

To do this we need to implement SessionState variables in our ashx handler class. This can be done by firstly importing System.Web.SessionState and having the class inherit IRequiresSessionState. What we are going to store in the SessionState is the search results of a given search and also the images that are retrieved. Now this will be A LOT of data if it were pushed out onto a production server however I am only using this method as this is really only a proof of concept. To store the search results I am made a struct to store the information retrieved from a search.

private struct SearchItem

{

public string MediaURL;

public string PageTitle;

public string PageURL;

public Size MediaSize;

}

We need to replace the example Live Search SDK code so it will now store search items in this type of struct and then store them as a List<SearchItem> in the SessionState using the SearchQuery as the key. Also as a sidenote, the SessionState is saved as part of the HttpContext we need to promote the variable to a class variable rather than local.

// List of the image results

List<SearchItem> _SearchItems = new List<SearchItem>();

// Save the Image results.

foreach (XmlNode result in results)

{

SearchItem _Result = new SearchItem() {

MediaURL = result.SelectSingleNode("./mms:MediaUrl", nsmgr).InnerText,

PageTitle = result.SelectSingleNode("./mms:Title", nsmgr).InnerText,

PageURL = result.SelectSingleNode("./mms:Url", nsmgr).InnerText,

MediaSize = new Size(

int.Parse(result.SelectSingleNode("./mms:Width", nsmgr).InnerText),

int.Parse(result.SelectSingleNode("./mms:Height", nsmgr).InnerText)),

ThumbnailURL = result.SelectSingleNode("./mms:Thumbnail/mms:Url", nsmgr).InnerText };

_SearchItems.Add(_Result);

}

// Save the results to the session state

httpContext.Session[queryString] = _SearchItems;

Now to test if this all work I changed the rendering code so instead of displaying text in the deep zoom it would instead display the first image of the search results list; in this case... Bill Gates

Now comes the big question; how do we want to display the images within the Deep Zoom? To give you one idea of what we could do is just panning the images across and then wrapping around at the edges, and so I give you the base of our deep zoom search.

One thing I had to do which I found very interesting was that if I just let told the graphics device to render the bitmap that sometimes it wouldn’t render it to the correct size so I made it render to the size that the search engine returned instead. To make transfer between server and client a little faster I also altered the context.Response.ContentType of the handler response to use jpeg instead of png, hopefully the lossy compression shouldn’t be noticable too much when compared to the bandwidth savings.

context.Response.ContentType = "img/jpeg";

...

bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);

Let’s go back to the UI now seeing as the search functionality is almost done. Now at the start I mentioned that the project was based on Mike Taulty’s underlying codebase, however he didn’t implement the full set of Deep Zoom mouse controls, so we have to add in MouseWheel support which isn’t as hard as you would think as any project created by Deep Zoom Composer already contains this code.

With some final adjustments to the UI with a nice shiny welcome page; making it more like a normal search engine I think I’ve done a good job on dull winter’s afternoon.

Follow the continuing development of DeepSearch at my Blog: www.blogplusequals.blogspot.com

If you want to try out DeepSearch, download the source code from MSDN

Microsoft IT Academy Student Pass

ukstudentzine — Mon, 19 Jan 2009 13:18:00 GMT

Ever fancied getting some more letters after you name and improving your job prospects when you leave uni? Then Microsoft certification is for you!

We're making a whole bunch of official eLearning content available to students for free through the IT Academy Student Pass programme. These courses will give you everything you need to learn to take a MCP exams and get ready for industry!

To sign up you need a unique code to authenticate yourself as a student, to get one either click here to email me or alternatively visit DreamSpark.com. Once you've got your code you can register here.

For all the details check out the official website.

Windows 7 for Tech Students

ukstudentzine — Fri, 16 Jan 2009 14:32:00 GMT

Ten top features in the next generation of Windows for development and productivity

Following Windows 7’s recent beta launch to the public, I’ve taken a look at the new development features and productivity improvements to Microsoft’s flagship product to see what it all means for technology students.

Windows 7 brings in a wide range of changes, and not only to the way the operating system works and how it behaves: there are new and innovative ways to control the computer and how it interacts with the user. The most exciting of these to develop for will be the brand new multi-touch, manipulation, and inertia APIs. These range from the low-level touch messages and input APIs to the higher-level gesture APIs, allowing developers as much or as little control over the input as they’d like. Programmers can work with rich API commands such as zooming, panning, and rotating the current view on the screen, right down to creating custom gestures with the lower level APIs. The inertia API works with the high-level APIs to allow developers to create unprecedentedly user-friendly, touch-based applications, including elements that can be controlled with touch gestures then “thrown” across the screen.

Along with the brand-new taskbar and more Start menu changes (more on those later), comes a new way for users to interact with applications, and an exciting way for developers to include new functionality: the Jump Menu. Application designers can add their own items such as tasks (for example, composing an e-mail) and recently opened files or URLs for that application to a default list of recent files, folders and tasks, creating an easy way for users to start working with the application which is accessible from the Start menu, or by right-clicking on the application’s icon.

Now a feature for the web developers: Windows 7’s new Federated Search creates a method for users to perform a search, from the desktop, on documents beyond the user’s own computer. You can add your search engine, a remote document store or media server, and even custom data sources to the Windows 7 search, without having to deploy client code. Windows 7 also supports the OpenSearch standard, which enables webmasters, simply by adding an RSS or ATOM output, to integrate their search with Windows 7.

Windows 7 allows developers writing custom file formats to create property handlers which are now implemented by Windows Explorer to show useful information relating to the file being viewed; if you include proper format handlers, search results for your custom file types can be just as rich as those Windows supports natively.

Along with Windows 7 comes Internet Explorer 8, featuring improved performance, reliability, compatibility, and for developers, new ways for the user to interact with the web. As well as a new “Suggested sites” feature, where users can view sites they may like based on their history, there is a new “Web Slice Gallery”, where users can subscribe to links and are notified when changes are made to the relevant website – a fantastic opportunity for web service operators to further integrate with the user through their browser.

But all of these exciting new changes for developers aren’t the end of it – there are many improvements to the core functions of Windows 7 that makes the operating system one of the most productive to use and work with. At the core of this is the brand new taskbar: featuring larger icons, no text (by default), and a plethora of configuration and notification options available to both developers and users. Instead of a quick launch area and lozenges for each application, all open applications have one icon each, and appear “stacked” on the taskbar; for example, if you had two Windows Explorer windows open, they appear as one icon on top with another “hidden” behind it. The taskbar also allows the order of icons to be rearranged for easy management, as well as previewing of open windows or tabs (Windows Media Player includes media controls on the preview window too). Combined with Jump Menus mentioned earlier, these features make for a fantastically useful and productive tool.

Another big change in Windows 7 is the inclusion of Libraries. These dynamic folders replace the (My) Documents, (My) Pictures and (My) Music of previous Windows versions with a more accessible way of collecting together files. With the increased distribution of files around your file system, external hard disks and network storage areas, it can be difficult to keep track of where you might find a document you are looking for. Libraries ease this problem by allowing you to add folders to the libraries, which then shows all the files of the relevant type inside the library; think of it like the way you would add folders to your Windows Media Player 11 library, but this time for all your documents, organized in one central location.

As mentioned earlier from a developer’s perspective, Windows 7 include some new Start menu features and searching options not seen in previous versions of Windows. Along with Federated Search and Jump Menus, it includes some new UI elements and animations to make it more visually appealing, changes to the often-confusing power commands, and an improved searching feature.

Following the introduction of Windows Sidebar and Gadgets in Windows Vista, Microsoft have gone a step further by removing Sidebar and letting users place Gadgets anywhere on the Desktop. In line with Microsoft’s aims of backwards compatibility with Windows Vista, other Gadgets are available from the Microsoft Gallery website, in addition to a brand new Media Center gadget. To complement the new mobility of Gadgets, the Taskbar now features a dedicated Show Desktop section on the right hand edge – when hovered over, it makes all visible windows transparent so that you can see the Gadgets on the Desktop.

The final large modification to Windows 7 features a multitude of changes to the Control Panel and the notification system. The Control Panel now features more views and a more accessible interface, making it much simpler for users to find the setting they wish to change quickly and easily. Changes to User Account Control include a slider for choosing how you are notified, with a range of intermediate values replacing the simple and inconvenient On or Off found in Windows Vista; Windows Security Center has been consolidated with other system notification services to form the Windows Solution Center, which contains sections on security and maintenance; and there is a new way to control which system and program notification icons appear on your taskbar.

The enhancements and developments I have mentioned here represent only a brief overview of the many changes made in Windows 7: I haven’t even started on networking, services, power efficiency, automation, handwriting recognition and so much more. If you’re interested in any of the new developments in Windows 7, I would highly recommend the Windows 7 Developer Guide, available to download from MSDN. Or, download and check out the Beta for yourself, freely available from the Microsoft site until February.

A better way to visualising media search (Part 1)

ukstudentzine — Fri, 16 Jan 2009 14:30:00 GMT

Search... the most important aspect of the internet; without it no one would be able to explore easily the vast amount of content available in an efficient manner, but could it look better?

Over the years search has come a long way, improving its algorithms and search techniques with the addition of other search categories such as image and video. We have reached the point now where the quality of results are sublime yet the search interface is still little different from where we originally started, therefore it’s time for a face lift.

So how do we go about this then? Well most search engines nowadays such as Live Search and Google have their own API sets that allow developers to utilise their search tools, then we need a way to merge the results and then output them in a graphically appealing way. There are several search visualisation plugins available already online but I thought I would try and make my own.

All this as usual I’ll be doing in Silverlight, allowing us to create a very rich and powerful interface. The only problem is that Silverlight doesn’t support much in the way of 3d graphics so we have to create a pseudo 3d impression.

The 3d effect I will be using is a common one that gets used a lot these days; a wall of images that you can scroll along, creating a highly tactile surface. When you click on an image it will scale it later and give more information about it.

Now for the coding...

One of the first problems I had was trying to create the boxes to house each of the image search results in the visualisation. The problem I had was that the shape couldn’t be achieved just by using a rectangle and applying transformations to it, I had to use the Path shape to create the custom shape I required to give the pseudo 3d effect I wanted.

Another problem that I have run into a few times is the quality of image scaling in Silverlight, although in WPF you can adjust these settings it seems locked in Silverlight. In our application this is a problem when the images become smaller as they go off into the pseudo distance, to get round this I altered the opacity of the images as they go further away till they fade out completely just before they hit the scaling problems. Once completely faded or off screen I make the objects visibility collapsed thus to increase rendering performance of the application.

Coming in the next issue I will be adding to the visual effect and adding tagging so you can play with the images in the search that you like along with talking more about what goes into search itself and how for images finding what you want can be even harder. Along with this I will be giving out the source code for you to play with, however for the time being you can see the progress of the application by visiting my blog at www.blogplusequals.blogspot.com