Well, I haven't blogged for a day and a half, but not because I haven't wanted to. 

 

Attended a Parallel computing session with .NET 4.0. - All code samples, and most of it beyond my comprehension. Well, not really, but it was pretty detailed stuff.  In a nutshell, threads are being replaced with tasks, and there's some pretty cool language extensions.  Only one task/thread can communicate with the UI, and yada yada yada.  Thought it would be interesting, and the beginning was, but when the speaker went into cancelling tasks, and signalling between tasks, it got really dense....  Or I did...

 

Another one was a personal favorite of mine, DotNetNuke with Windows Live Services.  Windows Live Services is a very compelling reason to get involved with Azure, because Microsoft has done a lot of work at all levels (high level, medium, and low coding level) to make Instant Messenger functionality available anywhere and on any web page.  This is the future folks, and I beleive nearly every website will eventually include these social features like "who's on-line" and "let's chat". Again, nearly all code samples so not much to blog about..

 

Went to a Linq session.  Boris and I agreed, it was pretty simplistic, but failry good explanations of var's, anonymous delegates, anonymous initialization, lambda's, and Linq's deferred execution, and ordered execution.  Lot's of "gotcha's" with Linq, and if you understand Linq already, the big takeaway, is to almost ALWAYS take linq's output and do a ToList() or ToArray(), or some other methoud of output transformation, otherwise, you'll the framework will doing A LOT OF WORK that probably doesn't need to be repeated.  I'm probably going to do a few lunch and learns on this.  It's real simple stuff, and people seem interested...  Boris and I agree, the "coolness" is everything BUT the Linq syntax... Go figure...

 

Went to a few agile sessions, nothing new, just a takeaway that Visual Studio Team System has A LOT of unit testing, source code control, and work event tracking that works real well together.  It's a hard sell to my company to "dump" (I think the politically correct word is "adopt") the current starteam/subversion/mbunit/swat/jira stuff for just a VSTS solution around Team Foundation Server.  All I can say, is, it is possible and it's VERY agile.  They showed a very cool dashboard of the contiuous build, who last broke it, the burn down charts, performance measurements, code coverage stats, and unit test stat's.  This is what we should have on all of our Monitors in the hallways and teamrooms...  All of it was driven from VSTS.  Ah well....

 

Went to a cool AT&T after party where they gave every team a phone with a web app that directed the team on a scavenger hunt through the city.  The phone had GPS, and song recognition capabilities, as well as taking pictures and video's.  It was all cool because it was a high-tech scavenger hunt, and people were googling, recognizing songs, and doing videos everywhere.  Yes, extremely dooky, but fun way to play with technology and explore the city.

 

Let's see what's coming next at teched...

 

TechEd 2009 - Using LAAAM (Lightweight Architectural Alternative Assessment Method) to make good architectural decisions, fast!

 

Architecture - represents the set of earliest design decisions

                        hardest to change

                        most critical to get right

 

Quality - no universal measurement, communicating with the business is key

 

Quality manifests in the architecture

 

LAAAAM inspired by Architecture Tradeoff Analysis Method from SEI

            Process is flexible and adaptable, lightweight and you don't need to lock all stakeholders in a room until decisions are made.

            rebranded Quality-Oriented Decision Assessment

 

There is a web tool/application that helps you by putting in the decisions, scenarios, building the quality tree, performing the mathematical rankings and the score.  Looks really cool, by a Company called VistaPrint

 

This Application helps you build the following

Process

            Build a quality tree

            Rank each node

            Determine alternatives

            Access each scenario (alternative)

            Let the tool do some math

            Consider (think hard) about the results

Flexibility at each step, as well as the order

Consider what's most important - quality

 

Quality Tree

            Seed with commonly-important quality attributes

            Unrelated to the alternatives being considered <- independent of the architectural choices

            "Leaves" of the tree are scenarios (like Performance, Maintainability, Scability,all the *ilities)

                        the scenarios need to be precise by providing Context, Stimulus, and Response

                        Example, "Under normal operation, perform a transfer trasnaction, in under 100 ms"

                        Example, "For a new release, integrate a new component implementation, within 2 days"

                        Example, "System Network is partitioned and restored, complete DB resync, in 30 minutes"

Produces a "hierarchy of goodness"

 

Can't have everything, so need to set Ranking - everything can't be top priority

Since ranking scenarios is too hard, you rank the nodes in the quality tree

 

Rankings produce a weight for each scenario

            Use rank order centroids or a liniear distributon, or even manually

 

Evaluating

            For each scenatio/alternative pair, evaluate

            Keep it simple, like, poor, fair, adequate, good, excellent (can be turned into numeric as well)

            Don't go by order of tree (that's cheating)

            End result is an Assessment Matrix

           

            Scenario           Weight              Alternative 1      Alternative 2      Alternative X

                1                  (from q-tree)      Poor (0)                        Good (2)          

                2                                                                                          Excellent(4)

                x

            Totals

                                                Usually, the highest number(s) will be part of

 

The Final Assessment

            Sensitivity Analysys

            Persistent value in the artifacts

 

Caveats

            Cost is hard, generally broght in as  a prefilter to alternatives considered, or as a postfilter to the "winning alternatives"

            We are reasoning about potential, not promise - Since this is architectural, you could always mess up implementation, even with the right architectural decisions

 

 

Tech Ed Keynote

 

Bill Veghte? was the speaker

 

