Pluralsight Blogs

Silverlight 2 RTW tomorrow and more goodness

brian-randell — Mon, 13 Oct 2008 17:03:00 GMT

http://www.microsoft.com/presspass/press/2008/oct08/10-13Silverlight2PR.mspx

ScottGu detailed a bunch of stuff this morning to the press including an October 14, RTW of Silverlight 2.

More goodness:

"Microsoft also announced further support of open source communities by funding advanced Silverlight development capabilities with the Eclipse Foundation’s integrated development environment (IDE) and by providing new controls to developers with the Silverlight Control Pack (SCP) under the Microsoft Permissive License."

Good times.

When it rains, it pours --- articles on parallel processing that is

joe-hummel — Sat, 11 Oct 2008 04:47:00 GMT

Wow, my reading pile just got a lot bigger today. First, the latest (Oct 2008) issue of MSDN contains 4 articles related to parallel processing:

"Design considerations for parallel programming"
"Improved Support for Parallelism in the next version of Visual Studio"
"Solving 11 Likely Problems in your Multithreaded Code"
"Build Concurrent Apps From Simple F# Expressions"

I'm currently reading #4, since I'm a believer that functional programming may be one of the ways we make parallel processing safer, scalable, and generally more approachable. I don't see much in F# yet, it seems right now to be just another way to gain access to PFx and MPI.NET. But the potential is definitely there.

If that isn't enough, the latest issue (Oct 2008) of ACM's Queue magazine ("Architecting Tomorrow's Computing") presents a broader view of the concurrency problem, with articles on

"Real-world Concurrency"
"Erlang for Concurrent Programming"
"Parallel Programming with Transactional Memory"

Erlang is another functional language, but with a proven process-based approach to concurrency and parallel processing. I'm just learning about Erlang now, I really really need to implement some apps and collect some performance numbers. Erlang's process-oriented concurrency model was originally designed for system building and robustness, so the question is how it fares for HPC. Transactional memory is an interesting approach --- in short, you don't worry about accessing shared memory, you just go for it and check when you're done to see if a conflict has occurred. If not, you commit, otherwise you rollback and try again.

Anyway, happy reading!

32-bit SDK for HPC Server 2008 fails --- "The procedure entry point GetProcessIdOfThread could not be located..."

joe-hummel — Sat, 11 Oct 2008 02:21:00 GMT

The RTM for HPC Server 2008 was recently released, and I've been happily running HPC apps on my clusters. I wanted to run some demos for my students, so I installed the SDK for HPC Server 2008 on the classroom machine (a 32-bit Windows XP box), and launched as usual with mpiexec:

mpiexec -n 4 MyMPIApp.exe

A dialog box immediately appeared with the error message "The procedure entry point GetProcessIdOfThread could not be located in the dynamic link library KERNEL32.dll". I closed the dialog, and the console window then displayed this error message:

ReadFile() failed, error 109
Error: unable to start the local smpd manager

A firewall problem? Disabled the firewall, same error. Reboot? Same error. Installed MPI.NET and ran an MPI.NET app; same error. So it seems to be a problem with the 32-bit SDK for HPC Server. I did find a temporary solution: uninstall the SDK, download and install the v1 SDK for Compute Cluster Server, available here. Same MPI apps ran fine with the older SDK. I've submitted a bug report to Microsoft, I'll post when we figure out what's going on.

Rails - Database Access

kevin-jones — Fri, 10 Oct 2008 15:37:16 GMT

One of the driving forces of Rails is to make things easier for developers. It does this partly by taking decisions out of developers hands. It's an 'opinionated' framework, and one of the opinions it has is on the pattern to use for database access. Its choice in this case is the 'active record' pattern.

Rails has an ActiveRecord module and the model classes all derive from

ActiveRecord::Base

for example

BlogEntry < ActiveRecord::Base

it is this module that provides the active record support for the framework.

Like much of the rest of Rails, ActiveRecord follows naming conventions. Here for example the BlogEntry class represents a row in the blog_entries table. How does this happen?

Looking back to the Learning Rails - Part 2 post you will see that this script was run

script/generate scaffold blog_entry ...

This script created two files, the file with the model class BlogEntry definition and a "migration". The migrations are "scripts" that help create and mange the database definitions, essentially they are DDL for Rails.

Migrations are used to both set up and tear down databases. The files contain class definitions that specify the steps to take when managing the database.

Migrations are timestamped so that it is easy to apply migrations in the correct order and to rollback those migrations in reverse order if needs be. The migrations live in the db/migrate directory. Currently there are 4 migrations in there

