User Experience Design : Microsoft

Evolution of Windows Explorer

Andries van der Meulen — Tue, 30 Aug 2011 13:05:15 GMT

Nice post of Steven Sinofsky on MSDN blogs about the history and future of Windows Explorer.
http://blogs.msdn.com/b/b8/archive/2011/08/29/improvements-in-windows-explorer.aspx

(edit 31-08-2011)
And Martin Tirion of Microsoft Netherlands wrote about it a day later (in Dutch).
http://blogs.microsoft.nl/blogs/ux/archive/2011/08/30/windows-explorer-in-windows-8-en-user-experience.aspx

Storing and retrieving WPF RibbonWindow settings (including the usercustomizable QuickAccessToolbar)

Andries van der Meulen — Tue, 17 May 2011 16:42:31 GMT

When you’re creating a desktop application you'd probably want to store some user settings.
Especially when using the Ribbon inside your application, there are several things (like RibbonIsMinimized and ShowQuickAccessToolBarOnTop) that users can set and want to keep even if the application en closed and restarted.

There are several ways to store these user settings, and you can find some methods if you search the internet. But the biggest challenge is to store and retrieve the Quick Access Toolbar content which the user can change.

Defining

First the storage of the settings. I use the application user properties which are set through the project settings.
We define the following settings:

FirstRun (bool)
WindowSize (System.Windows.Size)
WindowLocation (System.Windows.Point)
WindowState (System.Windows.WindowState)
RibbonIsMinimized (bool)
ShowQuickAccessToolbarOnTop (bool)
RibbonQuickAccessToolbar (string)

If you can’t find the right type inside the type combobox, just select [Browse…] to select it from available DLL’s. Point and Size are found in WindowsBase, and WindowState is in PresentationFramework.

Storing

Next step is storing the settings. I leave the QuickAccessToolbar out for this moment. I’ll add it later.

The storing is taking place in de code behind of the Shell, which is the main window of the current application. It is not mandatory to do this in the code behind, but for the moment it is the easiest.

I store the settings when the window is closing.

protected override void OnClosing(CancelEventArgs e)
{
    Properties.Settings.Default.FirstRun = false;
    Properties.Settings.Default.WindowSize = new Size(Width, Height);
    Properties.Settings.Default.WindowLocation = new Point(Left, Top);
    Properties.Settings.Default.WindowState = WindowState;
    Properties.Settings.Default.RibbonIsMinimized = RibbonMenu.IsMinimized;
    Properties.Settings.Default.ShowQuickAccessToolBarOnTop = RibbonMenu.ShowQuickAccessToolBarOnTop;
    Properties.Settings.Default.RibbonQuickAccessToolBar = XamlWriter.Save(buttons);

    Properties.Settings.Default.Save();

    base.OnClosing(e);
}

The RibbonMenu is referencing to the <Ribbon x:Name="RibbonMenu" > inside the Shell.XAML.
Width, Height, Left, Top and WindowState are properties of the WPF (Ribbon)Window.

Retrieving

And when the application is starting again, you just have to get these settings and set them back. The best moment to do this is in the OnInitialized of the Shell.

protected override void OnInitialized(EventArgs e)
{
    base.OnInitialized(e);

    if (!Properties.Settings.Default.FirstRun)
    {
        Width = Properties.Settings.Default.WindowSize.Width;
        Height = Properties.Settings.Default.WindowSize.Height;
        Left = Properties.Settings.Default.WindowLocation.X;
        Top = Properties.Settings.Default.WindowLocation.Y;
        WindowState = Properties.Settings.Default.WindowState;
        RibbonMenu.IsMinimized = Properties.Settings.Default.RibbonIsMinimized;
        RibbonMenu.ShowQuickAccessToolBarOnTop = Properties.Settings.Default.ShowQuickAccessToolBarOnTop;
    }
}

So far the easy part.

QuickAccessToolbar

