greg cowin

What might surprise you about Windows 8 store apps written in HTML5/JavaScript?

2013-03-03T19:46:00.000-06:00

The surprise: plain JavaScript source code can be viewed easily. The JavaScript codebase is available as one or more text files. No DLL. Just code sitting in the app directory. As shown previously, you can browse the Windows App directory and view assets for any store app.

36% of Windows Store apps are written using HTML5/JavaScript (WinJS). These apps are not just news reading apps, but more serious apps. One example is the Bank of America app.

Having worked on some other serious financial applications (www.bmwusa.com and a fully-automated trading system), I am certain that the Bank of America app is well analyzed and protected with extra security features across the service layer. Communication that crosses the service layer also crosses a security boundary. When a security boundary is crossed, you must assume that every call is a potentially intrusion attempt. A zone where real security comes into play. Here are some actions to take and decisions to make when writing service apps that I wrote for the Microsoft Developer Network (MSDN) back in 2011: http://www.pursuitofgreatdesign.com/2011/08/why-use-decision-framework.html. When security is paramount, you should consider taking multiple countermeasures for each threat so that if one of the countermeasures is compromised or misconfigured, others are still in place to protect against the threat.

As for the JavaScript files (codebase) in plain text files, you can take extra steps to strip comments, minimize, and obfuscate the code — likely a good idea. This is a common technique for JavaScript producers since their source code can be viewed online as it is downloaded to browsers to run. Even C#/C++ apps can be decompiled, but with JavaScript there is no need.

Whatever you decide, make sure that you protect the service boundary. The service protector pattern could also help. Another option: use a message processing layer that can immediately deny and log offending messages; that is, where each message is analyzed before it is allowed to pass through to application code. This way, every message is guaranteed to be analyzed.

Enjoy.

What percentage of Windows Store apps are written in HTML5/JavaScript?

2013-02-20T09:40:00.000-06:00

Windows 8 provides a new touch first experience for Store apps. You can write Windows Store apps using a common API (WinRT) with language projections (bindings) to C#, Visual Basic, C++, and JavaScript. XAML (Extensible Markup Language) is used to create not only Windows Store apps, but also Silverlight and WPF applications. There are differences between Windows Store apps, Silverlight, and WPF apps, but knowing one makes the others easy. JavaScript uses HTML5 markup and CSS3 to create fully native apps.

Here is the breakdown according to Robert Evans, Microsoft Technical Lead for Windows Store App Labs (Source):

