You've reached the internet home of Chris Sells, who has a long history as a contributing member of the Windows developer community. He enjoys long walks on the beach and various computer technologies.
Wednesday, Sep 2, 2009, 10:56 AM in Oslo Featured Content
Amanda Laucher on Using Oslo for DSLs
Amanda Laucher talks about Oslo and its tools, Intellipad, m.exe and mg.exe - the "M" compilers - and how they can be used to create a DSL. She demonstrates the creation of a demo DSL in Oslo, and she does it in a very approachable way. [ed: Quadrant is available with the May CTP.]
Friday, Jul 24, 2009, 7:59 AM in Oslo Featured Content
SQL Script to Uninstall an "M" Image
"In the May CTP bits, we started working on parts of uninstall support for schema created by an image, but didn’t expose it as a user-visible feature as we will in future CTPs. So if you want to get your hands on this functionality right now, give this SQL script a try. This creates a stored procedure creatively named 'Uninstall,' which takes one argument, the id of the image to uninstall which can be obtained from the [Language.Catalog.Runtime].[Images] table."
Friday, Jul 10, 2009, 5:44 PM in The Spout
PowerBoots makes me want to use PowerShell!
I've picked up PowerShell half a dozen times or more. The central premise, that I can pipe streams of objects instead of streams of text between programs, is pure genius. However, in the day-to-day, two things make me put it down again every single time:
- The differences between ps and cmd.exe are annoying and unnecessary.
- The lack of pushing the boundaries on the text output in a GUI window leaves me wondering what I really gain when I get over the hump of #1.
I understand the need to "reboot" the DOS command line and get something scalable and consistent, but ps is a superset of cmd.exe and aliasing could've made the transition seamless. However, because little more than "dir" works (and "dir /s" doesn't) I'm constantly bumping into barriers just trying to get my work done in the new shell.
And I'd be really ready to learn ps, especially since it's everywhere now, but what am I really gaining? I never wrote a bunch of shell scripts in cmd.exe and I don't find myself writing them in ps either, which means that the cool "piping objects" thing doesn't make my life any simpler. What I really really want is for the text window of the ps shell to also be something active, e.g. if I do a "dir", I'd like to be able to click on a file or folder in output of dir and open it or right-click on a file and choose a method on the .NET File object to execute. Even better, I'd like all of that functionality but with a keyboard command interface like the old Norton Commander used to provide. I've tried the ps IDEs and GUI shells and haven't liked any of them.
Anyway, the first thing that's made me really really want to move to ps is PowerBoots! It's starting to really deliver on what I had hoped to get out of ps and it feels like Shoes, which I already know I love. Check it out!
Friday, Jul 10, 2009, 1:13 PM in Oslo Featured Content
Modeling Inheritance in "M"
Dave Langer, an architect at Microsoft, explores the question of how to model inheritance in "M". What do you think? What support for inheritance should "Oslo" provide? What scenarios do you need us to nail in this area? Let us know!
Friday, Jul 10, 2009, 8:09 AM in Oslo Featured Content
Use the "Oslo" Repository to Store Service Config
Mikael Håkansson has built a WCF ServiceHostFactory to load service configurations from the "Oslo" Repository, which allows you to configure your services with "Quadrant". And he does it even though the Service.ServiceModel type that has been removed from the May CTP (Keith Short talks about why). Check it out!
Thursday, Jul 9, 2009, 8:13 AM in Oslo Featured Content
Telerik Ships Alpha "M"-Based Comparison Tool
Imagine you've shipped v1 of your database applications against a schema created from "M". Now, you're about to ship the v2 of your database, but what about the v1 clients? Are the tables and views exposed from your database backward compatible or are you going to break those existing clients? How do you even find out?
Well, wonder no more! Telerik has shipped the alpha of their "Oslo" comparison tool, which can compare v1 of your "M" source code against v2 to see what's changed and whether that's going to break your v1 clients. And as if that weren't enough, they're working on another version of the tool that will create scripts so that you can migrate your v1 data to v2 after you're satisfied that your v1 clients will continue to work.
And the best part? It's all free! Download yours today.
Wednesday, Jul 8, 2009, 5:13 PM in Oslo Featured Content
Telerik Does LINQ to "M"
Stephen Forte and Mehfuz (who, like Prince and Cher, needs no last name), have built LINQ to "M", which means that if you've got "M" source code like this (shown in a C# string variable for loading convenience):
string MGraphCode =
@"{{Name=""Stephen Forte"", Age=37}, ... }";
and a C# type like this:
public class Person {
public string Name { get; set; }
public int Age { get; set; }
}
then you can load the "M" source and run LINQ queries against it:
var persons =
QueryContext.Instance.Load<Person>(MGraphCode);
var result =
from person in persons
where person.Age == 37 &&
person.Name == "Stephen Forte"
orderby person.Name ascending
select person;
Enjoy!
Wednesday, Jul 8, 2009, 8:33 AM in The Spout
Dynamic Languages: A Separation of Concerns
I saw Nick Muhonen give a talk on the new language features in C# 4.0 last night at the Portland-Area .NET User Group. He did a good job in spite of the constant questions I asked. He showed one example that I found especially compelling:
object GetConfig() {
return new {
WindowSize = new Size() { Width = 100, Height = 200 },
ConnectionString = "...",
...
};
}
Of course, you wouldn't hard code settings in your application -- you'd load them from somewhere (ideally a database, but that's another story : ). Anyway, in C# 4.0, I can write code like this:
dynamic config = GetConfig();
mainWindow.Size = config.WindowSize;
...
Notice the use of the dynamic keyword -- this means I don't have to know the type at compile-type -- I'll check for the WindowSize property at run-time ala .NET Reflection, COM IDispatch or VB "Option Explicit Off". Of course, this is the cornerstone of all dynamic languages, e.g. Perl, Python, Ruby, etc. These languages have been gaining in popularity for the last few years and I didn't understand why. Tim Ewald, my close friend and compadre, kept trying to explain it to me, but I'm just too slow to get it and I didn't ''til last night watch Nick do his thing. It wasn't looking at the code that Nick typed that made the point for me, it was looking at what he didn't type.
When writing dynamic code, there is no requirement to define a type.
That is, when I inevitably add another property or 10 to my app config, I have to write code to use the new properties, but that's all. I don't have to write a class and I likely don't have to update the save/load code either, because it's also going to be dynamic and just expose whatever data is part of the serialized config. Or, to put it another way:
When writing dynamic code, I only have to write the part I care about.
In the case of dealing with application config, that's about 2/3rds of the code I no longer have to write. Of course, this isn't a new idea -- Stuart Halloway has been talking about embracing essence (the code you care about) and rejecting ceremony (the code you don't) for a long time now. It just took Nick's concrete example for me to understand it.
And not only does this make dynamic code good for reducing the code you type, it always makes it good for the code you're generating, e.g. COM interop assemblies, database mapping code, XML mapping code, etc. In general, I find that most of the code we have generated for us in the .NET programming environment is code to map to foreign type systems, i.e. COM, databases, XML, web services, etc. With dynamic languages, you can write that code once and just use it. In fact, in C# 4.0, there's no need to use Primary Interop Assemblies (PIAs) anymore -- those can just be mapped to a sub-class of the "DynamicObject" type that .NET 4.0 ships to provide that dynamic mapping bridge.
When writing dynamic code, you don't need generated code layers to map to foreign type systems.
This means I don't have to do the mapping to databases per query or to XML per XSD -- I can just have an implementation of DynamicObject, point it at my configuration and go -- no muss, no fuss. Of course, purely dynamic languages have a construct for DO built right in, so it's even easier.
Around the table after Nick's talk last night, someone was complaining that with purely dynamic languages, I give up the benefits of the compiler doing static type checking (I think it was Nick : ). I argued that this was a good thing. The compiler is really just one kind of unit testing -- it's testing names. It can't do any of the other unit testing you need done, however, so you still need unit tests. What that means is that, with static languages, you've got some unit tests separate from your code and some baked into the code via types, casts, etc.
When writing dynamic code, you can separate unit tests completely out of your code.
Of course, as software engineers, we already know that separating concerns leads to better, more readable and more maintainable code, which is why we've long separated our applications into tiers, separated our view from our data, our interfaces from our implementations, etc. Dynamic languages let us do another complete separation of concerns with regards to unit tests that static languages don't allow. In a static language, the ceremony is required, thereby obfuscating the essence.
And all of this is great except for one question -- how do I get my list of possible code to write when I type "." if I'm using a dynamic language or dynamic features of a static language ala C# 4.0?
When writing dynamic code, I don't get Intellisense.
My name is Chris Sells and I'm an Intellisense addict. Admitting I have the problem is the first step...
Tuesday, Jul 7, 2009, 4:09 PM in Oslo Featured Content
Part 3 of Dana's End-to-End "Oslo" Series: Quadrant
In part 1 and part 2 of his series, Dana Kaufman, a Program Manager on the "Oslo" team, used "M" to model the schema for employee information and to create a domain-specific language (DSL) for creating values of that schema. In part 3, Dana shows how to navigate the schema and models in "Quadrant," the data visualization and manipulation tool of "Oslo." Enjoy!
Monday, Jul 6, 2009, 1:07 PM in Oslo Featured Content
Rocky's MCsla on the Olso May CTP
Rockford Lhotka of several C# and VB books and the world-renown CSLA .NET business object framework has ported his "Oslo"-based MCsla.NET to the May 2009 CTP. For the part that he's made work in "Oslo," Rocky has told me that the amount of code you need to write to take advantage of his framework is down by 90% over the C#/VB.NET versions, which sounds like a pretty big win to me. Enjoy!
Monday, Jun 29, 2009, 2:38 PM in Oslo
MGraph Visualizer Plug-in for Intellipad!
Ceyhun Ciper is at it again, this time taking advantage of the Intellipad plug-in capabilities in the "Oslo" May 2009 CTP and adding real-time "M" visualization as you type. This is a wonderful way to see both the textual and graphic abstract symbol tree of your data as you type it. Keep up the good work, Ceyhun!
Wednesday, Jun 24, 2009, 9:43 AM in Oslo Featured Content
JavaScript implementation of "M"
Matthew Wilson is pushing "M" into the land of browser client-side scripting with his partial (but growing!) JavaScript implementation, as seen in his web 3-pane "M" grammar mode ala Intellipad. It's work like this that could make "M" a cross-platform solution for languages as well as data types and values. Good job, Matt!
Tuesday, Jun 23, 2009, 4:09 PM in Oslo Featured Content
Deep Fried Bytes: Shawn Wildermuth on "Oslo"
Keith and Woody speak with the first repeat guest of the podcast, Shawn Wildermuth about Oslo and the M language. In this episode listeners will get some real world examples and use cases for using Oslo and M along with a clearer understanding about DSLs and what the future may hold.
Be warned, this podcast uses the phrase "bowled shrimp." : )
Tuesday, Jun 23, 2009, 7:48 AM in Oslo
Need a visualization of "M" in your programs?
If you want to display "M" languages or values, Ceyhun Ciper from sixpairs.com has got you covered with the MGraph Object Model Display Library for WPF. It's as simple as this:
Canvas canvas = new ObjectModel().Display(
"Person {Name=>'Ciper', 47, 'sixpairs\n.com'}");
Sweet!
Tuesday, Jun 9, 2009, 11:37 AM in Oslo Featured Content
From DSLs & Models to “Quadrant” w/ “Oslo” May CTP
Dana Kaufman, a PM on the extended "Oslo" team, has been blogging a series of articles on the definition of a set of "M" types, the associated "M" language definition for a domain-specific language (DSL) and concluding in how that data can be visualized and manipulated in "Quadrant" (the first two parts are available now and the third is coming). Enjoy!