Storing and retrieving the QuickAccessToolbar is a bit more complicated. Because this can’t just be serialized.
First I tried and used XamlWriter and XamlReader to try serialize the items inside the QuickAccessToolbar. Although storing it worked fine (it made a huge xml file), when trying to load the Xaml, I soon experienced the problem that the XamlWriter also serialized the bindings (with it’s content) i set on the command property. Unfortunately these bindings are DelegateCommands from Prism, which can’t be constructed through deserialization.

The solution is a bit complex, but it works just fine. I created my own entities for storing and retrieving the items inside the QuickAccessToolbar.

[Serializable]
public class QuickAccessToolbarButtonCollection : List<QuickAccessToolbarButton> { }

[Serializable]
public class QuickAccessToolbarButton
{
    public ImageSource LargeImageSource { get; set; }
    public ImageSource SmallImageSource { get; set; }
    public string Label { get; set; }
    public object QuickAccessToolBarId { get; set; }
    public object ToolTip { get; set; }
    public string ToolTipDescription { get; set; }
    public string KeyTip { get; set; }
    public Binding CommandBinding { get; set; }
}

Off course you can add more properties if you’re setting more attributes on the RibbonButton. These properties were everything I’ve used.

Next step is creating and storing the QuickAccessToolbar items.

#region Create the QuickAccessToolbarButtonCollection
QuickAccessToolbarButtonCollection buttons = new QuickAccessToolbarButtonCollection();

foreach (RibbonButton rButton in RibbonMenu.QuickAccessToolBar.Items)
{
    if (rButton.KeyTip != "S") // Don't include the savebutton!
    {
        QuickAccessToolbarButton qaButton = new QuickAccessToolbarButton()
        {
            Label = rButton.Label,
            KeyTip = rButton.KeyTip,
            LargeImageSource = rButton.LargeImageSource,
            SmallImageSource = rButton.SmallImageSource,
            ToolTip = rButton.ToolTip,
            ToolTipDescription = rButton.ToolTipDescription,
            QuickAccessToolBarId = rButton.QuickAccessToolBarId,
            CommandBinding = BindingOperations.GetBinding(rButton, RibbonButton.CommandProperty)
        };
        buttons.Add(qaButton);
    }
}
#endregion

And when the collection filled, I use the XamlWriter to set this data inside a user setting

Properties.Settings.Default.RibbonQuickAccessToolBar = XamlWriter.Save(buttons);

The reason I’m not using a conventional XMLSerializer is because the XamlWriter can serialize bindings.

Last step is to read the stored setting. For this I use the XamlReader to deserialize back to our custom entity.

#region Load the QuickAccessToolbarButtonCollection
if (!string.IsNullOrEmpty(Properties.Settings.Default.RibbonQuickAccessToolBar))
{
    QuickAccessToolbarButtonCollection buttons = null;
    using (StringReader stringReader = new StringReader(Properties.Settings.Default.RibbonQuickAccessToolBar))
    {
        XmlReader xmlReader = XmlReader.Create(stringReader);
        buttons = (QuickAccessToolbarButtonCollection)XamlReader.Load(xmlReader);
        xmlReader.Close();
    }

    if (buttons != null)
    {
        for (int i = RibbonMenu.QuickAccessToolBar.Items.Count - 1; i >= 0; i--)
        {
            RibbonButton button = (RibbonButton)RibbonMenu.QuickAccessToolBar.Items.GetItemAt(i);
            if (button.KeyTip != "S") // Don't delete the savebutton!
                RibbonMenu.QuickAccessToolBar.Items.RemoveAt(i);
        }

        foreach (QuickAccessToolbarButton qaButton in buttons)
        {
            RibbonButton rButton = new RibbonButton()
            {
                Label = qaButton.Label,
                KeyTip = qaButton.KeyTip,
                LargeImageSource = qaButton.LargeImageSource,
                SmallImageSource = qaButton.SmallImageSource,
                ToolTip = qaButton.ToolTip,
                ToolTipDescription = qaButton.ToolTipDescription,
                QuickAccessToolBarId = qaButton.QuickAccessToolBarId
            };
            if (qaButton.CommandBinding != null)
                SetBinding(RibbonButton.CommandProperty, qaButton.CommandBinding);

            RibbonMenu.QuickAccessToolBar.Items.Add(rButton);
        }
    }
}
#endregion