20080925064318_create_sessions.rb       
20080925065056_create_blogs.rb
20080925064319_create_users.rb          
20080925065210_create_blog_entries.rb

The first is a fairly standard Rails migration that creates the session tables (run rake db:sessions:create to create this), the others are specific to this application. Each migration has a date-time as part of the file name and it's this name that determines the order in which the migrations are run. The 20080925065210_create_blog_entries.rb looks like this

class CreateBlogEntries < ActiveRecord::Migration
  def self.up
    create_table  :blog_entries do |t|
      t.string    :title,             :null => false
      t.text      :entry,             :null => false
      t.integer   :author_id,         :null => false
      t.datetime  :entry_added_date
      t.datetime  :entry_last_edited
      t.timestamps
    end
  end

  def self.down
    drop_table :blog_entries
  end
end

So it's a class that derives from ActiveRecord::Migration and provides two class methods (static methods to C#/C++ folks), up and down (it's the "self" that indicates that these are class methods and not instance methods). You can run the migration from the command line by using the Rake command

rake db:migrate

This runs any migrations that have not yet been run. How does it know which migrations to run? Tthere is a database table that holds the information about the migrations that have been run.

$ mysql -u root
mysql> use rblog_development
mysql> show tables;

shows something like

+-----------------------------+
| Tables_in_rblog_development |
+-----------------------------+
| blog_entries                |
| blogs                       |
| schema_migrations           |
| sessions                    |
| users                       |
+-----------------------------+

and

mysql> select * from schema_migrations;


+----------------+
| version        |
+----------------+
| 20080923152418 |
| 20080923152427 |
| 20080923152435 |
| 20080925064318 |
| 20080925064319 |
| 20080925065056 |
| 20080925065210 |
+----------------+

on my machine as I type this. Notice that the last entry in the table matches the datetime portion of the name of the last migration file.

When a migration is run (assuming it has not yet been added to the database), then the self.up method is executed. This method creates or modifies database entries. In the case of the blog_entries migration it creates the table and adds the eight columns from these five entries.