59% XAML/.NET (C# and Visual Basic)
36% HTML/JavaScript
5% XAML/C++

During my inspection of apps, there seems to be even a higher percentage of XAML/.NET apps; however, I trust the submission numbers. Just the ones I tend to use are generally written in XAML/.NET.

You can inspect your installed apps, too. You can look behind the Windows 8 curtain.

Despite the numbers, in my view all of us could be writing TypeScript/JavaScript or some other variant someday soon. I always thought that it would be a dynamic language, but never thought it would be based on JavaScript.

Whatever you pick, enjoy it.

Update: These percentages are based on over 4000 apps that have come through the app labs. These are mostly consistent with the numbers that I have found through limited inspection. Here is how: http://www.pursuitofgreatdesign.com/2013/02/a-look-behind-curtain-of-windows-8.html

A look behind the Windows 8 curtain

2013-02-19T07:51:00.001-06:00

Windows 8 provides new kind of touch first apps available from the Windows Store. These Window Store apps use WinRT—the new windows runtime—not to be confused with Surface RT (the new ARM based tablet from Microsoft). WinRT provides language projections (bindings) for C#, Visual Basic, C++, and Javascript.

Loosely speaking, WinRT can be thought of as an object-oriented sandboxed secure replacement for Win32.

In my view, you will like Windows 8 Store apps even on a desktop or laptop. Give them a try. The Modern UI style that Windows 8 Store apps use can provide a better experience.

This quick look behind the curtain for Windows 8 Store apps answers these basic questions:

Where are the Windows Store apps located?
Where do the apps run?
Where do apps store your data?
Where is the WinRT?
Where do XAML apps get their style?

Where are the Windows Store apps located?

Windows Store apps are stored in the directory C:\Program Files\WindowsApps.

Each app will have its own subdirectory.

Now, you will not be able to open the directory without first changing the ownership of the directory, so I have included terse instructions at the bottom of this post: [How To] change permission on the WindowsApps directory.

Once you dig deeper into the WindowsApps directory, you will notice a directory for each app (and an additional one for updates).

Digging further, you will notice that the majority of apps are written with XAML/C# apps, not HTML5/Javascript.

As you will see, one of the disturbing things about HTML5/JavaScript apps is that you can read the JavaScript code. While you can decompile C# code as well, it is a bit more disturbing just to see the source sitting there. This is a good reason to obfuscate and minimize your Javascript before shipping. Most JavaScript developers are already used to this since the majority is delivered to web browsers.

Where do the apps run?

If the app was developed using HTML5/JavaScript, then it runs in a host process called WWAHost.exe. This host process runs Trident and Chakra engines along with the JavaScript projections to WinRT. You will have to view the command line parameters via ProcessExplorer or Task Manager to view the command line parameters to narrow down the app.

.NET Language C#, VB, and C++ are compiled into their own binary. MyApp.exe for example.

Where do apps store data?

There are three main types of app storage:

Local: Persistent data that exists only on the current device

Typical location: C:\Users\{username}\AppData\Local\Packages\{app_id}\LocalState

Roaming: Data that exists on all devices on which the user has installed the app. The current limit is 100K. The limit can be founding using the following WinRT call: ApplicationData.Current.RoamingQuotaLimit

Typical location: C:\Users\{username}\AppData\Local\Packages\{app_id}\RoamingState

Temporary: Data that could be removed by the system any time the app isn't running

Typical location: C:\Users\{username}\AppData\Local\Packages\{app_id}\TempState

Where is WinRT?

The API is specified in the following directory using but the code runs elsewhere winmd:

C:\Program Files (x86)\Windows Kits\8.0\References\CommonConfiguration\Neutral

The Windows Store apps (Metro) .NET profile can be found in the following directory:

C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETCore\v4.5\

Where do XAML apps get their style?

When styling your XAML apps, you will likely edit StandardStyles.xaml located in the Common directory of your app—by default. As you will notice, these styles reference other styles that do not seem to exist. You can find these referenced (default) styles in the following directory:

c:\Program Files (x86)\Windows Kits\8.0\Include\WinRT\Xaml\Design\themeresources.xaml". Generic.xaml

You can redefine the desired styles such as Font color from the default in your StandardStyles.xaml.

I find it useful to put them into corresponding sections called Standard Styles Overrides.

Sidebar: [How To] take ownership of the Windows App directory
In order to take ownership of the Windows App directory, you will have to be Administrator.

You might also first need to set the option to display hidden directories. Once you can see the directory, then select the "Windows App" folder and select Properties of the following directory: C:\Program Files\Windows Apps\.

Select the "Security Tab" from the Properties window and select advanced. Change the owner using the "Change" link. Give yourself ownership. You will have to be Administrator in order to do this.

Sorry for the terse description. If you need more help, you can search the web for how to take ownership of Windows directory.

I hope that this quick peek behind the Windows 8 curtain helps you understand how apps run, store data, and get their style.

Enjoy.

Security Alert: Disable UPnP on your router!

2013-02-04T09:16:00.000-06:00

You should disable UPnP (Universal Plug and Play) on your router.

In case you have not heard, there are about 81 million routers on the internet that can be completely compromised via exposed UPnP—likely including yours. There are known vulnerabilities in UPnP that have been exposed externally by most every router vendor (~1500 vendors). Since it was found to be exposed to 81 million routers combined with known UPnP vulnerabilities, these routers can be easily compromised giving complete control of your network to anyone able to address your router. This is a very serious and widespread security vulnerability!

The main thing that you need to do: make sure that UPnP is not available externally. It could be acceptable to have UPnP enabled internally only, if your router supports it. Xbox live, BitTorrent, Skype, and other apps can benefit or require having it enabled internally.

It all starts with UDP port 1900 (UPnP Simple Service Discovery Protocol).

More details...
Vulnerability Note VU#922681: http://www.kb.cert.org/vuls/id/922681
Security Now (#389: Great explanation): http://twit.tv/show/security-now/389
Computer World: http://blogs.computerworld.com/malware-and-vulnerabilities/21717/check-your-router-now-lex-luthor-does
HD Moore’s blog post (he found it): https://community.rapid7.com/community/infosec/blog/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play

Just wanted to help get the information out so you do not get pwned.

Fall in love with your work

2013-02-03T07:07:00.000-06:00

"Once you decide on your occupation, you must immerse yourself in it. You have to fall in love with your work. Never complain about your job. You must dedicate your life to mastering your skill. That is the secret to success and is the key to being regarded honorably."

"All I want to do is make better sushi. I do the same thing over and over, improving bit by bit. There is always a yearning to achieve more. I'll continue to climb trying to reach the top, but no one knows where the top is. Even at my age after decades of work, I don't think I have achieved perfection, but I feel ecstatic all day. I love making sushi."

Jiro Ono - Jiro Dreams of Sushi

Perhaps, love does lead to great design. Dreaming should be encouraged. Enjoy.

Linus Torvalds' code now in a Microsoft development product

2013-01-31T08:42:00.001-06:00

Announced yesterday, TFS (Team Foundation Server) now supports Git as an integrated TFS repository. Microsoft has chosen Git as their DVCS (Distributed Version Control System) solution instead of building their own. They have full-time employees contributing to libgit2. I am really happy to see the TFS team move in this direction. Git repositories seems to support the full ALM (Application Lifecycle Management) features of TFS.

Great interview/overview with Martin Woodward, TFS Program Manager, yesterday on .NET Rocks: http://www.dotnetrocks.com/default.aspx?showNum=842

The irony: Linus Torvalds' code is now in a Microsoft development product. Thanks Linus. I, like many, appreciate your work and cannot wait to see your reaction. Years ago, Linux was the only operating system that I ran--even on a laptop. Linus Torvalds is the chief architect of the Linux kernel and also founded the Git project.

More details:
http://blogs.msdn.com/b/bharry/archive/2013/01/30/git-init-vs.aspx

Git support is still in CTP at this point and will only run on Visual Studio 2012 Update 2 (also CTP).

Enjoy!

Top 10 reasons why TypeScript will be widely adopted

2012-10-05T08:07:00.001-05:00

TypeScript is a new programming language launched this week by Microsoft. TypeScript is an open source JavaScript superset that adds classes, interfaces, modules, and arrow lambdas to JavaScript.

With a computer science career (or any other for that matter), it pays to pick the right technology; the one that will ultimately prevail. We invest a lot of time and energy in learning a new technology—granted it is fun—but it helps to be on target. It is easier. Companies and projects benefit as well; the development velocity increases when you pick a good technology, the approach, and business processes are simpler. Training and architecture are inherently easier. No matter the size, these matter.

Here are, in my view, the top 10 Reasons why TypeScript will be widely adopted:

#10: Works well with existing projects
TypeScript can be easily be adopted by any project that uses JavaScript today.

#9: Uses structural interfaces
Structural interfaces are automatically implemented by any object/prototype that complies structurally. This means that you can define an interface for existing JavaScript library as long as the object/prototype complies structurally; that is, it has the same properties and functions. It is powerful and practical.

#8: Generates JavaScript
TypeScript is compiled into Javascript to ensure compatibility. This means that it can instantly run in just about any browser—just needs to be ECMA Script 3 compliant.

#7: Great tool support
Even though TypeScript is at 0.8, there is great tool support especially in Visual Studio. Also, text editor support for Sublime Text, EMACS, Vim. Visual Studio IntelliSense is amazingly good for the TypeScript plug-in and the compiler is built-in.

#6: Simplicity
TypeScript has a simple design. The TypeScript compiler is written in TypeScript—an example of computational reflection—a beautiful thing. The C# compiler will only be implemented in itself in the next version. The typescript compiler is less than 25k physical lines of code excluding test cases and harness. Check it out the code out for yourself at CodePlex.

#5: Open Source
Microsoft has open-sourced the implementation and libraries. This is still in the best interest of Microsoft—internally they have large JavaScript projects to support Office, web properties that they own such as MSN, Windows 8 apps, etc. The code is available at CodePlex under an Apache 2 License.

#4: Anders Hejlsberg is involved
Anders Hejlsberg is a prominent Microsoft Fellow who co-designed several popular and commercially successful programming languages and development tools. He was the original author of Turbo Pascal and the chief architect of Delphi. Anders is the lead architect of C# and core developer on TypeScript.

I have admired Anders’ work since his first product: Turbo Pascal. Turbo Pascal, an amazing compiler and IDE, was written single handedly by Anders and it ran in less than 64k of memory. It was also lightning (turbo) fast.

#3: TypeScript is a Javascript superset
TypeScript extends the JavaScript syntax. Any existing JavaScript program or library works with Typescript without a change. Existing frameworks such as JQuery and Node.js are full supported. In addition, type declarations are provided. You can also install via Node.js.

#2: Aligned with future JavaScript standards: ECMAScript 6
TypeScript is essentially an ECMAScript 6 bridge for us. Microsoft's aim is to get the class, interface, and module constructs added to the upcoming ECMA script 6 standard.

#1: Enables programming in the large
Introduces classes, interfaces, and modules—essential ingredients for programming in the large. JavaScript has often been criticized for not allowing programming in the large. In essence, moving us back. In my view, a great developer can produce good code in any language, but it is essential to have modules and other constructs to help with large teams.

Closing
Do not necessarily jump ship from .NET and start writing all your code in TypeScript. No doubt, we all have to write JavaScript from time-to-time and TypeScript can help improve the structure of it and increase its scale. Large scale JavaScript can be necessary for Windows 8 JavaScript/HTML apps.

This week, Scott Hanselman (@shanselman) tweeted, "he who is most likely to make declarative statements is most likely be to called a fool in retrospect." In my view, TypeScript will be widely adopted (or I am a fool). Tell me what you think?

Additional Resources
There are many ways to contribute to TypeScript: discuss the spec, write libraries, contribute to the CodePlex project, write code, submit bug reports, answer questions, learn it, provide feedback, and tell others.

TypeScript: http://www.typescriptlang.org/

Anders Hejlsberg introduction video: http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript

TypeScript Dart vs. TypeScript comparison by a Dart team member: http://www.reddit.com/r/programming/comments/10rkd9/welcome_to_typescript/c6g37xd

It is all about elegant code: simple yet powerful—the more the better; otherwise, much less is better. Enjoy.

Two reasons why you will like Windows 8 store apps even on your desktop and laptop

2012-09-24T07:39:00.000-05:00

For more than a year, I have been thankfully using a Windows 8 tablet that was given to attendees of build last year. Since then, I have been using the tablet as both a consumption and creation device—and even as a +95% replacement for my Moleskine notebook. Windows 8 preview editions have been very stable for me throughout the process including Visual Studio 11 (2012).

Two reasons why, in my view, you will even like to use Windows 8 store apps on your desktop and laptop:

1. Reduced Friction
Traditional window management tasks such as moving, sizing, restoring, minimizing, maximizing, and closing are excise. This excise creates friction in the user experience. It may seem small, but it takes work to even get to the point where you can accomplish a goal. Great interfaces get out of the way and window management, often times, gets right in the way.

2. Improved Focus
Multi-tasking is a fallacy. Many studies done including a recent one at MIT conclusively show that what we commonly consider to be multitasking actually occurs in a sequential, not simultaneous manner (Source). All of us, should focus on a single task at a time. People do fuse with their tools—cognitively at least; so, proper tooling can make a big difference in our behavior and productivity.

In my view, using Windows 8 store apps can help improve your focus by forcing you to focus on one or two apps at a time. This style will just help us create better apps to help people be more productive overall.

"But I need to monitor my email and switch quickly between applications," you say.

I agree. Sometimes there is no substitute for a multi-monitor multi-window environment; however, Windows 8 does enable a quick context switch without having to re-launch the Windows store app. Quickly spin through your cognitive context of 5 to 7 things and start new ones. With simple gestures, you can quickly switch between contexts, dock, or close an app. These simple gestures also work well with a track pad or mouse. If you had to re-launch the app every time that you did a context switch, that too would create friction and excise.

With the focus on the content and not the excise and chrome, the experience can be much better.

Conclusion
My belief is that you will enjoy Windows store apps even on a laptop and desktop. Now, as a developer, I spend a lot of time using the traditional desktop with Visual Studio and with many other apps.

This only the beginning—a 1.0—of a shift in using Windows without windows. Even with a multi-monitor desktop, I use Window Store apps often—and even trumps over some traditional desktop apps. One example, I prefer using the Windows store app tweeTRO over any other desktop or web Twitter client.

Imagine making the same gestures without touching the display or a mouse—in front of a TV, game console, or even desktop. I can imagine a day when we will develop code with our hands and bodies not just our fingers (do not worry: computational thinking is still required).

We will fuse with Windows 8 in many other ways beyond the keyboard and mouse.

In my view, the Modern UI style (formerly known as Metro) is great design. Windows 8 is certainly not perfect and granted not everyone will enjoy it as much as I do, but my belief is that sooner or later you will too.

Enjoy.

Top 3 WinRT .NET needs

2012-09-19T07:30:00.000-05:00

WinRT is the new Windows 8 runtime used to create Windows Store apps. WinRT provides language projections (bindings) for C#, Visual Basic, C++, and Javascript.

Loosely speaking, WinRT can be thought of as an object-oriented sandboxed secure replacement for Win32.

In my view, the top 3 WinRT .NET needs are as follows:

Update: Thanks to Jayson Go for pointing out that #1 now works. I am very happy for this feedback. However, each method must return Task<TResult>.

~~Need #1: Allow async in Interfaces~~
~~Interfaces are contracts that a class or struct can implement in its own way. Interfaces help separate the contract from the implementation. Interfaces provide a powerful mechanism that helps make~~ ~~dependency injection~~ easier (and some would argue even possible). Interfaces can also help to reduce dependencies in general. They also make Test Driven Development easier by enabling clients to bind to a contract—not a concrete implementation. This way, it is easier to introduce a test double.

~~C# 5.0 introduces two new powerful keywords (async and await) to help make~~ ~~asynchrony~~ easier. The problem: only a method can be modified with the async keyword. This includes anonymous methods, and lambda expressions. This does not include a method definition in an interface however. This is a problem because you will not be able to call an async method when expecting an interface type.

~~This is the #1 need, in my view, because interfaces are a key architectural mechanism when implementing services, repositories, facades, roles, partial views, etc.~~

~~If you are using Javascript, then this will not be a problem. Javascript uses promises to handle asynchrony.~~

~~Workarounds~~
~~Use inheritance with no interfaces.~~

~~Soft cast—not pretty.~~

~~Bridge pattern from the~~ ~~Gang of Four~~

Need #2: Mock testing framework
Mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A programmer typically creates a mock object to test the behavior of some other object, in much the same way (Source).

Currently, there are no mock testing frameworks such as RhinoMocks available for "Windows Store" app development.

The reason: there is no dynamic proxy generation due to a missing namespace in the "Windows Store" profile: System.Reflection.Emit.

Workarounds
Use other kinds of test doubles such as fakes and stubs instead; this has been my approach.

Microsoft Fakes, is a new framework that generates test code for interfaces instead of dynamically mocking them but in a mock like fashion. Microsoft Fakes is only available in Visual Studio 2012 Ultimate.

MoQRT like Microsoft Fakes in that it generates the test code for an interface instead of dynamically mocking them.

Need #3: ADO.NET and other APIs
The API for "Windows Store" apps is very tight and does not contain ADO.NET and Entity Framework. Mobile apps should also work when you are offline. Since WinRT is the future platform for Windows development, then there will be very sophisticated apps developed with WinRT. Sophisticated apps need sophisticated storage.

The WinRT profile is a significant subset of the full .NET 4.5 profile. In addition, many classes were moved into the Windows.* namespace (WinRT) which helps make them available to C++ and Javascript. This just creates an exercise in mapping the old to the new.

On the other hand, WinRT is tight. We are back to time where it is possible for the system to be understood by a single person.

Workarounds
Storage alternatives; these bits are even fresher than WinRT’s so be aware: http://winrtstoragehelper.codeplex.com/
http://winrtdatabase.codeplex.com/
http://siaqodb.com/
SQLite

Conclusion
Despite the needs, developing for Windows 8 still feels years beyond developing for iOS. Developing for iOS is like being back in 1995. Hey, the 90's were a blast, but it is time to move forward. Luckily, tooling is not a problem for Windows 8 development.

I have been developing with Visual Studio 11 (2012) and Windows 8 since I was given a prototype tablet about a year ago at Build by Microsoft. These needs have been on my mind since.

Please share any new frameworks or workarounds that you discover, and also the needs that are at the top of your list.

[Y2] in pursuit of great design

2012-08-01T09:16:00.003-05:00

In pursuit of great design started two years ago with a focus on software systems. From the start, my intent has been to share my pursuit of great design with my friends and colleagues.

No doubt great design takes focus and is, essentially, a battle against our common enemy: complexity.

So what is to come? There are two questions that will help drive the pursuit:

Does great software need to be intelligent or at least smart enough?
How do we produce great designs and products consistently?

The pursuit continues…

[Y1] chronologically

[Y2] chronologically
Why use a decision framework?

Who makes the best keyboard? 7 Reasons.

5 Perspectives why Build could be the best conference ever

What is the key to developing great mobile apps?

Does video playback flicker on your new Windows 8 Samsung 700t1a tablet that you got at Build a few weeks ago?

Why should you read "Steve Jobs" by Walter Isaacson?

Why is the next major paradigm shift in software design about to happen?

What do geeks do during the holidays?

5 Reasons to use the "Feature" pattern in your product

Why has Microsoft's Metro design language captured the essence of modern interface design? 5 key elements.

How to identify an under-abstracted design?

Enjoy!

How to identify an under-abstracted design?

2012-06-13T11:39:00.000-05:00

What is an under-abstracted design?
A design can be over-abstracted in some areas and under-abstracted in others. Just as over-abstracted designs can have too many abstractions and classes, under-abstracted designs have too few to handle interactions and satisfy requirements. Intuitively, it might seem that an under-abstracted design would be good, easy, and simple, but the real problem is that an under-abstracted design is difficult to understand, change, and maintain. Ironically, the result of under-abstracted design is high complexity and excessive amounts of code.

The good news is that is easy to identify and address these areas. Once addressed, your confidence and development velocity will increase; and more importantly, you will be able to satisfy new business needs.

What is the best indicator of an under-abstracted design?
In my view, high complexity is the best indicator. Not only will it help identify under-abstracted areas of your design, but real problem areas within your codebase.

A simple and long standing complexity metric is cyclomatic complexity. Cyclomatic complexity (or conditional complexity) is a software metric developed by Thomas J McCabe in 1976. Basically, it is a measure of the number of control flows with a method, function, or module. The metric is computed by counting the number of decision points + 1. For a more formal definition, check out McCabe’s original paper: A Complexity Measure.

With Visual Studio Pro and above, you can identify these areas within a couple of minutes even if you are not familiar with the codebase. To do this in Visual Studio, use the following menu item: Analyze->Calculate Code Metrics for Solution. Visual Studio 2012 allows you to export the metrics to excel so that you can more easily identify the methods that have the highest complexity.

How to evaluate risk by cyclomatic complexity?
There is a strong correlation between defect density and high cyclomatic complexity. Below is a risk evaluation for methods as defined by Software Engineering Institute (SEI):

Cyclomatic Complexity Risk Summary

1-10	Simple, low risk
11-20	Moderate complexity, medium risk
21-50	Complex, high risk
51+	Untestable (Very high risk)

Why is using cyclomatic complexity metric important?
In short, complicated methods and classes are tough to understand, difficult to test, challenging to debug, and usually require vast amounts of time and attention to maintain.

To understand code, it must be readable. The concept, although not the method, is somewhat similar to that of general text complexity measured by the Flesch-Kincaid Readability Test. Methods with lower cyclomatic complexity are much easier to test.

When modifying a method with 50+ cyclomatic complexity, chances are very strong that you will introduce at least one defect while either adding a new feature or fixing another defect.

Other good indicators…
Here are a few other indicators to help identify under-abstracted design:

Duplicate code
How to identify: In Visual Studio 2012, you can identify duplicate automatically using the following menu item: Analyze->Analyze Solution for Code Clones
No business, service, or data access layers
How to identify: All the code is in the User Interface layer represents a lack of “separation of concerns”; that is, where all of the business logic, security, data access is performed in the user interface layer. This indicator might be obvious to many, but is not followed even more. Even if your design has a clean separation of concerns, there can still be high cyclomatic complexity in the business and UI layers.
Too many methods and members per class (Large classes)
How to identify: Look for large classes in terms of Lines of Code (LOC) and perform manual inspection. Look for classes that are doing more than one thing. The number of methods and LOC can be subjective, but here is a discussion on stackoverflow of what that number might be.

Conclusion
Under-abstracted design is definitely not great design. In my view, cyclomatic complexity is a simple, well established, metric that can identify under-abstracted areas of your design and codebase. The irony: under-abstracted design results in high complexity and excessive duplicate code.

Remember, complexity is our common enemy so keep fighting it.

Upcoming: How to advance an under-abstracted design?

Enjoy.

Why has Microsoft's Metro design language captured the essence of modern interface design? 5 key elements.

2012-03-05T06:46:00.000-06:00

What is Metro?
Metro is a typography-based design language. Metro style is guiding a new unified experience on Windows 8, Xbox, Windows phone 7, and can even be experience on Windows 7 in the form of Zune, and Windows Live. A design language, such as Metro, is used to guide the architecture of a group of products by capturing the principles and elements of a design approach into a single concise set. Metro gets its name from way finding systems found in metropolitan areas such as airports, subways, and urban areas. Metro gets its inspiration from modern design (reductionism), Swiss design (clear, honest, and beautiful), and motion design (the force of time—the way we experience the world).

In my view, great interface design gets out of the way and Metro gets out of the way by focusing on the content. Metro has captured the essence of modern interface design based on five key elements.

The 5 key elements

1. Typography
Metro is founded upon clean beautiful typography.
Proper color, weight, and size can help eliminate all of the chrome, color, and graphically over manipulated design elements. Even hierarchy can be easily and cleanly shown with just typography. It is not just about typography, it is about the content.

2. Authentically Digital (Inversion of Focus)
With Metro, the user is not focused on the chrome elements such as menus, buttons, panels, and color images with in the chrome that are shaded, the user is focused on the content.

With Metro, there has been an inversion of focus. Great interfaces get out of the way.

Metro is not just about typography, it is about content. By removing all chrome, it helps put the focus on the content whether it is text, images, or video.

With a modern interface, we do not need chrome to indicate what can be pressed or manipulated. Now, the content can be manipulated. After 40 years of WIMP based interfaces, we all know how to use a computer.

3. Spacing with thoughtful reduction
Spacing is important—and made possible with the removal of all of the chrome and over-manipulated design elements. Even if there is room for another button or feature, it certainly does not mean that you should add it. In fact the opposite, you should challenge every element. It takes focus. From a visual design perspective, no longer do we need chrome on top of chrome nested in chrome.

4. Motion (fast and fluid)
Motion, used properly, can create a fun fluid interface. It brings the experience to life. In my view, motion is more important than graphic design. Metro uses animation in the right places and for the right reasons:

     Delight the user
     Simplify the task
     Hint towards interaction
     Provide a feeling of moving forward
     Respond to user behavior
     Teach the user how to interact

5. Asynchrony and intelligence
It is easy to overlook the importance of this element just as Steve Jobs admittedly missed object-oriented programming when he visited Xerox Parc where he became inspired to produce the Mac. It is easy to miss Async Programming in the same way.

Asynchrony helps make an experience fluid.

Closing
Originally developed by Xerox over 40 years ago, the traditional desktop metaphor is a bit tired at least from a design and metaphor perspective. In addition, analog design elements and metaphors are not what digital design needs today. We know that live elements can be tapped or swiped. We do not need 10 pixels of shading and blasted with color inside of a box that is further shaded wrapped in a panel with indentation—you get the idea.

There is a design revolution at Microsoft. In my view, Microsoft is leading Apple at interface design—I know sounds like heresy. Metro and Windows 8 are not perfect, but the direction is game changing. It is easy and safe to jump on the Apple design bandwagon because mostly their designs are great. But I am not afraid to point out that Apple is not the only company that is doing great design and appreciates great designers. Now, it seems that almost every company cares about great design. Design matters.

In my view, the Metro design language has captured the essence of modern interface design. Metro is modern and clean—fierce reductionism, simple, and fluid.

Enjoy the pursuit.

5 Reasons to use the "Feature" pattern in your product

2012-01-30T21:27:00.001-06:00

A design pattern is a formal way of documenting a solution to a design problem.

The "Feature" design pattern is a simple yet powerful mechanism that enables you to rollout features based on configuration settings. It provides the ability to turn these high-level features "on" or "off" by changing the configuration parameter values. The basic idea: use a simple mechanism to control the features that are presented to the end user.

5 Reasons to use the "Feature" pattern in your product

1. Reduces the need to branch: The longer your branch remains unmerged, the greater chance that it will never make it. By being able to not turn the feature "on" until ready in production, but continue to work in the main or trunk branch is valuable.

2. Partial rollbacks (isolated): A single new feature will not hold up a production deployment, it can be turned "off" until ready. It keeps progress moving and a feature rollout does not have to necessarily coincide with a code rollout.

3. Different features for different folks: Will make it easier to turn a feature "on" for testing in a particular environment, but "off" for your production environment. It can also help with partial user and A/B testing.

4. Helps reduce risk: With the ability to turn features "off" until ready, it can allow you to increase development velocity without necessarily increasing risk.

5. Used by #winners: Facebook, Amazon, and many others. Today, Facebook has many new features that are not yet turned on yet but deployed to their production environment. Although not an intended reason, Facebook has even turned on features in production to react to new features from Google+. Features ready to be turned "on."

My hope: the "Feature" pattern will help you for the same reasons.

For more details about the Feature pattern, see the somewhat terse pattern description below along with the source code. There is not much to this simple yet powerful pattern.

Pattern Name: Feature

Intent
Provide a simple yet powerful way to turn features "on" and "off" via configuration. This enables certain environments to have certain features turned "on."

Also Known As

Motivation (Forces)
Demand for high development velocity and the need to mitigate risk.

Applicability
Web apps, freemium business models, mobile apps, services, etc.

Structure
The pattern structure is simple and consists of the Feature class.

Participants
Feature: Represents a Feature that can be turned on or off based on an app setting. You can take an action if it is on, off, or both.

Collaboration
Here is an example code fragment that interacts with Feature:

           Feature.BasedOn("Product.Feature.IsOn")

                .IfOn(() =>

                    // do the feature

})

                .IfOff(() =>

                    // do the alternative or not

});

