Entries Tagged 'work' ↓

My discussion with Craig Shoemaker about Live Labs Volta is now available from polymorphicpodcast.com. It was fun, though I wasn’t aware of the echo in my office.

Refactoring has been confined to object-oriented design for too long. The refinement through successive transformations and ability to revisit design decisions often is equally valuable (maybe even more so) for architecture. Live Labs Volta, one of the projects I’m working on, aims at providing just that. Today we are releasing a Live Labs Technology Preview of Volta. Volta introduces the Tier-Splitting refactoring, allowing a designer to move the distribution boundary in a declarative manner, while handling all the plumbing associated with distribution. In effect, it hides what Fred Brooks called accidental complexity, allowing the designer to focus on the essential complexity. Volta also stretches the reach of .NET to cover the cloud, but that’s the topic for a different post.

Right before leaving for OOPSLA 2007 I noticed that my colleagues from Live Labs released Live Labs Listas. Listas is a great example of the user experience that can be achieved in modern web applications (i.e., Web 2.0). For that reason a couple of months ago I invited a member from the Listas team to showcase the UX features such as responsiveness, drag-and-drop, etc. to p&p’s Web Client Software Factory team. Great to see it ship and I look forward to other sites providing a user experience on a par with Listas!

My article The Growing Divide in the Patterns World (co-authored with Wojtek Kozaczynski, Ade Miller and Jason Hogg) appeared in the Software Patterns issue of IEEE Software (July/August 2007).

Here’s the abstract:

Recently Microsoft’s patterns & practices group conducted a survey that indicates a significant gap between the patterns expert community and the software practitioners attempting to use patterns and leverage pattern thinking in their daily work. As this gap widens it will lead to an irreversible divide between the two communities, and patterns will fail to deliver their potential. In the light of our experience using patterns to package development guidance as well as input from practitioners using patterns we analyze the key causes behind this gap and recommend a set of actions aimed at the patterns community. Bridging this gap will have a dramatic effect on practitioners’ understanding of patterns and their ability to leverage them as the patterns expert community envisions.

More info off their web site (assuming the server is responding, which is not the case now).I’m glad to see that after over 12 years software patterns are still interesting. How many of the hot topics of 1994 are still talked about today?

If you’re going to next week’s QCon in London do yourself a favor and attend Erik Meijer’s keynote Democratizing The Cloud. Here’s Erik’s abstract:

The web is rocking the world of developers. Our customers love consistency. They want to have the same rich experience, anywhere, any time, on any device. Our sales people love market share. They want no platform that cannot leverage their web services. We ourselves have embraced agile methods. We want to keep our options open as long as possible and create software incrementally by successive refactorings. This surely sounds like a contradiction, another impossible triangle. As the Dutch artist MC Escher once said “Only those who attempt the absurd will achieve the impossible”. Hence we are trying to stretch the .NET framework to cover the Cloud such that it will become possible to incrementally and seamlessly design, develop, and debug complex distributed applications using your favorite existing and unmodified .NET compiler and deploy these applications anywhere.

Erik will show what consistency means; he will demonstrate how agilty translates into what you do right after you go to the File menu; he will prove how you can keep your options open until just about the very end. So if you’re only planning on attending a single QCon keynote, I strongly recommend Democratizing The Cloud. A few hours ago Erik, Jeff Van Gogh and myself reviewed the demos that he’ll show next week in London. You won’t believe me if I’d tell you, so better see for yourself. Do trust me though that they’re cool–I did work on the one involving validation. Hint: you’ll see p&p’s Enterprise LIbrary like you’ve never seen it before.

A recent conversation with my friend and colleague Erik Meijer provided the nudge to finally write about something has been bothering me for some time. So here it goes…The popular view about Inversion of Control (IOC) is that it represents a technique for removing dependencies in object-oriented programs. People immediately think of their favorite dependency injection framework, whatever that may be. That’s nice and well, but is that the real IOC?Consider the following:

• XML was pitched as a language specifically designed to make parsing easy so developers would not have to write another parser. That has happened allright, very few worry about parsing XML today. However while computers spend less cycles parsing well-formed markup, people crippled their languages with angle brackets, end tags, and a verbose syntax. This in spite the fact that the number of language users > number of XML parsers.
• Good SOA design recommends building stateless services. Service implementations that follow these guidelines retain nothing from one invocation to another. However while the services do almost nothing to maintain the state of the service conversation, the developers building service consumers picked up the tab. Again, the number of service consumers > the number of services.
• Web browsers allow people to interact with applications through widgets such as text boxes, radio buttons, check boxes, buttons, and a few more. These widgets are so primitive that they easily map into the native widgets provided by the virtually all contemporary host environments. However while the browser happily renders widgets with consipcuous text UI era traits, developers jumped through many hoops to push the user experience closer to what the platforms have been providing for years. And you guessed it, the number of web applications > the number of browsers.

There are other examples but I’ll stop at 3. The commonality across them is that in each case the software is simpler somewhere because many developers picked up the tab somewhere else. Instead of localizing complexity and putting the machines to work so we could enjoy other, more interesting challenges, the opposite happened. We now have to write in a verbose, ugly-looking language that the software can easily process; manage the state of service conversations so the servers would not bother about it; use plugins and pull lots of strings to give the user experience a face lift so the browsers do minimal processing and rendering; and so on. So consider this other way to look at IOC: the software is in control, and we’re working for it. Darn did I take the blue pill?