Check explicitly if the commandbinding are null, else you get exceptions when initializing the Shell.

Overview

Below the complete two methods.

protected override void OnInitialized(EventArgs e)
{
    base.OnInitialized(e);

    if (!Properties.Settings.Default.FirstRun)
    {
        Width = Properties.Settings.Default.WindowSize.Width;
        Height = Properties.Settings.Default.WindowSize.Height;
        Left = Properties.Settings.Default.WindowLocation.X;
        Top = Properties.Settings.Default.WindowLocation.Y;
        WindowState = Properties.Settings.Default.WindowState;
        RibbonMenu.IsMinimized = Properties.Settings.Default.RibbonIsMinimized;
        RibbonMenu.ShowQuickAccessToolBarOnTop = Properties.Settings.Default.ShowQuickAccessToolBarOnTop;

        #region Load the QuickAccessToolbarButtonCollection
        if (!string.IsNullOrEmpty(Properties.Settings.Default.RibbonQuickAccessToolBar))
        {
            QuickAccessToolbarButtonCollection buttons = null;
            using (StringReader stringReader = new StringReader(Properties.Settings.Default.RibbonQuickAccessToolBar))
            {
                XmlReader xmlReader = XmlReader.Create(stringReader);
                buttons = (QuickAccessToolbarButtonCollection)XamlReader.Load(xmlReader);
                xmlReader.Close();
            }

            if (buttons != null)
            {
                for (int i = RibbonMenu.QuickAccessToolBar.Items.Count - 1; i >= 0; i--)
                {
                    RibbonButton button = (RibbonButton)RibbonMenu.QuickAccessToolBar.Items.GetItemAt(i);
                    if (button.KeyTip != "S") // Don't delete the savebutton!
                        RibbonMenu.QuickAccessToolBar.Items.RemoveAt(i);
                }

                foreach (QuickAccessToolbarButton qaButton in buttons)
                {
                    RibbonButton rButton = new RibbonButton()
                    {
                        Label = qaButton.Label,
                        KeyTip = qaButton.KeyTip,
                        LargeImageSource = qaButton.LargeImageSource,
                        SmallImageSource = qaButton.SmallImageSource,
                        ToolTip = qaButton.ToolTip,
                        ToolTipDescription = qaButton.ToolTipDescription,
                        QuickAccessToolBarId = qaButton.QuickAccessToolBarId
                    };
                    if (qaButton.CommandBinding != null)
                        SetBinding(RibbonButton.CommandProperty, qaButton.CommandBinding);

                    RibbonMenu.QuickAccessToolBar.Items.Add(rButton);
                }
            }
        }
        #endregion
    }
}

protected override void OnClosing(CancelEventArgs e)
{
    #region Create the QuickAccessToolbarButtonCollection
    QuickAccessToolbarButtonCollection buttons = new QuickAccessToolbarButtonCollection();

    foreach (RibbonButton rButton in RibbonMenu.QuickAccessToolBar.Items)
    {
        if (rButton.KeyTip != "S") // Don't include the savebutton!
        {
            QuickAccessToolbarButton qaButton = new QuickAccessToolbarButton()
            {
                Label = rButton.Label,
                KeyTip = rButton.KeyTip,
                LargeImageSource = rButton.LargeImageSource,
                SmallImageSource = rButton.SmallImageSource,
                ToolTip = rButton.ToolTip,
                ToolTipDescription = rButton.ToolTipDescription,
                QuickAccessToolBarId = rButton.QuickAccessToolBarId,
                CommandBinding = BindingOperations.GetBinding(rButton, RibbonButton.CommandProperty)
            };
            buttons.Add(qaButton);
        }
    }
    #endregion

    Properties.Settings.Default.FirstRun = false;
    Properties.Settings.Default.WindowSize = new Size(Width, Height);
    Properties.Settings.Default.WindowLocation = new Point(Left, Top);
    Properties.Settings.Default.WindowState = WindowState;
    Properties.Settings.Default.RibbonIsMinimized = RibbonMenu.IsMinimized;
    Properties.Settings.Default.ShowQuickAccessToolBarOnTop = RibbonMenu.ShowQuickAccessToolBarOnTop;
    Properties.Settings.Default.RibbonQuickAccessToolBar = XamlWriter.Save(buttons);

    Properties.Settings.Default.Save();

    base.OnClosing(e);
}