If the the configuration parameter "Product.Feature.IsOn" is set to "true," then the IfOn action will be invoked; otherwise, the IfOff action will be invoked.

Consequences
Be sure to get granularity right. Be wary of adding features at too fine of detail. Complex feature interaction can also complicate testing. Although a more general discussion, make sure that each feature is justified. However, even in a design world driven by YAGNI and KISS principles, you still need some flexibility—just make sure that it is justified.

Implementation
Here is a simple implementation of the Feature pattern in C# below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Configuration;

namespace Product.Support
{
    /// <summary>
    /// Represents a Feature that can be turned on or off
    /// based on an app setting. You can take an action if it is 
    /// on, off, or both.
    /// </summary>
    public class Feature
    {
        /// <summary>
        /// Based on this app setting. 
        /// </summary>
        public string AppSettingKey { get; set; }

        /// <summary>
        /// Create a feature based on the given setting.
        /// </summary>
        /// <param name="appSettingKey">The app setting that determines whether the feature is turned on or off.</param>
        /// <returns>Newly created feature.</returns>
        public static Feature BasedOn(string appSettingKey)
        {
            if (string.IsNullOrEmpty(appSettingKey)) throw new Exception("setting key cannot be null or empty.");
            Feature feature = new Feature();
            feature.AppSettingKey = appSettingKey;
            return feature;
        }

