decav.com

Moving on...

mrdecav — Thu, 18 Sep 2008 22:38:00 GMT

To those that know me well, this post is of no surprise, however given that I haven't been posting for a while, and probably won't for a while more, I thought it was appropriate to post a quick, personal update. As of a week ago, I left my colleagues at Lab49 to pursue an exciting new venture which I hope will make the lives of many people easier. Because this venture is based on web technologies, I bought a mac and just to fit in a latte as well, and settled down in a world not as well known to me -- of Open Source and Unix/Linux. Unfortunately due to the sensitivity of any new venture, my next several months of work will be as secretive as possible. I will not be sharing technical secrets or what the project is about until a few months from now. For that reason, this blog will remain sparse for the next few months.

Introducing PowerShell Pages - Script Style HTML Rendering

mrdecav — Sat, 05 Jul 2008 17:59:00 GMT

Early in the web development world, scripting languages such as ASP or PHP were used to compose pages. Although this proved great for relatively static pages, the dynamic web, filled with rich applications called for a more powerful framework. Thus, frameworks like ASP.NET were born.

ASP.NET solved a good number of problem spaces, but has made creating simple pages (such as a resume or menu, or other primitive list of data) more cumbersome. With the world of COM development becoming less common and less preferable, the gap for a scripting language to replace VBScript/ASP is needed. PowerShell scripting has filled the gap left by the demise of VBScript, but nothing has come along to replace ASP.

PowerShell Pages is an ASP like language, based on the PowerShell runtime. Using a simple HTTP Handler, ASP.NET can render pages scripted using PowerShell script (including cmdlets, and CLR/.NET objects) to the web. Simple, fast and intuitive programming for simple pages that just need to display some content.

The PowerShell Pages project is an open source project that I am starting. Its implementation will be based on ASP.NET using a simple handler capable of consuming PowerShell HTML (PSH) scripts and writing HTML. Because the script is hosted in ASP.NET, the ASP.NET HttpContext and the other components of the object model are available. PSH scripts can work side-by-side with ASPX pages.

Ready to see what PowerShell Pages look like?
Sample Page: http://decav.com/psp/resume.psh
Sample Page Code: http://decav.com/psp/viewsource.psh?page=resume.psh
View Source Code: http://decav.com/psp/viewsource.psh?page=viewsource.psh

Join the Project - Visit the PowerShell Pages CodePlex project workspace

Gatsb.com Now Open Source (A Case Study in Geotagging, Workflow Foundation, SMS/MMS Parsing)

mrdecav — Sat, 14 Jun 2008 15:37:00 GMT

After hosting Gatsb.com for a year, I have decided to open source the project. I haven't had time to promote it the way I wanted to promote it, and it therefore hasn't caught on with too many users. I've been busy with other projects, other (grander) ideas, and think that this one should now belong to the community.

You can download the source code here: http://code.google.com/p/gatsb/

If you want to contribute to the project, please feel free to contact me at andreblog@decav.com

This project is a great case study of a bunch of new Microsoft technologies. It includes Workflow Foundation, .NET 3.0, Microsoft Virtual Earth and ASP.NET Ajax.

One of the coolest features is how it keeps open a "session" with an SMS client. Workflow Foundation is used to persist the state and when a new SMS comes in, it checks if theres an existing session for that SMS. If there is, then it will revive the workflow and continue the session. Cool stuff!

If you ever wondered how to create a database of geotagged entries, use ASP.NET ajax to make a snazzier site, or establish a user interface with any mobile device, I suggest checking out the code!

PowerShell: Repeat Yourself with the Command "Scratch Pad"

mrdecav — Wed, 21 May 2008 13:08:00 GMT

Heres a useful snippit of code I wrote as a utility and thought I'd post up for everyone. Very often when using a command line, you need to repeat a set of commands. For example, copy several files:

copy "c:\blah.txt" "c:\otherPlace\blah.txt"
copy "c:\dev\blah.txt" "c:\otherPlace\blah2.txt"

History is okay for this, but if you have a set of commands you need to run, you need to run them each individually. Also, if you go to do something else, they'll eventually lose their spot in the command history.

To solve this, I created a "scratch pad". Nothing special, but definately useful.

new-scratch "MyFirstScratch"
copy "c:\blah.txt" "c:\otherPlace\blah.txt"
scratch
copy "c:\dev\blah.txt" "c:\otherplace\blah2.txt"
scratch
## Do some other stuff here...
get-scratch # prints out the contents of the scratch.
invoke-scratch

This scratch pad is holds a set of commands that you want to rerun later. You can then call invoke-scratch to run the scratchpad. You can have multiple scratch pads, and use them by just adding the name to the end of the function (get-scratch "MyFirstScratch"). By default all scratch pad commands will default to the last used scratch pad.

The example below shows how to shorten the sample above:

new-scratch "MyFirstScratch"
copy "c:\blah.txt" "c:\otherPlace\blah.txt"
copy "c:\dev\blah.txt" "c:\otherplace\blah2.txt"
scratch 2 # Saves the last 2 items to the scratch pad

This can be very useful for writing scripts too. the Save-Scratch command lets you export your scratch to a file.

Heres the code. Add it to your profile and go. Enjoy!

function New-Scratch($name) {
  if ($global:scratchPads -eq $null) {
    $global:scratchPads = @{}
  }
  
  $pad = new-object System.Collections.ArrayList
  $global:scratchPads.Add($name, $pad)
  $global:currentScratchPad = $pad
  $global:currentScratchPadName = $name
}
function Get-Scratch($name=$null) {
  if ($name -ne $null) {
    $global:currentScratchPad = $global:scratchPads[$name]
    $global:currentScratchPadName = $name
  }
  
  return $global:currentScratchPad
}
function Scratch([int]$count=1,$name=$null) {
  if ($name -ne $null) {
    $global:currentScratchPad = $global:scratchPads[$name]
    $global:currentScratchPadName = $name
  }
  
  $hist = get-history
  
  if ($name -eq $null) {
    $name = $global:currentScratchPadName
  }
  
  for ($i=$hist.Length-$count; $i -lt $hist.Length; $i++) {
    $global:currentScratchPad.Add($hist[$i].CommandLine) | out-null
  }
}
function Invoke-Scratch($name=$null) {
  if ($name -ne $null) {
    $global:currentScratchPad = $global:scratchPads[$name]
    $global:currentScratchPadName = $name
  }
  
  foreach ($item in $global:currentScratchPad) {
    write-host ">> $item"
    invoke-expression $item
  }
}
function Save-Scratch($path, $name=$null) {
  if ($name -ne $null) {
    $global:currentScratchPad = $global:scratchPads[$name]
    $global:currentScratchPadName = $name
  }
  
  $global:currentScratchPad | out-file $path
}