Announced release of SQL Server 2008 Release 2 (CTP availble) and Microsoft Office 2010 (Preview available July 2009)

 

Windows 7 RC is available; it’s stable enough for logo and compatibility testing

Demo’ed a little bit of the enhancements of Windows 7 – Highlights include improved remote connectivity “BranchCache” and mobile connectivity, claimed performance and reliability improvements, and improvements in using the hyperthreading capability of intel processors.

 

New features include reorganizing the taskbar icons on-the-fly, and the ability to open specific documents right from the start bar (Think that Excel, IE and Word allow multiple open docs, now the taskbar lets you easily pick the one you want to open). Windows “snap” to sizes without having to manually resize them.  Integration w/WS 2008 R2 provides easier VPN usage and branch cache capability.  Think “off-line” connectivity.  For example, corporate intranets and assets are pre-loaded and cached for quicker remote usage. 

 

Windows Search has been expanded from just local and internet to include sharepoint, corporate, email sources, etc.  Sort of like google desktop from my perspective, but expanded to the corporate network.

 

For USB sticks and external memory devices, bitlocker can be policy driven from a Windows 7 OS to force encoding and password policies of data to/from the external memory devices.  Plugging in a memory stick will automatically activate and prompt the user to set/enter a password if needed, and automatically encrypt data to/from the external memory device.

 

Windows 7 now includes a new “problem steps recorder”, which is sort of a macro recorder where if you run into a problem, you can record the steps you did to encounter the problem.  The recorder will generate a zip file that includes comments and screen shots of all the steps you did to get to the problem,  You can email or send that zip file.  It was a cool tool that people can use to demonstrate problems or you need to show someone how to do something, such as read email or navigate somewhere.  Very simple, and the output was stunning, since it was just actual recorded screen shots, not an actual playback of the steps.

 

Lots of group policy demo for apps and IE8.  Let me know if anyone is interested in specifics…

Also, more virtual machine demos – such as running individual apps in a VM right from Start, using built in tools to read and create VHD files, etc.

 

Windows 7 is tracking to be released by holiday, which I presume is Christmas 2009…

 

Windows Server 2008 R2 demos – Pretty generic stuff IMO, moving VM’s from one machine to another, but live, Exchange 2010 demo, and a demo of Power Shell scripts searching (including OCR built into the OS when searching images and faxes) and moving files from one server to another.

 

The rest of the keynote was wrapped up pretty quickly, since the keynote seemed to drag at about 2+ hours…  Hopefully the next session will be a little more fast-paced…  This was interesting, but nothing like “woah!”, more just “hey, here is what’s coming”…

 

 

 For some reason, it feels like Tech Ed is starting late today.  Usually, I thougt the keynote was earlier, but today, the keynote starts at 10, and none of the conferences really start until after lunch.  I'll go down and catch breakfast, blog on the keynote and probably attend either the Windows Azure session, the Business Intelligence session, or the "What's new with ASP.NET 4.0 and VS 2010 session", which does sound the most fun.  Feel free to look up the sessions on www.teched.com, and recommend/comment on sessions you'd like me to participate in...