(title, entry, author_id, entry_added_date, entry_last_edited and timestamps

mysql shows this

mysql> show create table blog_entries;
+--------------+---------------------------------+
| Table        | Create Table                    |
+--------------+---------------------------------+
| blog_entries | CREATE TABLE `blog_entries` (
`id` int(11) NOT NULL auto_increment,
`title` varchar(255) NOT NULL,
`entry` text NOT NULL,
`author_id` int(11) NOT NULL,
`entry_added_date` datetime default NULL,
`entry_last_edited` datetime default NULL,
`created_at` datetime default NULL,
`updated_at` datetime default NULL,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1           |
+--------------+---------------------------------+

Notice that timestamps turns into two columns, and that an id column has been added as a primary key

A migration can also be rolled back. Running rake db:migrate rollback will rollback the last migration, or a specific version can be specified. For example rake db:migrate VERSION=20080925065056

Running the migrations this way runs the migrations in reverse order up to the specified migration, on the way the self.down mwthod of each migration is called. For the blog_entries migration that would drop the table. The down method should undo whatever the up method did!

One of the interesting (and frustrating) things about Rails is the way the migrations and the models work together. Running the script/generate scaffold blog_entry creates two files, the migration and the model. Looking in the model file there is ... nothing, just the class definition. The knowledge about the members of this class is in the migrations. This takes DRY (Do Not Repeat Yourself) to the limit but it can mean looking in several files (there maybe more than one migration per model) to find everything that the class uses. If the migrations get too "spread out", i.e. there are three or more migrations with modifications to one table then it is worth amalgamating those migrations into one file.

Rails, Ruby

.NET type casting -- assume nothing

mike-henderson — Thu, 09 Oct 2008 12:38:00 GMT

It's fun to talk to people about .NET and make bold, titilating statements like ".NET is type safe". We hear it all the time. While oversimplified a bit, it's basically a valid statement. The C# compiler is also generally wonderful at taking lazily written code and making it function as we intend.

Those things said, it's always best to channel your inner Fox Mulder and "trust no one". Every once in a while the framework slaps me with some generated native code which reminds me that I can trust no one. It happened again last night.

In WPF, you can define a special property called a DependencyProperty, which essentially plumbs your property for WPF's internals, making it play well with data binding, animation and the like. I had one such definition in my code:

public static readonly DependencyProperty BarValueProperty =

DependencyProperty.RegisterAttached("BarValue",

typeof(UInt32), typeof(SpiderControlWindow), new

UIPropertyMetadata(30));

However, the class in which this definition existed would crash and burn during instantiation (the good ol’ “object could not be instantiated” error). Managed debugging was not helpful, so I had to go that extra step and do some (insert gasp here) native assembly debugging.

Upon stepping through this call in the generated assembly code, I discovered the issue -- The code calling into the constructor for UIPropertyMetadata was creating "30" as an immediate value on the stack, then calling the constructor. The constructor, however, would then store a pointer to that initialization value for later use, presumably because it assumed it was being passed a class instance, not an immediate. Well, that's not so helpful, as that location on the stack was blown away when the constructor returned, and life continued. Later, the code attempted to use that pointer, which then happened to be pointing to a null value, and a null reference exception occurred at the native level, which bubbled up into the very generic and non-helpful .NET exception.

This is an example of where explicit .NET "boxing" is necessary – the constructor's code wants a .NET class, but doesn't actually specify an strong object type in its definition, so the system doesn't automatically box our parameter. We need to box the parameter on its behalf:

UIPropertyMetadata((UInt32)30)

There we go… that simple “static” cast causes the .NET engine to actually create a concrete object, and we no longer get a crash and burn. The JIT compiler generated assembly code now uses a pointer to an object that lives in .NET’s world, not some volatile set of bits on the stack. No crash and/or burn.

(Though it's interesting to note that if my DependencyProperty is a double, and I pass simply "0.0" into the UIPropertyMetadata constructor, it works fine -- the compiler does the boxing for us... I guess we can't always expect the compiler to intuitively guess what we want.)

And all was right with the world.

Sarah Palin and Security Questions

keith-brown — Thu, 09 Oct 2008 08:09:10 GMT

I've always looked at security questions used to automate user password recovery with quite a bit of skepticism. What's the point of requiring strong passwords if you allow anyone to reset the password on an account by answering a (potentially inane) question? And just how many good security questions are there, and how many web sites will ask similar questions, allowing the owner of one web site to reset a user's password at another site that uses the same question? I'm pretty sure that the typical user will tend to select the same security question if it's available at multiple sites. In many web sites I've seen, the security question is clearly the weak link in the chain.

Apparently a fellow recently was indicted on charges of hacking into the Republican vice presidential nominee's Yahoo email account, by simply doing some research on the Internet to find her birthday, zip code, and the answer to her security question, "Where did you meet your spouse?" All told the attack reportedly took under an hour to complete.

Given the level of interest in Palin and other public figures, and the large amount of information about them available to the public, it makes sense that they will be some of the easiest targets for attacks like this.

Talks I want to see @ PDC

don-box — Wed, 08 Oct 2008 09:17:00 GMT

In looking at the agenda for the event, here are some talks I'd really love to crash:

Oslo: Building Textual DSLs - lots of geek porn appeal, and if internal usage is any indication, a highly addictive technology. I predict this will be the World of Warcraft of 2009.
Intro to F# - I spent a month living in F# early this year and had a great time. I'm dying to hear how Luca has made the leap from OO to functional programming.
ASP.NET and jQuery - OK, so the title on the details page doesn't match, but if this is a session on how MS is going to integrate jQuery into the arsenal of .NET devs, I want to hear it.
The Raymond Chen talk - Despite being a former columnist for MSDN Magazine (hi Joel), I like unmanaged code too and would love to see what we're doing in the land of HWNDs.
Steve Marx codes - If you want us to run your code in our cloud, go see this talk. Period.
Vasters on messaging services - If you want to run your code at your place but want us to help wire it up to the rest of the world, go see this talk. Period.
Dharma - to hear Dharma talk about his work is always refreshing, and the stuff he's been doing is pretty compelling.
The New XAML Stack - We're getting a XAML stack in .NET 4.0 that spans all of our technologies. No more XOML!
The UAC talk - OK, call me selfish, but I really want everyone to write apps that work for standard user accounts. Nothing would please me more than if we had to repeat this talk 3 times due to overflow problems in the room.
Miguel in blue - no longer relegated to ad hoc hallway presentations or using nearby hotel rooms, Miguel is donning a standard issue blue Microsoft speaker shirt, applying the Silverfox powerpoint template, upgrading his laptop to Windows 7, and giving a sanctioned PDC talk that even Richard Klees would approve of. OK, so I'm sure one or two of those statements isn't true, but I need to see it with my own eyes.

typing-speed-mode Emacs Minor Mode

craig-andera — Tue, 07 Oct 2008 14:32:15 GMT

I’ve been really into Lisp lately, especially Clojure, which looks really interesting. More on that some other time, though. Anyway, I’m always looking for an excuse to write code in Lisp – any Lisp.

As I was writing some prose in emacs this morning, I got into a real flow. I started to wonder how fast I was typing…and there was my excuse! About an hour later, I had written the code below. It’s an emacs minor mode that displays your typing speed (defined as the number of times self-insert-command has been run in the last five seconds, times twelve) in the mode-line. So you can watch your typing speed go up and down in real time. Note that you can customize a few things about it, like changing the default five-second window.

My emacs-fu (and my Lisp-fu) is not all that it could be, so the code is likely suboptimal in several ways, but it seems to work, and I always hate it when people say, “I’ll post the code once I get a chance to clean it up.” To hell with that: enjoy my code for the garbage it is :).

;;; typing-speed.el --- Minor mode which displays your typing speed

;; Copyright (C) 2008 Wangdera Corporation

;; Permission is hereby granted, free of charge, to any person
;; obtaining a copy of this software and associated documentation
;; files (the "Software"), to deal in the Software without
;; restriction, including without limitation the rights to use,
;; copy, modify, merge, publish, distribute, sublicense, and/or sell
;; copies of the Software, and to permit persons to whom the
;; Software is furnished to do so, subject to the following
;; conditions:

;; The above copyright notice and this permission notice shall be
;; included in all copies or substantial portions of the Software.

;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
;; OTHER DEALINGS IN THE SOFTWARE.

;; Author: Craig Andera <candera@wangdera.com>

;; Commentary: Invoke this minor mode to have your typing speed
;; continuously displayed in the mode line, in the format [75 WPM]
;; To use, just load this file and invoke (typing-speed-mode) or
;; (turn-on-typing-speed-mode)

(define-minor-mode typing-speed-mode
    "Displays your typing speed in the status bar."
:lighter typing-speed-mode-text
:group typing-speed
(if typing-speed-mode
      (progn
    (add-hook 'post-command-hook 'typing-speed-post-command-hook)
    (setq typing-speed-event-queue '())
    (setq typing-speed-update-timer (run-with-timer 0 typing-speed-update-interval 'typing-speed-update)))
      (progn
    (remove-hook 'post-command-hook 'typing-speed-post-command-hook)
    (cancel-timer typing-speed-update-timer))))

(defcustom typing-speed-window 5
"The window (in seconds) over which typing speed should be evaluated."
:group 'typing-speed)

(defcustom typing-speed-mode-text-format " [%s WPM]"
"A format string that controls how the typing speed is displayed in the mode line.
Must contain exactly one %s delimeter where the typing speed will be inserted."
:group 'typing-speed)

(defcustom typing-speed-update-interval 1
"How often the typing speed will update in the mode line, in seconds.
It will always also update after every command."
:group 'typing-speed)

(defvar typing-speed-mode-text (format typing-speed-mode-text-format 0))
(defvar typing-speed-event-queue '())
(defvar typing-speed-update-timer nil)

(defun typing-speed-post-command-hook ()
"When typing-speed-mode is enabled, fires after every command. If the
command is self-insert-command, log it as a keystroke and update the
typing speed."
(if (eq this-command 'self-insert-command)
    (let ((current-time (float-time)))
      (push current-time typing-speed-event-queue)
      (typing-speed-update))))

(defun typing-speed-update ()
"Calculate and display the typing speed."
(let ((current-time (float-time)))
    (setq typing-speed-event-queue
      (typing-speed-remove-old-events
       (- current-time typing-speed-window)
       typing-speed-event-queue))
    (typing-speed-message-update)))

(defun typing-speed-message-update ()
"Updates the status bar with the current typing speed"
(let* ((chars-per-second (/ (length typing-speed-event-queue) (float typing-speed-window)))
     (chars-per-min (* chars-per-second 60))
     (words-per-min (/ chars-per-min 5)))
    (setq typing-speed-mode-text (format " [%s WPM]" (floor words-per-min)))
    (force-mode-line-update)))

(defun typing-speed-remove-old-events (threshold queue)
"Removes events older than than the threshold (in seconds) from the specified queue"
(if (or (null queue)
      (> threshold (car queue)))
      nil
      (cons (car queue)
        (typing-speed-remove-old-events threshold (cdr queue)))))

(defun turn-on-typing-speed ()
"Turns on typing-speed-mode"
(if (not typing-speed-mode)
      (typing-speed-mode)))

(defun turn-off-typing-speed ()
"Turns off typing-speed-mode"
(if typing-speed-mode
      (typing-speed-mode)))

Zermatt in Community Server

keith-brown — Mon, 06 Oct 2008 22:07:17 GMT

I'm about to embark on a mission to get Zermatt integrated into pluralsight.com as our single-sign-on solution, and a big part of that is getting our Community Server installation wired into that. I'm curious if anyone else has seen any work being done in this area, or if I'll be the first?

I plan to blog about my progress (and share it) if there's not already a built-in solution out there.

Demos for Maine Bytes User Group Custom Controls in Silverlight 2 talk

fritz-onion — Fri, 03 Oct 2008 11:56:38 GMT

For those of you that attended my talk in Portland, ME at the Maine Bytes user group, you can grab the demos here. Thanks for coming!

Microsoft's Next Gen application server offering: "Dublin"

matt-milner — Wed, 01 Oct 2008 20:26:42 GMT

Microsoft announced today the details of upcoming features that will be added to Windows Server 2008 to provide a rich host for WCF Services and WF workflows. In addition, the announcement provides some information about upcoming features in the .NET Framework v4.0 including. I'm extremely excited to have a host process for WCF and WF applications out of the box with management features for my services and workflows. This has been a big detractor for many customers looking at adopting these technologies. The great thing is that this host technology is integrated with IIS so I don't have yet another management story or some specialized application server, I get to leverage all the work the IIS team did to make IIS 7 and the tooling so great.

With WCF and building workflow services, having the correlation components is a huge step forward and addresses one of my biggest gripes with the correlation available today. It's a very exciting time to be building connected systems on the Microsoft platform. As more information is released at PDC, I'll start blogging about some of the new features and capabilities in the framework and using "Dublin" as a host. That's right, I said I'd actually start blogging some technical information. :)

Check out the information about what's coming and look for more information to come out of the Professional Developer's Conference (PDC).

Screencast: Using persistence services in Windows WF

matt-milner — Wed, 01 Oct 2008 18:32:16 GMT

My latest screencast in the Windows WF developer screencast series has been loaded up as of this morning. In this session, I discuss the basics of add persistence services into the workflow runtime using code or configuration. Additionally, to show off the power of this feature in Windows WF, I use two different host processes sharing a persistence store: the first host starts a workflow and then it persists, while the second host picks up the workflow after its configured delay and resumes the processing.

Endpoint Screencasts - Using Persistence Services in Windows Workflow Foundation (WF)

Previous screencasts in this series:

Running workflows in your .NET applications

Your first state machine workflow

Your first sequential workflow

RSS feed of all screencasts in the series

New Data Dude GDR is out

brian-randell — Wed, 01 Oct 2008 15:49:00 GMT

Gert's got all the details on his blog.

To me, the biggest point to latch on to is this:

This is the last CTP, we started our final descend, we will publish a public RC (release candidate) when it is ready, followed by the RTM release. The upcoming RC (release candidate) will be a "go-live" release. The two remaining areas the team is currently working on is performance and bugs, we are done with all work items.

It'll be nice to have a final version that I can use with SQL Server 2000, 2005, and 2008. Patience grasshopper, patience.

You Think You Like Halloween?

craig-andera — Wed, 01 Oct 2008 12:41:59 GMT

I don’t think you like Halloween like this guy likes Halloween…

I’m glad to have helped in even a very small way.

The Data Dude Is Immortal

david-starr — Wed, 01 Oct 2008 05:00:19 GMT

MSFT has announced plans to upgrade the .NET framework to 4.0 on the next major release, and in the same communiqué quietly slipped in some interesting news. The features previously relegated to the Visual Studio Database Professional SKU will be moved into other SKUs in the 2010 release of Visual Studio.

This is an interesting move. Certainly the features in Data Dude have always been super cool. Who doesn’t think massive DB compares, stored proc. unit tests, sample data generation, and database entity management as code files are sweet? Now everyone gets the love.

In a way, I am disappointed. I have always thought the Data Dude was a potential game changer. Targeting database developers as developers instead of DBAs is a fundamental change in the way these folks can manage their work and the expectations others have of them. Treating DBAs as developers holds the promise of increasing the data development role into one of respectability, and could serve to boost the overall profession of the traditional DBA.

Farewell, Data Dude. I liked thee.

On the other hand, simplifying the Visual Studio SKU set can not be a bad thing. Buying Team System and determining licensing can be harder to figure out than buying a house. And putting the Data Dude features into the hands of developers via the Visual Studio Development SKU is a nice trade.

Cast Cast 15 – Uncle Bob Martin

david-starr — Wed, 01 Oct 2008 04:06:34 GMT

When I heard Uncle Bob’s keynote address at the Agile conference in Toronto this year, I just knew he had to come on the show. Lucky for all of us, he agreed!

Given that the title of Uncle Bob’s latest book is Clean Code, the Elegant Code Cast was a perfect fit. This is a great episode, chock full of ideas for developers of all stacks.

Official Bio

Robert C. Martin has been a software professional since 1970. In the last 35 years, he has worked in various capacities on literally hundreds of software projects. He has authored "landmark" books on Agile Programming, Extreme Programming, UML, Object-Oriented Programming, and C++ Programming. He has published dozens of articles in various trade journals. Today, He is one of the software industry's leading authorities on Agile software development and is a regular speaker at international conferences and trade shows. He is a former editor of the C++ Report and currently writes a monthly Craftsman column for Software Development magazine.

Download the episode MP3

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)

Paul Vick relocates to Oslo

don-box — Tue, 30 Sep 2008 05:54:00 GMT

Paul just joined my team to work on the Oslo language, specifically the parts covered in this talk.

I can't put into words how happy I am that Paul signed up to help us birth this baby.

More News: Data Dude and Team Dev are now One!

brian-randell — Mon, 29 Sep 2008 20:50:00 GMT

If you go down the page here, you find some juicy goodness related to VSTS:

"Better Together – Visual Studio Team System Development Edition and Database Edition
In recognition of the increased need to integrate more of the lifecycle members together, we will provide a unified Development and Database product in Visual Studio Team System 2010. Beginning October 1, 2008 Development Edition and Database Edition MSDN subscribers will have access to both products."

Great news!

Visual Studio 2010 is its name

brian-randell — Mon, 29 Sep 2008 20:45:00 GMT

And the .NET Framework 4.0 is coming too!

More details here and here.

Rails - Testing

kevin-jones — Mon, 29 Sep 2008 11:33:22 GMT

Now that we have a Rails app up and running, all be it a simple one, it's time to think about testing. When you generate an application you also get a test structure created for us. This structure lets us create unit, functional and integration tests. Each kind of test has a different scope and I'll start, as we should, with unit tests.

Looking in the test/unit directory there's a single ruby source file for each model created previously, each of these files looks like this

class BlogEntryTest < ActiveSupport::TestCase
  # Replace this with your real tests.
  def test_truth
    assert true
  end
end

Pretty straightforward, assert that true is true. (If this is your first glance at Ruby code the first line says that BlogEntryTest derives from TestCase and the 'def' statement defines a method).

Before running the test I create the test database

mysqladmin -u root create rblog_test

There are two ways (at least) to run this test, running

ruby -I test test/unit/blog_entry_test.rb

(-I test here includes the test directory in the search path) or

rake test:units

Running the first command line on my machine gives this:

Loaded suite test/unit/blog_entry_test
Started
E
Finished in 0.033476 seconds.

  1) Error:
test_truth(BlogEntryTest):
ActiveRecord::StatementInvalid: Mysql::Error: Table 'rblog_test.users' doesn't exist: DELETE FROM `users`

This shows us that the database tables don't exist. Running

rake db:test:prepare

fixes this and re-running the test now succeeds.

Started
.
Finished in 0.095619 seconds.

It's also possible to run

rake test:units

This will run all the unit tests

Started
...
Finished in 0.056533 seconds.

3 tests, 3 assertions, 0 failures, 0 errors

Now that there's some confidence that the testing framework is in place it's time to start thinking about real tests.

The user class represents a user of the system, either a user with a blog or a user posting comments. This user must have a username, email and password. The user class looks like this

class User < ActiveRecord::Base
  validates_presence_of :name
  validates_presence_of :email
  validates_uniqueness_of :email
  validates_confirmation_of :password
  validate :password_non_blank

This suggest some tests. Does the user have a name and email, is the emil unique and does the password have some data! The first test checks that the user is valid

class UserTest < ActiveSupport::TestCase
  def test_empty_user_is_invalid
    user = User.new
    assert !user.valid?
    assert !user.errors.empty?
    assert user.errors.invalid?(:name)
    assert user.errors.invalid?(:email)
    assert_equal "Missing password", user.errors.on_base
  end

The test creates a User then calls the valid? method (if you're new to Ruby the ? on the end of a method is part of the method name and indicates that the method returns a boolean, a ! on the end indicates that the method mutates data) . The test asserts that the user is not valid and then asserts that the appropriate errors have been added to the errors collection.

The code has other tests for the user, checking that the password and password_confirmation match and that the password is not blank. There is also a test that a User is valid if all the fields are set correctly, none of these are shown here but the code is available here not that there's much to see at the moment!

The final test for the moment checks that the User must have a unique email. The code looks like this:

def test_user_unique_email
  user = User.new(:name => "Test Name",
                  :email => users(:kevin).email,
                  :password => "wibble",
                  :password_confirmation => "wibble")

  assert !user.save
  assert_equal "has already been taken", user.errors.on(:email)
  assert_equal ActiveRecord::Errors.default_error_messages[:taken], user.errors.on(:email)      
end

The thing of interest in this code is the line

:email => users(:kevin).email,

This loads a fixture named :kevin. Fixtures are test data defined in a yml file (YAML Ain't a Markup Language) file. Fixtures have names and cen be loaded by name in the test code. The fixture looks like this:

kevin:
  email: kevin@test.com
  hashed_password: hash
  name: Kevin

The fixture data is loaded into the database, then the line 'users(:kevin).email' loads the fixture and gets its email value. This means that the test tries to save a user with the same email address as one that already exists, and that should fail.

Changing Source Control as a Kaizen Event

david-starr — Sat, 27 Sep 2008 06:25:20 GMT

I often have opportunities to work with organizations in transition to Team Foundation Server for their source control solution. Most large organizations (and many smaller ones) look for a migration route for their source code that allows them to retain history and their current merge/branching model. In heavily regulated environments, this is often a fundamental requirement, in fact. Accordingly, there are many packaged conversion tools out there to serve this need. There are Team System SCC conversion utilities for IBM’s Clear Case, VSS, SVN, StarTeam, CVS, Perforce, and others. The mere existence of these tools lets me know that migrating source code in the same structure it previously existed is considered “good” by many.

My default recommendation is to do a clean, fresh, manual import rather than to migrate source code with existing structure. I have several reasons for this including:

Code migration is more complicated and it will take longer (cost more).
Tools have flaws. Everything may not turn out the way you think it will when you have been branching and labeling in that old system for 6 years.
The majority of code file comparisons occur at the tail end of source control. Very rarely is a comparison made on a code file in SCC older than 60 days.
The reason you want to retain history is to blame that guy.
Your branching model was probably over complicated anyway.
History for auditing purposes can be found in the old system, kept online and read-only for a year or two if necessary.

But the number one reason I don’t want to bring the source code over in the same model is because this is a golden opportunity to improve.

It amazes me that the structure of a SCC system reflects the nature of the organization that created it. I have learned, however, that it does. Are management decisions hectic? Are releases going out buggy? Look for lots of deep branching structures. Are developers working in separate branches on the same release? Look for lots of cherry pick merges.

It is a fundamentally healthy exercise to pull a large pile of source code out of the old system and bring it into the new one one project at a time, ensuring that each one is self contained. In other words, break the dependencies between projects and all of those weird references to resources outside the boundary of the solution.

It comes down to this, why are you making this tooling change in the first place? Odds are that the tool change is being done because the team wants things to get better. Whether you are moving to Team System, SVN, or something else, you are moving to a new system to make an improvement. Given the desire to improve, take advantage of the opportunity to actually make things better rather than to persist old dysfunctions into a shiny new tool.

As a manager of development teams myself, I found great value in migrating source control every 2 years or so, just to cause such a spring cleaning event.

And the number one thing you can do to make this a true Kaizen event? Ensure that each and every project (that is, every *.*proj file) gets build built via a CI build before adding another project to the system.

T-30: PDC 2008 Pre-con

brian-randell — Sat, 27 Sep 2008 05:18:00 GMT

Well, we're 30 days out from PDC 2008 pre-con day.

I'm doing a pre-con on VSTS.

A big part of the pre-con is best practices and worst practices, or anti-patterns.

As I get things all nice and packed up into a nice package with a bow on top, I'm curious.

If you're coming to my pre-con, what do you want to know? What are you looking for? What would make your day?

Feel free to leave a comment on this post or use the Contact link.

RTM for HPC Server 2008 is now available

joe-hummel — Thu, 25 Sep 2008 20:28:00 GMT

In case you missed it, RTM for Windows HPC Server 2008 is now available here. Don't forget to grab the SDK for HPC Server, which allows you to program MPI, as well as access a cluster programmatically via the HPC Server API.

There are also a number of tutorials and how-to articles available on Microsoft's developer resources page, two of which we wrote and blogged about earlier: "Classic HPC Development using Visual C++", and "From Sequential to Parallel Code". The former is for more experienced HPC C++ developers, and uses OpenMP, MPI and MPI.NET to develop an image processing application. The latter is oriented towards newcomers to HPC and HPC Server 2008, and shows how to move step-by-step from a sequential, desktop GUI application (managed C++ or C#) to a parallel, cluster-based application. A variety of parallelization techniques are presented, including parametric sweep, explicit threads, OpenMP, TPL, and HPC Server's new SOA-based approach. Both tutorials include extensive lab exercises, solutions, and demos.

Cheers!

Learning Rails - Part 2

kevin-jones — Thu, 25 Sep 2008 07:32:22 GMT

I wanted to make this a series about Rails and about Ruby. To that end I'm going to write a series of entries on building an MVC application. As I said in the previous post I am a Ruby and Rails neophyte, so I'll be learning as I go along, regard this as a developer's journal. The aim being that you can learn from the mistakes that I make. If this really gets going I also hope to do some screencasts along the way.

What am I going to write - a blog of course (is there any other sort of web app out there today :) ). I chose blogging software because

Everybody understands what a blog is, so no trying to figure out the behaviour
It gives me a chance to play with different formats (html and RSS)
At some point I'll need to write support for the various APIs (atom, etc)
There'll be chances to use AJAX
I can learn how to deploy to Apache
It shouldn't take too long to get things going

I'm going to rely heavily on the 'Agile Development With Rails' book, and hopefully any feedback I get. I'm learning Ruby at the same time as Rails and Ruby is a very idiomatic language, I know I'll get some of the idioms wrong, so again feedback is welcome. Oh and initially I'm doing this on MacBook using TextMate as the editor. At some point I'm going to play with NetBeans and Eclipse as tools and so try out JRuby, not that I like a challenge of learning 17 new things at once!

Start at the beginning. Go on the end and then stop, said the Red Queen

So the beginning of a Rails app is the code generator, to create the application I fire up a terminal make sure I'm in the right directory and call

rails rblog

This gives the well known directory structure of

app
config
db
doc
lib
log
public
script
test
tmp
vendor

Most of the time I'll be in the app directory (that's where the models, controllers and views are), but I'll also use stuff from the db directory where the 'migrations' are stored, in the public directory where public the web files are and in config, where various setup files live.

Once the application has been created I can fire up another terminal (I usually have three open, one for my commands, one for the server and another to see the log file), change the the project directory and run the server with the command 'script/server'

This starts the server on port 3000, the server I'm using here is Mongrel, you can also start WEBrick. There's plenty of discussion on these servers out on the web so I won't go into the differences here.

Once the server is running you can point your browser at http://localhost:3000 and you should see something like:

I'm going to use MySql for the database and this needs to be configured. To do this I've edited config/database.yml to look like this:

development:
adapter: mysql
encoding: utf8
database: rblog_development
username: root
password:
socket: /tmp/mysql.sock

Adding similar entries for test and production databases. Once that's done I created the development database

mysqladmin -u root create rblog_development

Now that all the necessary structure is in place I can create the first controllers and models. What do I know about the blog? I know it's going to have users, users can have blogs and blogs will have entries and comments. There may be more things eventually, such as tags, categories, pingbacks etc, but for now that's enough. So not to get too far ahead of myself I decided to create scaffolding for users, blogs and blogentries.

For the users model I'm going to user a similar approach to that used in the Rails book, so the user will have an email address and password, the password will be stored as a hash will be salted. A user will have a name that can be displayed on comments or on a blog and users may also own blogs. For now I'm going to limit this to one blog per user, but in the future this may expand to multiple blogs.

Running

script/generate scaffold user email:string hashed_password:string name:string blog_id:integer

gives me what I want. Doing something similar for blogs and blogentries

script/generate scaffold blog title:string sub_title:string owner_id:integer admin:boolean
script/generate scaffold blog_entry title:string entry:text author_id:integer entry_added:datetime entry_last_edited:datetime

creates those models and their corresponding controllers and migrations.

Notice that as in my previous post I'm using singular names for the model components, so user, blog and blog_entry.

Now that's done it's then onto setting out some of the UI and writing some unit testing code.

Rails, Ruby

Screencast: Running workflows in your .NET applications

matt-milner — Wed, 24 Sep 2008 20:04:00 GMT

My latest screencast is up on the Endpoint.tv show on Channel 9. In this screencast I cover the basic steps to host workflows in your applications. I cover the basic hosting steps in a console application, then jump in and run a workflow in an ASP.NET application.

Screencasts: Running Workflows in your NET Applications

Previous screencasts:

RSS feed of all screencasts in the series