So that being said, let start off with the problem that generics solve in the first place. (If you have a good understanding, you can jump to the new features in C# 4.0)

C# Prior to 2.0

Lets say I have the following class hierarchy:

    public abstract class Fruit { }
 
    public class Apple : Fruit { }
 
    public class Orange : Fruit { }
 
    public class FruitBasket
    {
        public Fruit[] Fruit { get; set; }
    }
 
    public class Tree
    {
        public Fruit[] PickFruit()
        {
            Fruit[] daFruit = new Fruit[2];
            daFruit[0] = new Apple();
            daFruit[1] = new Orange();
            return daFruit;
        }
    }

We have a hierarchy of objects, a base Fruit class, an Apple class, which is a Fruit, and an Orange class, which is also a Fruit. In addition, we have a FruitBasket which has an enumerable of Fruit, and a Tree which I can "PickFruit()" from.

Now, lets say I want to have an instance of a fruit basket, however, I also want another one that deals with only Oranges (I don't want it to even be possible to put apples in the basket) so that I can make orange juice, apples just ruin a good glass of orange juice. I have two possibilities, I can create another fruit basket and ASSUME that I only put oranges in, or I create another classes that only allows oranges to be inserted in. Because I decide that I want the compiler to absolutely not allow apples in with the oranges, I now have to create a new class:

    public class OrangeBasket
    {
        public Oranges[] Oranges { get; set; }
    }

    public class PotatoBasket
    {
        public Potato[] Potatos { get; set; }
    }

Right. Pattern. We are repeatedly creating virtually identical objects that simply contain other objects or that apply some sort of processing to those specific elements, all because we want the consumer (the person that is using this object) to be able to put an specifically typed object in and get a specifically typed object out, without having to cast it.

C# 2.0 - 3.5

    public class Basket<T>
    {
        IEnumerable<T> Contents{ get; set; }
    }

Now, instead of having a PotatoBasket, a FruitBasket, and a OrangeBasket we can replace it like so while still using the same class:

    Basket<Potato>
    Basket<Fruit>
    Basket<Orange>

And our Tree class now becomes:

    public class Tree
    {
        public IEnumerable<Fruit> PickFruit()
        {
            yield return new Apple();
            yield return new Orange();
        }
    }

This is where it gets… Interesting.

Lets say I have an instance of a Tree class, and an instance of my Basket<Fruit> class. Now, it’s simple to do an assignment like this:

    var fruitBasket = new Basket<Fruit>();
    var Tree = new Tree();
    fruitBasket.Contents = tree.PickFruit();

    public IEnumerable<Apples> PickApples()
    {
        yield return new Apple();
        yield return new Apple();
        yield return new Apple();
    }

And I attempt to do the same assignment as before but with the PickApples() method instead, C# 3.5 will not compile it because the generic parameters are not the same:

    var fruitBasket = new Basket<Fruit>();
    var Tree = new Tree();
    fruitBasket.Contents = tree.PickApples();

That sucks. Why?

The reason has to do with the relationships of types, covariance / contra-variance / invariance (Erick Lipperts post on the difference between covariance and assignment compatibility is a much better source for it's relation with mathematics and type hierarchies). With versions prior to 4.0 the C# compiler does NOT allow generics of one type to be assigned to generics of another type. Thus, an IEnumerable<Apple> cannot be assigned to a variable of IEnumerable<Fruit>. But lets say we were allowed to do this, why would it be a problem? Lets say I have an IList<Fruit> and an IList<Apple>; it seems to make perfect sense that I could so the following assignment:

    var fruitList = new List<Fruit>();
    var appleList = new List<Apple>();
    fruitList = appleList;

Right?

Wrong.

This assignment would actually be plausable for IEnumerable<T> because IEnumerable<T> is immutable, it can not change, there's no way to "Insert" a new element into an IEnumerable. However, with an IList<T> it defines an Add(T item) method. An IList can be altered. In the previous example, if I were to take fruitList and look at the Add method in intellisense, it would show that I can insert any object that is a fruit into the add method of the fruitList, however, fruitlist isn't technically a list of fruits anymore given this senario, its a pointer to a List<Apple>. So in this flawed example, I could now call fruitList.Add(new Orange()); which would now be a runtime error because I can't insert an Orange into a List<Apple>. Bad. (In C# however, there is an edge case where this sort of error can occur with arrays. For instance, if you have a object[] objarray = new string[10]; you can then assign a fruit to one of the slots and cause a runtime exception. For more detail on this, see Erick Lipperts post on Covariance and Contravariance in C# arrays) So we have two things that should be solved. We know that there are certain situations where IEnumerable<X> should be assignable to IEnumerable<T>, specifically when X is a subclass of T, but we also realize that something like IList<X> should not be assignable to a variable of IList<T>.

C# 4.0

Enter variance modifiers for generic types that have now been introduced in C# 4.0.

First, these can only be applied to generic type parameters of interfaces and delegates, in can only be applied to generic parameters that are contra-variant or invariant valid, and out can only be applied to generic parameters that are co-variant or invariant valid.

Gulp.

First, invariance, contra-variance, and covariance. In terms of types, if I have T1 and T2, those types are Invariant if they are the same type. For instance, a Fruit and a Fruit are invariant, a Fruit and an Apple is not invariant even though a Fruit variable can hold an Apple object.

Co-variant is where the inheritance chains are kept, if I have T1 and T2, the projection of T1 to T2 is covariant if T2 is lower in the inheritance chain than T1. For instance, a Fruit to Apple is Co-variant because Apple is an instance of Fruit.

Contra-variant is where the inheritance chain is reversed, if I have T1 and T2, the projection of T1 to T2 is contra-variant if T2 is higher up the inheritance chain than T1. For instance, an Apple to Fruit is contra-variant because Apple is an instance of Fruit, the relationship is reversed, flipped.

So, it allows me to do the following in C# 4.0 with the new variant structure:

    var fruitBasket = new Basket<Fruit>();
    var Tree = new Tree();
    fruitBasket.Contents = tree.PickApples();

Because IEnumerable is defined as follows:

    IEnumerable<out T> { /* .. */ }

Remembering that out is co-variant because it can return the item or a subclass of that item, in this case PickApples() is returning an IEnumerable that is lower in the inheritance chain than the variable it's being assigned to (by lower, I mean that its a subclass, or sub-sub..n class of the other object)

To demonstrate a class with contra-variance with an in parameter, lets say we have an interface and classes like so:

    IPieMaker<in T> where T : Fruit
    {
        Pie MakePie(IEnumerable<T> fruits);
    }
 
    ApplePieMaker : IPieMaker<Apple> { /* ... Some implementation ...*/ }
    FruitPieMaker : IPieMaker<Fruit> { /* ... Some implementation ...*/ }

Now, because the input parameter is contra-variant, I can have a variable declaration like so:

    IPieMaker<Apple> applePieMaker = new FruitPieMaker();

Wait. Seem odd? Because T is not specifying what Pie we are making only what is put IN to make the pie, I can put apples into a FruitPieMaker. It’s contra-variant.

Try and wrap you head around that :)

Note: There's a good possibility that I didn't accurately describe the terms covariance and contra-variance in relation to mathematical projection and ordering, corrections and better descriptions are greatly appreciated.

Additional Links:

• Discord & Rhyme: http://kohari.org/2008/10/28/generic-variance-in-c-40/
• Erick Lippert: http://blogs.msdn.com/ericlippert
• Eric Lipperts Blog posts on the subject: http://blogs.msdn.com/ericlippert/archive/tags/Covariance+and+Contravariance/default.aspx
• Specific Posts by Eric Lippert:
  • http://blogs.msdn.com/ericlippert/archive/2009/11/30/what-s-the-difference-between-covariance-and-assignment-compatibility.aspx
  • http://blogs.msdn.com/ericlippert/archive/2007/11/02/covariance-and-contravariance-in-c-part-nine-breaking-changes.aspx
  • http://blogs.msdn.com/ericlippert/archive/2007/10/17/covariance-and-contravariance-in-c-part-two-array-covariance.aspx
  • http://blogs.msdn.com/ericlippert/archive/2009/09/21/why-do-ref-and-out-parameters-not-allow-type-variation.aspx
• Future of C#: http://code.msdn.microsoft.com/csharpfuture

I’m going to have so much fun with this thing, watch out!

- Paul Rohde

Over the past few weeks I’ve wanted to figure out how to add or extend glass into my application like you see in Word (2010 preview):

As you can see, the whole title bar area is seamlessly integrated into the look and feel of windows, it feels native, its got that cool semi-transparent blur-the-background effect and everything. So come RECESS I did some research and pieced together what you’d need to get an effect like this.

 
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media;
using Codelogic.Windows.Native.APIManagedExceptions;
 
namespace Codelogic.Windows.Native
{
    public static class DesktopWindowManagerAPI
    {
        public static void AllGlassWindow(this Window window)
        {
            ExtendFrameIntoClientArea(window, new Thickness(-1), false);
        }
 
        public static void ExtendFrameIntoClientArea(Window window, Thickness thickness)
        {
            ExtendFrameIntoClientArea(window, thickness, false);
        }
 
        public static void ExtendFrameIntoClientArea(Window window, Thickness thickness, bool exceptionOnFail)
        {
            var compEnabled = IsCompositionEnabled();
            if (exceptionOnFail && !compEnabled)
                throw new DWMNotEnabledException();
 
            if (exceptionOnFail && !window.IsInitialized)
                throw new WindowNotLoadedException();
 
            if (!compEnabled) return;
 
            var margins = thickness.ToDWMMargins();
            var windowPointer = new WindowInteropHelper(window).Handle;
 
            //convert the background to nondrawing
            var mainWindowHwnd = HwndSource.FromHwnd(windowPointer);
            if (mainWindowHwnd != null)
                mainWindowHwnd.CompositionTarget.BackgroundColor = Color.FromArgb(0, 0, 0, 0);
 
            try
            {
                DwmExtendFrameIntoClientArea(windowPointer, ref margins);
            }
            catch (DllNotFoundException)
            {
                window.Background = Brushes.White;
            }
        }
 
        public static bool IsCompositionEnabled()
        {
            try
            {
                return DwmIsCompositionEnabled();
            }
            catch (DllNotFoundException)
            {
                return false;
            }
        }
 
        #region WPF to Native
 
        private static DWMMargins ToDWMMargins(this Thickness t)
        {
            var rtrn = new DWMMargins();
 
            rtrn.Top = (int)t.Top;
            rtrn.Bottom = (int)t.Bottom;
            rtrn.Left = (int)t.Left;
            rtrn.Right = (int)t.Right;
 
            return rtrn;
        }
 
        #endregion
 
        #region Native Interop
 
        [StructLayout(LayoutKind.Sequential)]
        private struct DWMMargins
        {
            public int Left;
            public int Right;
            public int Top;
            public int Bottom;
        }
 
        /// <summary>
        /// Extends an hwind's frame into the client area by the specified margins.
        /// </summary>
        /// <param name="hwnd">Integer pointer to the window to change the glass area on.</param>
        /// <param name="margins">Margins, what to set each side to</param>
        [DllImport("dwmapi.dll", PreserveSig = false)]
        private static extern void DwmExtendFrameIntoClientArea(IntPtr hwnd, ref DWMMargins margins);
 
        /// <summary>
        /// Checks to see if the Desktop window manager is enabled.
        /// </summary>
        [DllImport("dwmapi.dll", PreserveSig = false)]
        private static extern bool DwmIsCompositionEnabled();
 
        #endregion
    }
}
 

Alright, lets begin breaking this down.

 
        [StructLayout(LayoutKind.Sequential)]
        private struct DWMMargins
        {
            public int Left;
            public int Right;
            public int Top;
            public int Bottom;
        }
 
        [DllImport("dwmapi.dll", PreserveSig = false)]
        private static extern void DwmExtendFrameIntoClientArea(IntPtr hwnd, ref DWMMargins margins);
 
        [DllImport("dwmapi.dll", PreserveSig = false)]
        private static extern bool DwmIsCompositionEnabled();
 

First, Windows 7 and Vista provide us with the Desktop Window Manager which was first included in Vista and continues on into Windows 7, it manages all the cool graphical windowing and effects you see in those operating systems. It also gives us an API dll to access these all the features, including many that are unavailable in WPF.

The first declaration you see sets up the data type that the DLL uses internally to represent Left, Right, Top, and Bottom glass margins. The others are pointers to unmanaged (non .NET) methods in the DLL. DwmExtendFrameIntoClientArea is the method that allows me to adjust how far in the glass extends in to the client drawable area, and DwmIsCompositionEnabled tells me if Aero Glass is enabled.

 
        private static DWMMargins ToDWMMargins(this Thickness t)
        {
            var rtrn = new DWMMargins();
 
            rtrn.Top = (int)t.Top;
            rtrn.Bottom = (int)t.Bottom;
            rtrn.Left = (int)t.Left;
            rtrn.Right = (int)t.Right;
 
            return rtrn;
        }
 

A simple extension method (denoted by the ‘this’ in front of the Thickness t, it allows me to write the declaration as though the method were part of the Thickness class, so if I have a thickness variable thick I could convert it to a DWMMargins type by writing var margins = thick.ToDWMMargins();) it converts a WPF Thickness object to the internal DWMMargins struct.

 
        public static void ExtendFrameIntoClientArea(this Window window, Thickness thickness)
        {
            ExtendFrameIntoClientArea(window, thickness, false);
        }
 
        public static void ExtendFrameIntoClientArea(this Window window, Thickness thickness, bool exceptionOnFail)
        {
            var compEnabled = IsCompositionEnabled();
            if (exceptionOnFail && !compEnabled)
                throw new DWMNotEnabledException();
 
            if (exceptionOnFail && !window.IsInitialized)
                throw new WindowNotLoadedException();
 
            if (!compEnabled) return;
 
            var margins = thickness.ToDWMMargins();
            var windowPointer = new WindowInteropHelper(window).Handle;
 
            //convert the background to nondrawing
            var mainWindowHwnd = HwndSource.FromHwnd(windowPointer);
            if (mainWindowHwnd != null)
                mainWindowHwnd.CompositionTarget.BackgroundColor = Color.FromArgb(0, 0, 0, 0);
 
            try
            {
                DwmExtendFrameIntoClientArea(windowPointer, ref margins);
            }
            catch (DllNotFoundException)
            {
                window.Background = Brushes.White;
            }
        }
 
        public static bool IsCompositionEnabled()
        {
            try
            {
                return DwmIsCompositionEnabled();
            }
            catch (DllNotFoundException)
            {
                return false;
            }
        }
 

Finally I wrapped native methods with .NET versions that take a more useful WPF Window class and WPF Thickness class for the ExtendFrameIntoClientArea method. Internally it checks to make sure the window is initialized and that Desktop Composition is enabled, gets the integer pointer to the window, resets the background, and then calls the native method to extend the glass into the drawable (client) area of the window. Two custom classes not shown are the DWMNotEnabledException class and the WindowNotLoadedException class, which are thrown if something goes wrong.

That’s all well and good, but wouldn’t it be nice if we didn’t have to worry about all these calls to this custom DesktopWindowManagerAPI class and could just set how much we wanted the glass to extend into the client area? Or bind it to something so that the glass area expands or contracts when a value changes?

I thought so:

 
using System.Windows;
using Codelogic.Windows.Native;
 
namespace Codelogic.Controls.WPF
{
    public class GlassWindow : Window
    {
         #region Glass Thickness Dependency Property
 
        public static readonly DependencyProperty GlassThicknessProperty = DependencyProperty.Register(
            "GlassThickness", typeof(Thickness), typeof(GlassWindow), new PropertyMetadata(new Thickness(0, 0, 0, 0), GlassThicknessChanged));
 
        //when the thickness changes, apply the change to the window.
        private static void GlassThicknessChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ((GlassWindow)d).UpdateGlassState();
 
        }
 
        /// <summary>
        /// Local property for Glass thickness.
        /// </summary>
        public Thickness GlassThickness
        {
            get { return (Thickness)GetValue(GlassThicknessProperty); }
            set { SetValue(GlassThicknessProperty, value); }
        }
 
        public static readonly DependencyProperty IsAllGlassProperty = DependencyProperty.Register("IsAllGlass",
                                                                                                   typeof(bool),
                                                                                                   typeof(GlassWindow),
                                                                                                   new PropertyMetadata(
                                                                                                       OnIsAllGlassChanged));
 
        private static void OnIsAllGlassChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ((GlassWindow)d).UpdateGlassState();
        }
 
        public bool IsAllGlass
        {
            get { return (bool)GetValue(IsAllGlassProperty); }
            set { SetValue(IsAllGlassProperty, value); }
        }
 
        private void UpdateGlassState()
        {
            if (!IsInitialized) return;
 
            if (IsAllGlass)
                this.AllGlassWindow();
            else
                this.ExtendFrameIntoClientArea(GlassThickness);
        }
 
        static GlassWindow()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(GlassWindow), new FrameworkPropertyMetadata(typeof(GlassWindow)));
        }
 
        protected override void OnSourceInitialized(EventArgs e)
        {
            base.OnSourceInitialized(e);
            UpdateGlassState();
        }
    }
}
 