Invoking PowerShell Scripts from An Application

mrdecav — Thu, 01 May 2008 20:01:00 GMT

If you want to run your PowerShell scripts from a piece of code you're writing, and would prefer not to use Process.Start, you can easily use the PowerShell runtime classes to run those scripts for you, completely in-process.

The code snippit below shows how you can create a Runspace and pass it some simple commands.

List<Command> commands = new List<Command>();
commands.Add(new Command("set-location c:\\"));
commands.Add(new Command("./MyScript.ps1 'myParameter'", true));

using (Runspace runspace = RunspaceFactory.CreateRunspace())
{
    runspace.Open();
    using (Pipeline pipeline = runspace.CreatePipeline())
    {
        foreach (Command cmd in commands)
        {
            pipeline.Commands.Add(cmd);
        }
        pipeline.Invoke();
    }
    runspace.Close();
}

One thing to note here is you do not have a PSHost, so if you have a write-host anywhere, it will fail with the following exception:

CmdletInvocationException: Cannot invoke this function becasue the current host does not implement it.

To get around this, you can remove write-host from your scripts and just have them write single lines, or you can implement a simple PSHost (although this is a bit harder than it sounds).

Solution: "Unknown error", LDAP connection strings and System.DirectoryServices

mrdecav — Thu, 01 May 2008 19:50:00 GMT

If you've been using System.DirectoryServices.DirectoryEntry class, or the newer System.DirectoryServices.AccountManagement namespace to access your LDAP or Active Directory server, you may have experienced the following error:

COMException: "Unknown error (0x80005000)"

This can happen for numerous reasons, but one of the most frustrating and overlooked reason's I've found for this problem is when your LDAP connection string is malformed. One of the most common malformations is in the case sensitivity of the LDAP:// component. For example, LDAP://myServer/cn=users,dc=myserver,dc=com is a valid connection string, however ldap://myServer/cn=users,dc=myserver,dc=com is not.

If you use the Uri or UriBuilder classes, the builder may lowecase your scheme. Always make sure to recapitalize the scheme when passing it into DirectoryEntry or any other API.

Cluster Primitives: MPI, MPI.NET, Large Data, and Passing Classes

mrdecav — Sun, 27 Apr 2008 05:06:00 GMT

The Message Passing Interface (MPI) standard, and its .NET implementation, MPI.NET have been some of the cornerstones of development on compute clusters. The standard supplies a simple yet primitive way of both sending and receiving data between running compute processes.

The large advantage of MPI has been a mix of its simplicity and speed. A call to MPI Send on one node and MPI Receive on another block both callers until the operation is complete. Some more complex calls, such as MPI Scatter and MPI Gather allow a single node to distribute data to a set of nodes or retrieve it from a set of nodes. An MPI Barrier allows all nodes to stop until they have all reached the agreed upon place in code, then allowing them to continue. Such primitives allow a distributed set of processes to communicate, do some work, and then share values that each needs to continue with eachother. Because this is all done with some low level, bare metal socket tricks and/or shared memory, the result is blazingly fast communication.

With this simplicity however, comes a trade off. MPI has been a standard for nearly 20 years and has changed very little since its inception. The way we program today has changed drastically, especially with managed languages such as C#. No longer do we tend to worry about memory allocation, or dealing with raw memory. Today, most languages have a concept of automatic memory allocations, garbage collection and type safety. Although the primitives in MPI are unparalleled in simplicity for allowing multiple processors to communicate about a shared set of work, some striking limitations are found once we dig a bit deeper.

When I started with MPI.NET, I found the interface very simple. An Mpi.Send<T>(obj) would send an object to a waiting client. Mpi.Receive<T>() would give you back that object. Nothing could be simpler. In my example, however T happened to be a class that contained a byte[] of an undetermined size. Once run on the cluster, the size of the byte[] I was passing increased dramatically, and an unexpected exception occured:

AccessViolationException: Attempted to read or write protected memory. This is often an indication that other memory has been corrupted.

After lengthy investigation, I found that MPI.NET was attempting to pin some memory in the .NET GC heap and pass that memory location as a buffer to the underlying MSMPI stack. In doing so, it did not allocate enough memory for my large byte[], causing the write to try to write into the GC heap, thus throwing the exception. In my case, to solve this, I created a large enough buffer and passed it into an override of Mpi.Receive<byte>(byte[]). This overload pins the entire array that was passed in on the GC, and then passes that to the MSMPI stack. On the send side, I manually serialized my class, checked the length (to ensure I would not overflow the receive buffer) and sent the byte[] instead of the raw class. This solution does not take into accound messages larger than my expected buffer. For that, I would have needed to chunk down the data.

The moral of the story here is sending primitives, arrays of primitives or fixed-sized structs over MPI.NET (which is the most common scenario) is a great use of a very fast messaging interface. Once your demands get more complex, the MPI stack gets less favorable, not because of its inability to send more complex messages, but because of the manual labor involved in serializing and chunking down data.

It is no wonder that the HPC community is moving away from the traditional methods of MPI and communication across a set of processors to a Service Oriented (SOA) model. The benefits of using existing components, such as WCF and its NetTcpBinding, the threading models, serialization and transport models, and other features already provided by these frameworks outweights the possible performance penalty. Problems such as the one explained above simply do not happen with frameworks like WCF. Furthermore, although the underlying concepts of MPI and its simple messaging model are very simple and appealing, the overall development, maintainence and debugging of a SOA application is much simpler than that of a MPI application. The amount of code complexity and custom code drops when compared to an MPI implemenation.

The general industry trend seems to be towards SOA models. Microsoft Windows HPC Server 2008 is a great example of this. HPC Server uses WCF to distribute load across the cluster, and can even dynamically scale resources depending on demand of a particular service. Platform, another industry competior has been building with a SOA model for some time now.

