|Stable release||November 2009 CTP / 17 November 2009|
|Written in||.NET Framework|
|Type||Application programming interface|
Oslo is the former code name for what is now called the SQL Server Modeling CTP, a set of future Microsoft modeling technologies that aim to provide significant productivity gains across the lifecycle of .NET Framework applications by enabling developers, architects and IT professionals to work together more effectively. Its goal is to significantly increase programming productivity within the context of a broader initiative known as Dynamic IT. It was first announced in October 2007 and early Community Technology Previews (CTPs) of the technology have been released in October 2008, January 2009, May 2009 and November 2009. In November 2009 CTP, the technologies are collectively called the SQL Server Modeling CTP, slated to ship in a future major release of Microsoft SQL Server. On 22 September 2010, however, Microsoft announced the project had been cancelled, to focus on OData instead.
Originally, in 2007, the "Oslo" name encompassed a much broader set of technologies including "updated messaging and workflow technologies in the next version of BizTalk Server and other products" such as the .NET Framework, Microsoft Visual Studio and Microsoft System Center (specifically the Operations Manager and Configuration Manager).
By September 2008, however, Microsoft changed its plans to redesign BizTalk Server around "Oslo". Other pieces of the original "Oslo" group were also broken off and given identities of their own; "Oslo" ceased to be a container for future versions of other products. Instead, it was identified as a set of software development and systems management tools:
- A centralized repository for application workflows, message contracts (which describe an application's supported message formats and protocols) and other application components
- A modeling language to describe workflows, contracts and other elements stored in the repository
- A visual editor and other development tools for the modeling language
- A process server to support deployment and execution of application components from the repository.
When "Oslo" was first presented to the public at the Microsoft Professional Developers Conference in October 2008, this list has been focused even further. The process server was split off as code name "Dublin" that would work with "Oslo", leaving "Oslo" itself composed of the first three components above that are presently described (and rearranged) as follows:[dead link]
- SQL Server Modeling Services (formerly the 'repository'), a core database role for models and a set of shared, common domain models. Modeling Services is built on Microsoft SQL Server and is highly optimized to provide your data schemas and instances with system-provided best SQL Server practices for scalability, availability, security, versioning, change tracking and localization. Common domain models include identity, CLR and UML.
- A configurable visual tool (Microsoft code name "Quadrant") that enables you and your customers to interact with the data schemas and instances in exactly the way that is clearest to you and to them. That is, instead of having to look at data in terms of tables and rows, "Quadrant" allows every user to configure its views to naturally reveal the full richness of the higher-level relationships within that data. Microsoft stopped development on Quadrant in July 2010.
- A language (Microsoft code name "M") with features that enable you to model (or describe) your data structures, data instances and data environment (such as storage, security and versioning) in an interoperable way. It also offers simple yet powerful services to create new languages or transformations that are even more specific to the critical needs of your domain. This allows .NET Framework runtimes and applications to execute more of the described intent of the developer or architect while removing much of the coding and recoding necessary to enable it.
Most recently, at the Professional Developer's Conference in November 2009, Microsoft announced that the 'Oslo' name was being retired and that the technologies were now called the SQL Server Modeling CTP. This naming was chosen because of the natural alignment of the technologies with Microsoft SQL Server and because the technologies would be shipping with a future major release of that product.
The use of SQL Server in the name has generated some confusion about how things like the "M" language relate to a database engine. The SQL Server product, however, encompasses many features beyond the core database, as architect Douglas Purdy explains.[dead link]
Relationship to "Dynamic IT"
SQL Server Modeling is also presently positioned as a set of modeling technologies for the .NET platform and part of the effort known as Dynamic IT. Bob Muglia, Senior Vice President for Microsoft's Server & Tools Business, has said this about Dynamic IT:[dead link]
It costs customers too much to maintain their existing systems and it's not easy enough for them to build new solutions. [We're focused] on bringing together a cohesive solution set that enables customers to both reduce their ongoing maintenance costs while at the same time simplifying the cost of new application development so they can apply that directly to their business.
The secret of this is end-to-end thinking, from the beginning of the development cycle all the way through to the deployment and maintenance, and all the way throughout the entire application lifecycle.
One of the pillars of this initiative is an environment that is "model-driven" wherein every critical aspect of the application lifecycle from architecture, design, and development through to deployment, maintenance, and IT infrastructure in general, is described by metadata artifacts (called "models") that are shared by all the roles at each stage in the lifecycle. This differs from the typical approach in which, as Bob Kelly, General Manager of Microsoft's Infrastructure Server Marketing group put it:[dead link]
[a customer's] IT department and their development environment are two different silos, and the resulting effect of that is that anytime you want to deploy an application or a service, the developer builds it, throws it over the wall to IT, they try to deploy it, it breaks a policy or breaks some configuration, they hand that feedback to the developer, and so on. A very costly [way of doing business].
By focusing on "models"—model-based infrastructure and model-based development—we believe it enables IT to capture their policies in models and also allows the developers to capture configuration (the health of that application) in a model, then you can deploy that in a test environment very easily and very quickly (especially using virtualization). Then having a toolset like System Center that can act on that model and ensure that the application or service stays within tolerance of that model. This reduces the total cost of ownership, makes it much faster to deploy new applications and new services which ultimately drive the business, and allows for a dynamic IT environment.
To be more specific, a problem today is that data that describes an application throughout its lifecycle ends up in multiple different stores. For example:
- Planning data such as requirements, service-level agreements, and so forth, generally live in documents created by products such as Microsoft Office.
- Development data such as architecture, source code, and test suites live within a system like Microsoft Visual Studio.
- ISV data such as rules, processes modes, etc. live within custom data stores.
- Operation data such as health, policies, service-level agreements, etc., live within a management environment like Microsoft System Center.
Between these, there is little or no data sharing between the tools and runtimes involved. One of the elements of SQL Server Modeling is to concentrate this metadata into the Modeling Services database, thereby making that repository really the hub of Dynamic IT.
The SQL Server Modeling CTP, then, is that set of tools that make it easier to build more and more of any application purely out of data. The SQL Server Modeling technologies aim to have the entire application throughout its entire lifecycle completely described in data/metadata that it contained within a database. As described on the Data Developer Center:[dead link]
Model-driven development in the context of the SQL Server Modeling CTP indicates a development process that revolves around building applications primarily through metadata. This means moving more of the definition of an application out of the world of code and into the world of data, where the developer’s original intent is increasingly transparent to both the platform and other developers. As data, the application definition can be easily viewed and quickly edited in a variety of forms, and even queried, making all the design and implementation details that much more accessible. As previously discussed, Microsoft technologies have been moving in this direction for many years; things like COM type libraries, .NET Framework metadata attributes, and XAML have all moved increasingly toward declaring one’s intentions directly as data—in ways that make sense for your problem domain—and away from encoding them into a lower-level form, such as x86 or .NET Framework intermediate language (IL) instructions. This is what the SQL Server Modeling CTP is all about.
The "models" in question aren't anything new: they simply define the structure of the data in a SQL server database. These are the structures with which the SQL Server Modeling tools interact.
Modeling Services Repository and Domains
SQL Server Modeling Services provides a robust, enterprise-ready storage location for the data models. It takes advantage of the best features of SQL Server 2008 to deliver on critical areas such as scalability, security, and performance. The Base Domain Library (BDL) of SQL Server Modeling Services provides infrastructure and services, simplifying the task of creating and managing enterprise-scale databases. Modeling Services provides the foundation for productively building models and model-driven applications with SQL Server Modeling CTP.
Modeling Services also includes additional pre-built "domains," which are pre-defined models and tools for working with particular kinds of data. At present, such domains are included for:[dead link]
- The Common Language Runtime (CLR), which supports extracting metadata from CLR assemblies and storing them in the Modeling Services database in such a way that they can be explored and queried. A benefit to this domain is that it can maintain such information about the code assets of an entire enterprise, in contrast to tools such as the "Object Explorer" of Microsoft Visual Studio that only works with code assets on a single machine.
- Unified Modeling Language (UML), which targets the Object Management Group's Unified Modeling Language (UML) specification version 2.1.2. UML 2.1.2 models in the Object Management Group's XML Metadata Interchange (XMI) version 2.1 file format can be imported into the Modeling Services database repository with a loader tool included with the SQL Server Modeling CTP.
Note that while the SQL Server Modeling Services is part of the toolset, models may be deployed into any arbitrary SQL Server database; the "Quadrant" tool is also capable of working with arbitrary SQL Server databases.
"M" Modeling Language
According to the Data Developer Center, the "M" language and its features are used to define "custom language, schema for data (data models), and data values."[dead link] The intention is to allow for very domain-specific expression of data and metadata values, thereby increasing efficiency and productivity. A key to "M" is that while it allows for making statements "about the structure, constraints, and relationships, but says nothing about how the data is stored or accessed, or about what specific values an instance might contain. By default, 'M' models are stored in a SQL Server database, but you are free to modify the output to any storage or access format. If you are familiar with XML, the schema definition feature is like XSD."[dead link] The "M" language and its associated tools also simplify the creation of custom domain-specific languages (DSLs) by providing a generic infrastructure engine (parser, lexer, and compiler) that's configured with a specific "grammar". Developers have found many uses for such easy-to-define customer languages. Examples can be found in the "M" Language Gallery.
Recognizing the widespread interest in the ongoing development of the language, Microsoft shifted that development in March 2009 to a public group of individuals and organizations called the "M" Specification Community.
"Quadrant" Model Editor
Users can create a new database using the “M” language or connect to an arbitrary number of SQL Server databases and open multiple windows (called workpads) to view and edit data in what is called a session. This is accomplished without typing a query. In every workpad, the data is displayed in one of a number of standard viewers. The query for the data displayed in each workpad is shown in the query bar at the top of each workpad. Data can be viewed in a variety of viewers: as a simple list, a set of properties, a table, a diagram, or as a tree of expandable nodes. You can change the viewer of any workpad. This allows you to either see different data or to see the data in a new way. For example, a list view gives you the most basic information, but a table view of the same data reveals properties of any single item. A tree view of the same data shows hierarchical relationships between the original list and the properties of any single item.
Microsoft intended for "Quadrant" to support greater degrees of domain-specific customization, allowing developers to exactly tailor the interaction with data for specific users and roles within an enterprise.
Microsoft stopped development on Quadrant in July 2010.
- Brockschmidt, Kraig (22 September 2010). "Update on SQL Server Modeling CTP (Repository/Modeling Services, "Quadrant" and "M")". Model Citizen blog. Microsoft. Retrieved 7 December 2012.
- Directions on Microsoft - Research, November 2007. Available by subscription on www.directionsonmicrosoft.com
- Helm, Rob (22 September 2008). "BizTalk Server to Skirt 'Oslo'". Directions on Microsoft. Retrieved 7 December 2012.(registration required)
- "SQL Server Modeling CTP and Model-Driven Applications". MSDN. Microsoft.[dead link]
- Foley, Mary Jo (5 August 2010). "Another piece of Microsoft's Oslo modeling puzzle disappears". ZDNet. CBS Interactive. Retrieved 7 December 2012.
- http://www.douglaspurdy.com/2009/11/20/is-sql-server-modeling-nee-oslo-only-for-sql-server[dead link]
- http://www.microsoft.com/winme/0705/30242/Bob_Muglia-Dynamic_IT_MBR.asx[dead link]
- http://www.microsoft.com/winme/0705/30242/Bob_Kelly-Virtualization_MBR.asx[dead link]
- "SQL Server Modeling Domains Overview" on the Data Developer Center[dead link]
- "Documents associated with UML Version 2.1.2". Object Management Group. November 2007. Retrieved 7 December 2012.
- "Documents associated with xMI Version 2.1". Object Management Group. September 2005. Retrieved 7 December 2012.
- "'M' Language Gallery". Data Developer Center (MSDN). Microsoft. Archived from the original on 23 August 2010.
- "M Specification Community". Data Developer Center (MSDN). Microsoft. Archived from the original on 22 August 2010.
- Kyle, Bruce (13 October 2008). "First Oslo CTP Ships at PDC". ISV Developer Community (MSDN blogs). Microsoft. Retrieved 7 December 2012.
- Krill, Paul (10 October 2008). "Microsoft elaborates on Oslo". InfoWorld. IDG. Retrieved 7 December 2012.
- "Microsoft "Oslo" SDK - January 2009 CTP (Refresh)". Download Center. Microsoft. 2 March 2009. Retrieved 7 December 2012.
- "Microsoft "Oslo" - May 2009 CTP". Download Center. Microsoft. 26 May 2009. Retrieved 7 December 2012.
- "SQL Server Modeling CTP - Nov 2009 Release 3 (formerly "Oslo")". Download Center. Microsoft. 20 April 2010. Retrieved 7 December 2012.