Architecture + Strategy : .NET

Architect Council | Pragmatic Patterns for Architects

dachou — Wed, 27 May 2009 06:03:43 GMT

“Cloud computing will supersede traditional IT”, “SOA will enable business agility”, “my way or the highway”, etc. We’ve all heard this type of proclamations before, as many look to the “next big things” in technology to exact sweeping changes and solve many issues; truth is, technologies and tools aren’t as instrumental in influencing progress, as the design and discipline in applying them to specific issues. When used appropriately, technologies and tools can be powerful enablers that bring about change.

To address this, and trying to be a bit more green, our team is hosting a series of live webcasts at noon PST on June 9th – 11th, 2009, which will focus on guidance and patterns for some of today’s hottest topics. Just another excuse to have lunch at your desk (if your time zone is nearby)! :)

Patterns for Moving to the Cloud – June 9
Larry Clarkin & Wade Wegner

Building Silverlight & WPF Applications with Prism – June 10
David Hill

Patterns for Parallel Computing – June 11
David Chou

For more details and registration, please visit http://blogs.msdn.com/sac/pages/council-2009q2.aspx

Free WPF Training in Los Angeles on 4/24-25 and Phoenix on 6/26-27

dachou — Sat, 04 Apr 2009 02:14:42 GMT

Overview

This two day training is designed to teach developers how to create Line of Business (LOB) applications using Windows Presentation Foundation (WPF).

Day One is an introduction to the WPF graphics subsystem, the tools used to build WPF applications, and the core UI services: styling, data binding, templating, layout and input-
The second day begins with interop (Windows Forms and Win32) and then quickly dives into LOB topics, including building applications using the Model-View-ViewModel pattern, creating unit testable applications, implementing data validation, and error handling.
After completion, attendees will have a solid understanding of WPF, its advantages over other Microsoft UI platforms, and how to use the M-V-VM pattern to create great WPF LOB applications.

Dates, Locations, and Logistics

Los Angeles, CA | 4/24-25 | To register: www.msregistration.com/wpflobLA

Phoenix, AZ | 6/26-27 | To register: www.msregistration.com/wpflobAZ

Registration tips:
If you are not a partner or don't know if you are:
When asked "are you registered" select No. Select "Visiting partner" under Partner Level.
Get creative on the Partner Type; if in doubt, we are all "System builders"
Note that registration links with * are not active today (4/2). Sorry for inconvenience, they will all be active in next few days. We blogged all at once to avoid people flying from say St. Louis to LA when they could have driven to Chicago. We wanted you to know what was coming.

Format

Instructor-led training from 9 AM to 5:30 PM. 15 minute breaks every couple hours. 45 minutes lunch around mid-day.
Food: Breakfast, lunch and afternoon snacks are provided.

Cost

The training is FREE! You do need to register prior to the event, but there is no cost. You can register for one or two days. Registration is first-come-first serve, sign-up as early as possible to reserve your spot!

Agenda

Day One:

Lap Around WPF
WPF Tools ( Blend, Visual Studio 2008)
Graphics Subsystem
Layout
WPF Fundamentals and new concepts
- Application Model
- Dependency Properties
- Trees (logical & visual)
- Events
- Threading
- Resources
Controls
Styling
Templating
Q&A with instructors at end of day

Day Two:

WPF integration with Win32 and Windows Forms
Data binding
Introduction to Model-View-ViewModel
Commanding in M-V-VM
Views, Navigation and Transitions
Data Validation
Error handling, Model dialogs, Logging
Unit Testing
MVVM & LOB tips and tricks
Q&A with the instructors

About the instructors
Karl Shifflett is a software architect, former Microsoft MVP, current Code Project MVP and MCAD from Bellevue, Washington. He is currently working for Microsoft on the Cider Team as a Program Manager II. He has been designing & developing business applications since 1989 and transitioned to .NET in March of 2003. In April of 2007 he joined the list of WPF and Microsoft Expression fanatics & evangelists. He is a member of Team Mole that delivered Mole Visualizer For Visual Studio to the world. He is the author to XAML Power Toys and loves WPF LOB. Karl’s Blog: http://karlshifflett.wordpress.com/

Jaime Rodriguez is a Senior Technical Evangelist at Microsoft. He focuses on WPF and Silverlight. For the last four years, he has helped a lot of enterprises and ISVs adopt WPF in large scale, mission critical, projects.
Jaime has been doing software development for fifteen years. Prior to Microsoft, he worked at Xerox, HP, Cerner and GeoAccess. He joined Microsoft 9 years ago, he spent the first four years as an Enterprise Architect Consultant in Microsoft Services, and the last five he has been a client evangelist covering Windows Forms, WPF and Silverlight. Jaime’s blog is at http://blogs.msdn.com/jaimer.

Event – XamlFest on January 14 & 15, 2009 at Irvine, California

dachou — Tue, 06 Jan 2009 20:04:29 GMT

Are you interested about WPF (Windows Presentation Foundation) but concerned about the learning curve? Have you seen Silverlight but don’t know where to get started? Or are you curious about how tools like Visual Studio and Expression Blend help designers and developers work together to deliver great user experiences? If so, join us at XamlFest!

XamlFest is a two day interactive event where you’ll learn about the platforms the tools and processes used to deliver differentiated user experiences. It’s a chance for you to mingle with UX minded Microsoft folks as well as industry leading design integrators. It’s also an opportunity to pick up a free copy of Visual Studio 2008 and Expression Studio 2 for you attendance.