Alright, this class creates a WPF Window subclass, adds a dependency property for GlassThickness and a change handler that internally calls the DesktopWindowManagerAPI.ExtendFrameIntoClientArea if the window is loaded or attaches an event handler if the window is not loaded. Now all you have to do is change your window class over to a GlassWindow class, set the thickness and you rock and roll!

 
<WPF:GlassWindow x:Class="Codelogic.Controls.WPF.Demo.GlassDemoWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:WPF="clr-namespace:Codelogic.Controls.WPF;assembly=Codelogic.Controls.WPF"
    Title="Glass Window Demo"
    Height="300"
    Width="300"
    GlassThickness="10000">
    <Grid>
        <InkCanvas HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Background="Transparent" />
    </Grid>
</WPF:GlassWindow>
 

Something I have not yet done that I would like to do is figure out how to add functional buttons into the title-bar of an application. If you remember the Microsoft Word snippet from above there’s save / undo / redo buttons in the title bar. But that will have to be a later post.

Hope someone enjoyed my Glassy exploration,

Updates:

• 2 Dec 2009
  • Changed ExtendFrameIntoClientArea to check to see if window.IsInitialized instead of window.IsLoaded
  • Updated GlassWindow to override OnSourceInitialized instead of adding an event handler for Loaded
  • Added in a method that turns the entire client area into glass by setting the margins to -1.
  • Changed Glass Window to have a Boolean Dependency property to turn it all glass.