Enjoy!

Microsoft Silverlight 5.0 features for developers

Andries van der Meulen — Tue, 21 Dec 2010 14:56:03 GMT

Recently on Silverlight 5.0 Firestarter event ScottGu has announced road map for Silverlight 5.0. There will be lots of features that will be there in Silverlight 5.0 but here are few glimpses of Silverlight 5.0 Features.

Improved Data binding support and Better support for MVVM:

One of the greatest strength of Silverlight is its data binding. Microsoft is going to enhanced data binding by providing more ability to debug it. Developer will able to debug the binding expression and other stuff in Silverlight 5.0. Its also going to provide Ancestor Relative source binding which will allow property to bind with container control. MVVM pattern support will also be enhanced.

Performance and Speed Enhancement:

Now Silverlight 5.0 will have support for 64bit browser support. So now you can use that Silverlight application on 64 bit platform also. There is no need to take extra care for it.It will also have faster startup time and greater support for hardware acceleration. It will also provide end to end support for hard acceleration features of IE 9.

More support for Out Of Browser Application:

With Silverlight 4.0 Microsoft has announced new features called out of browser application and it has amazed lots of developer because now possibilities are unlimited with it. Now in Silverlight 5.0 Out Of Browser application will have ability to Create Manage child windows just like windows forms or WPF Application. So you can fill power of desktop application with your out of browser application.

Testing Support with Visual Studio 2010:

Microsoft is going to add automated UI Testing support with Visual Studio 2010 with Silverlight 5.0. So now we can test UI of Silverlight much faster.

Better Support for RIA Services:

RIA Services allows us to create N-tier application with Silverlight via creating proxy classes on client and server both side. Now it will more features like complex type support, Custom type support for MVVM(Model View View Model) pattern.

WCF Enhancements:

There are lots of enhancement with WCF but key enhancement will WSTrust support.

Text and Printing Support:

Silverlight 5.0 will support vector base graphics. It will also support multicolumn text flow and linked text containers. It will full open type support,Postscript vector enhancement.

Improved Power Enhancement:

This will prevent screensaver from activating while you are watching videos on Silverlight. Silverlight 5.0 is going add that smartness so it can determine while you are going to watch video and while you are not going watch videos.

Better support for graphics:

Silverlight 5.0 will provide in-depth support for 3D API. Now 3D rendering support is more enhancement in Silverlight and 3D graphics can be rendered easily.

You can find more details on following links and also don’t forgot to view Silverlight Firestarter keynote video of ScottGu.

http://www.silverlight.net/news/events/firestarter-labs/

http://blogs.msdn.com/b/katriend/archive/2010/12/06/silverlight-5-features-firestarter-keynote-and-sessions-resources.aspx

http://weblogs.asp.net/scottgu/archive/2010/12/02/announcing-silverlight-5.aspx

http://www.silverlight.net/news/events/firestarter/

http://www.microsoft.com/silverlight/future/

From http://jalpesh.blogspot.com/2010/12/microsoft-silverlight-50-features-for.html

Windows 7

Andries van der Meulen — Tue, 25 Aug 2009 09:03:13 GMT

I’ve been using Windows 7 Enterprise (RTM) for about a week now, and I must say, I really see the benefits of working with it. Although you might consider it “Windows Vista +”, I’m sure that there’s still plenty of new features I haven’t noticed yet.
But for the end user (like me) there are a couple of things that I’ve used now (whether it’s desired or not). Here is an overview of these features for those who are thinking about using this new OS.

