RyanKeeter - A Soldier in a Tie

Good Morning Afghanistan!

The Admin — Wed, 07 Jan 2009 18:28:00 GMT

You may be asking yourself “why the hell is he going to Afghanistan, isn’t it dangerous there?” And the answer to your question is a resounding “yes,” but I am going because I am an Army Officer for the United States and sometimes one must put on the uniform and boots and go to war. However, this trip isn’t without it’s perks, by doing such a mission one can advance their career, get training and experience that will never be available again, and can learn great deals about themselves at an emotional and psychological level.

In war, as in other stressful periods of one’s life, a new awareness of one’s inner thoughts and desires begins to show. The days become long and arduous as the winter months pass slowly. In the Summer, the sun pounds upon your head persistently, never faltering, but always powerful. My mind will bend towards thoughts of family and life in my home country, but my will will force me to drive on with the day to day operations. Often I think about my future plans, my goals and the life I will have with my wife and son in the days after the deployment. However, the days after the deployment might never come, for this is war, and only war itself can dictate my life; not I, nor my rifle.

The will of a man can be determined through his patriotism. No great leader has said this, but I believe this as the best men and women I have met had more patriotism and passion then most. When the shots are firing and the smoke is in the air, you want the person that can be trusted with your life next to you, and more than likely, those people have shown a great deal of patriotism.

The duration of this tour will be 400 days, give or take, from February 2009 as the starting point. The tour should allow for a trip back to the states for time with my family (and I hope that I’ll be able to choose this time). I shall do my best to continue to maintain a social presence, but saying that it will be hard is an understatement. I wish all of my friends good luck and fun in their lives.

Rockin,

1LT Ryan Keeter

Going to Afghanistan from ryankeeter on Vimeo..

Script Tip: Cross Domain calls and JSONP

The Admin — Fri, 12 Dec 2008 05:31:00 GMT

Script Tips : JSONP and the Cross Domain Request from ryankeeter on Vimeo.

Download this video in its entirety to watch later here: Download script tip # 1

Snap Pic : Kickin' Keurig Coffee Selection at my Work

The Admin — Thu, 11 Dec 2008 23:07:59 GMT

Silverlight MVVM pt 1: Hello World style

The Admin — Thu, 11 Dec 2008 19:36:00 GMT

To Watch the Video of this post, click HERE

Holy crap, we have another freaking model to learn?

Yuppers.

Does it suck?

Nope, it makes things so much easier, it is a model that leverages what you already know.

What kinda stuff I already know?

You know about separation of concerns?

yup…

You know about designing for testability?

yup…

you know about the command pattern?

yup…

you heard about Model View Controller pattern?

yup…

Then you are set, this model leverages all of that, so it is only a matter of applying it and seeing how it all works in this new RIA world!

Silverlight Programming, How I Initially Want to do it

Initially, I want to take all of my objects within the XAML, such as the textblocks and the buttons and what not, and I want to give them names and declaratively call them from my code behind. Then, I want to wire them up in my code behind with click events and so what have you. Lets see some of this stuff:

1. The xaml markup on the front end(just to get some UI out there):



br />











<

A picture of the XAML from above is below:

2. I will be using a people service just to return a person object and then post that data to the UI (by the way, this is an outrageously contrived example that probably teaches you nothing…but we are getting somewhere)

namespace MVVM.HelloWorld
{
    public  class DummyPeopleService :IPeopleService
    {
        public  IList RetrievePeople()
        {
            IList people =  new List
                                        {
             new Person("Albert","al@foo.com", "Pujols", "STL", "63101"),
             new Person("Jose", "jo@foo.com", "Rodriquez", "LA", "90210"),
             new Person("John", "john@foo.com", "Franco", "NY", "123456")
                                        };
            return people;
                                   
        }
        public Person GetPersonByEmailAddress(string emailAddress)
        {
            IList people = RetrievePeople();
            return people.Where(p => p.EmailAddress == emailAddress).First();
        }
    }


    public interface IPeopleService
    {
         IList RetrievePeople();
         Person GetPersonByEmailAddress(string emailAddress);
    }
}

You could imagine what the person object looks like, but I'll go ahead and show it regardless:

 namespace MVVM.HelloWorld
{
    public class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string City { get; set; }
        public string Zip { get; set; }
        public string EmailAddress { get; set; }