I'm looking forward to playing with HPC Server 2008 and WCF more as time progresses. I think that the WCF model will solve a whole bunch of headaches that one incurs when trying to communicate over perhaps over simple primitives such as MPI. Many models and workloads simply do not require the type of communication MPI provides, and using MPI can be like fitting a square peg into a round hole. This is not to say MPI does not have its place, many complex processes do require constant communication between a set of workers, however I believe many of the problems we use HPC for today can distributed using SOA in a much simpler fashion.

Ruby, From The Eyes of a C# .NET Developer

mrdecav — Wed, 12 Mar 2008 02:37:00 GMT

I recently got to playing with Ruby, something that some colleagues in Lab49 have been big fans for some time. I've never been a big fan of scripting languages, but have grown more of an appreciation for functional programming over the past several months and thought I would give it a try.

Ruby is a very smart language, and I can certainly see why it has some appeal. The "don't repeat yourself" and "defaults over configuration" aspects of the language and its framework are really nice for cranking out simple applications.

ORM and Inference of Properties from database

I am a big fan of the objects that automatically get their properties from the database (a Customer object will automatically be linked with the Customers table when pulled through the ORM). Things like this make it dirt simple to crank out web projects of moderate size without writing tons of redundant code (as is the case with a classic OO approach, using adapters, abstractions, etc).

Even though this is a nice feature, and great for many projects, I am concerned that this is simply not sufficient for larger enterprise apps. Very often your app layer and database layer should be different, as one does not always properly map to the other. I suppose that you could achieve this nicely with views, however for large applications, the lack of abstraction seems a little brittle to me. At the same time, if you did change something in your database, you'd still have to change your abstraction logic, so maybe this isn't all that bad.

Syntax

The syntax of Ruby is very clean and straight forward. I like the bare bones structure, nothing more than needed is written. Reading into it a bit more, I found it interesting that various things can be written in several ways, for example:

while i < 3
print(i)
end

can also be written

print(i) while i < 3

While conceptually this is nice (the latter "reads" better), it is something I have a really hard time accepting. Yes it is nice not to have to write things like "end", however, syntactical differences like this (and others, such as the optional parenthesis around method parameters) concern me. While its great that you can develop your own style, and do what feels comfortable to you, it may be very confusing to other developers. An argument can be made either way, after call you can do this:

if (i < 3) Console.WriteLine(i);

in C#. Nothing stops you. At the end of the day, sloppy code is sloppy code, and its really a matter of having a well trained developer, not a strict language.

Naming Conventions

Here's something that threw me off. Ruby does a very good job of making names intuitive, however some of their names seem to break their own concepts. First of all, names like to_s are just sloppy. If you're making a lanugage thats supposed to be readable, why write cryptic names like this? Also, whats the deal with properties count and length being synonyms? Why have both? It seems relatively dangerous to me to have methods that mean the same thing on objects. A developer who sees count in one place and length in another may think they are different, something that certainly doesn't help code legibility.