Two of the projects I’ve been involved with since I started in Microsoft’s p&p group have just shipped:

• The Web Service Software Factory helps developers build Web services. This version employs the Windows Communication Framework (WCF).
• The Web Client Software Factory caters to developers building Web-based applications. It uses the Workflow Foundation (WF).

Both ship in source code and include reference implementations.

If you haven’t heard of software factories my colleagues Jack Greenfield, Keith Short, Steve Cook, Stuart Kent have an excellent book with the same title.

In the patterns & practices (p&p) group at Microsoft we have been using software patterns for several years. I’m working with a couple of colleagues on gauging how the folks employing the guidance coming out of p&p (such as guides, application blocks, software factories and reference implementations) have, are, and will be using software patterns.

To do that we assembled a short survey. If you’ve used patterns I encourage you to take it. If you haven’t used patterns yet but your development tools use patterns one way or another then you could also take it since I’m also interested in your perspective.

You can find the survey Software Patterns: Past, Present, Future here. Thank you in advance for your answers.

After a long gestation the fifth volume of Pattern Languages of Program Design (PLoPD) has been published.

Myself, Markus and James selected among patterns workshopped at PLoP conferences from 1998 through 2004. We structured the book in six parts. Part I focuses on design and contains patterns aimed at people designing object systems. As the Internet and embedded systems continue to expand their reach they bring with them concurrency and resource management problems; Part II contains patterns on these topics. Part III continues the shift from one to many applications and contains patterns for distributed systems. The domain specific patterns from Part IV focus on mobile telephony and Web-based applications. Part V shifts gears to architecture and comprises patterns that tackle composition, extensibility, and reuse. Finally, Part VI offers a smorgasbord of meta-patterns for improving the quality of pattern papers and helping their authors.

Here’s what you can find in each chapter:

1. The Dynamic Object Model pattern combines ideas from class-based (like Java) and prototype-based (like Self) languages to address dealing with elaborate flexibility requirements.
2. The Domain Object Manager allows application code to handle transient and persistent domain objects while supporting multiple data stores or application servers, keeping the domain objects independent of the persistence or middleware APIs.
3. Encapsulate Context provides value to developers who are seeking ways to lower the ripple effects of code changes regardless of programming language, allowing them to manage an increasing number of call parameters without introducing global variables.
4. A Pattern Language for Efficient, Predictable, Scalable, and Flexible Dispatching Components addresses the challenges associated with developing dispatching components, providing one of the building blocks of a handbook for distributed real-time and embedded middleware.
5. Triple-T focuses on writing software for real-time processing is hard and poses unique challenges, covering five patterns harvested from time-triggered bus architectures for safety-critical real-time systems, such as the ones employed by Airbus airplanes or BMW and DaimlerChrysler automobiles.
6. Real Time and Resource Overload Language presents a pattern language for designing reactive systems that gracefully accommodate load bursts, applicable to any systems that process incoming requests, such as web servers, middleware, OLTP, and so on.
7. Drawing upon examples from several systems that deal with distribution De-Centralized Locking covers a pattern for managing locks in the context of distributed systems.
8. The Comparand Pattern focuses on dealing with identity when working with objects from different hosts or processes within a distributed system.
9. Service Discovery tackles a common problem in practical ways, distilling solutions from well-established examples such as SLP, JXTA, UPnP, LDAP, DNS, and the now ubiquitous and IEEE 802.11.
10. MoRaR is a pattern language focused on mobility and radio resource management.
11. Content Conversion and Generation on the Web is a pattern language aimed at people building applications that deal with dynamic HTML generation.
12. Plug-ins represent a popular technique for extending applications, allowing users to late-bind new functionality. The Patterns for Plug-Ins pattern language covers techniques mined from a wide body of software, including operating systems, web browsers, graphics programs, and development environments.
13. The Grid Middleware Architectural Pattern covers the architectural elements of grid middleware as well as guidelines for implementing and deploying them.
14. Targeting application developers integrating components written in different languages or built with hetereogenous component concepts, the Patterns of Component and Language Integration distill insight from systems that include Apache Axis and the Simplified Wrapper Interface Generator (SWIG).
15. Patterns for Successful Framework Development
    Frameworks covers a set of patterns for mitigating the mismatch between the recommended practice of building frameworks and the reality of many software development projects.
16. Distilling from 10 years of writing and reviewing patterns Advanced Pattern Writing provides advice for improving pattern writing.
17. A Language Designer’s Pattern Language explains how does one generate a pattern language from a system of forces.
18. The Language of Shepherding focuses on analyzing and providing feedback about patterns.
19. Patterns of the Prairie Houses uses the design themes of Frank Lloyd Wright’s prairie houses as an exploratory vehicle for showing how people should approach pattern mining and writing.

I gave this talk in the Patterns - Past, present, future track at JAOO, in Aarhus, Denmark.

Most newcomers think that patterns are limited to the topics that made a big splash about 10 years ago. In fact many other patterns and pattern languages are quietly put to work, helping
practitioners solve problems in a growing number of areas such as enterprise architectures, AOP, middleware and grid computing, embedded systems, performance tuning, and so on. In this session I tour some of the most interesting developments and trends in the patterns world based on my experience with editing the 5th volume of the Pattern Languages of Programs book series. This overview will give you insight into current patterns work, prepare you for finding patterns for the problems that you’re interested in, as well as help you position in context patterns that you may consider authoring.

You can download the PDF from my talk list.