        public Person(string firstName, string emailAddress, 
            string lastName, string city, string zip)
        {
            FirstName = firstName;
            LastName = lastName;
            City = city;
            Zip = zip;
            EmailAddress = emailAddress;
        }
    }
}

3. The code behind will just grab some data and then put values into the text boxes.This represents the old way of doing things, where we merely grab data and assign values to controls:

namespace MVVM.HelloWorld
{
    public partial class Page : UserControl
    {
        private IList people;
        public Page()
        {
            InitializeComponent();
            this.Loaded += Page_Loaded;
        }

        void Page_Loaded(object sender, RoutedEventArgs e)
        {
            IPeopleService svc = new DummyPeopleService();
            var person = svc.GetPersonByEmailAddress("al@foo.com");
            txt1.Text = person.FirstName;
            txt2.Text = person.LastName;
            txt3.Text = person.City;
            txt4.Text = person.Zip;
        }
    }

}

4. Below is a picture of this code running:

How to do the above with MVVM

Now that we have done it one time by having ID’s on the elements and specifically putting values to them, lets try it in a different way. First off, I want to get rid of the x:Name attribute that is associated with each element, and I want to bind their text attributes to the value that I want them to bind to. Notice though that they have no clue where that data is coming from. All these textboxes know is that they are going to be getting a property sent their way that has a name that they are going to be looking for, like “FirstName,” or “LastName.” I am not defining a declarative type to show where they are coming from(like "person.FirstName”).

Now we get to the view model portion of this example. We will crate a view-model that will tie to the appropriate XAML file. For example, we have created an MVVMviewmodel, my default convention is to name it the same as the XAML usercontrol it represents, but just add a “viewmodel” to the end of it.

You will notice from the code below that there are properties on this class that might be familiar from the binding elements you saw earlier. This viewmodel does somethign interestesting, it accepts the usercontrol that it will be the DataContext for as a constructor (we will show how this all hooks in later).

namespace MVVM.PartOne
{

    public class MVVMviewmodel
    {
        private MVVM view;
        public string FirstName{ get; set;}
        public string LastName{ get; set;}
        public string City { get; set; }
        public string Zip { get; set; }
        private IPeopleService svc;
        public MVVMviewmodel(MVVM view, IPeopleService svc)
        {
            this.view = view;
            this.svc = svc;
            Initialize();    
        }
        private void Initialize()
        {
            var p = svc.GetPersonByEmailAddress("john@foo.com");
            FirstName = p.FirstName;
            LastName = p.LastName;
            City = p.City;
            Zip = p.Zip;
        }
    }
}

Below is the new code behind, it is much easier to define now, we are merely creating a new instance of the viewmodel and passing in the MVVM class. The values get bound by setting the Datacontext for the UserControl.

namespace MVVM.PartOne
{
    public partial class MVVM : UserControl
    {
        private readonly MVVMviewmodel vm;
        public MVVM()
        {
            InitializeComponent();

            vm = new MVVMviewmodel(this, new DummyPeopleService());
            DataContext = vm;
        }
    }
}

When this is ran, I get the same results as earlier:

This is a HIGHLY contrived example of this in action, but we will move on to better examples in the future.

Hope this helps.

Ryan

Silverlight MVVM Screencast pt 1

The Admin — Thu, 11 Dec 2008 16:38:00 GMT

Silver Tips : MVVM pt1 => Hello World from ryankeeter.

You can see this in Text format by going to the blog post: http://www.ryankeeter.com/silverlight-mvvm-pt-1-hello-world-style/

You can download the above video in full resolution here:

Download Movie

Group Picture at the end of BarCampSTL

The Admin — Thu, 11 Dec 2008 15:40:19 GMT

Series Planned: Through Hoops with Silverlight and MVVM

The Admin — Fri, 05 Dec 2008 06:39:00 GMT

UPDATE: Due to some odd circumstances I will be unable to update these posts for a while..I shall return to them however when time allows. I apologize!

...

I have been racking my brain lately trying to get this whole Model View View-Model pattern locked down and I think I might have it. This weekend I am going to try to go on a Video screencast extravaganza and record as much as I can about making Silverlight do freakin' backflips with the MVVM pattern. I will be filing these bad asses under the Silver Tips title, so search Silver Tips on my site to get at these.

What was kicking my ass for days was how to implement a Command behavior within Silverlight that mimics the command behavior within WPF. I had looked at Nikhil's Post on this and thought that it was valuable, but it wasn't a complete implementation. Then I found a gem from a codeplex project released last month, SL Extensions, that had an entire command service already in place. The way I see it, with the Silverlight toolkit out, and now these extensions, I don't need to go nuts writing my own framework.

The plan looks like this (from 50,000 ft, and it is windy up here, things might change):

1. Hello world with this MVVM junk. (First Post is up! go check it out: http://www.ryankeeter.com/silverlight/silverlight-mvvm-pt-1-hello-world-style/)

2. Implementing a regular asynchronous callback structure, and then implementing it with the command pattern.

3. Implementing Unit Testing within Silverlight

3. Small Demo app { Pulling data from a service and displaying it using this pattern, with tests }

4. Small Demo app { Pulling data and traversing through a set of pages }

5. Pulling data through a feed and rockin' out with our * out

The list will grow and I will start to add to it as I keep going, but this is basically it. I am going to follow a post/screencast type of scenario with this, so you can read and view the code, then watch a video on the whole thing unfolding...that sounds like a good plan.

If there is anything that you want to see, then hit me up and I'll do my best to get into it! And of course, make sure you grab the RSS feed so that you can keep up to date on the breaking changes.

w00t! I love this Silverlight shit!

Ryan

How to Aggregate your Life into One Usable Feed Pipe

The Admin — Thu, 04 Dec 2008 04:54:00 GMT

Goal: Teach you how to take feeds from multiple sources and put them into one feed that you can consume anywhere.

Resources: Feeds from whatever matters to you (in this article it will be Twitter, blog, flickr and blip.tv), Yahoo! Pipes, and Facebook.

Time Needed:~ 10 minutes

Download movie from: The Vimeo show page

How to Aggregate your Life into One Feed Pipe from ryankeeter on Vimeo.

True Power of Photoshop Scripting: Actions

The Admin — Wed, 03 Dec 2008 04:47:00 GMT

Yesterday I wrote about some basic setup information to get started with Photoshop scripting, you can check out that post here. I will be building off of that post to continue with the rest of this post; so lets get started!

Many advanced programs such as the entire Microsoft Office suite has the ability to record actions such as macros. These macros can be reran by performing certain events, such as on startup, on shutdown, or on some type of keyboard command being struck. This type of behavior is called an action within Photoshop, and I believe that the true power of Photoshop scripting is to call these actions from code. When you create these actions, you can have them do anything in a recorded sequence, and calling them from a script is puuurrdy powerful. The next portion will talk about these actions really quick, but if you know all about them, then scroll down to the scripting portion.

Creating a New Action Within an Action Set

Calling the Recorded Action within a Script

To get started here, lets look at the complete code from the previous post. This code can be ran from File >> Scripts >> {Name of the Script}. Once again, this script will get access to the application and then create three new documents of varying sizes.

//Set a variable holding the current preferences, because we will change
//them to our own needs
var startPreferences = app.preferences.rulerUnits;
app.preferences.rulerUnits = Units.PIXELS;

//Create a new document by using the global 'app' variable
var newFoo = app.documents.add(630,215,128,"Foo");
newFoo = null;

var newSmallFoo = app.documents.add(70,113,128,"FooSmall"); newSmallFoo = null;

var newLongFoo = app.documents.add(218,60,128,"FooLong");
newLongFoo = null;

var newScreencastFoo = app.documents.add(388, 250,128,"FooScreencast");
newScreencastFoo = null;

//set the preferences back to what they were 
//before we adjusted them
app.preferences.rulerUnits = startPreferences;
 //This is the variable we defined earlier

The next step will be to get load the action set into the Actions Palette. The code to do this is straight forward, calling the load method on the app global object and passing it a new File object that is a just a string representation of absolute path to the .ATN file.

app.load(new File(app.path.toString() + "/Presets/Photoshop Actions/RyanKeeter.atn"));

The final step will be to run an action within a set that we just loaded. The method to call this is “doAction,” and the parameters are two strings, the name of the action and then the name of the action set. I will show the action set that I will be using to call methods on:

Below is what this call looks like:

//The parameters are the name of the action, and then
//the action set they belong to
app.doAction('Foo Action','RyanKeeter');

REMEMBER: the action will be conducted upon the current document that has focus.

My example and current need is simple, but you could expand it to whatever you like. My need is to create three documents of specific sizes, and then stripe some color across the documents that is common across my whole site, so lets see the entire code and then the video performing this script:

var startPreferences = app.preferences.rulerUnits;
app.preferences.rulerUnits = Units.PIXELS;

//Load the *.atn files, or the action files
app.load(new File(app.path.toString() + "/Presets/Photoshop Actions/RyanKeeter.atn"));

var newFoo = app.documents.add(630,215,128,"Foo");
newFoo = null;

//Now that the action files are loaded, letssetup our Foo file
app.doAction('Foo Action','RyanKeeter');

var newSmallFoo = app.documents.add(70,113,128,"FooSmall"); newSmallFoo = null;

//Lets setup our Small Foo file
app.doAction('Foo Small','RyanKeeter');

var newLongFoo = app.documents.add(218,60,128,"FooLong");
newLongFoo = null;

//Lets stup out Long foo file
app.doAction('Foo Long','RyanKeeter');

var newScreencastFoo = app.documents.add(388, 250,128,"FooScreencast");
newScreencastFoo = null;

//Finally, lets setup our screenCast foo file
app.doAction('Foo Screencast','RyanKeeter');

app.preferences.rulerUnits = startPreferences; 
//This is the variable we defined earlier

Rockin, here is a vid of this all happening, hope this all helps you as much as it helps me!

Untitled from ryankeeter on Vimeo.

Rock on.

Ryan.

Scripting Photoshop with JavaScript : Hello World Style

The Admin — Tue, 02 Dec 2008 06:23:00 GMT

Who would have thought that it was possible to script Photoshop with such a language like JavaScript. One would think that it would be some proprietary language, or at the very least, Action script, which is a JavaScript type of language. Alas, JavaScript is the language of choice here and I won’t argue it as JavaScript is after all the assembly language of the web.

So how does it all work anyways, and why would one use it? I for one, need to create three different blog images for each post, and creating each one of those documents is highly annoying, so scripting it is the natural choice. Where is the entry point then for this, how does one start? First off, you need two things, one woudl be a notepad type of editor, and the second would be Photoshop (duh), so lets get started:

Quick Questions

Q. Where are the scripts stored?

A. They are stored at (Winders) C:\Program Files\{Your version of Photoshop, mine is CS2}\Presets\Scripts

Q. What file type are they?

A. They are JSX (the ‘X’ makes them, cool, that is why they added it => the evangelists told me so)

Q. Does it have to follow some convention, a type of API?

A. Yes, it does, but for the most part it is object oriented and all the objects are static in nature so you can just call api.foo whenever you want.

Q. Can we get started Already (*cough* code please)?

A. Of course!

For our example we need to create three documents, so lets do that by first defining our type of unit measurement, which will be pixels:

var startMonkey = app.preferences.rulerUnits;
app.preferences.rulerUnits = Units.PIXELS;

What we have done above is take the default unit measurements that is stored in our preferences and we put them in a variable called “startMonkey.” Next, we will create and open our new documents:

var newFoo = app.documents.add(630,215,128,"Foo");
newFoo = null;

var newSmallFoo = app.documents.add(70,113,128,"FooSmall"); newSmallFoo = null;

var newLongFoo = app.documents.add(218,60,128,"FooLong");
newLongFoo = null;

var newScreencastFoo = app.documents.add(388, 250,128,"FooScreencast");
newScreencastFoo = null;

What we did above is define three documents, added them to the current application by calling “app.documents.add” and passing in parameters of width, height, pixel ratio, and document name.

Now lets put the default ruler measurement back at the end of the document:

app.preferences.rulerUnits = startMonkey;
 //This is the variable we defined earlier

When we run this we are presented with exactly what we were looking for:

To RUN this SCRIPT

1. File >> Script >> {Name of the script}

2. Done.

Sweet, the script works and I never have to refer to my notebook again to get the sizes of those images (why did I even make them so screwed up?). In the next portion, we are going to extend this example to run some custom actions in JavaScript and talk about what actions are (think Macros for Photoshop).w00t!