Taskbar
For those who didn’t know yet, Microsoft changed the way the “start-bar” works. It’s now called Taskbar and it has combined the Quick-launch and the Active-programs part.
When you’re working with it the first time, you kinda get to used to it first. But after you’ve configured it, it’s working just fine. Although I sometimes miss a quick overview of all my open windows (especially explorer-screens), the preview mode you see when hovering over the group is pretty neat (Seeing all your Internet Explorer tabs in the taskbar). But I wonder if it is faster when switching between screens, because you first have to see the group, then selecting the window. On the other hand, your Taskbar is now much more organized.
If you want to read more about the new Windows 7 Taskbar you can view this blog post.
Docking
A feature I'm using frequently is the docking feature. This allows you to drag a window to the side or top of the screen where it will be resized to a specific portion of your screen. (you can also use the Windows-Button in combination with an Arrow-key)

Especially when trying to copy file’s between two explorer windows you can dock each to a side of the screen. Or when you’re writing a document where you will use different resources (other documents, internet browser, tooling, etc.).
This feature is something I’ve missed in previous versions and I’m very happy that this is implemented in Windows 7.
Window Transparency
When using Alt-Tab, hovering over a screen in the Taskbar or hovering over the Desktop button, the active windows become transparent.
Maybe this is not really useful, but more a “pretty” feature. Tough with alt-tab or the hovering in the Taskbar it comes in handy to let you focus on the particular window. Be aware when on large monitors, because when hovering quickly over different windows, all these fast changes can make you dizzy!
Desktop button
The desktop-button (or Windows-button in combination with D) is not really something new. But the change is they’ve now placed it in the right-bottom corner.

I used the “show desktop” function very often in the XP and Vista, but always with the shortcut, because finding the button with your mouse took too much time. Now they’ve changed this, and that’s a good thing. Just throwing the mouse to the corner is a lot easier.
The transparency kicks in when hovering above it, so you can see what's on your desktop. Now you can see the icons and (sidebar) gadgets. By the way; this is also what happens when using the Windows-button with the Spacebar. In Vista this showed the Sidebar. Now it makes all the active windows transparent.
Integrated fingerprint reader
As the Windows OS evolves, additional functionality becomes a standard part of the OS. This also applies the the fingerprint support.

Instead of using 3th party software, you now can use your reader directly with Windows. And I must say, It works quite well. It’s faster and more stable then what I used to have on Vista. Although I first had a little issue with the Ctrl+Alt+Del when logging-on which I explain next.
Ctrl+Alt+Del
When using your computer in a Domain like I do for my work, you have to use the Ctrl+Alt+Del for entering your username and password.
Although this isn’t really a problem, I did not have to do this when I used Vista. It's annoying in combination with the fingerprint reader. Because it’s not possible to scan when you haven’t pressed the Ctrl+Alt+Del yet (this also applies when locking your computer). And when you’re fingers are already on the keyboard, it’s just as easy to enter your password.
After a bit of research I found out that you can actually remove this extra action through Local Security Policy (run “secpol.msc”).
There you can find the option “Interactive logon: Do not require CTRL+ALT+DEL” in “Local Policies” > “Security Options” . When setting this to Enabled you’ll remove it.
Early adopters = Driver problems.
When you’re an early adopter, you will encounter the problem with missing or incompatible drivers. But just after installing I’ve encountered only 2 problems. Video-card drivers and the Card-reader drivers.

I were able to fix the Video-card drivers by installing the Vista-drivers and then using Windows Update because it could now identify the Video-card.
The Card-reader doesn’t have downloadable drivers, because in Vista it was installed automatically by the OS. It’s quite odd that now with Windows 7 it didn’t install by default.
Fortunately I don’t need the reader now, but I do hope that in time drivers will be made available by the manufacturer.

For the time I’ve worked with this new OS I think I made the right choice for switching to Windows 7. It certainly has benefits that I use. And with the driver problems… Well, I expect it’s just a matter of time. You can always try using the Vista-drivers.

