Most Popular Posts

Most Commented On

Current Bloggers

Sponsors

Wikis

  • You have not yet contributed to any pages.

Durandal Help Desk Training App Preview

Posted by Rob Eisenberg, Monday, December 16, 2013 (3,151 views)

I may have mentioned that we are running a Kickstarter to help fund Durandal and build the business for the future. As an incentive to contribute, there are a number of cool rewards. One of the most valuable rewards to developers is training. If the Kickstarter succeeds, we are going to create three application building tutorial series. Each of these three series will take you from ground zero all the way to a working application. Each will demonstrate recommended Durandal usage as well as various UI architecture techniques. This morning I released a short “off the cuff” video which demonstrates the second of these three applications, the “Help Desk”. I hope you enjoy it and please share this with as many people as you can. We know there are many tens of thousands of developers that are looking for something like this. Please check out the available rewards and consider whether you can help us meet our goals in the coming year. I think you’ll find there’s a lot of value for you waiting to be enjoyed.

See the video in this update.

New Durandal Opportunities for Companies, User Groups and Community Organizers

Posted by Rob Eisenberg, Monday, December 09, 2013 (2,494 views)

You may have heard that Durandal is currently running a Kickstarter. We’re doing that to enable us to create some new things that wouldn’t normally be possible with our typical time and resources. We’re also doing it to enable us to do what we normally do…but to do it better, quicker and more frequently.

There are a variety of rewards available for those who are generous enough to back our project. Today I'm happy to announce four new backer levels geared towards companies, user groups, conferences and community organizers.

Does your company produce a relevant product and offer consulting services? You probably want to check out the Polymath reward level. This level combines our Consultant and Partner levels.

Are you a large company, user group or community organizer interested in providing training for a group of developers? Are they distributed geographically or do they work from home? We've got a special backer level just for you: Virtual Conference. We'll let you invite up to 300 people to a private web cast where we'll provide up to 8 hours of Durandal training. We can schedule the conference any time after the first quarter of 2014 at a day and time that is appropriate for you. If you wish to sell tickets to recuperate your costs, that is permissible and we'll help you to get the word out. If needed, you may split the training up into two, four-hour sessions delivered on separate days.

Does your company want maximum exposure as a supporter of Durandal? Please consider the Benefactor reward level. You'll get all the benefits of the Polymath, plus some major marketing bonuses. Your logo will be displayed on the home page of durandaljs.com as a 2014 sponsor. Your company will be mentioned in all public presentations at user groups, code camps and conferences. We will work with you to publish a dedicated blog post to our readers talking about your company and your generous support of the project.

Finally, do you want Durandal training live in your city? Back as a Conference Host and I'll come to any city in the Continental USA to deliver a full day of Durandal training. You provide the location and invite as many people as you want. I'll show up and deliver the learning experience. We can schedule the conference any time after the first quarter of 2014 at a day and time that is appropriate for you. If you wish to sell tickets to recuperate your costs, that is permissible and we'll help you to get the word out.

I hope you will consider supporting us in any way you can.

Thanks you for your time and understanding.

Announcing the Durandal Kickstarter!!!

Posted by Rob Eisenberg, Friday, December 06, 2013 (4,361 views)

Today I’m happy to announce the launch of the Durandal 2014 Kickstarter!

Durandal is an awesome OSS JavaScript framework built by Blue Spire to empower developers in building web, desktop and mobile apps. Its features and capabilities exceed or are on par with those of frameworks made by the world's largest technology companies. Our community is rapidly growing and we're very excited about what the future holds. With your support we want to expand our current offering by doing more releases, building slick tools, publishing comprehensive video training and planning for the next generation.

We have some awesome plans and cool rewards…but we can’t do it without you. I hope you’ll consider supporting Durandal and OSS by backing this project. Please check it out on Kickstarter and consider becoming a part of our history.

Thanks!

Rob Eisenberg,

Durandal, Lead Architect

 

PS – Also check out other cool projects on CrowdFundFusion.

Launching External applications w/ Grunt.js

Posted by Derik Whittaker, Friday, November 29, 2013 (3,350 views)

I am using Grunt.js as my build/task tool for a project I am working on and I needed the ability to launch an external, console application via Grunt.  Fortunate for me there is an existing plugin called grunt-exec which can handle just this need.

