Entries tagged with arcast - Channel 9

ARCast.TV - Pat Helland on Memories, Guesses and Apologies

bobfamiliar — Tue, 18 Nov 2008 03:52:00 GMT

Part 2 of Patrick Weikle's interview with Pat Helland where he talks about the framing of unreliability and eventual consistency of transactions.

ARCast.TV - Pat Helland on the Drive to Many-Core Processors

bobfamiliar — Tue, 11 Nov 2008 01:13:00 GMT

Patrick Weikle interviews Pat Helland about the inevitability of ManyCore and parallel applications.

ARCast.TV - Michael Manos on Datacenter Leadership

bobfamiliar — Sat, 25 Oct 2008 16:53:00 GMT

This ARCast features Michael Manos who leads all the datacenters for Microsoft globally. Michael is leading Microsoft’s transformation into massive scale datacenter environments for Web 2.0 and online services. Michael is interviewed by Lewis Curtis.

ARCast.TV - Eric Newcomer of IONA on the state of Interoperability

bobfamiliar — Tue, 07 Oct 2008 19:36:00 GMT

Eric Newcomer, Chief Technology Officer of IONA, discusses the challenges of interoperability in a heterogeneous world, the state of middleware and interoperability standards with Bob Familiar.

ARCast.TV - Peter Provost on what’s coming for Architects in Visual Studio Team System 2010

bobfamiliar — Tue, 30 Sep 2008 16:42:00 GMT

The upcoming version of Visual Studio Team System 2010 has a number of new features and functions for Architects. Senior Program Manager of Visual Studio Team System for Architects Edition, Peter Provost, sits down with Joe Shirey to discuss what investments Microsoft has made into the product and how it will potentially improve the lives of Architects.

ARCast.TV - Christoph Schittko on the Innovation Framework

bobfamiliar — Mon, 22 Sep 2008 17:46:00 GMT

No matter if you're a developer or an architect, innovation is much more than just writing code for new features. How do you come up with innovative ideas that make your application more competitive and make you stand out as a recognized thought leader? Innovation works best when architects and developers understand how to guide and participate in the process around it and what infrastructure is required to support it. Bob Familiar interviews Christoph Schittko on how successful innovators like Yahoo!, Microsoft, eBay and others implement to build innovation into a company's culture, e.g., brainstorming for new ideas internally or with the user community, planning and executing regular events such as hackdays to create new ideas and prototypes, how to test out viability of ideas through rapid iterations, learning fast through feedback and through failure if necessary to move forward to bring innovations into products.

ARCast.TV - Stephen Tarmey of Tyco on adopting Robotics Studio CCR for High Performance Async IO

bobfamiliar — Tue, 16 Sep 2008 15:19:00 GMT

Bob Familiar interviews Stephen Tarmey of Tyco Software House on how he discovered the Concurrency and Coordination Runtime in the Robotics Studio SDK and used it to implement a high throughput asynchronous I/O pattern.

ARCast.TV - Mario Cardinal on Layer Module Injection

bobfamiliar — Tue, 09 Sep 2008 14:32:00 GMT

Layer Module Injection is a new pattern to enforce separation of concerns between domain logic and infrastructure services. Mario Cardinal and Joe Shirey will explain why to use abstract classes and interfaces as a means to reduce dependency surface. Mario and Joe will discuss the techniques of dependency injection and inversion of control to reduce the coupling between classes. In the same way, they will discuss benefits to modularize and decouple with layers using namespaces. The goal is to explain a new approach to simplify managing dependencies between the modules which compose a program. At the end of this discussion you will understand why architects worry so much about coupling, cohesion and separation of concerns.

ARCast.TV - Jim Holmes and Philip Jordan on Excel Services

bobfamiliar — Mon, 25 Aug 2008 13:24:00 GMT

Jim Holmes and Philip Jordan from Quick Solutions on how to easily leverage IP and business models that need to live in Excel using Excel Services.

ARCast.TV - Dennis McCarthy on Platform as a Service (PaaS)