- Paul Rohde

First, many thanks for the awesome comments about the site, its one of those ongoing projects that is continually evolving and changing, so its appreciated when someone does enjoy it.

Neumont is not round.

Ok. Sentimental comments aside, let me do the best I can to answer your questions. Since I am a Neumont Alumni, do keep in mind that the school has been evolving over the past several years and that there have been many alterations to the main program since I started (Cohort 15, July 2007). So take what I say with a grain of salt. Get in touch with one of the Neumont Reps if you haven’t already since they *should* be able to answer more direct questions about the current state of the school and the primary CS degree program.

From my experience, Neumont is a very technical school, it has one degree (There was previously a business masters degree program at the school, but that has been put on hold and may or may not re-emerge), and it is very geared towards graduating high quality and hopefully well rounded CS students. Because the program is so tightly geared toward CS there are some areas and classes that I personally felt were lacking. For instance, I really wish that the mathematics program went further, by the time I started at Neumont I had already completed Calculus II at WSU (Winona State University) and was beyond the current mathematics courses offered at Neumont. In addition, they do lack some of the general classes that form the basis for other fields of study: Chemistry, higher level Mathmatics, Physics, History, Literature, Art(To be fair, they did have an introduction photography class, and the last two quarters when I was leaving they were adding in a digital media concentration with courses that are more artistically bent). Part of my own draw away from Neumont was the fact that I wouldn’t have the opportunity to grow in some of these other areas, I love photography, art, the more classical sciences, and there’s a part of me that really does miss not having more time to explore those other subjects for my own personal interest.