Expression Blend not for Designers, but for Integrators

Andries van der Meulen — Wed, 01 Jul 2009 08:26:34 GMT

Last Friday I was at the SDN Event in Houten, where I followed several UX tracks, and spoke with the speakers afterwards. I was trying to find out how they worked with Designers and Developers and the technique’s Silverlight and WPF.

And almost everybody agreed (except Kevin McNeish for some reason) on how to let these two groups cooperate. You will need someone called an Integrator. Somebody who can merge the work of the designer with the work of the developer.

Expression Blend is not a tool for Designers. Maybe Microsoft would really like the idea that Designers would work with it, but you cannot really design in it.

You probably can educate your Designers to let them work in Blend, but personally I think that’s rather strange. Because with Microsoft’s Philosophy about “People Ready” and “User-centered design” where the application is adjusted to the person’s specific needs. This one doesn’t seem to fit in. It looks like they’ve created a new role within the development process.

So how do you need to work with a “Integrator”.

Well, it really depends on how much your designers are willing to “bend” towards the tasks of an Integrator. If they only make the design as pictures, then the Integrator must build the entire interface in XAML.

I also may be possible that a Designer (or someone else) can do the work of a Front-end developer, and build the interface architecture in Blend. The Integrator will then connect it to the work of the Developer.

With the interface architecture ready (build by either a Front-end developer or the Integrator), and you have “learned” Designers how to Style the different elements in the interface, then they can do this styling themselves right inside Blend. But you do need to teach them how to work with the different styling types, bindings, resources, etc.

Luckily most difficulties are with integrating the Design. Development on the other hand is a bit more straightforward and can be applied through patterns as MVVM. This article by Josh Smith in the February 2009 issue of the MSDN magazine explains how you can work with this.

Conclusion: When working with Silverlight or WPF, and have both Designers and Developers, make sure to get yourself an Integrator (or someone who can fill in that role). Having a naming-convention like I explained in this post will just not work in this scenario, because you cannot expect Designers to be able to build the entire interface in Blend themselves.

Designers & Developers within the ALM / TFS vision.

Andries van der Meulen — Tue, 02 Jun 2009 10:17:54 GMT

What Wikipedia says about ALM:

Application lifecycle management (ALM) is the marriage of business management to software engineering made possible by tools that facilitate and integrate requirements management, architecture, coding, testing, tracking, and release management.

Like most people know, Microsoft supports this with their Team Foundation system.

This is very cool and keeps getting better and better. And with the introduction of Blend 3 (The tool for creating interfaces & prototypes in WPF or Silverlight) Microsoft is extending this towards application design. And this progress is where I have a special interest in.

TFS supports different roles within their ALM vision. Project Managers, Testers, Architects, Developers, etc… There have been very much attention towards specializing the tooling towards the specific needs of the roles within ALM. And now they’ve added Blend to this.

I am currently spending a lot of time trying to integrate User Experience Design in this ALM vision, with primarily using Microsoft technology. And yet I still haven’t figured out how exactly Blend fits in the process. I mean, it’s a really great tool, and I do like to work with it, but when you look at how it must fit within your development process, it’s hard to tell where to place it.

I know for a fact that a lot of Designers aren’t really enthusiastic about it. Why is that? Because you can’t really design in it. Microsoft knows this and that’s why they created the Photoshop and Illustrator import in Blend 3. I also know that Developers try to avoid using Blend, because they like to prevent a tool that will alter their code, markups or projects.

So that means to me that there are only two roles possibly using Blend. Interaction Designers and/or Integrators. And now I am wondering if this is actually part a of ALM. And does it need to be a part of it. How do you work together as designers and developers. And how do you do this with TFS, using Blend.

I’ve seen some great ideas, but every project so far (including projects within Microsoft) does it their own way. There is no real thought on how to work together.

Maybe it’s time to refine all these technologies, patterns and project guidance's and set up a good way for letting the User Experience part collaborate within the Application Lifecycle Management.

