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

It's been a really hectic first day at GOTO here in Aarhus. Seeing as it's my first time here, I couldn't help observing how well everything seems to be organized.

Firstly though, I noticed a lack of some sort of breakfast. One of the things I remember from Øredev is that they have an absolutely immaculate breakfast for attendees every morning. This was lacking. However, I survived (only because we bloggers had access to a VIP room which had breakfast available. 

The first keynote of today was by Rickard Falkvinge, the founder of the Swedish Pirate Party. He held a really interesting talk about the foundations of where the Pirate Party comes from and what their political motivations are. One of the key points was about the whole point of privacy in the postal service. When our parents sent letters, they could choose to be anonymous or to let the receiver know upfront who was the sender - by writing their name on the outside of the envelope. They could also choose to only write their names on the actual letter. The final choice they had was to not identify themselves in any way. The important note here is that in the current day and age, this isn't a possibility. The copyright holders have lobbied enough that we can't move around on the Internet without our every move being logged in some form. The point of the Pirate Party is to work against this threat of anit-privacy. 

Another interesting talk I saw today was a talk by Jesper Boeg which was about the steps many of us have been through in trying to implement the perfect agile process. Right from our first Ceritfied Scrum Master training course, to the point where we realise that the team we are working with actually functions better with a more KANBAN-y approach. What tends to happen is that the teams adapt the process models into something that actually works. But only for them. What is imporatnt to note is that the agile processes that we all want to implement are extremely dependent on the teams that will implement them. So basically, lessons learned on one team in one organisation will hardly ever translate into something useful for another team. 

I participated in a single hardware-based talk today which was about some work being done by Nat Pryce & Steve Freeman on the Raspberry Pi board. This was a really good hands-on look at the problems and challenges about designing user-mode hardware targeted at this platform. As it turns out, a lot of the people buying the Pi these days are actually some of the people who were around when the ZX-81 and C-64 were around. These were the days when hardware was an important piece of knowledge when it came to computers. Since then, hardware has become more of a commodity that we just accept for what it is. This is where the Raspberry Pi comes in. These two guys have developed an interface system to the Pi, which allows pretty much anyone to start experimenting with hardware-based development. 

 A final talk I want to bring up was the closing keynote of today.  

This was probably one of the most high-paced high-energy, high-intellect talks I have ever seen. The way the presentation was put together meant that most people wouldn't have trouble following it (you would simply end up laughing yourself to sleep). The talk was about some of the crazy stuff that Damian Conway has done in the upcoming version of Perl (version 6). This topic touched (and delved quite deeply) into subjects like parallel computing, quantum mechanics, quantum physics and how these topics could relate to one another. The point where my brain melted down completely was when he showed off his "pipe-based" programming language. This is a language entirely made up of the basic boolean constructs like AND, OR, NOT, NAND, but only written using the characters -,_,|,^,v,[ and ] . Ever seen the language "Brainfuck"? This took things to the next level. 

So now, after the conference party/dinner, I'll nod off to sleep and look forward to experiencing tomorrow's schedule. 

0 comments

I always find it hard to create a schedule before going to a conference. And especially one with as many amazing talks as this year's GOTO. However to give myself just a little of a head start, I created a preliminary draft of a schedule a couple of weeks ago. 

I do know for a fact that this schedule will change once I'm actually at the conference. It will all depend on how my mood swings, the vibes I pick up from others, who I end up talking to during breaks/lunch/beertime and probably lots of other outside influences. What's important to me is that by creating this schedule, I forced myself to actually go over the programme in detail. So I have a pretty good general idea of what will be going on where, and who the different speakers are. 

Oh and one more thing! I was one of the lucky winners of the awesome GOTO hoodie competition that ran on Twitter. I'll really be able to blend in with all the other awesome conference-goers now.