        /// <summary>
        /// Whether the feature is turned on; that is, if the app setting
        /// has a value of true; otherwise, false.
        /// </summary>
        /// <returns>Whether the feature is on; that is, if the app setting
        /// has a value of true.</returns>
        public bool IsOn()
        {
            if (AppSettingKey == null) return false;
            string value = ConfigurationManager.AppSettings[AppSettingKey];
            return (value != null && value.ToLower() == "true");
        }

        /// <summary>
        /// Performs the given action if the feature is turned on.
        /// </summary>
        /// <param name="action">The action to take.</param>
        /// <returns>The feature</returns>
        public Feature IfOn(Action action)
        {
            if (IsOn())
                action.Invoke();
            return this;
        }

        /// <summary>
        /// Performs the given action if the feature is turned off.
        /// </summary>
        /// <param name="action">The action to take.</param>
        /// <returns>The feature</returns>
        public Feature IfOff(Action action)
        {
            if (!IsOn())
                action.Invoke();
            return this;
        }
    }
}

Sample Code
As sample code, here are some unit tests that interact with the Feature class:

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Product.Support
{
    [TestClass]
    public class FeatureTests
    {
        [TestMethod]
        public void Feature_IsOff_Success()
        {
            // arrange
            bool isPass = false;

            // act
            Feature.BasedOn("Product.Feature.IsNotOn")
                .IfOn(() =>
                {
                    isPass = false;
                })
                .IfOff(() =>
                {
                    isPass = true;
                });

            // assert
            Assert.IsTrue(isPass);
        }

        [TestMethod]
        public void Feature_IsOn_Success()
        {
            // arrange
            bool isPass = false;

            // act
            Feature.BasedOn("Product.Feature.IsOn")
                .IfOn(() =>
                {
                    isPass = true;
                })
                .IfOff(() =>
                {
                    isPass = false;
                });

            // assert
            Assert.IsTrue(isPass);
        }
    }
}

