Focus on controls.  They will build controls for Silverlight and WPF.  Ship with source, unit tests and samples.  Delivery is through codeplex.  Controls are released into various quality bands.

Silverlight controls toolkit just released.

Charting controls had a lot of help from Dundas.

Charting controls work very nicely on ObservableCollection.  Chart Builder App is cool.

Check out the charting example for Contoso.

Demo some of all the controls is at:
charts: http://silverlight.net/samples/sl2/toolkitchartsamples/run/default.html
controls: http://silverlight.net/samples/sl2/toolkitcontrolsamples/run/default.html

 

This used to be Biztalk services. Good to see that it has evolved into something more useful.

There is a diagram of the Internet Service Bus.  Need to get this.  Cant find it easy online.

Naming

• DNS has some practical constraints: latency, pollution, hosts not services, limited write
• Service Bus Naming System: r/w with access control, updates instantly, endpoints not machines
• Global naming structure: scheme://solution.servicebus.windows.net/name/...

Service Registry

• For service endpoints, not a general directory
• solution in name is a root of a hierarchy of feeds
• Looks like this also has an rss feed; nice!
• Interfaces by WCF ServiceRegistrySettings class
• Publishing is done with rest requests to access control, create WCF endpoint, then an Atom feed describing the endpoint (through an endpoint), and then publish.  Again, nice!
• For the CTP, these are ephemeral.  You need to recreate them all the time.  Will be sticky later.
  

Messaging

• WCF is the primary programming model (but you can do Java too)
• All kinds of bindings
• Supports, SOAP 1.1, 1.2, all WS-*, SSL, RM, Streaming, Full extensibility model, WebGet/WebInvoke, Metadata exchange
• Not supported: atomic transaction flow, protocol level transport authentication, webscripting behavior, direct tcp modes with RM of WS-* Sec.
  

Notes on bindings:

• NetOnewayRelayBinding is the most used.  Requires outbound port 828, although there are workarounds.  Routes from client to server one way through the fabric.  Just showed a nice demo of a laptop connect just on t-mobile edge receiving messages from a client on the local wifi; very nice.
• NetEventRelayBinding.  Similar to oneway, but allows two receivers.  Topic based model, eventing with multi-cast.
• NetTcpRelayBinding: should use for everything.  Highest throughput.  Introduces an intermediary.  Basically, this uses the bus to find the other node, and then direct connections between nodes are established through the relay.
  
• Hybrid mode of the previous.  Direct connect without relay, even with firewalls.  Predication algorithms used to determine which ports will next be open on NATs.  This is pretty cool as it will move between relayed and direct.
• WS|Basic|Web|HttpRelayBinding: Uses Http instead of sockets.  Connections are pooled.

Some links:

• http://msdn.microsoft.com/en-us/library/bb906065.aspx
• http://vasters.com/clemensv/PermaLink,guid,92d78bee-2cfd-4a29-95ab-c5abb9b905e7.aspx
• http://www.microsoft.com/azure/servicebus.mspx

Some pictures I found:

Boy, this was a waste of time.  Should have stayed in bed.  That is everyone else's opinion too as everyone is leaving early, like me.  It's a couple of guys from MSR rambling on things that no one cares about.  I'm out and over to the big hall.

• Cloud services have specific design considerations:  Always on, distributed state, large scale, and failure handling.
• Azure is an OS for the cloud: scale out, dynamic and on demand
• Azure manages services not just servers: tell is what you want and it will help automate the details
• Frees developers from many platform issues: allows concentrating on logic instead of platform

This session will show us how this is done.

Characteristics of cloud computing

• Scale out not up
• Add and remove capacity on demand
• Pay for what you use as you go
• Automation is key to reducing costs

Design coniderations

• Failure of any node is expected: each node is a cache and must be replicated
• No one-time install step: apps need to reinitialize on restarts, don't assume previous local state is available
• Configuration changes to due to load or failures: handle dynamic configuration changes
• Services are always running: rolling up grades/downgrades; must handle data schema changes
• Services are build on multiple nodes / roles: document service architecture and communications paths
• Services can grow very large: careful state management at scale is needed

benefits of adhering to a windows Azure design point