The question about well rounded-ness really boils down to this: Why are you going to school? If your goal is to get a degree, get a full time job in business software development, I honestly cannot recommend a better school. However, if your not sure you want to do business software, if your not sure you want to even DO software, or if your not passionate enough to pursue and devote yourself to it for the two and a half years it’ll take to get through the program, Neumont is probably not the place for you.

Hearing about Neumont

I first heard about Neumont sometime after taking my ACT a year early and getting piles of junk mail from colleges talking about the ‘college decision’ I would be making over the next year.

Right.

After two years of highschool at a private school I returned to being officially ‘home schooled’ after my sophomore year, enrolled in WSU via the PSEO Program (Post Secondary Education Option, basically, if your a good enough student and would like to take classes at the local college the state will pay for the tuition and books), and then spent the following year and a half taking a full load of college classes (plus two side classes at an online school the year I started). Sometime within that college span I began receiving mail from Neumont, glanced and discarded most of it into the large bin of college spam. After receiving several more mailings I did some research, ended up being contacted by a Neumont rep, and was invited to attend their ‘Geek Weekend’ where they flew out potential new students that were interested in the school along with a parent or guardian to visit, meet some of the students, etc… That trip was the turning point in my decision making process. During my time at WSU I was actively taking some CS classes, most of them in Java, most little console algorithm type problems and one cool little robotics project near the end in one of my classes. After a year and a half of WSU, and having had several years of my own personal experience doing web, C++, Visual Basic, Dark Basic, building several of my own small games, and working as a student programmer at WSU doing C#, ASP.NET, and Sharepoint development, I was completely outmatched by students in their second quarter at Neumont (6 months into the program) that I met that weekend. That was cool.