Known Uses
Facebook, Amazon, and others.

Related Patterns
For a couple more previously unpublished patterns (Instrumentation and Service Protector), check out this article that I wrote for the Microsoft Developer Network last year, WCF Decision Framework:
http://gregcowin.blogspot.com/2011/08/why-use-decision-framework.html

Enjoy the pursuit of great design.

What geeks do during the holidays?

2011-12-24T15:05:00.000-06:00

Just so you know: geeks have a bright inner spirit that is just hidden beneath a few layers of logic and critical thinking. Although not comforting to think about, geeks even require a bit of love.

In this spirit, here is my workstation.

Moreover, here is the other side sporting some Windows 8.

Happy Holidays! Do great work for people that you care about and it will lead to happiness.

One last thing: don't forget to treat your geek right.

Why is the next major paradigm shift in software design about to happen?

2011-11-20T08:08:00.001-06:00

What is the next major paradigm shift?
In my view, the next major paradigm shift in software development will be asynchronous (or async) programming and design. It is our next paradigm shift because it helps alleviate pressures and follows a surprising progression. Only when we change the way that we program, does it change the way we design. When we significantly change the way we design—a major paradigm shift occurs. This change has been brewing for over ten years, but only now is it about to happen.

What is async programming?
Async programming uses asynchronous method calls instead of synchronous calls especially for potentially long-running methods. The idea: you make an asynchronous call and then provide a mechanism to run code when the result returns. Async programming is necessary for responsive browser, mobile, and upcoming Metro style apps that are mono-threaded as well as for intensive multi-threaded server applications. When all components are async, it can be fluid, natural, and resilient.