More details are available at http://blogs.msdn.com/usisvde/archive/2009/01/05/you-re-invited-to-xamlfest-socal-january-14-15.aspx

.NET and Multiple Inheritance

dachou — Fri, 18 Apr 2008 01:29:20 GMT

Occasionally I get questions on why does .NET not support multiple inheritance. It is actually a pretty interesting question to contemplate with, though I usually start the conversation by asking: "what issue requires multiple inheritance to solve?".

More often than not, the question surfaces when people are trying to "do the right thing" by correctly refactoring code in an object-oriented manner, and facilitate code reuse by using inheritance, but encounter challenges when trying to reuse methods and code behaviors defined in separate places of the class hierarchy. Thus the most "natural" question was, if I can just inherit the code from these classes...

Many decisions in language design, just like software projects, are balancing acts between various trade-offs. There are many very interesting conversations happening in the community, such as the debate on generics and closures on the Java side (for example: How Does Language Impact Framework Design? and Will Closures Make Java Less Verbose? and James Gosling's Closures). Interesting to see how much thought goes into each seemingly small decision on adding specific language features, or not adding them.

There were many factors that influenced the .NET team to favor not implementing multiple inheritance. A few of the more prominent ones include:

.NET was designed to support multiple languages, but not all languages can effectively support multiple inheritance. Or technically they could, but the complexities added in language semantics would make some of those languages more difficult to use (and less similar to their roots, like VB, and for backward compatibility reasons) and not worth the trade-off of being able to reuse code in the manner of multiple inheritance
It would also make cross-language library interoperability (via CLS compliance) less of a reality than it is today, which is one of the most compelling features of .NET. There are over 50 languages supported on .NET in over 70 implementations today
The most visible factor is language semantics complexity. In C++ we needed to add explicit language features in order to address ambiguities (such as the classic diamond problem) caused by multiple inheritance, such as the "virtual" keyword to support virtual inheritance to help the compiler resolve inheritance paths (and we had to use it correctly too)
As we know code is written 20% of the time, but read 80% of the time. Thus advocates on simplicity side prefer not to add language features for the sake of keeping semantics simple. In comparison C# code is significantly simpler to read than C++ code, and arguably easier to write

Now Java doesn't support multiple inheritance as well, though probably for a different set of reasons. Thus it is not a case of simple oversight in design or lack of maturity, as it was a careful and deliberate decision to not support multiple inheritance in the .NET and Java platforms.

So what's the solution? Often people are directed to using interfaces, but interfaces don’t lend themselves very well to meet the requirements of reusing code and implementing separation of concern; as interfaces are really intended to support polymorphism and loosely-coupled/contractual design. But other than trying to tie behaviors into object inheritance hierarchies, there are many alternative approaches that can be evaluated to meet those requirements. For example, adopting relevant design patterns like Visitor, frameworks like MVC, delegates, mixins (interfaces combined with AOP), etc.

Bottom line is, there are considerably elegant alternatives to inheriting/deriving behavior in class hierarchies, when trying to facilitate code reuse with proper re-factoring. Plus trade-offs in code reuse vs. the costs incurred to manage the reuse is another full topic in itself. In some cases it may have been simpler to have multiple inheritance and access to sealed classes, but the trade-offs may have been greater costs in other areas.

PDC08!

dachou — Fri, 07 Dec 2007 01:00:05 GMT

I’m excited to let you know that Microsoft will hold the next Professional Developers Conference (PDC) October 27-30, 2008 at the Los Angeles Convention Center. More information on registration will be available shortly. For now, please save the date!

The PDC is the definitive Microsoft event for software developers and architects. PDC participants will have the opportunity to hear from executives about the latest platform advancements, and engage in in-depth discussions around upcoming technologies and the future direction of the Microsoft platform.

I will to share more information with you as the event gets closer. Please also check out the PDC Website -- http://msdn.microsoft.com/pdc2008 -- for updates.

I hope you will be able to join us at the PDC!

Microsoft releasing the source code for the .NET Framework libraries

dachou — Thu, 04 Oct 2007 09:28:59 GMT

ANNOUNCEMENT - 2007.10.03:

Microsoft is releasing the source code for .NET Framework libraries under the Microsoft Reference License. This license allows viewing of source code, but not modification or redistribution. The source code will be downloadable and viewable by anyone who accepts the license agreement.
Microsoft will introduce a capability in Visual Studio 2008 to allow .NET developers who are debugging applications, to debug not only into their own source code, but also into .NET Framework source code using Visual Studio.
This release falls under Microsoft’s Shared Source Initiative, which encompasses a spectrum of source code offerings, complementing the company’s other activities around sharing source code. This is another example of Microsoft’s continued commitment to increasing transparency and addressing developer needs.

My thoughts:

This is truly a step in the right direction for Microsoft, and an especially good thing for the .NET developers community. When I work on the Java side I enjoy having access to all the source codes to the various editions (standard, enterprise, mobile, etc.). It provides us developers better insight into the behaviors of our code when needed, and in many cases, the source code provide really good code samples on how certain tasks can be accomplished.

Now this is Shared Source (not open-source), meaning we have access to the source code for reference purposes (and thus the "Reference License") but we cannot modify and rebuild the code. Of course, we still have the opportunity to contribute suggested changes to the source code (via the product feedback process), but for the majority of developers building solutions on top of the .NET Framework, being able to step through the source code and debug applications with full transparency can significantly improve productivity.

More information: