Live Chat Programs

Also see: Where to Find Technical Support

Uniqueness Typing Simplified , by Edsko de Vries, Rinus Plasmeijer, and David M. Abrahamson.

We present a uniqueness type system that is simpler than both Clean’s uniqueness system and a system we proposed previously. The new type system is straightforward to implement and add to existing compilers, and can easily be extended with advanced features such as higher rank types and impredicativity. We describe our implementation in Morrow, an experimental functional language with both these features. Finally, we prove soundness of the core type system with respect to the call-by-need lambda calculus.

Uniqueness typing is related to linear typing, and their differences have been discussed here before. Linear types have many applications. This paper describes the difference between linear and unique types:

In linear logic, variables of a non-linear type can be coerced to a linear type (dereliction). Harrington phrases it well: in linear logic, “linear” means “will not be duplicated” whereas in uniqueness typing, “unique” means “has not been duplicated”.

In contrast to other papers on substructural typing, such as Fluet’s thesis Monadic and Substructural Type Systems for Region-Based Memory Management , this paper classifies uniqueness attributes by a kind system. This possibility was mentioned in Fluet’s thesis as well, Section 4.2, footnote 8, though the technique used here seems somewhat different.

(more…)

Also see: ASP.NET MVC in CodePlex and Extensible Unit Testing

Also see: Implied tags in the IE HTML parser and how that can be interesting.

Also see: We Live in an “Open Book” World, the Lie of Information Overload

As many of you know, FxCop is static code analysis tool that we originally wrote to ensure the.NET Framework itself adheres to the.NET Framework Design Guidelines. 

The tool as been integrated into Visual Studio as the "Code Analysis" feature, but we also continue to ship the stand alone FxCop download.

Check out the FxCop team blog and download FxCop 1.35 from Code Gallery.

Also see: REST2SQL in a Jiffy, with Tagspace for Spice

Also see: Introducing Microsoft Tagspace

Also see: SourceGear at SD West next week

If you watched the Mix keynote , I am sure you saw the very cool Silverlight Momentum video that shows off a lot of the cool apps we have already seen in Silverlight. 

In case you missed it, here it is:

[Mobile ] [Progressive download ] [streaming ]
[4M CBR ] [720p ] [640x360 ]

Also see: Java perfomance talk

An
AppDomain is a light-weight process. 
Well, if you actually measure the costs associated with an AppDomain –
especially the first one you create, which has some additional costs that are
amortized over all subsequent ones – then “light-weight” deserves some
explanation:

size=2> 

A Win32
process is heavy-weight compared to a Unix process.  A Win32 thread is heavy-weight compared
to a Unix thread, particularly if you are using a non-kernel user threads
package on Unix.  A good design for
Windows will create and destroy processes at a low rate, will have a small
number of processes, and will have a small number of threads in each
process.

size=2> 

Towards
the end of V1, we did some capacity testing using ASP.NET.  At that time, we were able to squeeze
1000 very simple applications /
AppDomains into a single worker process. 
Presumably that process would have had 50-100 threads active in it, even
under heavy load.  If we had used OS
processes for each application, we would have 1000 CLRs with 1000 GC heaps.  More disturbing, we would have at least
10,000 threads.  This would reserve
10 GB of VM just for their default 1 MB stacks (though it would only commit a
fraction of that memory).  All those
threads would completely swamp the OS scheduler.

(more…)

Also see: From C# to Java: Part 5

I had
hoped this article would be on changes to the next version of the CLR which
allow it to be hosted inside SQL Server and other “challenging”
environments.  This is more
generally interesting than you might think, because it creates an opportunity
for other processes (i.e. your
processes) to host the CLR with a similar level of integration and control.  This includes control over memory usage,
synchronization, threading (including fibers), extended security models,
assembly storage, and more.

< ?xml:namespace prefix = o ns =
"urn:schemas-microsoft-com:office:office" /> size=2> 

However,
that topic is necessarily related to our next release, and I cannot talk about
deep details of that next release until those details have been publicly
disclosed.  In late October,
Microsoft is holding its PDC and I expect us to disclose many details at that
time.  In fact, I’m signed up to be
a member of a PDC panel on this topic. 
If you work on a database or an application server or a similarly
complicated product that might benefit from hosting the CLR, you may want to
attend.

(more…)

Also see: Will you watch what I watch ?

Also see: From C# to Java: Part 5

Also see: Microformats are like RFID tags for the Web

Jon’s fascination with libraries has given him a deep understanding of the ISBN format. This reminds me of all the people that “whip” together a XML parser and forget to support all the complex corners of it. Everything is much more complicated than it first seems once you have understood it completely.

Favorite bug of the day: Someone was parsing version numbers and thought the format was always 4 sets of 1-4 digits separated by periods. (1.23.456.5678)… of course, the actual format for version numbers is 4 DWORDs, which, when printed can be many more characters long… boy I wish people would read specs before writing code!

Also see: Never keep your emotions bottled up