• Azure manages services not just severs: tell it what you want and it automates; system manges nodes, services and network
• Automates sevice live-cycle management: MDA, allocation deployment snd SLA
• Turns pool of physical resources into a shared fabric: pay for what you use; platform insures isolation

Azure Service Lifecycls

• Coding and modeling
• Provisioning
• Deployment
• Maintain goal state

Service Model Guides Automation

• Describes service as distributed entities: authored by service developer, and configured by service developer
• Logical description of the services: same model used for testing and prod, mapped to hardware at deployment time
• Powerful declarative composition language

Azure Service Model Elements

• Service
• Role
• Group
• Endpoint
• Channel
• Interface
• Configuration settings
  

Fault Domains

• Purpose: avoid single points of failure
• Unit of failure: ex: compute node, rack of machines
• System considers fault domains when allocating service roles: ex: dont put all roles in the same rack
• Service owner assigns number required by each role: ex: 10 front-ends across 2 fault domains

Update Domains

• ensure service stays up while updating
• unit of software/configuration update: ex: set of nodes to update
• Used when rolling forward or backward
• Developer assigns # required by each role

Dynamic Configuration Settings

• Purpose is to communicate settings to service roles; there is no registry for services
• Application configuraiton settings; declared by the developer; set by deployer
• System configuration settings: pre-declared, sample kinds for all roles (instance it, fault domain id, update domain id); assigned by the system
• Both cases, available at run-time via callbacks when values change

Azure Automation

• Fabric controller: maps declarative service specs to available resources; manages service life cycle starting from the bare metal; maintains system helth and SLA
• What's special about it?: MDA

Azure Push-Button Deployment

1. Allocate nodes, across fault domains, update domains
2. Place OS and role images on nodes
3. Configure settings
4. Start Roles
5. Configure load balancers
6. Maintain desiered # of roles: failed roles automaticall restarted; node failure results in new nodes automatically allocated

Managing running services

• Adding capacity: push-button; steps repeated to the running service
• Removing: pb, steps reversed
• Rolling service upgrades: pb, iterative\

Rapid reliable software provisioning

• image based multicast deployment (scalable and reliable)
  
• seperate OS and service images: images copid, not installed; same images used for physical machines and vms
  
• multiple images are cached

Monitoring and Events

• Log collection
• Alerts
• Usage metering
• Data available through portal

Service Isolation and Security

• Yours are isolated from other services: model is boundary of isolation; local node resources is temp storage; network end-points
• Isoolation using multiple mechanisms
• Automatic application of windows security patches (rolling OS image upgrades)

Axure is Highly Available