Why is async design the next major paradigm shift?
The main reason is that it helps satisfy a strong and growing need: to make use of multi-core processors and to make mono-threaded user interfaces highly responsive. In-browser apps allow only one thread. Async programming makes both possible. New mechanisms for async programming in upcoming C# 5.0 makes it much easier. Asynchrony dramatically affects design.

The shift also follows a surprising progression. Realize that for the past 50+ years, we have had stable high-level programming elements: data, functions, and threads; although combining them was a challenge.

Even though structured programming and design (SP/SD) techniques are still used today, before the mid 90's, it was the conventional or mainstream way to build applications. The problem: structured design treated data, functions, and threads as complete separate abstractions.

Today, object-oriented programming and design (OOP/OOD) techniques are the conventional way to build applications. Object-oriented programming and design combine data and functions into a single mechanism: the class or object.

Async Programming and Design (AP/AD) gives us a simple way to combine all three into a simple unified mechanism. An async object or agent consists mostly of asynchronous method calls. New mechanisms in async programming make it easy to combine data, functions, and threads.

These paradigm shifts (structured, object-oriented, and async) have gradually combined these high-level programming elements. Each paradigm shift has always started with changes to programming, and then to our designs. Only when it moves to design do we realize that a paradigm shift has occurred.

High-level programming elements in relation to paradigm shifts.

If this is truly the progression, then async programming will lead to async design. It might also hold true that async design is a natural evolution in computational thinking. Moreover, it provides an easy way to map to multi and mono-threaded applications and to avoid deadlock, latency issues, and race conditions.

Why is it about to happen?
It is about to happen because great mechanisms for Async Programming are about to become mainstream that will make it much easier. And once async programming becomes mainstream, then so will async design. Our designs are about to significantly change and a major paradigm shift will follow. This has been brewing for over ten years. Just as with structured design and object-oriented design, it took over ten years for it to evolve and become mainstream.

What are the implications?
Today, best of breed architectures consist of a directed-acyclic graph (DAG) of object-oriented components. Fully async objects or agents can help flatten this DAG of components reducing overall dependencies. Realize that most of today’s software architectures are probably not the best of breed.

Looking back, structured design led to some of the least desirable forms of cohesion and coupling. OOP/OOD led to much more desirable defined shapes of software. For me, the revelation at a time of uncertainty for the OOP/OOD paradigm shift was that it naturally led to more desirable forms of cohesion and coupling.

One of the key benefits of Async Design is that it leads to even better shape, and reduces overall dependencies. Flattening the DAG will be the required for ever-increasing architectural complexity. Great software design will, eventually, require software intelligence.

Asynchronous systems are radically different and will require new patterns, architectural viewpoints, mechanisms, and education. Unlike synchronous systems, asynchronous systems will not be halted like an assembly line due to a single point of failure or delay. Asynchronous systems will be even a truer reflection of the way a real company operates—like an organism—not an object-oriented an system.

A new category of software patterns will emerge. These new patterns will help us deal with more autonomy and system intelligence.

We will begin to design fully autonomous objects that consist primarily of async methods that leverage mono and multi-threaded environments.

Where can you go from here?
Change the way you program and it will change the way you design. Check out some of the resources below for more information on async programming for .NET.

You know you are close to crossing this chasm within your company or team when the last objection is performance. Unbelievably, functions were thought too costly for structured programming and dynamic binding was thought too costly for object-oriented programming. Once people overcome the performance objections of asynchronous methods, we will know that the industry is about to shift.

Soon, great designs that are fluid, intelligent, natural, and resilient will be async.

Whenever we go, make the most of it. If you do not enjoy programming and design, then you are probably doing something wrong.

Additional Resources
Async CTP (can be used with .NET 4.0)
Metro async/await
C# 5.0
C# Specification

Why should you read "Steve Jobs" by Walter Isaacson?

2011-11-17T08:06:00.003-06:00

Read it, if you want to feel inspired, surprised, sad, confident, spiritual, or compelled to build something great. You will enjoy. Steve Jobs by Walter Isaacson is a great read especially for the 2011 holidays. The book is authentic, compelling, inspiring, informative, surprising, and even sad. So sad, that you will likely cry.

While the book is over 600 pages, it was not enough. Steve's life was messy. He was petulant and took credit for many others work. Johnny Ives, one of Steve’s best friends, admitted that it hurt deeply when Jobs took credit for many of his designs. At times, he was unusually cruel and rude. Even though he could be a jerk, he deeply admired other great designers, spiritual leaders, and “A” players.

There are many surprises in the book such as he knew that his cancer had metastasized and would likely kill him. At times, he thought that diet and magical thinking could overcome it. He should have opted for surgery nine months earlier. Ironically, it put him in overdrive to produce the iPad. Steve was obsessed with the pursuit of great design.

I was surprised and oddly comforted that Steve was often unsure of his decisions, direction, designs, and leadership. Bad reviews would devastate him. He was human.

Walter Isaacson took an honest, authentic, and interesting look into Steve's life.

In typical Jobsonian manner, the last chapter is a "one more thing", that is mostly in the words of Steve Jobs instead of traditionally the Biographer. The words are from one of the last interviews that Isaacson did with Jobs.

Steve: you are one of the crazy ones. You definitely were able to quiet your lizard brain to consistently produce great designs.

Does video playback flicker on your new Windows 8 Samsung 700t1a tablet that you got at Build a few weeks ago?

2011-10-02T16:13:00.000-05:00

Over the weekend, I got the following recommended update to Windows 8:

Intel Corporation driver for Intel® HD Graphics Family (Microsoft Corporation - WDDM 1.2) (Recommended) Windows Update

It started causing flicker during any video playback including backgrounds such as in the Weather app. If you are having the same problem, there is an easy fix.

Rollback to the Intel Corporation driver for Intel® HD Graphics Family (Microsoft Corporation - WDDM 1.2) to 8/3/2011 v 9.16.10.2472

I used the Driver rollback feature but did not work remove the flicker even after reboot, so, I loaded the driver from the USB drive that was given to us at build. It fixed this issue.

Hope this helps some of the attendees from Build. It was the best conference ever.

What is the key to developing great mobile apps?

2011-09-12T09:45:00.000-05:00

The key is focus. You must find the essence of the product. You must deliver the key features needed—not all of them—just the essential ones. It requires focus because that is what people want and expect. People want the NUI (Natural User Interface) experience to be better, simpler, and to satisfy their goals in a simple natural way. Just because there is room for another link, gadget, button, or ad, does not mean you should add it. The friction that is created, conceptual weight, and maintenance usually don't justify it. It is just a different way of thinking. Simple, minimal, and beautiful—the attributes all apps should have. By focusing on what is important, you could even change your whole company. Focus leads to great design.