Yes, it was a hard decision, I had a good job for where I was, I could have continued at WSU, graduated with a lot of current job experience (Read: ~4 years if I had graduated from WSU), but it wouldn’t have challenged me as much or pushed me as far as I am today.

The Campus

First of all, Neumont is not a normal school. They are located in an office building that’s been converted into the University as it is today. In fact, there are other companies that have offices in the same building, at least when I was there. Since I’ve been there they’ve made some additions and changes to the building, there’s now a new computer lab complete with iMacs, the common area has a pool table and a large screen TV that students will bring in and hook up their 360, Wii, or PS3 to and play games. The school does have a reasonable catering service during lunch on school days, but nothing like a normal cafeteria. When I was leaving they were experimented with having another place come in on Fridays, so I’m not entirely sure as to the state of the school provided food. From what I’ve experienced however, most students will eventually move away from the catered food and get something nearby (which is what I eventually did), there is a Zupas across the the street and a coffee shop within walking distance, and there’s quite a few additional places a short drive away.

The campus “Housing” is two sets of apartments, one set is at The Falls at Hunters Pointe, the other is Sterling Village in South Jordan, both are about a 20 minute walk from the school (although most people tend take the shuttle or carpool). I was only in student housing for a year, when I first moved in, one of my roommates was also just moving in and the other was close to graduating. During second quarter after the senior in our house moved out we got a new freshman, who ended up moving out without telling any of us before the end of the quarter… Anyhow, after that first ~10 months a friend of mine and two other guy’s rented a 4 bedroom 3 story house for about what we were paying in student housing, so, I ditched Neumont housing and moved. As far as rules and regulations go for student housing (Yes, they are regulated) they aren’t too bad, you do need to keep the apartment clean and they do have inspections. You also can’t bring weapons into the apartment (no paintball guns, swords, non-kitchen-knives, etc…).