Overall, Ruby has been fun to learn (although I'm still a novice), and I can certainly see its value. I'm not sure if I agree with some of its "friendly" tendencies -- being able to write whatever you feel and have it probably compile is not necessarily good. Just because code compiles doesn't mean its good code -- some bugs the compiler may catch now become runtime bugs. On the other hand, things like the ORM make it very easy to build rich apps with little code, something that .NET still comes up short on (just because designers generate LINQ classes doesn't mean that the code isn't there). Looking forward to playing more!

WPF Compute Cluster Monitor Demo - Using 3D, Transparency and Styles

mrdecav — Tue, 19 Feb 2008 21:22:00 GMT

Here's a cool demo that Ronald Lintag and I threw together for Lab49. The application is supposed to demo a basic GUI that shows the status of nodes and jobs on a compute cluster. We're showing off the use of WPF 3D and styles to create a cool looking console for a sys-admin. You can imagine how something developed off this base could turn into a real product.

This demo is a bit rough around the edges, and definately needs polish, but its still worth a look.

Press J to bring up the job list.
Use the dropdown at the bottom of the job list to add some jobs.
Click on job to view details about their tasks.
The nodes in the background vary from gray to green to red depending on their utilization

Click here to launch the application (.NET 3.5 required)

Here are a few screenshots for those of you who are not adveturous enough for the ClickOnce...

Distributed/Grid Computing with Silverlight

mrdecav — Wed, 26 Dec 2007 08:07:00 GMT

Daniel Vaughan has a very cool project up on CodeProject.com. He's built an awesome grid computing "platform" using Silverlight for his compute nodes. Think SETI@Home style.

CodeProject article: http://www.codeproject.com/KB/silverlight/GridComputing.aspx

Online Demo: http://www.orpius.com/Silverlight/Legion/

Make sure you checkout the administration console in the demo!

Windows Compute Cluster (HPC) Basics: Running Map/Reduce Models on CCS 2003

mrdecav — Wed, 26 Dec 2007 07:31:00 GMT

After not writing anything about HPC or Windows Compute Cluster for a while, I figured its about time I write *something* about it because I've been working with it so much recently!

Download the Sample Project (Visual Studio 2008, Beta 2)

Windows Compute Cluster Server 2003 is Microsoft's relatively new implementation of cluster computing running on Windows. Although Microsoft is starting behind in this game (Unix has been in grid computing for a long time now), the .NET development environment and ease of administration makes CCS a very compelling environment. The first version of CCS is not very feature rich, but provides the core components required to build distributed applications. Version 2 (named Windows HPC 2008) which is currently in beta offers a much wider range of functionality and should add some new ideas and competitve edge to the Windows grid computing world.

In my current project, I have gotten to experience quite a bit of what CCS has to offer, and have been building on top of the CCS system. One of the common tasks that we've run accross is the ability to run "map-reduce" style financial models against the cluster. These types of models require a wide range specified by an input parameter to be split into segments of work that can be executed in parallel against the cluster. The segments generally create a significant amount of output data, which then must be summarized by a reduce process to produce a "meaningful" output. In some cases, the summarized output will then be fed into another map, and the process continues.

The ability to run a simple process like the one shown above is an important capability of CCS, however CCS is designed to be a tool, not a means to the goal, and does not have built in support for a "map reduce". In the worlds of CCS, each step outline in the graph (the map, segments and reduce) would all be "tasks" grouped into one logical "job".

To handle this map/reduce scenario, a function of CCS jobs, task dependencies, can be used to ensure that the tasks run in the proper order (and that the reduce does not occur before all the segments have completed). In the sample code included with this project, three console apps are included. One does the split, one runs a single map, and one does the reduce.

Split:
The split will add tasks to the job that it is currently a member of so that they can run as maps. The maps will each get their own input file so that they know which segment they are responsible for. Each map task also "depends" on the split task, meaning that they will wait for the split to complete before they start.

The split will also schedule a reduce task, and ensure that that task depends on all the maps, so it does not start until all maps are complete.

Map:
Each map/segment will run given its input prameters (written by the map) and output another file containing their results.

Reduce:
The reduce step will take all the map outputs and run an average on the values to come up with a "summarized" value, in this case, the average of the primes that were requested.

How To Run This Project:
When you run this model, it is expected that you use a system such as the CCS job console, the command line interface or your own custom-built interface to submit a job with the following characteristics:

The only task specified to run within the job is the map task, where the first command line parameter is the input XML file you want to use (this input file needs to be defined to be deserialized into a PrimeFinderInput object) (This task is responsible for creating the rest of the required tasks)
The "minimum processor count" is set to the number of nodes processors you wish to parallelize accross.
Your input parameters are well formed, and the Processors property of the input is set to the number of segments you want to run. Ideally this is equal to (or greater than) the "minimum processor count".

There you have it. The basics to a simple map/reduce job in CCS!

Download the Sample Project (Visual Studio 2008, Beta 2)

WTF: "Problems" with Anonymous Delegates, LINQ, Lambdas within "foreach" or "for" Loops

mrdecav — Sun, 18 Nov 2007 19:30:00 GMT

Sample code available here that exemplifies this bug (requires Visual Studio 2008 Beta 2 and SQL Server).

So here is an incredibly unintuitive problem I ran into with anonymous delegates (same will happen for lambda expressions) in C# while using them inside loops. This will also happen in a few other circumstances (for example, in LINQ) , as I will explain in a minute below.

Symptom:
When using an anonymous delegate or lambda expression inside a loop, the results of the delegates execution (outside of the loop) are unexpected. For example:

Your expression is not evaluated as you expect and returns an unexpected value.

Your LINQ or DLINQ (LINQ2SQL) execution creates SQL or a query result which is not consistant with your assumptions based on how your loop was constructed.

This problem exists when you create an anonymous delegate inside a loop, using the loop's variable within the delegate, or when you change a variable after creating an anonymous delegate. The result is sensibly by design but pretty misleading, especially the first time you see it. Take the example below. This example was sent to me by a Microsoft employee after I filed a bug with them. He claims this is by design, and conceptually I agree with him. Can you guess what would be returned with the statement below?

   1:  const int count = 10;

   2:  Predicate<int>[] predicates = new Predicate<int>[count];

3:

   4:  for (int i = 0; i < count; i++)

   5:  {

   6:      predicates[ i ] = delegate(int j) { return i == j; };

   7:  }

8:

   9:  Console.WriteLine(predicates[0](0)); // False

  10:  Console.WriteLine(predicates[0](count-1)); // True

When the first predicate (predicates[0]) is called in above, one may expect it to return true because when it was created i == 0. This is where it gets confusing. In the closure of the anonymous delegate, the variable i is held by reference, not by value. Because int i is declared outside of the loop, i within the delegate's closure will increment along with the for loop. Once we leave the for loop, i is the max value of i throughout the loop (or count-1). Not what you were expecting? Me either.

The next example shows the "correct" way of dealing with this, such that line 9 of the code above returns true.

   1:  for (int k = 0; k < count; k++)

   2:  {

   3:      int l = k;

   4:      predicates[k] = delegate(int m) { return l == m; };

   5:  }

6:

   7:  Console.WriteLine(predicates[0](0)); // True

In this case, because variable l is created within the for loop, holding reference to l in the delegate is okay, because the value of l will never change, and therefore we get our expected result. Personally, I was originally expecting it to hold the value of the variable, not the reference to the variable.

This brings us to another interesting example (my original, which you may download the source code to below), where I construct a DLINQ where clause in a loop. Look at the where clause constructed below.

   1:  // Create a few new items that we can test with.

   2:  TestEntity[] testData = new TestEntity[] {

   3:          new TestEntity(1, "One"),

   4:          new TestEntity(2, "Two"),

   5:          new TestEntity(3, "Three") };

6:

   7:  // Add all our test data and submit it to the server

   8:  foreach (TestEntity item in testData)

   9:  {

  10:      context.TestEntities.Add(item);

  11:      Console.WriteLine(item.Name);

  12:  }

13:

  14:  context.SubmitChanges();

15:

  16:  var result = from item in context.TestEntities

  17:               select item;

18:

  19:  // Go through all our local items and append "WHERE" clauses to the

  20:  // result statement.  This is kind of like doing a "NOT IN"

  21:  foreach (TestEntity localItem in testData)

  22:  {

  23:      // See note in FixedTest for diagnosis.

  24:      result = result.Where(sqlItem => sqlItem.Name != localItem.Name);

  25:  }

One would expect that the WHERE clause would exclude all the items in the testData array ("one", "two" and "three" would not be selected). However, because localItem is held by reference, only the third item ("three") is not selected. The code below will print "one" and "two" on seperate lines:

   1:  // The WHERE clauses above should have effectively cancelled out all

   2:  // the items in the database and left us selecting nothing.

   3:  foreach (var item in result)

   4:  {

   5:      Console.WriteLine(item.Name);

   6:  }

One would have expected nothing to be printed to the console by simply reading the code.

You can download some sample code here for this bug (Visual Studio 2008 Beta 2). Note that you will need a SQL Server database at localhost to run this properly.

Thank you to Colin Meek of Microsoft for contributing some of the sample code above, and helping clarify that this functionality is by design in C#.

Update:

To clarify, I'm not saying that this behavior doesn't make sense, but more that its not expected. I think this should at least provide a compiler warning (I believe VB does this) to tell you that you could possibly be confusing something in your logic. Because of LINQ's delay-execute, this problem becomes more obvious in the "Where" example.

Tricky Generics: "New" Keyword and Generics

mrdecav — Fri, 16 Nov 2007 19:42:00 GMT

Trying to decide how to write some unit test helper classes, I ran into an interesting question. What happens when you use the new keyword along with .NET generics? The example below shows my dilemma:

   1:  [TestMethod]

   2:  public void DoBase()

   3:  {

   4:      DoT<Base>(new Base());

   5:  }

6:

   7:  [TestMethod]

   8:  public void DoDerived()

   9:  {

  10:      DoT<Derived>(new Derived());

  11:  }

12:

  13:  public void DoT<T>(T item)

  14:      where T : Base

  15:  {

  16:      item.Blah();

  17:  }

18:

  19:  public class Base

  20:  {

  21:      public Base()

  22:      {

  23:      }

24:

  25:      public void Blah()

  26:      {

  27:          Console.WriteLine("Hello");

  28:      }

  29:  }

30:

  31:  public class Derived : Base

  32:  {

  33:      public new void Blah()

  34:      {

  35:          Console.WriteLine("Bye");

  36:      }

  37:  }

The question is what happens when you call DoDerived()? Because the class is typed as T (which in this case is the Derived class), you would expect "Bye" to be written to the console. How would that work though, since the compiler has no concept of Derived.Blah, and therefore cannot generate the IL to access it at compile time of the generic?

Sure enough, "Hello" will be written from Base.Blah, as if we were cast to Base at the time of invocation.

Life With ActionScript and AIR: The Command Pattern Is Your Best Friend

mrdecav — Fri, 16 Nov 2007 16:02:00 GMT

I've recently started a project (top secret!) using the new Adobe Integrated Runtime (AIR), Flex and ActionScript 3.0. Coming from a .NET and WPF world. this has been a step in a very different direction. There are a lot of things I don't really love about ActionScript, however it does do its job, and the Adobe AIR deployment strategy (along with its SQLLite database) is pretty damn good.

One of the first things any developer will realize when trying to build a real Rich Internet Application (RIA) in ActionScript is the lack of threading. This makes doing background tasks very difficult. ActionScript, and its class library, works largely with callback methods (either from calling setInterval, using a Timer class, calling a SQLConnection or using the HTTPService or other class to make a data call). From what I can tell, this works much like the Windows message loop, inurrupting synchronous code on your UI thread to process the callback.

While this is great for simple actions (say, a UI that calls a web service or REST service), building a background process (such as a SQL Server synchronization engine) can get complicated. Due to the number of callbacks you'll receive each time you make a request (to SQLConnection or HTTPService), there is a great amount of complexity in writing simple procedual background processes (that don't freeze up the UI).