bobfamiliar — Mon, 18 Aug 2008 15:22:00 GMT

Bob Familiar interviews Dennis McCarthy, a software architect at Kronos about his research into leveraging Microsoft Dynamics 4.0 as an S+S Platform.

ARCast.TV - Greg Galipeau on ASP.NET MVC

bobfamiliar — Tue, 05 Aug 2008 11:05:00 GMT

In this interview, Greg Galipeau of RDA discusses three different patterns -- MVC, MVP and ASP.NET MVC with Dr. Zhiming Xue “Z”, Microsoft Architect Evangelist. He articulates the advantages and disadvantages inherent in each pattern, and explains when to use one versus another when creating Windows forms applications and web applications.

ARCast.TV - Essential WCF

bobfamiliar — Mon, 21 Jul 2008 20:04:00 GMT

Authors Steve Resnick, Rich Crane and Chris Bowen discuss their new book Essential WCF with Bob Familiar.

ARCast.TV - Sundar Swaminathan on MOSS for Public Facing Web Sites

bobfamiliar — Tue, 15 Jul 2008 00:50:00 GMT

SharePoint Server has long been viewed as an "intranet-in-the-box" and has enjoyed great success behind corporate firewalls. But what about using MOSS to build public-facing, high volume commercial web sites? In this episode, Denny Boynton sits down with Sundar Swaminathan of Quilogy, the lead architect of Energizer.com (yes, the site with the bunny that goes on and on and on...), and talks about why he chose to use MOSS as the architectural foundation of this high visible site.

ARCast.TV - Biff Gaut discusses the Microsoft Certified Architect Program

bobfamiliar — Sun, 06 Jul 2008 23:55:00 GMT

More than 100 people at Microsoft and from the IT industry in the world today have become Microsoft Certified Architects since the program was launched about two years ago. For people who are interested to become an MCA, they may wonder what it is like to go through the certification process. In this interview with Biff Gaut, who earned his MCA title during the pilot phase of the MCA programs, Dr. Zhiming Xue “Z”, Architect Evangelist of the Microsoft DPE East Region, and George Cerbone, Microsoft MCA Program Manager and an MCA himself, interview Biff Gaut about the untold aspects of the grueling interview process, the trade-offs candidates have to make, and the key things to do before the interview day.

ARCast.TV - Juval Lowy on Interface Based Design

bobfamiliar — Thu, 26 Jun 2008 00:10:00 GMT

Should you use abstract classes or interfaces? What about WCF service contracts? Is the decision which one to use a design decision or a direct product of the technology at hand? Why is .NET allowing you such wide range of options, and why are other technologies (from COM to WCF) restricting you? In this ARCast, Juval Lowy of iDesign will demystify these age-old questions and share his insight and perspective with Denny Boynton.

ARCast.TV - Simon Guest on Architecture at Microsoft

bobfamiliar — Tue, 17 Jun 2008 16:29:00 GMT

Join Simon Guest, who leads the platform architecture team in Redmond, as he shares his thoughts on the industry, the architect community, and how Microsoft thinks about architecture with Bob Familiar.

ARCast #6

Michael Lehman — Wed, 30 Nov 2005 20:55:22 GMT

Week 2, the discussion continues about: Is model-driven development likely to gain widespread adoption? Will it make building software faster, better, cheaper? Come hear the leaders in this industry discuss this relevant topic

ARCast #5

Michael Lehman — Thu, 03 Nov 2005 20:03:30 GMT

Is model-driven development likely to gain widespread adoption? Will it make building software faster, better, cheaper? Come here the leaders in this industry discuss this relevant topic

Transcript

Harry Pierson: Hello. This is Harry Pierson, and welcome to "ARCast". "ARCast" is a panel-style discussion podcast featuring panel members from inside and outside Microsoft as they discuss and debate architectural topics. Each month, we will feature a new topic and new panelists and we will post their ongoing discussions weekly. For more information, please visit the Architecture Resource Center at microsoft.com/architecture.