At Mix08 , several people asked me about the possibility of creating a single source base for both WPF and Silverlight.  The scenario folks had in mind was to provide a reach solution with Silverlight that hits *ALL* possible users while also offering a really rich solutions for some users on full WPF (.NET Framework 3.0 or 3.5). 

This is a clear benefit of the Microsoft Ux platform.. We have worked hard to get a smooth continuum between WPF and Silverlight… Basically if it works in Silverlight you should be pretty sure it will work on WPF. 

I was chatting David Anson (one of the developers of the Silverlight 2 controls) and he mentioned that the shipping versions of ListBox and ScrollViewer were written this way!   That is right, to test out the continuum message, David built ListBox and ScrollViewer for Silverlight in such a way that the run (and past unit tests) on both WPF and Silverlight.  

Now, in and of itself, this is not all that interesting, because WPF already has a ListBox and ScrollViewer, but it does serve as a nice test case to demonstrate how you can build controls and applications that work on both Silverlight and WPF. 

Because we shipped the source and unit tests for the Silverlight controls, you can check this out yourself ! 

In addition, David did a nice blog detailing the work he did and why and posted the test project you can try out as well. 

On a related note, be sure to check out the final step of ScottGu’s Silverlight 2 tutorial…  Notice how easy it is for him to make a WPF application out of it.

Also see: Using Silverlight 2 on a production Web Server

Also see: Web Services with Spring 2.5 and Apache CXF

Also see: NHL seven days a week

Just a quick explanation for why there hasn’t been a new
blog lately.  I’m partway through a 3.5 week vacation on Maui.  I have
wireless & broadband out by the pool, but I can’t seem to find the time to
blog.  Things will return to normal by mid-July.

Also see: A Start at Test Driven Development with Silverlight 2

Applied Metamodelling: A Foundation for Language Driven Development (2004)
by Tony Clark, Paul Sammut, James Willans

An excerpt:

Language-driven development is fundamentally based on the ability to rapidly design new languages and tools in a unified and interoperable manner. We argue that existing technologies do not provide this capability, but a language engineering approach based on metamodelling can. The detailed study of metamodelling and how it can realise the Language-Driven Development vision will form the focus for the remainder of this book.

In software engineering circles the term “language driven development” is synonymous with “language oriented programming”, a term which LtU members are more familiar with (thanks to Martin Ward’s article Language Oriented Programming which first appeared in 1994, and then Martin Fowler’s essays on the topic). The book hasn’t appeared on the radar here on LtU, despite 41 citations. I suspect this is due in part to only one citation at Citeseer , and the lack of cross-talk between computer scientists and software engineers.

There are a lot of similarities between the XMF language (discussion at LtU ) and that of the Katahdin language (discussion at LtU ). Other related discussions here at LtU, include Language Workbenches: The Killer App for DSLs - about the essay by Martin Fowler, Ralph Johnson: Language workbenches - a response to Fowler’s essay, XActium - Lightweight Language Engineering? - which discusses an essay about a previous version of XMF, Generating Interpreters? , Language Oriented Programming - discusses an essay by Jetbrain’s Sergey Dmitriev, “Language Oriented Programming” Meta Programming System - discussion of the Jetbrain MPS system, The DSL, MDA, UML thing again… - an older discussion on the relationship between DSLs and MDA.

(more…)

Also see: Introducing Microsoft Tagspace

As a member of Microsoft’s VSIP
program, we have been creating source control plugins for the Visual Studio
line of products for eight years.  As I started my recent foray into the
Eclipse world, I was eager to explore the area of plugins over on this side of
the fence.  So far, I’m impressed.

Source Control and Bug Tracking

The first plugin I installed was our own.  SourceGear
Fortress includes an Eclipse plugin, but I had never even tried it.

My first reaction is that I really like the way Eclipse
handles installation of plugins.  The whole process is managed from within
Eclipse itself.  Under the Help menu is a submenu called Software Updates.  All
I have to do is provide the URL of our Eclipse update site:

http://download.sourcegear.com/Fortress/latest/update

The rest of the job is very simple, essentially automatic.

Once installed, I have several additional views:

src="http://software.ericsink.com/entries/1731_image001.jpg"/>

And some new stuff under the Team menu:

src="http://software.ericsink.com/entries/1731_image002.jpg"/>

And some new items under Preferences:

src="http://software.ericsink.com/entries/1731_image003.jpg"/>

All in all, I have found using source control under Eclipse
to be very pleasant and straightforward.  If this seems like I am bragging
about my own product, I suppose it is, except for two mitigating factors:

1. I personally had nothing to do with this plugin, so this
   is less of a boast and more of a compliment to the efforts of my
   coworkers.

2. In my experience, source control plugins are a lot like
   children.  To some extent, the behavior of a child (or plugin) reflects
   the quality of the structure and guidance provided by the parent (or
   IDE).  In saying that our source control plugin works very well, I am
   complimenting Eclipse.

(more…)