As far as ‘life on campus’ goes you have lots and lots of geeked out guys (And about a 50:1 guy to girl ratio) that live life on Mountain Dew, Guitar Hero, WoW, and DotA. They are the stereotype, and you will find them on almost every non Neumont campus you visit, but you’ll find a much higher concentration than you would elsewhere. However, there are many people there that really do take what they’re doing seriously, and are already well rounded individuals. I was never that ‘involved’ in the geek culture. It’s cool, I like parts of it, I’ve rocked my share of Guitar Hero and Rock Band, and played my hours of Counter Strike. Still, I spent a lot of my time outside of Neumont towards the end of my time there. Most of who I considered my ‘good’ friends were up at the University of Utah and were not CompSci majors. I was involved in the photographic community, I did several photowalks, met lots of photographers and models, made some good friends there. I was involved in a church (Gateway Community Church), and had several friends through that. The community is out there, but you have to go to it, it’s not going to drop into your lap as much as it would at a “normal” University.

If you make good friends, keep in touch, work hard, help and teach others (not just giving answers), and really strive to be a personable, well rounded individual, you will be fine. The homework can be hard, and there are ALWAYS group projects that you’re in and will be working on. It’ll force you to deal with and work with other people and figure out how to make things work. From personal experience, it’s exactly what you’ll be doing in the real world.