When I sat down to add grunt-exec to my gruntfile.js script everything worked during my test runs, but when I went to launch the real console application I quickly realized that something was not right. 

Take a look at my grunt setup below

image

You can see that all I am doing is calling the cmd executable and passing it the path to my  application to be launched.  The issue is that this code will run the exe in the same space as the console and I wanted my ServerHost.exe to run in its own instance.

To try to resolve this I thought I would simply use the start command (see below), sadly this caused other issues.

image

When I ran the code above it would correctly launch a 2nd console instance, but it would not start my application, no idea why.  However, I thought it may have been the path to the .exe so I added single quotes around the path to see if that would help…sadly it did not.

I realized that my issue was that I need to change my current working directory to be the same as my .exe, but how to do this because I could only issue one command via the grunt-exec command.  It then dawned on me that I could use the ‘&’ in my commands and have the left command run followed by the right command.

Using the ‘&’ I changed my script be below and everything just worked

image

The moral of this story is you can use Grunt.Js to launch external applications, it just takes a bit of patience to get the command correct to do so. 

Till next time,

Filed under: ,
Discuss (0)

Using Autofac as the DependancyResolver for SignalR

Posted by Derik Whittaker, Wednesday, November 27, 2013 (3,449 views)

I have been playing around w/ SignalR and I have to say IT IS PRETTY COOL.  I have been pretty impressed with the simplicity and the ease of the the framework as well as its extension points.  One area that I am happy to see the ability to use IoC within SignalR, more so the ability to use any container I want to handle the DI.

Recently I switched to using Autofac (for no other reason to learn something different).  Because I am learning this I of course wanted to use this in SignalR, and of course it was pretty simple.

To use Autofac w/ SignalR we need to do the following

  1. Add Autofac to your project.  (using Nuget: Install-Package Autofac)
  2. Add Autofac.Configuration to the project, this allows for convention based bindings (using Nuget: Install-Package Autofac.Configuration)
  3. Add Autofac.SignalR to the project (using Nuget: Install-Package autofac.signalr)
  4. Setup the bindings for Autofac (see below)
  5. Set the Autofac resolver for SignalR

Setup the Bindings for Autofax

The first thing we need to do is create the general wiring for Autofax.  The last 2 lines are the magic to get SignalR to use Autofac.  Here we are creating the correct resolver class and setting it as the global DependencyResolver

            
var builder = new ContainerBuilder();
builder.RegisterModule<ServerIoCModule>();

var service = builder.Build();

var resolver = new AutofacDependencyResolver(service);
GlobalHost.DependencyResolver = resolver;

Below is the code for my Autofac module.  Please make sure you add the .AsSelf convention.  If you do NOT do this your hubs will not be created.  This is because there is no interface attached so Autofac will have no idea how to create the class.

            
public class ServerIoCModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        base.Load(builder);

        var thisAssembly = typeof(ServerIoCModule).Assembly;

        builder.RegisterAssemblyTypes(thisAssembly)
            .AsImplementedInterfaces()
            .AsSelf();
    }
}

Once you have the above setup correctly you will be able to inject dependencies into your Hub as well as have your Hubs created via IoC

Till Next Time,

Filed under: ,
Discuss (0)

Caliburn.Micro 2.0.0-alpha2 Is Here

Posted by Rob Eisenberg, Monday, November 25, 2013 (3,905 views)

I’m happy to announce that the Caliburn.Micro team has been hard at work on a new version: Caliburn.Micro 2.0.0. We’ve just published the second alpha on Nuget. This new version was made entirely possible by the hard work of Nigel Sampson and Thomas Ibel. These two gentlemen managed to not only add support for Windows 8.1 in this release but to also refactor the library so that it’s core is now a Portable Class Library (PCL).  See the details below.