Well, the three sessions I attended toay were all coding samples and tons of Q&A.  It was hard to take notes as I was trying to follow along.  The only session I made A POINT of taking good notes was Oslo.  The topic was very abstract, but they tied it into the same old tired "How do we get data into SQL Server" problem, only this time, they created a model, then used a parsing tool to translate plain english into the model, then used the Oslo platform to read the data into the DB (from the text file of p"plain english".  Here's some Oslo notes and jsut a summary of the rest of the day...

 

A Lap around “Oslo”

What is a model?

A description of a given domain. (Drawing, model assised, model driven)  Gives transperncy, flexibility and productivity

Oslo is the platform for model-driven applications

M –the language for authoring models and DSL’s

Quadrant – the tool for interacting with models and DSLs

Repository – database for storing and sharing models

Run-times can execute against the models, or leverage Oslo to create models for your app – (think using Oslo to produce our Process.xml’s)

Oslo SDK is available from MSDN.

Example – (Follow this, in the end you’ve actually created your own Domain Specific Language.

module Microsoft.Samples

{

                type MusicItem

                {

                                Id : Integer64 = AutoNumber();

Album : Text;

                                Artist : Text;

                                Rating : Integer32 where value <=3;

                }

                MusicLibrary : MusicItem*;

}

They shows a tool that was creating code and schema simultaneously as you were typing the code above.  This included the creation of the table in a database, etc.  Then a different command line utility was run to compile the code to an OPC package that can be used to add to a repository.  Once it is in the repository, it can be accessed as a datasource.  They used Excel to attach to SQL Server and drilled into the repository to ”automatically” produced a spreadsheet where you can add and edit musicitems.  Just to demonstrate the modeling language defining a schema, putting it into a repository and then using that model to create functionality.

M doesn’t have to be used, XML and XSD’s are perfectly acceptable to be added to the repositorys.  The M language can automatically generate TSQL (Inserts/Updates/etc) for SQL if required, and as your typing M Code you can see the SQL being generated for you.  The backend doesn’t have to be a SQL DB, but can be any “backend”.

OSLO can be used to create a custom DSL to parse human friendly code to transform sentences into syntax that can be used to drive data.  For example, just typie this:

“Four” by “Led Zepplin” is awesome.

MGrammer is the tool in Intellipad (parts of the Oslo SDK) that generates code that you can use to map to the MusicItem.  It actually generates parsing code for you.  In the example above, “Four” was mapped to Album, and awesome was mapped to a rating.  So in the end, you can rifle through a text file and automatically insert records into a database.  You can parse anything to add data to your backend.  Cool way of abstracting stuff to actually create your own language.  All this was just using M, a specialized text editor, and a bunch of command-line utilities.

Quadrant is a modeling tool that’s more visual.  Quadrant itself is built on models and all the models available in Quadrant are available for reuse.  Quadrant is a UI tool for model driven access.  Other people (non-developers) can utilize quadrant to create their own models.

 ---------------

The other sessions were around using Windows Azure (or Microsoft's new cloud services).  One session was .NET Live Services, where they wrote a simple c# program to iterate local running processes and display or kill them.  Then, with a few wrapper functions, they changed very little and was able to use it to iterate and delete folders "in the cloud", as well as another example of publishing a website "into" Windows Azure.  I've signed up for a free "Azure" account.  They flexibility is pretty cool.  You can use Azure to host your entire app, which is pretty standard stuff.  Or you can use Azure to host .SQL Services, which is pretty much like it sounds.  Using Azure as a database ackend.  Or you can use Azure to host storage, which is pretty analgous to a filesystem in a cloud.  Or you can use Azure's Live Services, which is using Azure of identity management, identification and profile storage (which is not only .Live accounts but now conforms to the "standard" OpenID protocol too).  They have the standard (or new depending on how you look at it) presence and instant messenger stuff, but technically, this isn't part of Azure, it just has the ability to use Azure's .Live Services (which is mostly identity and storage).  The interesting stuff (at least for me), is Azure can host your web app, and your web services used can still be hosted "locally" or you can host your web app, and still host some or all services in Azure.  Sounds like standard hosting stuff, but Azure is being branded as best of breed with auto sync/replicate/load services across the world, sort of like a true mesh environment.  Plus they have a whole bunch of services (Office, OS Platform, SQL) stuff that you can use in the cloud or "federate" your local stuff so that other things can access it.  Another session I went to demonstrated "Live Mesh", which showed a lot of replication and sync stuff to take advantage of multiple clients using and sharing resources at the same time.  Oh, well.  Onto tomorrow...

 

Keynote – Day 3

The keynote today was more than 3 hours, and simply overwhelming.  I was so stunned, I couldn’t even take notes while I was watching.  Later, I’ll review the video and powerpoint presentation to share it on the blog.  The amount of demos were overwhelming – here’s a few I can recall…

They demoed Windows 7- My boss is right.  Vista is dead.  This OS is very cool, and fixes almost everything wrong with Vista as well as adds a ton of new stuff. Home networking was cool.  Searching is actually usable, remote desktops with multi-screen, UAC control, taskbar improvements, and I never even mentioned IE8.

They demod VS 2010 extensibility – very cool stuff and think “Silverlight and VS mixed” – The amount you can customize is amazing.  The VS2010 editor itself is now built on WPF, so the possibilities are unimagainable.  Wait to you see some demos.  Night and day difference between VS2005/VS2008 and VS2010.  I never figured out how much diff VS2005 is from VS2008.  With VS 2010 it will be painfully obvious.

Demoed Lots of Multi-touch demos – pretty cool.  Autocad with multitouch was cool.  Tesco’s grocery app was mind-blowing, what was shown looked so far out and futuristic but its all available now.  It was amazing.  Think ordering groceries using a touch screen, combined with delivery, pick up, calendar and social networking, all for novices and it was just so cool.

Demoed Live Mesh for collaboration, showing live video and displaying people’s interest while they were watching.  Think “Running Man” but with today’s UI’s.  Killer stuff.

Demod sharing photos between devices was cool.  Combined with touch, they were dragging photos between the desktop, social networking sites and mobile devices in a way that reminded me of Tom Cruises’ movie

Demoed Windows Live federated services, finally an easy way to access SSO, include messenging features on our website, share calendars.  The demo stunk, but the ability to do it easy is very cool.

Demoed Office Web apps, and how it integrated with Windows Live sites.  Boring to me, but the audience liked it.

Over all, this was one of the best keynote sessions I've ever seen.  It definitely got my psyched on Windows 7, VS 2010, and finally some cool stuff for Live Mesh and Windows Azure (Windows cloud everything mumbo jumbo).

ASP.NET MVC

 

These are just random notes.  At the bottom it may be more interesting.  I'll try and do a lunh and learn to tie it all together.  It's getting ahrder to blog when my head is getting more full of all this stuff....

What is Web 2.0? (some common characteristics)

www.stackoverflow.com is a typical example that shows a lot of Web2.0 common characteristics

Lot’s o AJAX, lots of user interactivity, nice clean URL’s, OpenID identification, etc.

Not a lot of current Web 2.0 sites uses ASP.NET.  ASP.NET MVC enables a lot of the above features easily.

What is ASP.NET MVC?

A new Web Application Project Type

Not a replacement for Webforms, but builds on top of ASP.NET

Good Analogy: Manual vs Automatic , where MVC gives you more control but requires a little more work

MVC was developed using Agile wih a small development team, 94% code coverage, 1051 unit tests, daily triage meetings and weekly design meetings (no check ins unless there is code coverage tests), not former Scrum, but Scrum but… (Scrum but not this, Scrum but we do this instead)

MVC is a design pattern, came out of Small Talk community in 1974!  Separation of Concerns - separating Model from View from the Controller. Each component only has one responsibility, easier to test in isolation, and helps with concurrent development (data model, view, and controller can all be developed simultaneously)

 

Step 1 – Incoming request is directed to a controller (a class),

Step 2 - forms a data Model, to

Step 3 - hand off to a View

Step 4 - View transforms to a presentation

The new project type will also optionally create unit tests projects and automatically hook them up to the project.  Can use 3^rd party test providers like xunit, mbunit, nunit, and Visual Studio Unit Test.

The Controllers are simple classes.  The Views are ASPX pages.

The default project adds into Global.asax.cs code that registers new routings and figures out what controller to route a URL to.

www.domainname.com/controllername/action is the standard MVC URL – calls controllername class with the action.

The controller will eventually return a view result (aspx page).  By convention, the view name matches the controller name, but could be overridden if needed.

 

Goals

Testability, Tight control over markup, Search Engine Optimization/User friendly URL’s, still leverages ASP.NET like webforms and membership providers.  Data access and providers are an open book.

Project template provides lots of guidelines and best practices.

Demo:

 

They made a demo that used the entity framework to generate an object model directly from a database, and code could be written against the model directly.  This became the Model for the data of the demo app. 

The demo demonstrated that the entry point into the controller is the Index() method.

The controller get data from the Model class, passed it into the view.

Then the demo showed changing the view markup (just a regular aspx page) to display the data from the passed in model.  It was really easy to do, and isn’t really that different of a paradigm as I first thought.  The markup created a listitem that iterated through the object collection and displayed the data.  Really cool example of the concept of “Seperation of Concerns” and made visualizing the View, Model, and Controller pretty easy.  I’ll probably do a lunch and learn on this as well.  It’s just too easy.  “Creating your first ASP.NET 4.0 MVC App from scratch”.  Sounds cool to me.

Once you display data, you view may contain links to other controls and actions to enable the functionality of your website.  URL’s aren’t hardcoded, but  uses helper routines like HTML.ActionLink(Controller, Action);  You go on and on creating controllers, models and views which can all be shared, a controller can call any number of views, and several controllers can use the same view.  It’s all VERY testable, but currently doesn’t leverage the existing declarative ASP.NET controls.  Right now, MVC has a more limited set of controls that can be used, but will eventually encompass all the controls you can use in “standard” asp.net projects.  Values are passed around as objects between controllers, so you never deal with form values or http requests or context objects.  Again, VERY testable, which is one of the main intents of the MVC pattern.  There’s a lot of Ajax that can be used, but since views are simply calling other controllers, you pretty much never “care” whether you are posting to separate pages, or using AJAX.  JQuery was used in the demo to add a little “flash”.

The rest of the session pretty much showed more advance uses of MVC, and a neat trick for wrapping “packaged” controlsin a way that can be used in the MVC framework pretty easy.  Stay tuned for more…

Either I am getting tired, or this session was much more boring than I anticipated.  Maybe both...

ASP.NET 4.0 Roadmap

Scott Hunter – Microsoft

Released so far: ASP.NET 3.5 SP1 Beta, MVC Preview, Asp.NET controls for Silverlight

www.codeplex.com/aspnet www.asp.net

Coming in VS10, DynamicData (Linq to SQL), Ajax (histories), MVC – Codeplex will have interim releases, they say “cutting edge”, we say “pre-beta”, also includes source code drops, thoughts, priorities

Some of the 4.0 preview stuff for asp.net is up on the codeplex site.  This includes new DynamicData, Ajax and MVC, new stuff went up today.

Visual Studio 10 can target 2.0, 3.0, 3.5 and 4.0 .net platforms. .NET 4.0 should be HIGHLY compatible with 3.5, but you still have to recompile and target your source to the appropriate framework. (This is painfully obvious, but they made it a point anyways.)

ASP.Net 4.0 will strongly support web standards, CSS< Ajax, etc.  Supports pattern based development like MVC and TDD.

4.0 features:

More control over Client ID’s – avoiding bloating and mangling the client id’s of controls (gets rid of x123_formname_controlname control id’s)

Controls can automatically render and/or use CSS – will support non html-based tables in the editor.

Includes URL routing (using friendly URL’s in place of www.domain.com/pagex.aspx?this=1&that=2 can be renamed to user friendly URL)

View-state can be enabled/disabled on specific controls, including enabling a child control but disabling a parent control.  Also, can indicate all off and specify controls that are on, or all on, and off for specific controls.

Ajax innovation: RIA, javascipt developer support, and page developer (non-programmer) support, and jQuery including intellisense.  jQuery will be included in the 4.0 asp.net framework and is available today with the intellisense.

More Ajax controls, and formally supported as part of the ASP.Net framework, not as a separate toolkit.  Improving script libraries for better performance.

They showed a demo using VS10 dropping Ajax controls calling a web service on an ordinary HTML page.  The html page included javascript from the dropped control that included localization and a selectable list that included pictures, text, formatting and a summary detail.  What made this significant is that the AJAX control was just dropped on the HTML page, nearly all the code was generated, and all of it ran on the ciient-side, no server generated code (other than of course, the called webservice).  It used jQuery and was pretty impressive for a straight HTML page with no server-side coding and no “required” javascript programming from the developer.

New ASP.NET MVC will support ajax controls, dnamic data (CRUD) and declarative controls all from the dev environment.

Showed MVC/AJAX/JSON/Jquery demo.  The source code showed a really clean jscript interface into Microsoft’s AJAX routines, and JSON parsing is already all included.

Lots of other demos showing new bindings and dynamic data stuff.  Couldn’t really relate, we’ll see when I download some of the demos… 

What was weird about this session is that everything that will be "built into" 4.0 is available for 3.5 from codeplex.  Also, they showed lots of databinding and AJax.  A little MVC was shown, but now I see LOTS of options to get to the same results. "Classic asp.net, MVC asp.net, AJax, Jquery, Dynamic Data, Silverlight" wow.  There are too many choices for showing data on a web page.  I suppose each one has its strengths and weaknesses, but how much do you have to know about each one to figure it out? The drag and drop is cool, but we'd have to wrap it for standardization and consistency anyways.  The new databinding and Linq asp.net object was cool, but again, how many different ways are we going to bind data to a web form.  Smarter people than me will have to pick one and I'll follow.  I can pick one, of course, but the pros and cons of each one and how it best applies to our business, as well as time to delivery, robustness, performance, longevitity of technology is overwhelming, and it's still too easy to "pick what you know" rather than risk investing in a cool new technology that may go nowhere.  Microsoft has a lot of balls in the air right now, and not all of them are going to be in the mix.  JQuery and MVC are cool and work well together, but require a massive investment in education and reengineering.  Are they worth it?  Longevity hits me hard, because I'd hate to invest in delivering production ready implementations and then find out Dynamic Data and Linq woulda done the same thing and proved more popular.  Of course, they all work together, but how much do I have to learn to display a page, get data from a server and then display it? Ouch!  I think I am just getting tired and bleary eyed.  On to the next session...

 

Please refer to previous post on Keynote for background, otherwise, you won't understand anything here...

Introduction to Windows Azure (formally Introduction to Cloud Services)

What is a cloud?

Developers can install and run services, and retrieve data

Using the cloud has advantages in that we don’t have to worry about hardware resources and maintenance (OS, patches, storage, traffic) – Service Glue and Operations are taken care of by the cloud rather than a typical datacenter usage.

Windows Azure Cloud services give you this as well as OS hardware abstraction that you typically have automatically with desktop applications.

 

Azure is a platform to run services that you can develop locally and deploy to the “cloud”.  It includes services as well as monitoring (Automated Service Management).

There is a Cloud Storage Service

Has blobs, file streams, tables, caches, etc.

. – it is not a database service

The rest of this particular session was almost a rehash of the keynote.  I’m downloading the azure bits, and signing up for “free” azure subscription (which still seems to be a lot like hosting, but with included services like sql, exchange, sso, etc.).  Not much more interesting than that, as later sessions will go into more detail.

Keynote Notes for PDC

Keynote Speaker – Ray Ozzie

Pitch for why to develop using Microsoft platforms

The industry is transforming inexorably to services. Combine the best of software with the best of services.  Ray explained how cloud computing and the growth of internal applications to external applications is driving the need for cloud computing.

Introduced new service from Microsoft called “Windows Azure”

-          Lowest level foundation for building high scale services

-          Windows for the cloud.

-          Service based operating system platform

-          Open cloud environment for developers

-          Requires new patterns and practices for horizontal scale and modeling techniques

-          Released as a Community Technology Preview

-          First U.S., then globally

-          Scalability, Availability, Security, Redundancy

-          Azure Services Platform

o   Live Services – extends services to other (mobile) through sync

o   .NET Services

o   SQL Services

o   Sharepoint Services

o   Dynamics CRM Services

-           

Bluehoo was developed as a social application built on top of Azure

Red Prarie demoed supply chain application(s) connecting with partners of Azure

Bob Muglia demoed System Center monitoring performance of servers using Azure services

Dave Tomas introduces Microsoft Online Services, (Exchange Server and Clients, Office, Sharepoint, all enterprise software packages will be offered as on-line services)

Microsoft is providing early bits and “free” azure services to all attendees for beta testing and feedback.  Looking forward to trying it out.

First day at PDC – Sunday – Registration and a pre-Conference Session (a 6 hour session!)

“Creating Rich Applications with Silverlight” –

Let me say right away, Yes, I believe Silverlight “could” replace our Web front end for v10.1. Should we?  That’s hard to say.  Probably not. 

In my opinion, it is at least compatible (if not more) with IE 5.5 and higher, Firefox, Safari and Opera (and Mac and Linux) as much as our current HTML/ASP.NET/AJAX web front end for v10.1.  We’ve invested a lot of time, money, resources and customer stake in our current “new” platform.  If management is interested in pursuing this “new” technology at all, we should probably take baby steps, and introduce it slowly.  See how market acceptance is, as well as longevity.  I think HTML/AJAX (and even the current ASP.NET model) is fairly “old”, but it’s proven and not going to disappear ever.  I can’t say the same about the longevity of Silverlight right now.  Our best opportunity for actually using this is probably working with Product Strategy (your PO’s) for some small functionality that could take advantage of the strengths of Silverlight.  Then work with Product Development Management for getting approval to use the technology to deliver the functionality.  Who will step up first?

Anyway, the 6 hour session was extremely informative and taught me a lot about Silverlight.  Most significantly, how to actually get into it and start using it.  Basically, other than the obvious flash/macromedia plug-in alternative, for us .NET developers, it’s best to think of Silverlight as a .NET platform that uses WPF and runs in the sandbox of a browser.  I am hoping to give a lunch and learn to show everyone how to create their first Silverlight app from scratch.  I mean, from scratch, showing the tools you need, developing the app, and deploying it.  Won’t cover nearly anything in detail, but at least you’ll be able to now exactly what Silverlight is and how to start using it.

So if your still reading and want some actual highlights of the Silverlight pre-conference, here you go.  To develop Silverlight 2 applications you need VS2008 SP1, Expression Blend SP1, and the “Silverlight Tools for VS2008” add-in.  You’ll need to get an education on XAML, but using Expression Blend to create your UI’s is a really good and easy head start.  The editor in VS2008 is mostly for those already fluent in XAML.  So if you are really serious about creating Silverlight Apps, Expression is probably a requirement.

You can create a new Silverlight 2 project type in VS2008.  It creates 2 projects, one the actual silverlight app, and the other a web project test harness to actually host, run and debug the app.  A Silverlight app is deployed as a .XAP file  This is really just a zip file that holds a deployment/configuration XML and the assembly/resources required for the Silverlight App.  For the most part, this file is generated for you when you build your silverlight app, and created automatically in the web project.

A few notes.  Images with local references are by default embedded in the resources and downloaded as part of the .XAP file. Video and Audio are not embedded by default, but automatically streamed from the server.  Be careful embedding too many images into the app locally as your download file would get very big.  Downloads usually open happen once on installation or upgrade, but it’s still a really good idea to keep your initial .XAP file as small as possible.  Also, semi-obvious stuff like encode your video and images at the actual size to display rather than using silverlight to set the width and height greatly improves performance as well.

Silverlight apps are just WPF apps scaled down to run in the browser sandbox.  These are windows form apps, but with only a subset of the .NET framework available to you, as well as Silverlight media extensions.  WPF is VERY powerful and does all sorts of automatic tiling, scaling, animations, clippings, drawings, colorings and everything.  Silverlight just takes advantage of all this built-in display functionality.  You build a page, sort of like a winform, which is creating XAML behind the scenes.  Connect up events, just like you do in ASP.NET today, but there is no client/server like paradigm.  Everything is running locally on the client.  So the code and the presentation and the events are all local.  You have a drawing area (typically a layout control like a canvas, grid, panel, etc.) and put controls and media within the area.  Attach events, write code to the events in the code behind of the display and that’s about it.  There are lots of controls like button, checkbox,textbox,datagrid,calendar and mediaelements.  Some of these controls have properties called  “content” that can be entire XAML display areas themselves.  For example, the content of a button can be text, or another entire XAML UI, like a button within a button.  There are controls that can use resources like images or media files (video, audio, etc) and these run on any platform!  Because of this, Silverlight doesn’t currently use external codecs, but has a limited set of compatible media.  This includes a limited set of audio and video codecs.  It DOES NOT use Windows Media Player, again for compability across platforms and OS’s.

Some attributes/properties are actually objects them selves, so they can be written as new tags within the parent.  It’s really cool, and you need to see it to appreciate it.  Something like

<Button height=10 width=10 content=”Press me”/> OR you can write it this way:

<Button height=10 width=10>

<content>

                <Image src=”Flower.jpg” />

   </content>

</button>

XAML elements can use styles templates and control templates.  Using a combination of both let’s you control behavious and appearance of multiple controls very easily and efficiently.   If you have a button that you want to look and act a certain way, you can design a style and template so that when you create more or new buttons they can inherit those styles and behaviours and override pretty easy.  It’s much more powerful than CSS and all declarative (if desired) rather than writing code.  Oh the power of XAML.

Silverlight supports threading, but only 1 thread can update UI elements and access the XAML DOM.  All background threads must marshal to the UI thread through dispatcher or posting or sending on the UI thread context.  Its easier to do than explain, but it is a thread limitation you need to be aware of.  All the networking stack calls spawn a thread by default, and some return on a background thread and others on the UI thread, so you need to be aware of where you are before you update the UI.

Since Silverlight has no ADO.NET, datasets, or database access, it has a networking stack that you can use to make REST calls, open sockets, web call services, HTTP Requests, etc.  You can do the same as normal Visual Studio stuff and reference a web service WSDL, and Visual Studio will create a proxy for your Silverlight apps to call the service with little effort.  There are a lot of “gotcha’s” in security (no cross-domain or cross-protocol calls unless the server hosting the service allows it), but it’s all doable with effort.  The called service (even if it’s the same domain that hosts the silverlight app) needs a policy file, and can reuse the one required for macromedia apps, or has a Silverlight version for more fine tune control and permissions.  If you get your Silverlight App over HTTP, and need to make a webservice or REST call over HTTPS, you’ll need this policy file, because this is considered a cross-protocol call.

Silverlight also supports WCF-Duplex (HTTP protocol only) where the server can push information to the client – this is like a stock ticker update where Silverlight doesn’t poll, but the server pushes when data changes.  Silverlight technically does have a polling "listener”, but the programmer paradigm is that the Server is pushing data to the client, rather than Silverlight asking or polling for it.  As a side note, Silverlight does support LINQ, but your sources have to be information returned from services or embedded as code or resources.That about wraps up what was covered.  They built a demo of a Silverlight App that showed a video, clipped it into a circle, that rotated it while it was playing the video.  Then utilizing the mouse events and wheel, allowed the video to be scaled up and down and moved as needed, all while playing and rotating.  It’s all pretty cool. 

Yes, VS 2008 is shipping at the end of THIS YEAR.

 

It natively supports:

.NET 3.5, Atlas, VSTO (Office Development built in)

 

It can directly target older versions of the framework both at design, dev and deployment.  For example, if you target .NET 2.0, it will limit your intellisense to that version, and grey out menu items of the cool tools that don't work with that version of the framework.  Currently, it targets 2.0, 3.0 and 3.5.  Sorry no v1.1 framework support, as it is officially "dead" and "unsupported" at this year's tech ed.  Makes sense, as it's 5 years old now.

 

It has new "local caching" features built into the tool and language, so not only can you locally cache databases (they say "read only" data), the framework will automagically keep that data in sync with the backend, whenever the backend changes.  The tools to control the configuration and process are all built into the IDE, so essentially, they are adding a "sync data" API and toolkit to the IDE.

 

The new VSTO tools are pretty cool.  Out of the box, you can develop an outlook add-in, and when you hit compile/run it will automatically start outlook, run your new code/add-in and even break on your lines of code during the running of your add-in.  It even natively supports office ribbon add-ins, and excel/powerpoint/word add-ins in a way that is really integrated, and so easy, you practially just do "File/new" and the add-in is almost totally created for you.

 

They are pushing expression pretty heavily as a designer tool, rather than VS 2008.  Expression is the UI Designer's tool that produces output directly usable by VS 2008.  It's pretty cool, and I can't wait to attend some Expression classes.

 

Data is pretty heavy in this version with some new (stronger) Object relation modeling tools and designers for strongly-typed datasets.  The new tools allow you to put types in different assemblies but still allow you to establish relationships (like parent-child) between assemblies at a modeling level.  It's hard to describe, but when you start using VS 2008, you hardly know all the underlying technologies being utilized.  They have some new performance tools (identifyies bottlenecks).  It uses WPF natively (with integration with the old windows forms) so the UI now does pretty cool stuff.

 

Onto the next class!

renderinfo

Welcome to my first blog entry for the 2007 Tech Ed Conference!

 

I attended the keynote hosted by Microsoft's Bob M.

It was pretty high level, with the first 3rd saying businesses need to be "agile", with "no walls between business users, operations, infrastructure and apps dev", and "set up ongoing costs rather than attemting to pay for everything upfront".  In short, they recognized that trying to pay fro large projects upfront all at once is what drives the inability to be agile, and they are calling on corporations to attempt to adopt a new model.  Then they went into lots of benfits as of agile, how to get into it, blah blah.  But as long as a company tries to fund large pojects upfront with a fixed cost, you can't really be "agile" in the sense that it is very hard to implement change, and it's harder to deliver incremtal value and ROI.

 

Off the agile soapbox, the middle part of the keynote was some pretty cool Operations Manager enhancements and Windows Server 2008 Virtualization features.  Turning physical machines into VM's, and moving them around from Virtual Server to Virtual Server for application load balancing was very cool  Operations Manager now has plug ins where you can drill all the way down to a service (like a web service, but really any kind of service), troubleshoot, diagnose and fix problems, and even remotely restarting services.  All visually, with modeling interfaces and power user tools.  Not sure how easy it is to instrument our apps so that Ops Man can do all this cool stuf, but Engineering and Operations would love it, if the Apps Dev developers can do this.

 

The final part of the keynote was mostly the announcements of VS 2008 (shipping THIS YEAR), SQL 2008 (Shipping THIS YEAR), and WS 2008 (mostly shipping this year).  I'll attend other conferences on this stuff later, so other blogs will go into more details.

 

See you at the next posting!

renderinfo

I pretty much went over the new admin tools, and the new content management system for building a new site.  The session was mostly for Sharepoint Administrators, and not necessarily users (like PM's and team resources). 

• VS2005 has the concept of classes, files, projects and solutions.  TFS brings one more umbrella to the table: Team Projects.  A Team Project encapsulates Source Control, Work Items, Solutions and Projects into one integrated area.  As near as I can figure, either all of Apps Dev should work under a single Team Project, or at the most it should be divided by department.  All of the eCommerce projects should logically be under one team project.

 

• TFS will migrate and import Clearcase and Clearquest.  In fact, we could (long term not short term) completely map our CQ Defects, Requests and Enhancements to Work Items and automate the communication between the two.  Work Items (which is another way of saying a task, defect or request) have states and have other advantages to tracking in CQ.  Wait till class...

 

• Source Control in TFS is radically different from Source Safe and much closer to Clearcase.  There is no more "sharing" of files across projects, but there is linking.  So Microsoft's recommended approach is that in the Repository, create a branch of shared components, and have projects reference these directly.  This is by design.  Other interesting design choices are that checking out doesn't necessarily get the "latest" version.  Since the latest version of a file is usually related to a changeset (a group of files that were changed together), TFS assumes that if you haven't gotten the latest version of everything, you probably don't want the latest version of a single file.  It's an interesting design choice and we will see how it works out.  TFS PROMOTES branching and merging and makes it really easy.  I firmly believe our Maintenance release team will see IMMEDIATE gains using TFS.  TFS also makes it easy to code freeze and code chill (chilling is the concept of allowing people to check out files but not allow them to check in).  TFS also allows multiple checkout of files BY DEFAULT.  They are promoting no more exclusive access to files, and when you check them in, you would address any merge issues right there.  They have a lot of confidence in their new powerful merge functionality, and expect you to branch if parallel development is required.  One more new concept is "shelving".  If you are working on a file, but it's not ready to check in, rather than just leave it local if you have to stop working on it, you can "shelve" it in TFS.  No one else can get to it (except administrators), and if your PC blows up or you get hit by a train, you can just pull it off the shelf when you need it again.  For me, all of this together is a whole new way of thinking about source control and team sharing.

 

• TFS also makes it easy to automate builds, and heavily promotes build scenarios.  You can quickly and easily set up and manage nightly/weekly/daily/continuous builds as well as set up builds for regression testing and long-haul testing.  This combined with the new testing management system, you can enforce a certain level of testing when you check in files, and a certain level of testing for each type of build.  So with TFS, you can EASILY automate a continuous build and test cycle (for example when someone checks in files), a nightly build and test cycle, and a regression build and test cycle (for example when we are ready to move to System Test.  We do nearly all of this manually now, but TFS automates it and makes it much easier to setup and implement and enforce. 

 

• They have truly wild report capabilities now.  They pulled up one stock report that showed in a single graph bugs(work items) coming in, overlayed by bugs being worked on, overlayed by test scripts that passed and failed, overlayed by code coverage tests performed.  The speaker said some mumbo jumbo of how they can track developer productivity, feature creep, and quality of tests being performed.  I have never looked at software developer management this way, and it was truly amazing.  I feel like I live in the stone ages as far as managing developer productivity (like my own for instance).  The tools are all here and I can see now how Microsoft manages their software development.  For example they use TFS in their 900 developer team that produces Visual Studio.  This is a scale so far above any of our projects, it is just amazing.

 

• I already mentioned in a previous email that you can enforce policies on check in, like passing unit tests, associating a work item to the check in, and kicking off a type of build/test after check in.  The cool thing is that Microsoft built in the capability for a developer to always override policies and check in anyways.  There is an audit trail, the explanation given is that if you have developers that would abuse this feature, you probably have the wrong developers AND it's better to get the code in the system than to lose it completely if necessary.  I like their thinking, and with all this new process and tools, it's good to see that they are still keeping power in the developers hands...

• VS2003 compiles all code behind pages into a single assembly in the bin directory.
• VS2005 DOES NOT.  VS2005 dynamically and on-demand compiles aspx, ascx and code in special folders (like APP_CODE).  There is a "pre-compile" option for deployment that you can elect to do in the build scripts, but it's not the "VS2005 way".  Oh yeah, VS2005 creates multiple assemblies for a website, and since they are created dynamically, it's no longer a good idea for external assemblies or applications to link to the exposed methods of a website.  It's best to move that kind of stuff into it's own assembly.

 

• VS2003 requires a project file for a web application.
• VS2005 does not require a project file, but instead, natively uses the file system and a folder structure to identify a web site.  (Again, notice the purposeful use of web app and web site - two different paradigms, and VS2005 is using the new paradigm.)

 

[Side note:  I went to a Mobile 5.0 class for fun, got to see all the new devices and what the mobile platform can do now and where it's heading.  Got to see and play with new origami PC's (Ultra Mobile PC).  Here is Microsoft's mobile positioning:
Smart Phone - Mobile 5.0 - No Touch Screen
Pocket PC Phone - Mobile 5.0 - Touch Screen
Ultra Mobile PC - Windows XP - Touch Screen, no standard keyboard
Tablet PC - Windows XP - Touch screen and keyboard
Laptop

 

• Create and modify Sharepoint sites
  You can create web forms that output to data sources, and views (called Dataviews) that read from data sources.  Create custom lists and populate form controls with dynamic data.  It's all there and no coding necessary.
• It also has an extremely good CSS editor that shows inheritance and allows you to just highlight something on your form, it shows you what CSS style(s) is being applied and where you can add or change the CSS Style sheet. 
• You can create Master Pages, Webpages, Web Parts (encapsulated like controls) and workflows that can be used in VS2005 in separate Web projects.
• Create templates specifically designed to be used with the Content Management System built into Sharepoint
• Source Control Integration and Versioning built in - Even includes "cool stuff" like if you accidentally modify a theme element (like a stylesheet or masterpage), you can roll back to the original template.
• A very powerful workflow tool based on Windows Workflow Foundation (not WWF, but WF). 
  This looks and acts a lot like Outlook's Rules Wizard, with conditions and actions.  If we start using Windows new Workflow API in Visual Studio, this tool is a great place to start.  The workflow stuff has a lot of integration points, and a lot of functionality out of the box as well.  For example, we could add a workflow that would get initiated automatically after a status report is uploaded to our current project portal.  This workflow could route the status report (via outlook or anything else) to various reviewers and approvers as well as automatically email it to Stakeholders after final approval.  All this is possible without coding, but with the addition of Visual Studio, we could route it to webmethods or some other external source. 

   A little paragraph about Windows Workflow.  There are a lot of conferences here about Microsoft's new "workflow" functionality.  It's available now in release (not beta).  It will be part of .NET 3.0 (coming this year), Sharepoint 2007 and can be easily integrated into most of our projects.  We should seriously consider this platform as an alternative to Ultimus, Documentum  or Dialogue.  This is really powerful and easy to use stuff I saw and since we already use Sharepoint, it's coming whether we use it or not.