Five perspectives why Build could be the best conference ever

2011-09-11T17:32:00.000-05:00

Build is a new Microsoft conference that replaces the PDC (Programmers Developer Conference), and also possibly combines MIX and even WinHEC (Windows Hardware Engineering Conference) moving forward. The idea for the first Build: combine developers, designers, and hardware partners to create a new platform and a unified ecosystem around Windows 8. Build 2011 is in Anaheim, CA from 9.13 – 9.16.

Build sold out by the end of August even though there is no real agenda defined yet—even now two days before the conference begins. While Windows 8 has been demoed and talked about before, Microsoft is keeping most of the details to be revealed at Build (Source, Source). We do know that it will be about Windows 8. Windows 8 or whatever it might be called could be a radical departure from traditional Windows architecture and create an entirely new ecosystem.

Five perspectives why Build could be the best conference ever

Perspective #1: Personal

One of the main reasons why I switched from Java to .NET over seven years ago is because of the CLR. When Microsoft originally launched .NET, I thought, “Wow, Microsoft finally has great technology and it is the CLR with .NET. Eventually, I know it will become Microsoft’s future platform someday.” I went out and bought a copy of the original Visual C# .net that was launched in 2002 to begin learning C# and the .NET framework.

In my view, the CLR is great technology. Microsoft had dedicated big resources to .NET, Visual Studio, CLR, etc. The CLR is fundamental technology that now makes many things now possible such as the Azure fabric controller, which is really a utility of computing by hosting CLRs in different roles.

Could the CLR be the future of Windows 8 as well? Will the CLR become the future of Microsoft’s platform? What will Microsoft’s core API be for Windows 8? How radically different could it be? What is the name of it? Rumors of Silverlight’s death been greatly exaggerated?

As it could turn out based on a leaked Windows 8 build (Source), Hyper-V will run both Windows 8 and the traditional Windows (think 7 branded as 8) side-by-side—not one on top of the other. The distinction is important. This traditional Windows is said to not even load until it is touched.

Therefore, Windows 8 could be a CLR with a new framework based on top of DirectUI and a XAML based NUI (Natural User Interface). Could it be the CLR a top MinWin? It appears that this Modern Shell will not sit on top of Win32. It will likely be a departure. Windows 8 will also need to incorporate XNA. XNA an Silverlight can be mixed even with Windows Phone 7.

I have also been using Silverlight for the past 3 years. I want to find out if it is the primary way to develop for Windows 8 and what are the other ways? Is there HTML5 tooling?

No doubt, Java developers are doing just fine especially with mobility dev. Some of my Java friends must be at least a little curious about this conference. My plan is to live blog the entire event (details at end the end of the post).

The great thing from a personal perspective: I will have a front row seat to find out that I could be very wrong Windows 8. Either way, it will unfold in a couple of days.

Perspective #2: As a Developer and Designer

From a developer and designer perspective, a week of energy, time, and focus dedicated to understanding many new technologies and a new ecosystem that could potentially unify the three screens (with NUI) and the cloud. Think NUI with Xbox 360 and Kinect. As a developer, the CLR, .NET, Visual Studio, and other frameworks makes it easier to develop for Windows 8, Mango, and potentially the Xbox. Clearly, development will be much easier with better technology when compared to iOS development. This factor should help the ecosystem grow.

Some of the new technology areas and sessions to attend (although no session titles announced yet):

RedHawk (Source)
Jupiter
AppX
Visual Studio 2012
Expression Blend/Web Next
New Windows 8 frameworks and APIs
MOSH (MOdern SHell) Design
Azure

I will post more of these with sources.

Perspective #3: Product Development

From a new product development perspective, there could be many new product opportunities for this new ecosystem with a marketplace that could unify an API and tools for Windows Phone, Xbox, PC, and tablet. Clients are already waiting for Windows 8 for a possible large field deployment.

The screens combined with Azure can create new opportunities for consumer and line of business apps. This new ecosystem will provide opportunities and potential for new products.

Perspective #4: As a User

From Windows 8 user perspective, it will be interesting to experience and review Windows 8 in the tablet form factor. The rumor is that a quad core arm HD tablet will be issued to all conference attendees (Source). If it is true, I will take some images and video of the tablet and a review. I will even try to use it to help with the live blogging, email, etc. if possible. I believe that it could finally be a great NUI content creator not just mostly consuming.

No doubt: the iPad is great design with a beautiful form factor. My view is that the experience with a Windows 8 tablet could even be better than the iPad for some of the same reasons why Windows Phone 7 is better than the iPhone. I look forward to experiencing and reviewing the interface first hand.

Perspective #5: Pure Fun

Build is at the Anaheim Convention center which is just a couple of towns north of where I went to high school. It is a very nice area in Orange County.

The only thing really on the agenda so far is a Tuesday night reception and a Wednesday Party. There should be some great conversations and energy. Sushi!

One other fun factor: all you have to do is give a bunch of geeks a quad core arm HD tablet with Windows 8 and they will go wild (Source). Geeks gone wild.

RBA

Thanks RBA for sending me to Build—perhaps, the best conference ever. I will share some great stories about RBA later. Not surprising, RBA was voted one of the best places to work and is one of the fastest growing companies. They treat geeks right.

Live Blog of Build 2011

Follow the live blog (text, photos, audio, and videos) of Build including any geeks gone wild: http://build2011.tumblr.com or http://build2011.tumblr.com/mobile

I have been excited about Windows 8 since Sinofsky showed it off at D9 (Source) in June this year.

Who makes the best keyboard? 7 reasons.

2011-08-24T19:04:00.005-05:00

For the past four years, I have been using, in my view, the best keyboard ever made—especially for Windows development. The maker might surprise you. It is the Apple keyboard (ultra slim). It sells for $49 and that is luckily within reach for most of us. If you have a PC with a USB port, it just works. If you have not used a Mac recently, it has a control, alt (option), and command key. The command key becomes the Windows key. There are a lot of people that run Windows on Apple hardware so it needs to work.

I have tried what seems like a reach of different keyboard types including split, natural, heavy tactile and gaming keyboards. In 1997, I even tried the Dvorak keyboard layout instead of QWERTY for three months in hopes of typing a little faster.

Tools become an extension of our bodies. Typing becomes an extension of us just as using a mouse, or Natural User Interface (NUI) of tablets, phones, and gaming consoles. The idea that Your Computer is a Part of You is the result in a recent study done by cognitive scientists at Franklin & Marshall College. The results seem to indicate that people do fuse with their tools—cognitively at least.

Currently, Apple makes the best keyboard, in my view.

7 Reasons

1. Easy to type
Smooth hurdling (awkward stroke requiring a single finger to jump directly from one row to another row). The keyboard gets out of the way to a large degree.

2. Low profile
The keyboard is so slim that there is no hand rest needed; it feels good; just slide your hands forward naturally on it.

3. Short key travel
Helps me type faster and smoother. Has a nice short crisp tactile feedback.

4. Easy to clean
Let's face it, keyboards make excellent homes for nasty bacteria.
When keys are pressed, they are at the level as the aluminum making it easy to clean since you can clean the base and keys at the same time with a swipe of a paper towel.

5. Beautiful
Heavy for its size; made of aluminum with flat rounded rectangular white keys.