Packages Available on Nuget
Changes
  • portable library net45+sl5+win8+wp8 (issue #259), SL4, WP71 and NET40 will not be supported
  • Support Windows 8.1 (issue #336) and use new Behavior SDK (issue #338)
  • Fix CultureInfo in CoerceValue
  • Remove Bootstrapper<TRootModel> and PhoneBootstrapper, use BootstrapperBase and PhoneBootstrapperBase
  • Remove package builder (will not work because portable/platform split)
  • Remove EventAggregator PublicationThreadMarshaller and Publish() without marshaller
  • Add EventAggregatorExtensions (PublishOnCurrentThread, PublishOnBackgroundThread, PublishOnUIThread, BeginPublishOnUIThread and PublishOnUIThreadAsync)
  • Fix OnViewReady should be called on child views too (issue #292)
  • Screen only have one TryClose(bool? dialogResult = null)
  • Coroutine uses CoroutineExecutionContext instead of ActionExecutionContext (as it is not portable)
  • SettingsService.RegisterCommand renamed to RegisterFlyoutCommand
  • CallistoSettingsWindowManager removed, replaced with SettingsWindowManager
  • Dependency on Callisto removed
  • Dependency on Windows.UI.Interactivity removed, replaced with 8.1 Behaviours SDK.
  • NotifyOfPropertyChange() does not support [CallerMemberName] at the moment
  • Fix Memory leak in ActivateWith() and DeactivateWith()
  • View/ViewModel-Locator performance improvement (issue #342)

RichTextBox Threading issue when used in a List Control (I think….!)

Posted by Derik Whittaker, Monday, November 18, 2013 (2,903 views)

I have just finished spending 5 hours on a bug which lead me down many different paths to only find that ALL of them were wrong and there is some sort of threading issue when using RichTextBox in a XAML based Windows Phone application.

A little background.  I have an application which shows IM messages and I noticed that when I would load the initial set of data everything appeared as expected, however when I would load more items into the list (older messages) the data seemed to be out of order.  This was weird, but to make it more weird the order in which the data was being displayed in the UI was pattern-less and random which really, really pissed me off.

To try to isolate the issue I ran though an entire series of steps to try to isolate the issue.  Theses steps are:

  1. Ensure my data was in fact being ordered as expected in my underlying ObservableCollection – IT WAS
  2. Make sure that the UX control’s ItemSource is also ordered correctly – IT WAS
  3. Remove the use of my custom control which is displaying my data and replace it w/ a simple text box to make sure it was not a control issue – EVERYTHING WORKED AS EXPECTED (ordered correctly)
  4. Add back the custom UX control and put break points inside my dependency property to ensure my bindings were setup correctly – THEY WERE

    *** At this point I am at my wits end so I go home for the day ***
  5. Add a text box along side w/ the existing RichTextBox and push the EXACT same value (e.NewValue.ToString()) into each and see what happens.  The results are here:
    image

    As you can see my text box bindings/value are correct, but my RichTextBox data is completely wrong.  It has the correct value ALONG with some data from another instance of this control… WTF 

    Now I get to thinking that this MUST be some sort of UX Threading issue.  Just to see if I could solve this simply wrapped my entire call in a  Dispatcher.BeginInvoke call, but of course this did not work.

I am now completely at my wits end, WTF do I do.  The incoming bound value is correct but my control’s data is not… UGG

For fun I decided to CLEAR my RichTextBox’s contents (by using Blocks.Clear()) prior to setting it just to see what would happen and to my amazement EVERYTHING just worked as seen below.

image

 

Now I am 100% sure this is NOT the correct solution for this problem and I fully expect this to bit me in the A$$ at some point in the future, but I don’t care :)  I have a significant demo in 1 day and I need to get stuff working ASAP.

Hope this helps.

Till next time

Filed under:
Discuss (0)

Leveraging your XAML MVVM Skills in HTML – Changing UI Apperances

Posted by Derik Whittaker, Tuesday, November 12, 2013 (2,918 views)

This is a multi-part excerpt series from my PluralSight course Knockout for the XAML Developer 

knockout-xaml-developer

Knockout for the XAML Developer

The Knockout for the XAML developer course helps XAML developers, whether you’re a WPF or Silverlight developer, take their existing MVVM skills and transition them to the exciting world of HTML development.

This series is going to be broken down into 6 parts and should be enough show you show you can leverage your existing MVVM Skills you acquired while building XAML based and apply those to building HTML application with Knockout JS

Series Table of Context

  1. Setting up the Data Context
  2. Working with Observable Properties
  3. Working with Observable Arrays
  4. Handling User Click Events
  5. Handling Binding Context Changes
  6. Changing UI Appearances based on Bindings (this post)

Anytime you build an application which has any type of visual complexity you are going to have the need to change the look and feel of UI elements based on data values.  Your need may be as simple as needing to show or hide elements.  It could also be as complicated as completely changing the appearance of the element. 

When building applications in HTML w/ Knockout we can accomplish both of these needs in very similar ways ways to how XAML accomplishes these.

How to change Visibility State:

When working with a XAML application you can change an elements visibility by setting the Visibility attribute of an element to either Collapsed or Visible.  Typically this is done via some sort of converter, normally one which converts a boolean to either visible or collapsed.  The code below is an example of how this may look in a XAML application

image

When working with HTML and Knockout we can accomplish the exact same result but with less code.  The reason we can use less code is because unlike XAML, Knockout uses a boolean to toggle state by default.  In fact to set an element’s visible state we simply need to use the visible binder as seen below

image

When you compare the 2 options above you can see that the intent is exactly the same and their implementation is almost as well.

How to change an Elements Appearance:

When working XAML we have the ability to define the look and feel as an external style.  We can then use binding and converters to dynamically apply a different style based on some setting.  The code below will illustrate how to do this.

image

You can see in the example above I am binding the Status.Description value to the Style attribute.  We are then are using a external converter to dynamically apply the style. 

When working with HTML and Knockout we can accomplish this same task by using the css binder.  See below for an example.

image

If you look at the example above, what we are doing is attempting to apply the ‘overdue’ css style to our element based on the evaluation of the bound Status property.  If this returns true our CSS will be applied to the element, if false it will not be applied.  Although CSS and Styles in XAML are not a 1 to 1 match they do expose the same basic concept, which is to apply styling information to a UI element.

If you want to learn more about how your XAML MVVM skills transfer to HTML Development watch my Pluralsight Course – Knockout for the XAML Developer

Till next time,

Discuss (1)

Join Us In Changing The Web With The Durandal Project

Posted by Rob Eisenberg, Friday, November 08, 2013 (3,898 views)

Hello Community!

I’m excited to announce that this week the Durandal project officially launched its 2014 Sponsorship Campaign. We have a variety of sponsorship options, each of which provides different benefits to the sponsor, as well as different benefits to the Durandal community. There are plenty of opportunities to showcase your brand, products, services or just your love of developers. Whether you’re a product company, work in consulting services, provide cloud technologies or education and training, I hope you will consider how you can join with us to make 2014 a great year for the Durandal project. Please contact us at info@bluespire.com if you are interested in finding out more.

Looking forward to working together!
Robert H. Eisenberg
President - Blue Spire
www.durandaljs.com

Durandal 2.0.1 Released. How You Can Help...

Posted by Rob Eisenberg, Wednesday, October 23, 2013 (5,818 views)

Durandal 2.0.1 is a patch release containing a number of bug fixes and improvements applied after the release of 2.0.0. There are no breaking API changes in this release and no new features; only fixes. You can find the full list of changes and their related issues in the Changes.txt file found here. With this release we've updated the following assets: all Nuget packages, the Bower package, the VSIX, the Mimosa Skeleton, the HTML and Raw zip downloads and the TypeScript definition file.

Additionally, we've updated the web site with fixes and improvements to existing articles. We've also added some new topics such as testing, SEO and localization. All these articles are now located in the repository under docs/2.x. So, if you want to make corrections, additions or create completely new topics, all you have to do is submit a pull request.

Next, we begin work on 2.1.0. This minor version will continue to incorporate fixes to bugs as we find them, but will also include some new functionality. We will also be upgrading our dependencies to their latest versions. There are some pretty neat things planned, so keep a look out :)

If you are wondering how you can help out the Durandal project, here's a list of things you might consider doing:

  • Blog about Durandal: How To's, Tutorials, etc.
  • Make some instructional videos and post them to YouTube or Vimeo.
  • Speak about Durandal at user groups and conferences.
  • Help answer questions in the google group.
  • Follow the official Durandal twitter account: @durandaljs.
  • Star the Durandal project on GitHub.
  • Tweet about Durandal.
  • Consider donating or purchasing commercial support during your project.
  • Build awesome apps and tell everyone about it!

If you blog, speak publicly or make videos, please let me know and I will be glad to help get the word out. Thanks to everyone who contributed pull requests, reported bugs and made suggestions. This release wouldn't have happened without you!

Durandal’s Edge

Posted by Rob Eisenberg, Monday, October 21, 2013 (11,269 views)

With so many SPA-style frameworks emerging in the last couple years, you may wonder what makes Durandal unique or different. Why would you want to choose it for your next project?  I’d like to share a few key points to that end…

A Natural Alliance

Rather than re-invent the wheel, Durandal starts by combining and building on top of three existing libraries. Each of these libraries is very mature, has a large, active community and was strategically chosen because it meets one specific need very well. First we start with jQuery. In some ways you can think of it as a better DOM or the “missing JavaScript core library”. Next, we add in RequireJS, which gives us rich, declarative JavaScript modules. Finally, Knockout provides us with powerful two-way data-binding.

With these three libraries as a foundation, Durandal constructs a thin integration layer and transforms them into a powerful SPA framework. In addition to strategically connecting these libraries, Durandal adds new functionality. Some things Durandal adds are:  a client-side router, rich view composition, screen state management, pub/sub, simple conventions, modals/message boxes and more…

Maximum Skill Reuse

If you’ve worked with any of the three libraries listed above, then you already have skills you can leverage on a Durandal project. You already know part of the framework. This makes it relatively easy for existing web developers to get started. The time you’ve invested learning the three core libraries on prior traditional web projects translates directly to Durandal apps. Choosing Durandal is almost a “no brainer”.

Suppose you’ve never worked with jQuery, RequireJS or Knockout. Is Durandal worth your time to learn? Why not pick a different SPA framework that is “all inclusive”? The simple answer is YES, it is well worth your time. Here’s the longer answer: Almost every major SPA framework has a way to work with the DOM, create modules and declare data bindings. No matter what framework you pick, you are going to have to make the effort to learn these things both conceptually and in terms of the chosen library’s API. The difference with Durandal is that we get those capabilities from other libraries which were originally designed for traditional web development. That means that when you learn those things in the context of Durandal, you are also learning things you can directly apply to traditional web development too. It’s a huge return on investment.

Powerful Modularization

All Durandal code is modularized based on the AMD standard, which is supported by our use of RequireJS.  To my knowledge, Durandal is the only SPA framework based on this de-facto standard for JavaScript modularization. As a result, Durandal’s capabilities in this department far outshine everything. Because we use the AMD standard, there is no presentation-framework-specific code required to create modules. This not only keeps your own code clean, but also makes it more portable: You can write a Durandal module for use both in a SPA and in a traditional web application where Durandal itself is not even used.

But that’s only the beginning of the advantages…

The AMD spec is pluggable via the notion of loader plugins. These plugins can acquire and transform any resource in any way and supply it as a module dependency. Want to load some JSON data? You can do that declaratively. Want to load CoffeeScript? You can use a loader to compile it on the fly if you want. You can write loaders to do just about anything. Most of Durandal’s view engine is in fact supplied by the text loader plugin. What’s the really awesome thing about loaders? They can execute code both at runtime and at build time. This means you can have a loader optimize content as part of a build process, but not have to change your application code at all. It’s extremely powerful.

Speaking of the build process….RequireJS supplies a build tool called r.js. It essentially takes a list of modules as inputs and spits out 1-n optimized files. For a small or medium-sized application, you might choose to build to one optimized file. For larger apps, you might choose to build a shell with each feature area optimized into its own file…and download features on the fly based on live user usage. That and many more deployment scenarios are what this tool was designed for. On top of that, there are many higher level build tools that work with RequireJS. You can use Grunt, Mimosa or even Durandal’s Weyland to automate the process.

Language support for AMD is also great. If you are using CoffeeScript, you’ll quickly notice that it’s function and block syntax makes defining modules really clean. But an even better  experience is had when using TypeScript because it has direct language support for the concept of modules. When you compile your TypeScript code you just tell it that you want AMD modules and it will spit out JavaScript ready to work with RequireJS. But that’s not the end of it. The work on TypeScript modules, RequireJS and the AMD spec has been influencing the next version of JavaScript directly. RequireJS is already planning to provide a direct migration path for code written with it today to the native module implementation of the JavaScript of the future.

Beyond Unobtrusive

Because Durandal relies on AMD modules and a lite set of conventions, you actually don’t see Durandal itself in your code very much. Yes, you use its APIs to configure the framework and set up your application’s router, but beyond that you don’t invoke Durandal much at all. You won’t be calling into Durandal to create modules, controllers, models or anything else. You don’t need to inherit or extend from any special classes or objects. Most code in a Durandal application is vanilla JavaScript and you could take it out and use it without the framework at all. It’s particularly powerful when used in combination with the observable module, which allows you to also remove all traces of Knockout from your code as well.

Flexible Composition

Not only do you need the ability to break down complex applications into small modules, but you need to be able to “compose” these small pieces together again at runtime. The declarative features of the AMD specification enable you to do this with your JavaScript objects in much the same way that you would leverage IoC and even simple name-spacing in other languages. The result is powerful and flexible object composition right out of the box.

But you don’t just need to compose objects, you need to compose views. Fortunately, Durandal has the most powerful, declarative view composition engine available in any framework today. Here’s a short list of some things you can do declaratively:

  • Statically/Dynamically compose a child view into a parent, allowing the binding context of the parent to be applied to the child.
  • Statically/Dynamically compose a child view with it’s own binding context into a parent view.
  • Statically compose a model with a dynamically changing view.
  • Statically compose a view with a dynamically changing model.
  • Statically/Dynamically compose in a view while overriding parts of the view with custom HTML on a case-by-case basis in the parent. It can have it’s own binding context or inherit its parent’s.

This is just a few examples of what can be done. Keep in mind that in all these cases the composition can be configured with transition animations, optimized per composition site to cache views or be driven entirely by static or dynamically changing data.

Elegant Asynchronicity

Building rich clients usually involves asynchronous requests for data or other resources. Durandal was designed to handle this with elegance from the very beginning. To that point, Durandal uses promises throughout. Durandal’s own API exposes all potentially asynchronous commands via promises. Internally, Durandal also understands when you use promises and it can therefor cause the binding system, router and other key features to respond appropriately. Out of the box, our promise implementation is provided by jQuery. However, existing site documentation explains how you can switch that out in favor of your favorite promise library, such as Q.

If you are targeting an ES5 browser, you can then enable the observable module. When this module is active, it teaches the binding system to data-bind directly to promises. The result is that you can set up a foreach binding over a promise for an array of data. In your own code, you don’t have to handle the promise yourself at all.

Navigation & Screen State Management

Durandal’s router is perhaps the most powerful router available today. It is configured with simple route-to-module mappings but can also be configured for convention-based routing. It automatically handles bad routes, supports hash and push state navigation and provides a lot of capabilities around data driven routes such as parameters, optional parameters, splats and query strings. Additionally, we support the notion of “child routers” allowing you to structure and encapsulate entire areas of your application, reducing the overall complexity of the navigation structure.

In real applications you need more than just routing though. You need something which is occasionally called “screen state management.” What is that? Imagine you’ve got a customer filling out a form in your application. Before they save, they attempt to navigate to a new screen. The current screen is in a “dirty” state and the application may want to prevent the user from navigating away…or at least temporarily halt the process and ask the user what it should do with the data. In Durandal, the router supports something we call the “screen activation lifecycle” which allows any screen to synchronously or asynchronously control flow into and out of screens. But this functionality is implemented so that it’s decoupled from the router itself, thus Durandal also uses it to handle the lifecycle of its modal dialogs. In fact, you can use it anywhere in your app, even controlling fragments of a screen and individual component activations. This is a complex bit of functionality to get right but it is critical in real applications. Most frameworks just ignore it entirely, but not Durandal.

Enterprise Ready

Consistent Testability

SPA’s can be complex code-bases and such projects need to be tested. Durandal has this area covered well. Because we’ve built on RequireJS and all of your code is built as AMD modules, you can easily fake, mock, or stub any part of the system. This applies both to your code as well as all of Durandal’s modules. The test strategy is consistent.  In fact, if you want to see how to write unit tests for your application, all you have to do is fork the Durandal test suite, change some file paths and you are up and running with a test setup for yourself. If you are interested in testability, keep an eye on the site. Our upcoming release will contain additional documentation showing multiple strategies for testing.

SEO Optimization

From the beginning of work on Durandal 2.0, SEO was considered. Interestingly, much of this work has to be handled on the server for a SPA. That said, Durandal supports all the necessary client-side hooks and configuration options to enable full Google crawling of your application. Our next site release, coming this week, will show you how to do it.

Globalization and Localization

Modern applications need to be made available to diverse people groups. Today Durandal is being used by companies all over the world who are rolling out apps to multiple cultures. Since Durandal was designed to be pluggable, it actually only takes a few minutes to plug a localization solution into the binder. With just a few lines of code centralized in one part of your code-base, you can ensure that everything displayed on the screen is properly localized; no hassle, no fuss. As part of our release this week, you’ll see some new documentation showing you just that.

Responsible Versioning

The Durandal project follows Sematic Versioning with great rigor. APIs do not break on minor or patch releases. Minor releases contain only additions and patches contain only bug fixes. Only major version changes signal potential breakage. Those aren’t going to happen very often. When you depend on Durandal, you know exactly what the version numbers mean and what you can expect when updating. The docs from previous versions are made available perpetually and conversion guides are provided for major version changes. We handle integration of the dependent libraries for you as well.

Commercial Support and Training

Durandal has an active community that is happy to help you learn the framework as you work through your application’s unique challenges. Much discussion is taking place already in our Google Group as well as on Stack Overflow. However, if that is not enough for you, or if you or your business need a safety net, Durandal has a few options available to you.  First, we have commercial support. This is a monthly subscription you can cancel any time and is priced based on the team size. We usually have clients purchase the commercial support for the few months they are working on the project and then discontinue after a successful rollout. It’s a great bargain compared to traditional consulting prices and turnaround time is very good. Additionally, my company provides customized training either delivered in person at your place of business or virtually through a series of web meetings. Pricing is usually negotiated on a case by case basis depending on the depth, time length and number of students. Finally, in the next couple of months you are going to start seeing official video training become available. Some of this will be free and some of it will be available for a reasonable price, providing you not only with a way to learn directly from me, but also to financially support the project.

Conclusion

While there are several SPA frameworks available today, only Durandal has all the benefits and characteristics listed above. But not only is it one of the most powerful and flexible options today, it also provides you with a great return on investment for your non-SPA web work. On top of all that, it’s enterprise ready and the kind of training and support you would expect is readily available. And this is just the beginning. Wait until you see what’s next…

Leveraging your XAML MVVM Skills in HTML – Changing Binding Context

Posted by Derik Whittaker, Monday, October 14, 2013 (4,224 views)

This is a multi-part excerpt series from my PluralSight course Knockout for the XAML Developer 

knockout-xaml-developer

Knockout for the XAML Developer

The Knockout for the XAML developer course helps XAML developers, whether you’re a WPF or Silverlight developer, take their existing MVVM skills and transition them to the exciting world of HTML development.

This series is going to be broken down into 6 parts and should be enough show you show you can leverage your existing MVVM Skills you acquired while building XAML based and apply those to building HTML application with Knockout JS

Series Table of Context

  1. Setting up the Data Context
  2. Working with Observable Properties
  3. Working with Observable Arrays
  4. Handling User Click Events
  5. Handling Binding Context Changes (this post)
  6. Changing UI Appearances based on Bindings

 

When building applications which use the MVVM pattern it is common to have deep view model.  Working with a deep view model is not difficult but it becomes easier if we change change our binding context to remove some of the property chaining.

Take a look at the XAML below and notice how I am chaining the properties in my binding setup

image

In XAML this can be accomplished by setting the DataContext property on a given control as seen below:

image

Once you set the DataContext all child controls will have this set as their root context.

When working with Knockout you can accomplish the EXACT same result by utilizing the ‘with’ binder.

How to change Context Binding in Knockout

Take a look at the HTML markup below and notice who I am still using property chaining.

image

Now by using the ‘with’ binding in Knockout I can update my markup to look like below

image

If you want to learn more about how your XAML MVVM skills transfer to HTML Development watch my Pluralsight Course – Knockout for the XAML Developer

Till next time,

P.S. – Check out any one of my other Pluralsight courses

    1. InDepth Knockout Validation - Online Training Course for Developers
    2. HTML for the XAML Developer - Online Training Course for .NET Developers
Discuss (1)

Leveraging your XAML MVVM Skills in HTML – Handling Click Events

Posted by Derik Whittaker, Thursday, October 10, 2013 (4,653 views)

This is a multi-part excerpt series from my PluralSight course Knockout for the XAML Developer 

knockout-xaml-developer

Knockout for the XAML Developer

The Knockout for the XAML developer course helps XAML developers, whether you’re a WPF or Silverlight developer, take their existing MVVM skills and transition them to the exciting world of HTML development.

This series is going to be broken down into 6 parts and should be enough show you show you can leverage your existing MVVM Skills you acquired while building XAML based and apply those to building HTML application with Knockout JS

Series Table of Context

  1. Setting up the Data Context
  2. Working with Observable Properties
  3. Working with Observable Arrays
  4. Handling User Click Events (this post)
  5. Handling Binding Context Changes
  6. Changing UI Appearances based on Bindings

 

Once we understand how to setup our Data Context along w/ Observables we should learn how to handle user click events.  When following the MVVM pattern in XAML you would create a property in your bound view model which implements the ICommand interface and bind your button to this property as seen below.

image

Using this pattern is simple and easy.  One really great feature of the ICommand interface is the implementation of the CanExcute method.  This will enable or disable the user control based on the evaluation of a method in your view model.

Although Knockout does NOT have a direct 1 to 1 mapping for ICommand, we are able to achieve the exact same functionality within Knockout.

Knockout Bindings to handle user click events

image

The code above is pretty straight forward.  We are using ‘click’ bind and binding it to a method called ‘save’ in our underlying view model

Now, I mentioned that we do not have the 1 to 1 match for CanExecute in Knockout, this is true.  However, we can use the click binder in conjunction with the enable binder to achieve the exact same results

Knockout Bindings to enable/disable the User Control

image

As you can see from the code above we are still using the ‘click’ binder to bind to our save method but we are also using the ‘enable’ binder to bind to and evaluate the IsValid method.  If the evaluation returns true the control will be enabled, if it returns false, disabled.

If you want to learn more about how your XAML MVVM skills transfer to HTML Development watch my Pluralsight Course – Knockout for the XAML Developer

Till next time,

P.S. – Check out any one of my other Pluralsight courses

    1. InDepth Knockout Validation - Online Training Course for Developers
    2. HTML for the XAML Developer - Online Training Course for .NET Developers
Discuss (1)

Honored to be award the MVP for C# for the 6th year in a row

Posted by Derik Whittaker, Saturday, October 05, 2013 (3,261 views)

This post is a few days late but on October 1st I was honored to be awarded the MVP in C# for the 6th year in a row.  I am always honored to be renewed with this because of the company it keeps.

Sadly I will have to miss my first MVP summit later next month, although in fairness this is the 2nd one of 2013.

Thanks again Microsoft for the recognition.

Till next time,

 

P.S. – Check out any one of my 3 Pluralsight courses

    1. InDepth Knockout Validation - Online Training Course for Developers
    2. Knockout For the XAML Developer - Online Training Course for Developers
    3. HTML for the XAML Developer - Online Training Course for .NET Developers
Filed under:
Discuss (0)

DevReach Sessions (WebApi, TypeScript & Knockout)

Posted by Derik Whittaker, Friday, October 04, 2013 (5,176 views)

This year I was giving the honor of speaking at DevReach 2013 and I had a blast.  Telerik really puts on a world class event and treats their speakers and attendees to an amazing event.

If you attended my sessions or just want to take a look at the content you can download each session below.

 

Thanks again for Telerik for allowing me to come out and speak at this great event.

Till next time,

Discuss (0)
More Posts « Previous page - Next page »

About The CodeBetter.Com Blog Network
CodeBetter.Com FAQ

Our Mission

Advertisers should contact Brendan

Subscribe
Google Reader or Homepage

del.icio.us CodeBetter.com Latest Items
Add to My Yahoo!
Subscribe with Bloglines
Subscribe in NewsGator Online
Subscribe with myFeedster
Add to My AOL
Furl CodeBetter.com Latest Items
Subscribe in Rojo

Member Projects
DimeCasts.Net - Derik Whittaker

Friends of Devlicio.us
Red-Gate Tools For SQL and .NET

NDepend

SlickEdit
 
SmartInspect .NET Logging
NGEDIT: ViEmu and Codekana
LiteAccounting.Com
DevExpress
Fixx
NHibernate Profiler
Unfuddle
Balsamiq Mockups
Scrumy
JetBrains - ReSharper
Umbraco
NServiceBus
RavenDb
Web Sequence Diagrams
Ducksboard<-- NEW Friend!

 



Site Copyright © 2007 CodeBetter.Com
Content Copyright Individual Bloggers

 

Community Server (Commercial Edition)