I took a new job at the beginning of August. I wasn't at my last gig very long, but I have only good things to say about them. There's a decent chance I'll end up back there at some point in my career. But I'm excited for the new job in all sorts of ways I'd have a hard time putting into words.

One thing I can talk about is how the daily worky-work is going to be different. My last job was spent almost entirely writing a node web server and a single-page web app, and all development was done in an Ubuntu VM. The new job will be like the one before the last one. I will be doing .NET web and service development, fully immersed in the Microsoft ecosystem.

Things I'm going to miss:

  • The power and concision of working with a *nix CLI. Powershell just ain't the same.
  • OS-level package manager (apt-get)
  • Git. 'Nuff said.
  • The light footprint of Sublime Text
  • The compactness of server-side JavaScript. You can accomplish *so much* with so few lines, due to the absence of type system noise and the robust FOSS package ecosystem.
  • A culture of command-line build tools.

Things I'm not looking forward to:

  • Static types. For all their strengths, you can end up jumping through a lot of hoops and contorting your code into very unpleasant shapes in order to make the static type system happy. It only gets worse if a framework or library has decided to leverage it to solve a problem for which it's a poor fit.
  • The complexity of Visual Studio. So. Many. Features. It's really a mess in a lot of places.
  • TFS version control. After using Git exclusively for almost a year, going back to TFS feels like using a computer without a keyboard. Sad panda.

Things I'm not going to miss:

  • Ubuntu as a desktop environment. It looks and feels good, for a Linux. But that's an awfully low bar.
  • Linux video drivers. Just.... Ugh. What a mess.
  • The Unix Way: 20 ways to do anything. All of them involve text processing. 16 of them are kludgy, and the other 4 don't work consistently.

Things I'm looking forward to:

  • Static types. Apart from the typical discussion of the benefits of static typing, there are some things that are just quicker and simpler to express via the type system. In JavaScript, for those problems you've got to write the engine and define the declarative data structures that will be processed by it.
  • The power and convenience of Visual Studio. I've never encountered a dev tool quite like it. It can understand your code and give feedback like no other And it has tons of really handy tools to do things for you that would be annoying to deal with by hand.
  • Applying the new perspective and wisdom I've gained from working in a dynamic language to write better static-typed code.
  • Trying to convince my boss to let me use F# for something, somehow.