To better handle this situation, and ensure that your discrete functions run in the proper order (for example, Authenticate -> Get Data), a command pattern in ActionScript will become your best friend. You can string together multiple callbacks, and ensure that the code for these operations stay in one logical class. Furthermore, by using a queue, you can order your commands such that they run synchronously. This provides much more flexibility than the traditional scripting approach in ActionScript.

Unfortunately, I cannot currently provide code samples, as I do not want to compromise the intellectual property of my project, however, I hope that this will help you get an idea of how to best manage your code and synchronous operations in .NET.

Side Note: If you're using WCF I suggest you use the Basic HTTP Binding with Flex, as FlexBuilder gets confused with .NET Web Services

WCF: ConfigurationErrorsException When Defining Behavior Extensions

mrdecav — Tue, 06 Nov 2007 18:16:00 GMT

Just a quick note: There is a bug that looks like it won't be fixed for a while in the configuration of the <behaviorExtensions> section of the systm.serviceModel WCF configuration. You may get the ConfigurationErrorsException when adding a new type of behavior (see below):

System.Configuration.ConfigurationErrorsException: An error occurred creating the configuration section handler for system.serviceModel/behaviors: Extension element 'myService' cannot be added to this element. Verify that the extension is registered in the extension collection at system.serviceModel/extensions/behaviorExtensions.Parameter name: element (...\Service.exe.config line 43) ---> System.ArgumentException: Extension element 'wsdlNotice' cannot be added to this element. Verify that the extension is registered in the extension collection at system.serviceModel/extensions/behaviorExtensions.

This is a known bug, but was not accepted by Microsoft as a bug. See bug Microsoft feedback:
https://connect.microsoft.com/wcf/feedback/ViewFeedback.aspx?FeedbackID=216431

To fix this issue, you will need to use the fully qualified type name, as shown in the sample below:

<add name="myService"
type="Decav.FreeCode.MyServiceBehaviorElement,
Decav.FreeCode, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
/>

WCF: Throwing Exceptions With WebHttpBinding

mrdecav — Sat, 03 Nov 2007 22:42:00 GMT

One of the very cool new features in Windows Communication Foundation is the ability to create REST or POX services. Unfortunately, you will quickly find that WebHttpBinding and WebHttpBehavior (both the binding and behavior that are used to pull off the REST operations in WCF) will swallow your exceptions, and worse, leave you with a very generic error message, like the following:

Request Error
The server encountered an error processing the request. See server logs for more details.

This is no good when your client is expecting back XML or a fault code! How to get around this? Implement your own WebHttpBehavior and add a custom error handler. This will let you return a message of your choice. The code below will return a standard SOAP-like fault message. Note that you can use Message.CreateMessage and XmlDocument to create a differently formatted message if you want.

Also, this example wraps ALL exceptions, regardless of their type. The standard WCF way of protecting sensitive server-side information (like stack traces) is to use FaultException, or FaultException<T> in your code, and only show the message if the exception is of one of those types. I would suggest adding this type filter if you care about your server-side intellecual property rights.

FaultingWebHttpBehavior:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.ServiceModel.Description;

   6:  using System.ServiceModel.Dispatcher;

   7:  using System.ServiceModel.Channels;

   8:  using System.Xml;

   9:  using System.ServiceModel;

10:

  11:  namespace Decav.FreeCode.ServiceModel

  12:  {

  13:      /// <summary>

  14:      /// A <see cref="WebHttpBehavior"/> that does not attempt to display friendly error messages when an exception occurs

  15:      /// locating or invoking a service.

  16:      /// </summary>

  17:      public class FaultingWebHttpBehavior : WebHttpBehavior

  18:      {

  19:          protected override void AddServerErrorHandlers(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)

  20:          {

  21:              endpointDispatcher.ChannelDispatcher.ErrorHandlers.Clear();

  22:              endpointDispatcher.ChannelDispatcher.ErrorHandlers.Add(new ErrorHandler());

  23:          }

24:

  25:          public class ErrorHandler : IErrorHandler

  26:          {

  27:              #region IErrorHandler Members

28:

  29:              public bool HandleError(Exception error)

  30:              {

  31:                  return true;

  32:              }

33:

  34:              public void ProvideFault(Exception error, MessageVersion version, ref Message fault)

  35:              {

  36:                  FaultCode faultCode = FaultCode.CreateSenderFaultCode(error.GetType().Name, "http://tempuri.org/net/exceptions");

  37:                  fault = Message.CreateMessage(version, faultCode, error.Message, null);

  38:              }

39:

  40:              #endregion

  41:          }

  42:      }

  43:  }