6. Simple
Not a ton of extra keys, but all the ones you really need.

7. Easy key combos (such as Shift+Ctrl+B)
Just press between the two keys until you feel aluminum; this is one reason that I like it for development; it requires a lot of odd key combinations and symbols.

I first got an Apple keyboard for home. It was fun to type again. Typing became simple, not over-manipulated. Now, I try to bring one with me anytime that I will be riding a workstation for a while. It is slim even in the box.

In my view, the Apple slim keyboard is great design. It is simple, lasting, and like other great interfaces, it gets out of the way. Granted, you might not like it as much as I do, but definitely a keyboard to consider.

I hope that the command center will even have a few.

Enjoy.

Additional references
Print Screen in Windows - F14
Key mappings and comparison

Why use a decision framework?

2011-08-13T14:06:00.000-05:00

In my view, a decision framework represents a simple, yet potentially powerful, sequence of decisions to make and actions to take. Teams, projects, and clients must navigate effectively when tackling new business opportunities, projects, and technologies. A decision framework structures information in a way that makes it easier for people to make decisions and take actions.

A decision framework can help you...

Avoid traps and pitfalls such as analysis paralysis
Converge on the right decision
Take action
Do the right thing (most important of all)

For an example of a decision framework, check out this article that I recently wrote for the Microsoft Developer Network (MSDN). The article is a decision framework for WCF (Windows Communication Foundation) development. WCF is a unified communication framework in .NET for building connected, service-oriented applications:

WCF Decision Framework: The decisions to make and actions to take when developing a WCF project

The article also contains a couple of previously unpublished patterns: Instrumentation and ServiceProtector. I hope that the framework will help you develop the SOA that is right for your organization and that you also find it engaging.

Please let me know what you think of the decision framework method. I think that it has potential to be used in a lot of areas. I have already started simple decision frameworks for Azure and TFS.

In my view, the decision making process is the key to great design, but perhaps not in the way you that you might think—more to follow.

Enjoy!

[Y1] in pursuit of great design

2011-08-05T21:00:00.183-05:00

In pursuit of great design started one year ago with the focus on software systems. From the start, my intent has been to share my pursuit of great design with my friends and colleagues.

No doubt, the pursuit is going to take a lot of energy and cool deep sustained thought, but I finally have a guess where things might end up. Also, the pursuit became much easier when I stopped listening to my lizard brain.

I hope that you enjoy it in some way. Memes ready to go.

[Y1] chronologically

In pursuit of great design

What is great design?

Top 10 programming languages

How can we codify use cases more effectively?

Quiet your lizard brain in order to achieve greatness

Can great design be produced in a software factory?

Two necessities for you to lead a great team

Can command and control ever lead to great design?

What is the killer benefit of cloud computing?

5 reasons that over defensive programming is not great design

MTC is great design

What is the key to intelligent systems?

Why will it take 30 years for cloud computing to mature?

Why do we have so much potential?

Dieter Rams' ten principles to good design

Great design is not you

What is the most difficult challenge in software development?

3 tips to help you with software integration issues

What kills great design?

Top 10 reasons why Windows Phone 7 is better than the iPhone (this one got you talking)

Top 3 reasons why cloud computing is unstoppable

Two ideas to help your company move into the cloud

What is the federal government's new policy on cloud computing?

Great quotes from great designers

Azure forming a cloud: ask why, what, where, when, and how

Which programming language has the most profanity?

What can you accomplish with your little finger?

Is Windows 8 great design?

How to design your own command center

More to come.

How to design your own command center on a budget

2011-07-31T12:56:00.027-05:00

I realize that this post will probably land me in your Geek circle on Google+, but I feel compelled to share my design and quest for my own command center and lab. No, it is not in my Mom's basement. They do not even have basements in Texas—just saying.

It has been my goal for a long time. It is quite attainable. I think it makes a lot of sense for families. Most families do not have the right space for work, homework, and play. A space for new ideas and collaboration.

Besides, the single workstation office is often a contemptuous place where family members try to elbow each other out of the way. Traditional architectures just do not have the right spaces to accommodate this lifestyle—especially as a software developer. Even my wife now needs a dual-panel for Facebook and email. This has to be a point of contention for a lot of other couples as well.

Here are the DIY (Do It Yourself) Command Center initial steps:
1. Design with Visio: has a template to help you get the design down to the inch
2. Take inventory and make a budget: trying for less than 3K
3. Get it approved by the finance committee (the hard part)
4. Build it

My design was inspired by time that I spent in a lab at the Microsoft Technology Center (MTC) last year except they have labs with four and six workstations per lab. The labs at the MTC also have a whiteboard in the center instead of the flat panel. It is, also, inspired by actual network operation centers that I have visited.

Here is the Command Center floor plan. I used Visio with Office Layout Template:

Here is the text that was cut off to the left about the Plexiglas whiteboard:
Design and Homework Wall
6'x 4' Colored or clear Plexiglas board with rounded corners
Mounting: 4" metal stand offs or swivel center mount
If swivel mount, use LED attached to mounting facing wall for indirect lighting

It will be a great place to work and play. A place to collaborate with friends. Also, a workplace for my daughter for homework and games. Hopefully, trig and calculus will be more fun on a clear Plexiglas board.

My plan is to have no books or paper in the lab instead just workstations and iPads (that can contain an entire library of e-books).

I have ideas for a tight cabling system that I have already used successfully on another workstation. Just power and CAT 5 are needed to each workstation, then all other cabling is brought underneath the table.

It would be great to design the actual furniture and replace flooring, but that will blow out the budget. I plan to use cheap Ikea furniture until it can be replaced. The design challenge is to build a great comfortable workplace with a tight budget constraint. I use indirect LED colored lighting as well.

Maybe this effort will inspire someone else to enter the Geek circle and build his or her own command center.

I will post some more about this—hopefully about step #4. It will be a while until I reach step #3, but I promise I will get there.

Enjoy!

Is Windows 8 great design?

2011-06-02T09:24:00.002-05:00

Based on the unveiling last night at All Things Digital (D9), Windows 8 looks like great design. It is based on a combination of the Metro UI and Windows 7. See Windows 8 for youself. Here is a great overview video: http://www.youtube.com/watch?feature=player_embedded&v=p92QfWOw88I

Check out this comparison of iPhone with Windows Phone 7 for some idea of how Metro differs from iOS. Soon, I will do the same kind of comparison of iOS (tablet) and Windows 8.

Windows 8 was unveiled last night at All Things Digital by Steven Sinofsky, Microsoft Windows President.

Enjoy!

What can you accomplish with your little finger?

2011-05-25T14:27:00.001-05:00

You slide your left little finger forward over the control key onto the shift key—holding them both down with light pressure, and then simultaneously hit B with your forefinger. The build is a success. The feedback is immediate. It just feels good. Finally, it motivates you to build a framework that reduces your codebase by 50%, all starting with a beautiful simple motion.

While creative writing might not be my thing, I still hope you find these keyboard shortcut posters for Visual Studio 2010 useful: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=92CED922-D505-457A-8C9C-84036160639F&displaylang=en

Shift+Ctrl+B is my favorite shortcut.

Enjoy