0 comments

I'm really happy with Visual Studio 2012, and I do think it's by far the biggest leap forward for any iteration of VS. However, one new feature that bugs me is the "Auto Preview" where any file I click on in the Solution Explorer is opened for me in a special preview tab. 

This can be prevented if you hold down the ALT-key while clicking around the Solution Explorer, but IMO it should have been the other way round (i.e. don't preview unless you ALT-click).

Luckily this can be easily turned off by going to Tools -> Options -> Tabs and Windows and de-selecting the Solution Explorer under 'Preview Tab'

 

0 comments

So it’s been a week since I got back from GOTO in Aarhus. All in all I must say that the conference lived up to my expectations.

As I predicted in my pre-conference post, my final schedule ended up being a little different than what I anticipated. Although it did follow the same basic principles of spreading out and seeing a little bit of process-, development- and product-specific talks. Over the next few days I’ll hopefully be able to put together a series of blog posts that reflect on some of my take-aways from the talks. The post you’re reading is mainly a reflection on the conference itself.

Arrival and Registration

It’s always interesting to experience how different venues handle large flows of people arriving at the same time and how they manage to keep the flow going. This was essentially a non-issue for the GOTO organisers. Registration cards were laid out alphabetically and the only thing I had to figure out was whether they were sorted by first or last name. So this went really smoothly. As I picked up my registration card, I was asked whether I would be attending the party and whether I wanted a GOTO bag. Awesome.

Finding my feet and looking around

I arrived about an hour early so I had plenty of time to find my way around the conference venue. This was also a no-brainer since everything was clearly labelled with signs pointing to the different rooms, toilets, cloakroom and so on. One thing I was missing, though, was something to eat. I remember from my experience at Øredev that they had a magnificent breakfast for conference attendees every morning, so I was a bit surprised to find that there was nothing edible (apart from complimentary candy from the booths). I found out a bit later that we bloggers had access to the press room, which indeed did provide us with something to eat and drink. So this too was accounted for.

Welcome, talks and breaks

It was time now to attend the welcome speech and the first keynote. I really liked the fact that the track hosts of each day would spend 5 minutes introducing the day’s speakers and topics. This meant that I had a much better idea of what I was to expect, and also made me change my schedule a few times.

I find that the 50 minute time slots allotted to talks was quite adequate. It is enough time to let the speakers (at least the well-prepared ones) get into enough detail, but still short enough that we listeners can stay sort of concentrated. Especially during the slot straight after lunch.

Keynote Speakers

The keynote speakers were very well picked.
Monday morning,Rickard Falkvinge, founder of the Swedish Pirate Party gave us an interesting insight into his foundations for launching his political campaign. And even though I don’t agree with everything he said, he did have some valid (IMHO) points on how the copyright system is broken and how free speech and the right to privacy is being limited by laws being passed in numerous countries.

The afternoon keynote was by Damian Conway, one of the more prominent members of the PERL community. Damian gave us a brief introduction to the topic of Contra-Temporal Virtual Nanomachine Programming In Topologically Connected Quantum-Relativistic Parallel Space-Times... Made Easy. This was a hilarious talk which took us around a broad range of topics, mostly in the field of quantum physics and how he has used a lot of these theories in implementing quantum computing in PERL. Judging from the laughter and applause during his talk (which he frequently interrupted, noting that he didn’t have time for applause if he was to be able to go through all his material), lots of us were shaken around a bit while watching variables being declared in the future, only to travel back in time to the present to let their values be used. I’m still not sure I completely grasp the concept, but there was something in there about performing zero-time computations, for example for sorting large amounts of data.

Tuesday’s morning keynote was held by Microsoft’s own Scott Hanselman, who gave us an insight into how Microsoft has changed into a much more open source friendly beast, releasing more and more of their software, platforms and products as open source. Scott, as usual, gave us 50 minutes of very well put together entertainment and I’m sure a lot of the non-Microsoft developers watching were surprised to learn how much Microsoft is actually contributing to- and embracing the OSS world. The talk also highlighted how Microsoft’s Azure cloud is in no way Microsoft-centric. You can pretty much host anything in Azure, and this really is “Cloud the way it should be”. I haven’t really looked at Azure in a couple of years and I must say I was impressed with how easy it looked.

After Tuesday’s conference tracks it was time to open the doors to a number of local user groups. I chose to participate in Aarhus .NET User Group (ANUG)’s meeting which featured Anders Hejlsberg himself. I’ve already blogged about what came out of this, and the more I think about it, the more I actually like the position Microsoft have put themselves in with TypeScript.

On the final day of the conference, Dirk Düllmann from CERN told us a little about the challenges they face in handling the absolutely mind-bogglingly large amounts of data generated by the Large Hadron Collider. This was the kind of talk where you just sit there, wide-eyed, listening to big numbers that are extremely hard to relate to your day-to-day job (unless you work in CERN’s IT department, I guess). I’ll put together a blog post later on with some of the really amazing stuff that goes on there. And I thought trading systems were complex to do.

Conference Party

On Monday night it was time for the conference dinner and party. The theme of the night was supposed to be “Viking”. The food was good and the beer kept flowing in generous amounts. At some point during the dinner, we were interrupted by a group of loud, obnoxious “Vikings” who tried hard to put on a show for us. They had a really tough time getting the attention of the audience, who would rather spend time doing what the dinner was all about, namely networking. So apart from some quite impressive real-life sword fights, I wasn’t really drawn in to this experience. The “show” was something about the whole Mac/PC, iPhone/Android battle. But it didn’t really catch the attention of the room. I think it was a bit out-of-place and merely forced the people closest to the stage to stop socialising and instead try to be polite and watch what was going on on stage.

Apart from the intermezzo with the Vikings, I think the party was quite fun. I got to talk to a lot of really interesting people, and it’s always fun to see what happens to geeks once you start pouring beer into them. Most of them actually turn out to be quite out-going and friendly in these situations.

Wrap-up

As I have stated earlier, one of the most important features of a conference is the ability to socialise and hang out with like-minded people. It is the place where you exchange ideas, experiences and thoughts with others and possibly get some instant feed-back on your Next Big Idea. My general feeling was that these needs were catered very well for by the organisers, and there certainly was a lot of talking going on between sessions. I had the opportunity to get together with a couple of others and listen to Stefan Poulsen (@cyberzeddk) talk a little about his experiences with ServiceStack. We gathered around his laptop in the café area and talked for about 30 minutes during the lunch break. One thing I really think we needed here was the possibility of hooking his laptop up to a larger screen so we could all better see what he was doing. If I was to suggest one thing for next year’s conference, it would be to set up a number of “presentation stations” around the venue, where we could simply hook up our laptops to a larger screen to make it easier to do these spontaneous mini-talks. Maybe they would need to be booked a little in advance so as to avoid crowding, but I’m sure something like this could be made to work.

So in conclusion, I’m really happy that GOTO invited me to participate this year, and although I didn’t get a lot of blog posts out during the conference itself, I have a number of topics lined up that I really want to write about.

0 comments

Today, the last day of GOTO, I spoke to a number of different people whom I knew might have an opinion on Anders Hejlsberg's new language, TypeScript. Yesterday's post was mainly a "brain dump" of my notes from the talk. Now after having had time to digest what I saw, I thought I'd make a couple of observations.  

Firstly, TypeScript IS JavaScript. It is not a new syntax like CoffeeScript, and it's not an entirely new language that incidentally can be compiled to JavaScript but really wants to replace it completely, like Google's Dart project.

TypeScript, in my mind has two sides to it. Firstly, as Anders spent a lot of time pointing out, it extends JavaScript with static typing. Secondly, it introduces a class-based OO model that will be much more friendly to C# and Java developers than the traditional prototype-based model that JavaScript uses. The static typing system is, as I pointed out in my post from yesterday, applied using a postfix syntax, where types are appended after the name of the variable. Static typing allows the compiler to perform checks of our code to ensure that when I pass parameters in my method calls, they are indeed of the right type. But more importantly, it enables our tools to help us during development. Here's an example of types in action:

function add(a: number, b: number) {
   return a + b;
}

In the above example, the compiler will throw an error if I try to pass in the parameters as strings or any other type than numbers. An added bonus is that the return type can be inferred, since the compiler knows the types that are being dealt with in the method body.

One of the cool things about TypeScript's interface system is that objects don't have to explicitly inherit from the interface. All they need to do is to match the definition to work. For example: 

interface Person {
  firstName: string;
  lastname: string;
}

function Greet(Person person) {
   return "Hello " + person.firstName + " " + person.lastName;
}

Greet({firstName: "John", lastName: "Smith"});

Notice how the object I pass in to the Greet function isn't explicit about what type it is. It merely mimics the structure defined in the interface. This is quite nifty I think.

As I also mentioned in my post from yesterday, TypeScript's type system allows for far better tooling support than we have been accustomed to up till now. Now don't get me wrong, the latest version of Visual Studio (2012) has become extremely good at handling JavaScript. But I think TypeScript will give us far more that what we have today. Statically typed JavaScript will give us far better support for refactoring our code, since the tool will know a lot more about the code up front. Also, IntelliSense (or other intelligent code-completion methods) will be much, much better. 

On the topic of Intellisense, one of the other majorly cool things is the external declaration file system. External declaration files allow us (or third-parties) to provide files that describe the internal structure of a library. This will give us true IntelliSense support for libraries like jQuery and Underscore. When instantiating jQuery, we have 8 different overloads to deal with. When using TypeScript, we will have much better control, since our tools will be able to tell what we're trying to do and thus only display the constructors (or other methods) that make sense at the time. 

The other thing that TypeScript provides us is class-based object orientation, as opposed to prototypal inheritance which can be quite confusing to people coming from the C# or Java worlds. Here's a silly little example that should demonstrate how classes and inheritance works, as well as the resulting JavaScript code.

class Vehicle {
	private numberOfWheels: number;
	constructor(noOfWheels: number) {
		this.numberOfWheels = noOfWheels;
	}
}

class Bycicle extends Vehicle {
	constructor() {
		super(2);
	}
}

And the resulting code: 

var __extends = this.__extends || function (d, b) {
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
}
var Vehicle = (function () {
    function Vehicle(noOfWheels) {
        this.numberOfWheels = noOfWheels;
    }
    return Vehicle;
})();
var Bycicle = (function (_super) {
    __extends(Bycicle, _super);
    function Bycicle() {
        _super.call(this, 2);
    }
    return Bycicle;
})(Vehicle);

Notice the __extends method that gets injected at the top. This is one of the only places where TypeScript injects code to your system that you didn't actually write yourself. It's used for some of the prototype plumbing that is needed to get the JavaScript objects to behave the way we want them to. Now a major advantage here is that the private keyword can be enforced by the compiler and thus help us by hiding inaccessible members. This really isn't possible in JavaScript. Also, as I pointed out yesterday, the class syntax is based on the official ECMAScript 6 proposal, and thus isn't something Microsoft have just pulled out of a magic hat. What this means is that once we get support for ECMAScript 6 (sometime in the distant future), the TypeScript compiler won't have to worry about compiling classes anymore. Neat!

Finally, TypeScript gives us support for JavaScript's module concept: 

module Utils {
	function Util1() {
		return "Hello World"
	}
}
// results in
var Utils;
(function (Utils) {
    function Util1() {
        return "Hello World";
    }
})(Utils || (Utils = {}));

So all in all I am pretty happy about what I see coming in TypeScript. I was pretty skeptical (to say the least) when I heard the announcement that Microsoft and Anders Hejlsberg were going to be giving us something "In the JavaScript tooling space". I must admit that I think TypeScript hits a nice sweet spot without becoming intrusive. I look forward to playing around a bit more with it and seeing how it affects my coding. The fact that TypeScript does a lot of type inference means that I can continue coding JavaScript like I normally do, but my tools and the compiler will be able to do a much better job of helping me out.

0 comments

I had the privilege of attending the ANUG User Group event at GOTO this afternoon, and there to present the latest addition to our web language toolbox, was Anders Helsberg. The topic of the talk was a new language called TypeScript. 


What is TypeScript?

TypeScript is at its core a language that enables enterprise-scale application development in JavaScript. Because it is a superset of JavaScript, TypeScript is JavaScript. We aren't being forced to re-learn all the things we already know about the language. 

Some of the key points I picked up from the talk are: 

  • TypeScript is a superset of JavaScript
  • Provides typed parameters 
    function greeter(person: string) {
        return "Hello, " + person;
    } 
  • Provides "interface types" 
    interface Person {
        firstname: string;
        lastname: string;
    }
    
    function greeter(person : Person) {
        return "Hello, " + person.firstname + " " + person.lastname;
    }
    
    var user = {firstname: "Jane", lastname: "User"};
  • Optional parameters
    function Greeter(name?: string) {
        ... 
    }
    
  • Class definitions
    class Greeter {
    	greeting: string;
    	constructor (message: string) {
    		this.greeting = message;
    	}
    	greet() {
    		return "Hello, " + this.greeting;
    	}
    }   
    
    var greeter = new Greeter("world");
     
  • At compile time, all type info is erased and thus you are left with pure JavaScript. The type info is used solely as a help to you and your tools during development time.
  • Type information for libraries like jQuery, underscore etc. is provided through type declaration files. A few are shipped with the product, and Microsoft expects that the community will be helpful in building declaration files for all the commonly used libraries. 
  • Class definitions are based on the ECMAScript 6 proposal
  • You can provide default values for parameters
  • Lexical scoping of the "this" keyword using the fat arrow (=>)
  • Supports the module concept
    module Sayings {
        export class Greeter {
            greeting: string;
            constructor (message: string) {
                this.greeting = message;
            }
            greet() {
                return "Hello, " + this.greeting;
            }
        }
    }
    results in this code:
    var Sayings;
    (function (Sayings) {
        var Greeter = (function () {
            function Greeter(message) {
                this.greeting = message;
            }
            Greeter.prototype.greet = function () {
                return "Hello, " + this.greeting;
            };
            return Greeter;
        })();
        Sayings.Greeter = Greeter;    
    })(Sayings || (Sayings = {}));
     
  • An important point is that the compiler never changes method bodies. They are left untouched. This means you don't have to worry that the compiler does things to your code that you don't expect. 

All in all I think this looks really exciting. I must admit I was a bit skeptical when I heard that Anders Hejlsberg was going to announce a new language that compiles to JS. My first thought was that this was either a new CoffeeScript or a new Dart. But in reality, this is neither of those two. This language provides us developers with some tools to help us with some of the "thousand paper cuts" that JavaScript development can be. For example, refactoring becomes a lot easier since the compiler is context-aware, and because Visual Studio continuously compiles the code in the background. This means we can rename variables without risking renaming the wrong ones. 

If you want to have a look at TypeScript, head over to http://typescriptlang.org and download it. And the best part is that it's open source under the Apache 2.0 License. 

0 comments

I've been invited to participate as a blogger at the GOTO Conference in Aarhus this October. Yay, that means more activity on this blog in the coming weeks/months!

Since I will be there "as a blogger", my main task will of course be to blog about the conference and about topics I find interesting or controversial. 

When attending conferences like this, one can chose to attend talks that are completely related to one's day-to-day work, or one can chose to attend talks that are a long way out of one's comfort zone. I haven't yet decided exactly which conference strategy I will be going for, but one thing is for sure: I'm definitely going for the chance to hang out (maybe have a beer?) with brilliant minds; to become inspired; to become wiser.

Stay tuned for more, I'll be writing another post or two before the conference, as soon the programme is finalized and I know more about which sessions I'm going to attend.

Feel free to check out the awesome speakers list on the website linked above and if you aren't going yourself but have a question you want answered, maybe I can be your proxy. Use the comments field below or send me an email (or Twitter) and I'll see what I can do.