I’ll get back on this.

Blend 3

Andries van der Meulen — Tue, 24 Mar 2009 10:17:49 GMT

Most people probably already know that Microsoft's MIX09 event took place last week. Because I am specialized in Microsoft development, this event has introduced a lot of interesting new stuff.

But because there are so many people already blogging about the new releases and new developments, that I think it is really not necessary for me to start writing about it. For those interested I have a little link-list here about some of this published information:

The most interested I’ve seen so far is the new release of Blend. In this version there will be a great support of prototyping. This goes by the name of sketch flow and a session-video about this can be watched here. This with (finally) the integrated support for Team System, will be a great way for quickly creating impressions of the application within the ALM vision.

For all the new features in Blend 3 I want to redirect you to the following posts:

For our Dutch readers, Martin Tirion of Microsoft Netherlands has got some nice highlights posts about the MIX event:

Meet Adaptive IT

Andries van der Meulen — Tue, 10 Mar 2009 11:26:58 GMT

For those here in the Netherlands, my company has given the opportunity for those interested to learn more about Adaptive IT. The event is on the 20th of April. Look for more information on the invitation that is displayed below (in Dutch). You can register yourself at the Inter Access Adaptive ICT page.

Alleen voor de échte Top Professionals en IT Architecten:

Op 20 april a.s. geeft Inter Access jou een kijkje in eigen keuken over haar visie rondom het thema Adaptive IT. Een visie die ondersteund wordt door onze partners Microsoft, VMware, HP en Compellent, die op deze avond ook aanwezig zullen zijn. En jij kunt erbij zijn!

Laat je op 20 april a.s. bijpraten over actuele ontwikkelingen op het gebied van Virtualisatie en Storage oplossingen en kom kennismaken met Inter Access! Tijdens deze avond zal op het gebied van Storage zowel door Inter Access als door Compellent en HP ingegaan worden op oplossingen voor disaster recovery, restore, high availability en uitwijk van netwerken en virtuele infrastructuren. Virtualisatie en cloud computing wordt uitgebreid toegelicht door Inter Access, Microsoft en VMware. Naast het interessante programma is er voldoende gelegenheid om kennis uit te wisselen tijdens de informele momenten, en te vernemen hoe wij onze visie vertalen naar interessant en uitdagend werk voor storage- en virtualisatie experts.

Het avondprogramma ziet er als volgt uit:

17.00 - 18.00 uur	Ontvangst incl. dinerbuffet
18.00 - 18.45 uur	Plenaire sessie Adaptive IT: “Aanpak maakt het verschil”. Efficiënt navigeren vereist een visie en Inter Access heeft die rond Adaptive IT. Een visie vertaalt in een concrete eigen aanpak, die leidt tot een Adaptive IT infrastructuur. Sprekers: Vincent van der Linden, Architect Technical Infrastructure, en Eric Groot, Management Consultant
18.45 - 19.15 uur	Pauze / marktplaats
19.15 - 19.55 uur	Storage: op voorhand schrijf je je in voor een van onderstaande workshops: “HP Storage, hét platform voor Adaptieve Infrastructuren”, door Clemens Esser, HP Storage Consultant “Innovatieve storage oplossingen met Compellent”, door Steven Dahlin, International Sales Manager Compellent
20.00 - 20.40 uur	Virtualisatie: op voorhand schrijf je je in voor één van onderstaande workshops: “Microsoft’s server virtualisatie platform en visie’” door Edie van den Berge, Partner Technology Specialist Small & Midmarket Solutions & Partners. “vSphere: The next generation Virtual Data Center OS”, door Willem van Engeland, Partner SE Netherlands VMware
20.45 - 21.30 uur	Gezellige borrel en bezoek van de marktplaats

Kom vrijblijvend met ons én onze partners kennismaken en meld je nu aan.
Je bent van harte welkom!

Met vriendelijke groet,
Inter Access B.V.

Arjan Fluks
Manager Infrastructure Technology Services