This month, we are discussing modeling. Here is the topic we sent to our panelists. There is a great deal of buzz these days about model-driven development techniques such as software factories, domain-specific languages, language workbenches, UML, model-driven architecture, etc. Similar attempts in the past have failed, namely the CASE tools of the 80's. What is different now? Is model-driven development likely to gain widespread adoption? Will it make building software faster, better, and cheaper?

Our panelists this month are

Martin Danner, founder of Arrowrock Corporation and architect MVP for Microsoft,

Jack Greenfield, architect with the Enterprise Frameworks and Tools Group at Microsoft. Jack was formerly a chief architect at Rational Software and he is the co-author of the book "Software Factories", Steven Kelly, chief technical officer of MetaCase and co-founder of the DSM Forum.

Mauro Regio, architect with the Microsoft Architecture Strategy Team, and

Brian Selic, IBM Distinguished Engineer at IBM Rational, and adjunct professor of computer science at Carleton University. Brian is also the co-chair of the OMG team responsible for the UML 2.0 standard. Now, here are our five panelist's opening remarks.

Martin Danner: Hi, this is Martin Danner with Arrowrock Corporation of Boise, Idaho. I am an in-the-trenches developer and analyst with over 20 years of experience developing application of all sizes. I am really excited about the recent advances in model-driven software development. This technology promises to produce order-of-magnitude improvements in both productivity and quality. At the same time, I am more than a little concerned that this might be déjà vu all over again. I was there when the CASE tools hit the scene with great fanfare in the eighties. I was a system analyst at the time, working for a large airspace company. They put a lot of money and effort into the development of CASE technology, but for some reason it just never took off. Perhaps the models were too difficult to create and maintain. Perhaps the resulting code required extensive modifications to work properly. Or maybe it was just that the culture was not ready for the paradigm shift.

In any event, I would like to know from my other panelists what they have done to examine the mistakes of the past and what they are going to do to avoid those mistakes in the future. What is your strategy to gain mainstream adoption of your technology in the real world of software development? As I monitor the online chatter among folks creating this new model-driven development technology, I am concerned that the discussions centers mostly on academic concepts, with little or no concern as to whether the typical IS-shop is ready or able to adopt it. I often wonder if this new technology will require special skills that don't currently exist in the IS workforce. Will developers treat models as a new kind of development language, or will model-driven development be limited to only a few who are willing and able to master it? Will these models be first-class artifacts throughout the entire life-cycle of an application, or will the fancy code generators all be abandoned as soon as the developers start tweaking the code directly? I look forward to hearing from what other panelists have to say. I will measure their comments against my yardstick of practical experience and then report back to you my humble opinion of their strengths and weaknesses as well as their prospects for success in the real world.

Jack Greenfield: Hi, my name is Jack Greenfield. I've spent most of my career building either enterprise applications or model-driven frameworks and tools for enterprise application developers. I am currently an architect with Enterprise Frameworks and Tools at Microsoft. Before coming here, I was the chief architect for Rational XDE. During the dot-com era, I was founder and CTO of Inline Software, a company that developed model-driven frameworks and tools for enterprise developers. Before that, I was the chief architect for an enterprise application frameworks and tools projects at Fannie Mae which was Fortune one at the time. I was also one of the leads for the enterprise projects framework at NeXT.

In my mind, the primary factor that will determine the success or failure of model-driven development in the industry today is pragmatism. There is a stark contrast in terms of pragmatism between the two leading approaches, which are software factories from Microsoft and MDA from IBM and the OMG. With MDA, you have two domains, or viewpoints as we call them, the platform-independent model and the platform-specific model. These two viewpoints are both based on UML which is a general-purpose modeling language, and they are related by transformation, since PSMs are generated from PIMs.

With software factories, by contrast, you have an arbitrary number of viewpoints such as user interaction, business work-flow, or logical database design to name a few. In fact, you can define as many viewpoints as necessary to describe the business requirements in the software under development. Each viewpoint is potentially based on a DSL but is tailor-made to address a set of unique concerns for that viewpoint. Viewpoints can be related by nesting and by a variety of operations such as trace, validation, analysis, refactoring, weaving, or optimization in addition to transformation.