• Netowrk has redudancy: switches, lb, access routers
• Services deployed across fault domains (lb's route to active nodes only)
• Fabric controller state checkpointed:can roll back to previous chekpoints

Azure automates

• Provisioning and monitoring of hardware
• Hardware life cycle mmt
• Capacity planning
• Internal security measures

Roadmap

• PDC: automated service dployment; subset of service model - simple set of service template; can change # of isntances; simple upgrades / downgrades; automated service failure and recovery; hardware mgmt; managed code / asp.net; run in fixed-size VM instances; external virtual IP address per service; service network isolation enforcement
  
• 2009: expose more of underlying service model, native code; multiple data centers
  

REST and ADO.NET interfaces
First need to create a storage account

• gives you a 256-bit secret key
• Will provide security for accessing the store

Abstractions

• Blobs (names files and metadata)
• Tables (structured set of entities)
• Queues
  

Concepts

• Storage account
• Container
• Blobs

Sharing policies is at the container level

Notes on Blob access:

• 50GB total blob storage limit for now.
• Put/Get/Delete API. 
• 64MB limit per blob in CTP with PutBlob.  larger must use PutBlock. 
• Block is up to 4MB.
• Can associate metadata with the blob: name value pairs, 8KB limit per blob
• Uploads can be resumed: blobs broken in to chunks.  PutBlock, PubBlockList API's. 
• Blocks not use will be GC'd. 
• GetBLockList can be retrieved for a blob. 
• MD5 can be put in the REST PutBlock and the storage system will use it.
• Not a real directory structure, but delimiters can be specified that simulate it.
• Update, Append and Copy coming in the future.

Notes on Tables:

• Massively scalable and durable (replicated at least 3 times)
• Can be accessed by ado.net 3.5 sp1
• Table is created in and scoped by account
• Table is a set of entities
• Entity is a set of properties
• Partition Key is exposed in the programming model, and helps to assist with scalability. 
  
• Partition gives entity locality (stored together - better query), and scalability (usage patterns monitored and used for load balancing)
• partition key should be used in query to optimize, otherwise all partitions must be examined.
• Entity can have up to 255 properties, including Partition Key, Row Key, and one system maintained version property
• No fixed schema
• Pertition Key and Row key string up to 64KB
• Table Entities access view ADO.NET DS, LINQ, and REST
• Insert/Update/Delete, query over tables
• Tables represented as class objects, adorn with DataServiceKey attribute
• Every account has a master table called "Tables"
• Use a DataServiceContext object to get entry point to the storage account
• LINQ works just like you expect
• Optimistic concurrency checking
• Not a relational database: no joins, foreign keys, etc
• For now, results are sorted by partitionkey and rowkey.  seconday indexes in the future
• Also, single entity transactions for now, future will be multiple entities

Notes on Queues:

• Provides reliable delivery of messages between workers and roles
• No limit on # of messages, but they can only live for a week
• Message <= 8KB.  Larger store a blob and reference it in a message
• Create/Clear/Delete, Inspect length of queue
• Messages: enqueue, dequeue, delete

Notes on durability, avail, scale

• Data replicated at least 3 times across different fault and upgrade domains in the same data center
• Geo-diversity will be after the CTP
• Efficient filover
• Automatic load balance hot data
• Monitor usage patterns fro optimization
• Caching of hot blobs, entities and queues
  

• Synch data is the heart of mesh and it works great.
• Works great with silverlight
• Mesh and Silverlight is a great rapid development platform.
• With care you can cross compile.
• Much can be done without any work: User mgmt, authentication, invites, contacts, permissions.

Storage Hierarchy is based upon

• MeshObjects, DataFeeds, DataEntries and Enclosures
• MeshObjects are the top
• MeshObjects can contain 1 or more DataFeeds
• DataEntries: smallest storage units
• Enclosures: used when chunks of data get too big

Storing Data In The Mesh: Evolved from flat serialization or db storage to mergeable storage schema using DataEntries

Yesterday was back end, today is front end.

Windows 7 will be for bridging the latest hardware to the customers.  It will always be updated.

Showing enhancements to the taskbar in windows 7.  Things look really much more well done. Change order of things in the taskbar.  Can manage window state from each composited window image on the task bar.

Explorer now lets you mount various different drives and stuff into a single view.  Basically, there is a library setup.

New sharing options that connect you to all home systems and printers automatically.

Search allows searching on other computers, and you can "mount" results on other systems and access them as local.


Automatic switching between default printers when roaming.

Gadgets can be anywhere on the desktop.

New options for selecting backgrounds.

Explicit control of what is in the system tray.  You can rearrange them too.

Action center centralizes all taskbar menus.

Touch is being integrated.  Example, the HP TouchSmart.  there is support for gestures (forward and back shown).

Windows Live Essentials / Windows Live Services: sharing across many transport and devices.

Roaming seems to be around "home groups".  Wifi will figure it out.

Developing for 7.  Libraries, multi-touch, ink, speech, directx, jump lists, ribbon user interface.


Fundamentals
Decrease: Memory (referense set, graphics), Disk I/O (registry reads, indexer), Power (dvd playback, panel, timers)
Increase: Speed (Fast boot, device ready), Responsiveness (start menu, taskbar), Scale (256 processors)

Bitlocker on memory sticks
Can use VHDs!

can boot from windows 7 vhd.

Win-P can be used to manage multi monitor and external.

Multi-monitor in RDP.

Win 7 beta early 2009.

I'll put pictures up during the day.

New windows explorer.  Notice how the "folders" view now looks a lot more like that on the Mac.  Very nice, and about time.

Desktop gadgets:


Working with other devices:


Messages center.  Note that you can tell taskbar items not to show popups and only in here:


This is an example of selecting a background.  When selecting, the windows in from will become translucent so that you can see what it looks like:


Selecting a desktop:


Installed devices:


Touch:

Approach
- Flexible with Internet Scale
- Based on Internet Standards
- Extend your Existing Investments

There is a statement that there are Java, Perl and Pyhton SDKs in the box.

Identify and Access Control
- Leverage existing identity; don't force people to resubscribe if a backend system already has the info.
- Can use windows live id, "geneva", connectors.
- Geneva redirects user to corporate page that authenticates on back end AD service.
- Use Microsoft Services Connector

New mesh technologies will be introduced tomorrow.  Demonstration right now showing using liveID and mesh.  Showing redirect to live ID, where it asks the user for permission to give personal data to the caller.  More to be said tomorrow.

Service Bus.  Showing how to access it.  This is the same as the previous session on Dublin.  Looks like WCF programming.  The bus provides secure communications across partners.  Referred it to as the Internet Service Bus.

Workflow has been extended with Cloud Activities. They are showing the admin of workflow in the cloud service.  Really cool.  Deploy and run.

Showing how to build REST requests to SQL Server data, as well as access from Excel.

Three primary trends:

1. Declarative
2. Dynamic
3. Concurrent

Trend is towards multi-paradigm programming languages.

Declarative means what, not how.

Need to define languages to build multiple items of work that can be automatically parallelized.

Major theme in C# 4.0 is Dynamic Programming.
- This is meant to be anything that are not .NET classes.
-- Dynamically types objects
-- Optional and named parameters
-- Improved COM Interop
-- Co and contra-variance

Dynamic Language Runtime
- Expression Trees
- Dynamic Dispatch
- Call site Caching

Below the DLR are binders for:
- .NET
- Sivlerlight
- Python
- Ruby
- Office

Right now there is a different bridge to different dynamic languages.
With C# 4.0, you use dynamic instead of var or a type.  Ex:

dynamic calc = GetCalculator();
calc.Add(10, 30);

calc can be Ruby, C#, Python, ...

Add compile time it is dynamic. 
Memver selection deferred to run-time.
Actual types are substituted for dynamic
static result type of operation is dynamic.

This is interesting as the dynamic keyword lets you use dynamic objects in a static way.

This is all done by implementing from DynamicObject, which supports IDynamicObject.

Note that you do not get Intellisense on variables declared dynamic, which makes sense.

There is native support for DuckTyping.

You can now do optional parameters in C# just like in C++ (YEAH!!!!!!!!!!)

Named arguments use : syntax, and must be last items on the list.  Note that optional, named parameters may have side effects.

Don't have to specify "missing" by ref for com objects!

Past 4.0, there will be support for modern metaprogramming.  Compiler will be evolved to be a service.  This will allow support of:
- Meta-programming
- Read-Eval-Print loop
- DSL Embedding
- Language Object Model

Dublin is an extension of IIS/WAS/Server to host WF and WCF applications.  Dublin will automatically host and persist workflows.

Architectural Pattern for cloud apps

Cloud App: Your App, Event Handler (Publisher), WCF Service (updates)

.NET Services
-Service Bus
--Messaging Fabric
--Access Control Service (subscribes to app extension ISV hosted, which updates back)
--App extension in the cloud, similar.  Both run workflow / dublin

Now showing a demo of Sharpoint fronted by Infopath, creating new items to lists, which automatically run workflows that call the bus.  Vendors then update data from those requests, and new data shows up in sharepoint.

This was a hookup on a sharepoint workflow activation event.  It then sent a message to the service bus through publish interface.  Create a channel, bind to address, add behavior.

Now showing a monitoring application that subscribes to all events and keeps a list of all activities.  This can be used for reporting and SLAs.

The access control service can be utilized to define security rules.

Notes. 

• Sharepoint 2007 uses WF 3.0.
• You must always authenticate with the bus.  Uses an endpoint behavior.  Can use various means like cardspace, certificats or UI.
• New NetEventRelayBinding, gives pubsub behavior.
• Multicast is done if multiple people listen on the same binding.
• Client sets up a listening WCF service that uses NetTcpRelayBinding, when vendor replies go back to.