FaultingWebHttpBehaviorElement (this is the configuration element used in the app.config:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.ServiceModel.Configuration;

6:

   7:  namespace Decav.FreeCode.ServiceModel

   8:  {

   9:      /// <summary>

  10:      /// The configuration element for a <see cref="FaultingWebHttpBehavior"/>.

  11:      /// </summary>

  12:      public class FaultingWebHttpBehaviorElement : BehaviorExtensionElement

  13:      {

  14:          /// <summary>

  15:          /// Gets the type of behavior.

  16:          /// </summary>

  17:          /// <value></value>

  18:          /// <returns>A <see cref="T:System.Type"/>.</returns>

  19:          public override Type BehaviorType

  20:          {

  21:              get { return typeof(FaultingWebHttpBehavior); }

  22:          }

23:

  24:          /// <summary>

  25:          /// Creates a behavior extension based on the current configuration settings.

  26:          /// </summary>

  27:          /// <returns>The behavior extension.</returns>

  28:          protected override object CreateBehavior()

  29:          {

  30:              return new FaultingWebHttpBehavior();

  31:          }

  32:      }

  33:  }

App.config:

   1:  <configuration>

   2:    <system.serviceModel>

   3:      <services>

   4:        <service name="Decav.FreeCode.SomeService">

   5:          <endpoint address=""

   6:                    behaviorConfiguration="WebBehavior"

   7:                    binding="webHttpBinding"

   8:                    contract="Decav.FreeCode.SomeService"/>

   9:          <host>

  10:            <baseAddresses>

  11:              <add baseAddress="http://localhost/Services/SomeService"/>

  12:            </baseAddresses>

  13:          </host>

  14:        </service>

  15:      </services>

  16:      <behaviors>

  17:        <endpointBehaviors>

  18:          <behavior name="WebBehavior">

  19:            <faultingWebHttp/>

  20:          </behavior>

  21:        </endpointBehaviors>

  22:      </behaviors>

  23:      <extensions>

  24:        <behaviorExtensions>

  25:          <!-- NOTE:  Fully qualified name required, see: https://connect.microsoft.com/wcf/feedback/ViewFeedback.aspx?FeedbackID=216431 -->

  26:          <add name="faultingWebHttp" type="Decav.FreeCode.ServiceModel.FaultingWebHttpBehaviorElement, Decav.FreeCode, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>

  27:        </behaviorExtensions>

  28:      </extensions>

  29:    </system.serviceModel>

  30:  </configuration>

Strong Typed Functional Programming In C#

mrdecav — Mon, 17 Sep 2007 03:34:00 GMT

Functional Programming in C# Sample Solution (.NET 3.5)

I had an interesting discussion the other day with a collegue at Lab49 about the uses for functional programming over object-oriented programming. Although I traditionally have been very OO-focused, some of the points he made are very relevant and things I have found myself doing in the past. Although I have dabbled in some functional languages (PowerShell being the most prominent recently), I do not consider myself a functional programmer.

Typically, functional programming is loosely typed and uses dynamic languages, however functional programmers using an OO language (such as C#) will use hashtables or data sets to store loosely typed data. The benefit of the loosely typed, "flat" object model (single object for all your data properties) is that you don't wind up creating excess code (such as properties that will never be filled in) for doing something very simple (like binding to a grid). Furthemore, in an environment where new types are created daily, some of which will wreak havoc on your structured object model (which ultimately may never be used when you're just displaying data), the OO concepts can fall apart. Take into account distributed computing and thread safety, and you have a very comelling reason to have a set of small flimsy objects that don't care what data they hold.

Running with this concept (which I still have yet to actually accept), I started to realize this is largely the direction of the C# language. Extension methods, the var keyword, LINQ, and other recent developments in .NET 3.5 are all attempts to make a ridged OO language more dynamic.

Not wanting to lose my type-safety, I tried to go off an build a functional-style app using C#, and found an interesting way of using extension methods to apply "schemas" to loose typed hashtable data objects. While this is not perfect, and I certainly would never use this in production code, it provides an interesting way to apply composite interfaces on top of an object without ever modifying the object itself.

The use of extension methods is simple. By creating GetProperty() and SetProperty() methods (where Property is the name of the property you wish to get set) as extension methods in a seperate namespace, you can easily use the namespace as an interface that you place "over" the data object. You can write your functional method, import a few namespaces, and all of a sudden have a strong-typed interface for your functional method to access, cool stuff.

While I don't particularly condone this method of development (for if no other reason, other developers will have to wrestle with the code becuase its "not standard"), its worth looking at.

Functional Programming in C# Sample Solution (.NET 3.5)

Live Updating Line Graph in WPF

mrdecav — Sat, 25 Aug 2007 18:14:00 GMT

See a ClickOnce (.NET 3.5) Sample Here

Download the Source Code (VS 2008 Beta 2) Here

A live, updating graph in Windows Presentation Foundation and .NET 3.5 is a natural use of the new framework, and is something that WPF is well suited to do. You can make great visually appealing animated components, and a graph is just one example.

In this example, I have built an attractive, glassy (Vista style) control that presents an array of points ticking accross a graph in real time. The goal was to use this with a market simulator so that you could see the data that the simulation was spitting out. The graph uses the ticks as its concept of "time" in the market, and can readjust its speed based on the speed of the simulator. Cool stuff.

The graph always ticks from the right-most side to the left-most side, with the right-most side being "now" in the market. This is not a simple task, because with the market speed consistently changing, you need to constantly re-adjust your animation speed to ensure that the right most side is always where the next point appears.

Key Points

The graph "glows" in intensity based on how far off the median value you are (not zero)
A moving average is used to determine how fast the graph is currently moving, and this is a good example of readjusting animation speed to outside variables
The control resizes dynamically, the Grid was used to allow most of the resizing, with some code to remove UI elements that are "in the way" when the graph gets really small
ControlTemplate were used to style buttons and other elements used in making the graph appealing
Extension properties were used to extend Button with additional properties that could be used to find graph glow intensities.
The graph duration (time from start to end of the view area) can be changed by using the slider at the bottom of the application

Creating Your Own Data Source

Care to use this in your project? Making the graph use your own data source is simple. Derrive from TickerAdapter class (if you want to see an example look at the RandomTickerAdapter that is supplied in the demo). Add new securities to the collection by calling TickerAdapter.AddSecurity, and add new ticks by calling TickerAdapter.NotifyNewTick.

That's it!

Known Issues

This control was originally made for a demo, not production use. Although it is near production ready, some issues exist.

The MiniTicker.Ticks collection is never cleared
The Security.Ticks collection is never populated (and not used)
There is no way to remove a ticker from the collection of tickers managed by a TickerAdapter.
Some performance issues exist when adjusting the time scale. There is no "resolution" of the graph, so if you push the graph to a high duration, all the ticks show, rather than dropping some of the ticks for the scale selected. This is both easy to fix, and not an issue if you're only showing a time window

See a ClickOnce (.NET 3.5) Sample Here

Download the Source Code (VS 2008 Beta 2) Here

Fixing and Disabling UrgeMS.exe (MTV Urge Music Service) (100% CPU or HD on Vista)

mrdecav — Tue, 14 Aug 2007 16:53:00 GMT

This thing is really frustrating me so I finally killed it for good and thought I'd let everyone else know how.

If you have Windows Vista and use Windows Media Player, and you're seeing your hard drive or CPU usage spike and stay at 50% or 100%, you may be cursed by UrgeMS.exe.

This executable is for the Urge Music Store (which I highly reccomend) that runs inside of Windows Media Player. UrgeMS.exe gathers information about songs on your hard drive for the "Auto-mix" features. Why they haven't made this idle when you're using the computer (especially when on battery power) is beyond me, but you can force it yourself.

Press ctrl+shift+esc to bring up the task manager if it is not already open.
Go to the Processes tab and find UrgeMS.exe, click End Process
Open the start menu and type C:\Program Files\MTV Networks\urge and hit enter, this will open the Urge folder.
Rename UrgeMS.exe to something of your choice (such as UrgeMS_NoStart.exe)

When Urge starts, it will attempt to start this executable, if it fails, it does so silently, so theres no issue with just renaming it.

Enjoy!

Apple iPhone: The Keyboard and Browser

mrdecav — Sun, 01 Jul 2007 01:27:00 GMT

So I stopped by the Apple Store quickly to see tons of people packed around the huge set of iPhone's they had laid out on the table. I was really only curious about two things...

The Keyboard

The first thing I wanted to know about was the keyboard. How well would it really work with its "predictive typing?" Most people hate predictive input, so I was curious to see what Apple did with this "revolutionary" new technology (note Pocket PC started with the onscreen keyboard too).

Simply put: it sucks. Sure it grabs some misspellings and corrects them for you, but overall, the typing experience is damn near horrible. "Trusting the keyboard" as Apple puts it gets you a 70% accuracy rate at best. Enough to be frustrating. The worst part is, you don't know if its going to correct your spelling until you finish typing the word. So you type extra letters "trusting" the keyboard, and then end up erasing all of them because the keyboard got confused.

Web Browser

I was originally expecting the web browsing experience to require a ton of panning to read an article on the phone. After all, the "whole page" view just didn't sound like it would work to me. Luckily, Apple was very smart here and they find the "article" section of the page (I'm guessing any big block of text, but I'm not quite sure what the browser determines to be the article) and enlarge that text, leaving the page around it at its original size (to be zoomed in on). This makes for a very friendly browsing experience.

Exchange Support

There is a tab for Microsoft Exchange Server in the email setup. I didn't test this (didn't want to load all my email onto a store device), and it said it required IMAP. I'm not sure if this means that it uses the OMA HTTP trigger to "push" email or not, but I'm assuming it does. If it indeed does, cool stuff!

Conclusion

Overall, I found the iPhone to be a great media device. I love the touch gestures (why did Microsoft never get this right? Oh yeah, they wanted to copy the feel of a PC), and the overall interface. Very intuitive. Its not "revolutionary," this stuff has been around forever. What it does do, however, is impressive and well put together.

The biggest problem I see is its not really a business device. It doesn't store tasks (a big problem for me, I need to write todos down as soon as I get them), cannot accept rapid input, and only syncs email through the web (why is this???). Maybe version 2 will be more promising.

Lenovo: "Chinese Quality" (Abhorrant) Customer Service

mrdecav — Wed, 27 Jun 2007 15:07:00 GMT

A week ago, I tried to purchase an X61 Tablet PC from Lenovo and had significant issues handling the sales staff, estimated ship dates and websites. This is my first experience with Lenovo post-takeover of IBM and I am very disappointed by the level of service I have received. It is clear that an IBM brand has been taken over by a Chinese company that understands little about client communication and support.

I have cancelled my order and bought the tablet from a reseller that had a few in stock, and who shipped the same day (http://www.shopblt.com which has been very courtious and responsive).

I have run into the following issues that made for a miserable experience with Lenovo. I hope that thetechnical support does not have the same issues, should I need to call them:

30 minute or more wait times on the phone to talk to a representitive
Sales people giving me very different answers (one claiming there are no production snags and it should ship in a week or two, another claiming 4 weeks
An estimated ship date of 4 weeks (4/20) after I purchased, without an explaination.
An "order status" stating "in process." When I called to cancel, I was told it was already sent to "configuration". Does this mean it was going to be shipped earlier rather than later? That may have kept me from cancelling my order.
Numerous problems with the website, including:

broken links (ex: "contact" on the bottom of the order status form)
Session timeouts that erase your shopping cart
Broken "chat with a sales representitive" on the sales page
TYPOS INCLUDING "SXGA" INSTEAD OF "SXGA+" that no one cares enough to resolve

Fake, on-going sales that keep changing names, pretending that the product is "on sale" to lure customers.

Better communication, reasonable hold times, and a bit more transparency would have gone a long way to improving my experience with Lenovo. I am hoping the product and support are up to the same standards as IBM held it to, but given my experience thusfar, I will not be reccomending direct Lenovo sales to any of my clients or friends. I was sad when IBM sold out to the Chinese, and now that I see what the Chinese have done to IBM customer service firsthand, I'm very disappointed in both IBM and Lenovo for the way this transition was handled.

PostSharp: A .Net Post Compiler

mrdecav — Fri, 15 Jun 2007 19:38:00 GMT

For several months now, I've been collaborating with Josh Einstein about writing a post compiler for .NET. Our goal was quite simple: we wanted to supply the ability to generate code, such as:

thorough tracing
argument null checks
clone implementations
dependency properties
INotifyPropertyChanged event invocations
checking if disposed on each method invocation
etc

The job of creating a post compiler to properly handle all of this is not simple, and is quite time consuming, however we figured the benefit to the community would make it well worth it.

At the time I did several searches looking for a solution but could not find any implementation that I found adequate.

Enter PostSharp, a solution conceived and written by a developer named Gael Fraiteur. Gael has hit the nail on the head, and has implemented an incredibly well documented and functional .net post compiler. In addition, he goes above and beyond my original expectations, adding attributes that allow for easily intercepting and adding or replacing different types of code. PostSharp not only makes the aforementioned operations easier, it adds a sense of aspect oriented programming to .NET (thats not as painful as ContextBoundObject).

PostSharp is simple, intuitive, and best of all, comes with a suite of very well commented code samples. Kudos to Gael for beating me to it!

.NET: Sending Email to Japanese Mobile Phones

mrdecav — Tue, 12 Jun 2007 19:53:00 GMT

Following up on my previous post about configuring ASP.NET for Japanese mobile phones, I thought I would write about another irritating aspect of developing for the Japanese mobile market: sending email to the fairly ubiquitous Japanese phone email system.

Oddly enough, the most advanced Japanese phones on the market are very picky about which content encoding and content transfer encoding they support. Unicode does not seem to be an option (go figure), and it seems to me that the email gateway may be where the software bottleneck is, more than the phone itself.

Anyway, I started by trying to use the System.Net.Mail.SmtpClient. In our tests, we found that the supported content-encoding was iso-2022-jp. Nothing else. Not unicode, not shift_js, just this somewhat awkward standard. Fine. So we set our MailMessage.BodyEncoding to this format, and found that the Japanese phones still would show jibberish, rather than real Japanese. Sure enough, SmtpClient supports sets the content-transfer-encoding to quoted-printable, something the Japanese phones (or gateways) do not support. After trying AlternateView and other classes in System.Net.Mail, we gave up trying to send using this class. It simply was not possible.

Unfortunately, we were forced to use System.Web.Mail.MailClient to send our emails. This is a crappy wrapper around CDO, and is deprecated in .NET 2.0. The advantage, however, is that MailClient will send a MailMessage.BodyEncoding as 7bit, the required content-transfer-encoding for the Japanese mobile market.

In brief:

Japanese phones require:

content-encoding of iso-2022-jp
content-transfer-encoding of 7bit

System.Net.Mail does not send in 7bit encoding, unless you use AlternateView. At this point, I could not get mail sent with AlternateView to display properly on the mobile device.
System.Web.Mail will send 7bit, but has the disadvantage of being depricated

Hope this helps someone! Best of luck!

ASP.NET Mobile for Japanese Phones (DoCoMo/i-mode, SoftBank, KDDI AU)

mrdecav — Sun, 10 Jun 2007 02:11:00 GMT

In the Japanese market the mobile web is one of the most important web mediums for companies to target. Nearly every site has a mobile version that works with the major mobile carriers phone technologies. When developing for the Japanese market, it is important to develop a mobile site in addition to a full site, as some users only have phones and not a computer.

This article will cover how to properly configure ASP.NET Mobile 2.0 to work with the majority of Japanese mobile phones in the market.

Download KDDI .Browser File Here -- These browsercaps are imperfect (I haven't reviewed each and every setting), but will ensure that Japanese text renders properly in the browser).

ASP.NET Mobile provides the ability to change rendering of a web page based on the browser accessing the site. Because of the wide varieties of HTML supported in the Japanese mobile market (DoCoMo/imode perfers cHTML and XHTML whereas SoftBank prefers HDML). In addition, different browsers support different encodings (some use UTF-8, others use shift_js).

To support all of these, ASP.NET uses browser caps. Most of the browser caps you need to the Japanese market are included in .NET 2.0. Unfortunately, KDDI browsers seem to lack a browser caps file in ASP.NET. To resolve this issue, read on to find how to install a browser caps file into ASP.NET.

Installing a .browser file

If you have not already, download the KDDI .browser file.
Copy the browser file into the C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG\Browsers folder.
Open a command prompt and change path to C:\Windows\Microsoft.NET\Framework\v2.0.50727.
Run aspnet_regbrowsers.exe /i to recompile the browser files into an assembly and add it to the GAC.

At this point your ASP.NET sites should be compatible with the majority of Japanese phones on the market.

Security: Writing Password Protected Applications

mrdecav — Thu, 07 Jun 2007 22:23:00 GMT

Okay, here is something that is very frustrating to me. So many people do this incorrectly and it makes me feel insecure about giving my password to a website. The thing they don't do properly is password management.

In this day of web and hobbiests calling themselves developers, we've found ourselves with tons of accounts at every web property ever, each with a username and password. Users however seldom know how their password will be stored when they supply it. This leads to various simple but dangerous security holes.

Ways not to handle passwords

Never store passwords in plain text. Passwords should be stored with one-way hashes (such as an MD5) so that the hashes can be compared when a user enters a password to login. Storing passwords raw in a database not only makes you responsible for everyones lost passwords if someone hacks your system, but also is bad practice because DBA's have full access to password lists.
Never send a user their password for "forgot password" workflows. If you do the first, this should be obvious enough. Sending passwords via email is dangerous because anyone can sit down at users machine and open up a web browser history and Outlook; try "forgot password" on a few sites and get the users password to anything. Not very secure.

Proper ways to handle passwords

Store passwords with a one-way hash. Storing passwords with a one-way hash allows you to compare the hash against a hash you make when a user attempts to login, but secures the users password from the sight of both a potential hacker or a DBA.
Send links or new passwords to email accounts. When a user requests a forgotten password, send the user a single-use link to create a new password, or a temporary password they must change on next login. This will ensure the user can change their password, but the password cannot be compromised by someone with access to their email.