Why the other operations? Because in the real world, we don't always know enough about a pair of domains to fully automate the relationship between them with transformation. Sometimes it makes more sense to edit two models independently, for example, and then use a validation tool to make sure they are mutually consistent. A viewpoint is not always based on a DSL because software factories can use code, SQL, HTML, and a variety of other formats and tools to describe a domain in addition or instead of models. Why use these other formats and tools, because in the real world, we don't always know enough about a domain to model it effectively. In a software factory, we can use other forms of guidance like patterns, code samples, templates, wizards, frameworks to name a few.

So we learn more about key abstractions in the domain by working with these less automated forms of guidance; we can gradually move to models. So what is different this time from the CASE tools in the 1980's? I think it is precisely the pragmatic bottom-up approach we are taking with software factories. Unlike MDA, which optimistically assumes like CASE did that most or all of the software can be generated from models, software factories blend modeling with other software development practices to meet the needs of developers in the real world. There isn't time to talk about this topic in-depth here, so we will address it in the panel session. Also, we have about it written extensively in our book called "Software Factories - Assembling Applications with Patterns, Models, Frameworks, and Tools". Thank You.

Steven Kelly: Hi, I'm Steven Kelly and I work for MetaCase as CTO and lead developer of the MetaEdit+ domain-specific modeling tools. The last time we heard a message promising massive productivity increases was with CASE tools and fourth-generation languages like PowerBuilder. They failed to bring about the expected revolution because they tried to impose three things on the users, a way of working, a way of modeling, and a way of coding. Since the tool vendor's way rarely fit with the users' existing practices, there was a major disconnect. Of all the problems, perhaps the difference between the generated code and the kind of code the users had handwritten was the worst. Because the vendors had to make one tool work for as many people as possible, the code generated couldn't be tuned to the specific needs of all its users. It also had no chance to take advantage of their existing investments in code and frameworks.

This meant that the resulting code was bulky, ugly, inefficient, and unfamiliar. There were however a few success stories of CASE tool use. The key feature in the successes was that there was no need to go in and edit the generated code by hand. If you have to edit the resulting code by hand, you end up having to maintain the same system in two different formats. And all our experience teaches us that this is a nightmare that no round-trip promises can save us from.

To be able to generate full production code from models, you need to have both the modeling language and the code generator be domain specific. And when I say domain here, I'm talking about a very narrow range of applicability, say a single range of products of a single company. That way the modeling language contains concepts that are instantly familiar to developers since they are the problem domain concepts which they already work with. Similarly the code generators can generate just the kind of code the best developers there write by hand. Time and again, it's been proven in practice that such an environment is the best way to build software, leading to increases in productivity of 500 to 1000 percent in places like NASA, the US Air Force, Lucent, and Nokia.

The big question then is what's the cost of building your own modeling language, modeling tools to support it and your own code generator? For a long time that cost was measurable in tens of man years, way to high to make domain-specific modeling practicable for all but the largest projects. Now however there are tools like our own MetaEdit+ and Microsoft's DSL tools that make building such support much faster. We have dozens of successful projects, ranging in size from just three developers up to several hundred. However, even dozens of industrial success stories don't make something a mainstream success. It will be interesting to hear other participants' opinions on when and how the market will and turn and when we'll see the next big leap in software development productivity.

Mauro Regio: Hello, my name Mauro Regio and I'm a Solution Architect with the Architecture Strategy Team at Microsoft. My current area of focus is on large-scale enterprise integration projects.

In discussing software factories and modeling, many of our customers ask if they should seriously invest in them. In answering these questions, I like to offer my reflections on a couple of key factors about the role of XML and metadata and what makes software factories so powerful. XML technology is pervading the modeling world. XML makes model metadata open and self describing, flexible and extensible. So the point is they become really useful and effective for modeling. Openness and extensibility are two key values from a technical, and even more from a business, standpoint. An enterprise decision to use a certain model, in any business or technical domain, is a strategic decision.