Administration and Cost

I’m probably not the best person to answer a lot of these questions, but I’ll do what I can. Administration from my experience hasn’t been that difficult to get in touch with, I was always able to go to people and figure out what I needed when I needed it. However, I do know that in the past, people have had issues, specifically with tracking graduation credits. There was (or is) a student written program that allows you to track your progress towards graduation that I used, and it worked well. However, I would also go in and talk directly with the student advisers on a regular basis and verify that I was doing things correctly. There have been several occasions where people have been 1-2 credits short because they thought they were taking enough credits but didn’t take the time to go and check with advisers each quarter…

As far as finances go, I was able to get my loans through the Department of Education and Sallie Mae with my parents as co-signers on those loans. With the economy having tanked, and quite possibly still in the tank, I’m not sure how difficult it will be to get financing, it’ll really depend on your situation. I was lucky enough to not have to worry about it much or have deal with the financial aid department at school. I do know that if I had not received loans or financing, I would have had a VERY difficult (if not impossible) time going to Neumont. Again, this is where I would get a Rep, ask very specific, very direct questions. Make sure they give you an answer, that’s what their job is.

Was Neumont affordable? I made it through. I will be able to pay it off with my current job over the next ~3 years, and my interest rate seems rather standard as far as student loans go.

Was it a lot? Yes.

Was it worth it? For the field I’m in, Yes. For the contacts I made, the experience I gained, Yes.

Wrap Up

Neumont is a great school, for business software development. For what the school is and at the time I went through the program, I don’t know of any other degree program that could trump it. It does have a very narrow focus, it’s hard, it’ll make you learn, and you’ll be better for it. Like any school, you only get out of it what you put into it and there will always be people that don’t care, don’t work, fail out, and complain to all ends of the earth about how it’s the university’s fault or how this or that caused them to _____. Fill in the blank.

Work hard, do your best and you’ll be fine wherever you’re at.

If anyone has any questions, feel free to leave a comment, call me, send me an e-mail, I’ll do my best to get back to you when I can.

- Paul Rohde

Note: The opinions presented here are my own and do not in any way represent the opinion or position of my Employer or that of Neumont University.

It’s a question I often ask myself, and the answer has changed over the years, but I think it boils down to the challenge of creating. With photography there’s no limits, no end to the creative exploration, there’s always new ways to improve and better yourself. With the recent project I’ve started (Which you should take a look at here: http://www.project54.net) to take 50 pictures of 50 people over 50 days with a 50 mm lens I’ve realized two things: I’m becoming more comfortable around people with my photography (asking them to do this or that and to let me shoot their picture), and I’m shooting much than just the images for my project. Since moving out here to California I’ve slowed down and I really forgot the passion I do have for photography. It’s images like these from people that have never modeled or done any sort of photography before that make want to keep shooting.

So for your viewing pleasure, Chris the Accountant:

- Paul Rohde

Like taking self portraits.

And updating your twitter theme.

- Paul Rohde

- Paul Rohde