From a technical perspective, it's also a risk mitigation factor because I can extend the model. I won't be stuck in the future if, for any reason, the initial model chosen will not be powerful enough to express the semantics of the concepts I'm modeling. This means that key business and technical decision makers will feel much more comfortable than in the past in using modeling driven techniques in developing software systems. Then we need to consider that model driven development and software factories are not just about models. Yes, it is about sophisticated, open and extensible models. But it also means the ability to use the various models to capture different aspects of the problem we are dealing with and of the solutions to that problem.

To transform these models from the problem space into the solution space at a certain abstraction level, possibly using a Synapse transformation. It also means the ability to use these models together with descriptive development guidelines and to inject these models and transformation and guidelines into a developer environment. And make it tailored to the development of a specific solution, rather than having to start with another "Hello World" application.

So, will model driven make building software faster, better and cheaper? I don't like making marketing-like statements. And I don't have any conclusive quantitative data to prove how much faster and or cheaper. And, essentially, I don't think that is the point, not at all. However, I believe model driven development, based on open and semantically self-described models, integrating methodology and guidelines into the tools used to architect, design and develop software systems, will radically change the effectiveness of the development process. Thank you.

Bryan Selic: Hello, my name is Bryan Selic and I work for IBM. I'm an IBM Distinguished Engineer and my areas of responsibility involve modeling languages, the definition of standards related to modeling languages and tools that support model driven development. I've got a lot of experience, close to 40 years, in the software industry. And I've been doing model driven development in the past 18 years, I guess, although it wasn't called that when I started.

Modeling is something that has been used throughout history as a technique of dealing with complexity in engineering. And therefore it is quite appropriate for use with software, simply because software is one of the most complex things that we've ever attempted to do. Some of these systems reach orders of magnitude that are perhaps comparable to biological systems. And we definitely need help. To me, the essence of model driven development is about two things. One is abstraction. That is, raising the level of abstraction of our software, both in terms of how we think about the problem and then how we specify our solutions. And second, a very important thing that often gets forgotten is the introduction of more and more automation into software development, specifically using computer based tools to help us do development.

What has changed over the last few years, in fact I'd say over the last decade, is that we have reached a new level of maturity in the technologies involved. The modeling languages have gotten a lot more sophisticated, although to be honest, I think we still need a much more comprehensive theory of modeling language design. But we're certainly farther along than we've ever been before. And the other things that have matured to a significant extent are modeling tools. I don't believe that CASE actually failed.

I think CASE tools were simply a step, an early step in the right direction towards more automation and higher levels of development. And I've certainly seen in my experience, in the last seven to 10 years, some significant projects that have used model driven development and have greatly increased productivity and quality of the software produced. So I'm quite an optimist when it comes to the future of model driven development. There is something standing in the way. Perhaps the biggest impediment is the culture change that a company accompanies something like this.

Harry: Thanks for listening. I'm the host of "ARCast", Harry Pierson. Don't forget the conversation continues next week so tune in.

ARCast #4

Michael Lehman — Thu, 03 Nov 2005 19:16:34 GMT

A few closing remarks on standards based interop.

ARCast #3

Michael Lehman — Thu, 13 Oct 2005 22:07:10 GMT

This week our speakers discuss the challenges derived from ‘not quite yet’ standards based interop.

ARCast #2

Michael Lehman — Thu, 29 Sep 2005 17:50:48 GMT

Come hear our speakers continue their discussion about Interoperability challenges.

ARCast #1

Michael Lehman — Mon, 19 Sep 2005 17:50:15 GMT

Welcome to the NEW ARCast! ARCast is an ongoing podcast series created by the Architect Strategy Team with the goal of spawning insightful, enlightening and sometimes contentious conversations about the hottest topics in Architecture today.

Each new series will host five Architects from the community, both internal Microsoft and external folks. Panelists are free to discuss their own personal opinions about the topics and drive conversation to an open forum built for discussion and persuasion. We invite you to TUNE IN today!