Nachdem ich nun mehrfach darauf angesprochen wurde, was denn eigentlich mit meinem Blog los sei, da schon länger keine Einträge mehr erschienen sind, möchte ich diese Nachfragen nun doch zum Anlass nehmen, hier wieder aktiv(er) zu werden. Eine Idee, die ich schon etwas länger verfolge ist, regelmäßige (d.h. wöchentliche) Zusammenfassungen aktueller Neuigkeiten rund um Azure zu posten. Immerhin wird es immer anspruchsvoller, sich auf dem neuesten Stand zu halten. Darüber hinaus wird es natürlich auch wieder Blogs zu technischen Themen geben.

Los geht’s also mit den Neuigkeiten aus der aktuellen Woche (KW17):

Weitere Informationen

• Azure Mobile Engagement
• Azure Premium Storage
• Azure Stream Analytics
• Datacenter Extension Reference Architecture Diagram

Basic Authentication? Are you kidding?

This was my first thought when I was thinking about a simple approach to protect Web APIs, but then I found this nicely written blogpost: Why I love Basic Auth

The topic is still very controversial, but if it done right and you are using SSL: Why not give it a try. There are other well-known examples, like the GitHub API which can be used with Basic Auth.

Short introduction to Basic Authentication

We can all agree that Basic Authentication is dead simple for HTTP Servers and Clients. The Client just needs to send the given Username and Password Base64 encoded in the “Authorization” HTTP header like this:

Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

The “dXN” is just “username:password” encoded in Base64.

Now the Server just needs to decode the Username and Password and get the actual user lookup started. The Server can also inform Clients that the authentication is need via this HTTP Response Header:

WWW-Authenticate: Basic realm="RealmName"

All typical Clients and Servers can handle this “basic” stuff very well.

Basic Auth with ASP.NET WebAPI

The following code is based on this excellent tutorial Authentication Filters in ASP.NET Web API 2, but I’m leaving out the ASP.NET Identity stuff.

The sample code from Microsoft contains an abstract base filter, which will check the request for the authentication header and will extract username and password.

public abstract class BasicAuthenticationAttribute : Attribute, IAuthenticationFilter
{
    public string Realm { get; set; }

    public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
    {
        HttpRequestMessage request = context.Request;
        AuthenticationHeaderValue authorization = request.Headers.Authorization;

        if (authorization == null)
        {
            // No authentication was attempted (for this authentication method).
            // Do not set either Principal (which would indicate success) or ErrorResult (indicating an error).
            return;
        }

        if (authorization.Scheme != "Basic")
        {
            // No authentication was attempted (for this authentication method).
            // Do not set either Principal (which would indicate success) or ErrorResult (indicating an error).
            return;
        }

        if (String.IsNullOrEmpty(authorization.Parameter))
        {
            // Authentication was attempted but failed. Set ErrorResult to indicate an error.
            context.ErrorResult = new AuthenticationFailureResult("Missing credentials", request);
            return;
        }

        Tuple<string, string> userNameAndPasword = ExtractUserNameAndPassword(authorization.Parameter);

        if (userNameAndPasword == null)
        {
            // Authentication was attempted but failed. Set ErrorResult to indicate an error.
            context.ErrorResult = new AuthenticationFailureResult("Invalid credentials", request);
            return;
        }

        string userName = userNameAndPasword.Item1;
        string password = userNameAndPasword.Item2;

        IPrincipal principal = await AuthenticateAsync(userName, password, cancellationToken);

        if (principal == null)
        {
            // Authentication was attempted but failed. Set ErrorResult to indicate an error.
            context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
        }
        else
        {
            // Authentication was attempted and succeeded. Set Principal to the authenticated user.
            context.Principal = principal;
        }
    }

    protected abstract Task<IPrincipal> AuthenticateAsync(string userName, string password,
        CancellationToken cancellationToken);

    private static Tuple<string, string> ExtractUserNameAndPassword(string authorizationParameter)
    {
        byte[] credentialBytes;

        try
        {
            credentialBytes = Convert.FromBase64String(authorizationParameter);
        }
        catch (FormatException)
        {
            return null;
        }

        // The currently approved HTTP 1.1 specification says characters here are ISO-8859-1.
        // However, the current draft updated specification for HTTP 1.1 indicates this encoding is infrequently
        // used in practice and defines behavior only for ASCII.
        Encoding encoding = Encoding.ASCII;
        // Make a writable copy of the encoding to enable setting a decoder fallback.
        encoding = (Encoding)encoding.Clone();
        // Fail on invalid bytes rather than silently replacing and continuing.
        encoding.DecoderFallback = DecoderFallback.ExceptionFallback;
        string decodedCredentials;

        try
        {
            decodedCredentials = encoding.GetString(credentialBytes);
        }
        catch (DecoderFallbackException)
        {
            return null;
        }

        if (String.IsNullOrEmpty(decodedCredentials))
        {
            return null;
        }

        int colonIndex = decodedCredentials.IndexOf(':');

        if (colonIndex == -1)
        {
            return null;
        }

        string userName = decodedCredentials.Substring(0, colonIndex);
        string password = decodedCredentials.Substring(colonIndex + 1);
        return new Tuple<string, string>(userName, password);
    }

    public Task ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken)
    {
        Challenge(context);
        return Task.FromResult(0);
    }

    private void Challenge(HttpAuthenticationChallengeContext context)
    {
        string parameter;

        if (String.IsNullOrEmpty(Realm))
        {
            parameter = null;
        }
        else
        {
            // A correct implementation should verify that Realm does not contain a quote character unless properly
            // escaped (precededed by a backslash that is not itself escaped).
            parameter = "realm=\"" + Realm + "\"";
        }

        context.ChallengeWith("Basic", parameter);
    }

    public virtual bool AllowMultiple
    {
        get { return false; }
    }
}

There is a small helper class, which will issue an “UnAuthorized”-Response, with the challenge note:

public static class HttpAuthenticationChallengeContextExtensions
{
    public static void ChallengeWith(this HttpAuthenticationChallengeContext context, string scheme)
    {
        ChallengeWith(context, new AuthenticationHeaderValue(scheme));
    }

    public static void ChallengeWith(this HttpAuthenticationChallengeContext context, string scheme, string parameter)
    {
        ChallengeWith(context, new AuthenticationHeaderValue(scheme, parameter));
    }

    public static void ChallengeWith(this HttpAuthenticationChallengeContext context, AuthenticationHeaderValue challenge)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        context.Result = new AddChallengeOnUnauthorizedResult(challenge, context.Result);
    }
}

The real work is now done in this filter:

public class IdentityBasicAuthenticationAttribute : BasicAuthenticationAttribute
{
    protected override async Task<IPrincipal> AuthenticateAsync(string userName, string password, CancellationToken cancellationToken)
    {
        cancellationToken.ThrowIfCancellationRequested(); 

        if (userName != "testuser" || password != "Pass1word")
        {
            // No user with userName/password exists.
            return null;
        }

        // Create a ClaimsIdentity with all the claims for this user.
        Claim nameClaim = new Claim(ClaimTypes.Name, userName);
        List<Claim> claims = new List<Claim> { nameClaim };

        // important to set the identity this way, otherwise IsAuthenticated will be false
        // see: http://leastprivilege.com/2012/09/24/claimsidentity-isauthenticated-and-authenticationtype-in-net-4-5/
        ClaimsIdentity identity = new ClaimsIdentity(claims, AuthenticationTypes.Basic);

        var principal = new ClaimsPrincipal(identity);
        return principal;
    }

}

The Microsoft Sample uses the ASP.NET Identity Stack - for this demo I just hardcoded my expected username and password. If the request contains these credentials the filter will create a new ClaimsPrincipal.

Usage

Using this filter now is pretty simple:

[IdentityBasicAuthentication]
[Authorize]
public class ValuesController : ApiController
{
    ...
}

The “IdentityBasicAuthentication” filter will try to authenticate the user and after that the default “Authorize” filter will kick in.

Error-Results for different scenarios

This question came up in the comments: What are the results for the different “unauthenticated”-scenarios?

Of course, if the Authorization-Header is valid and has the correct username and password the result is HTTP 200 with the desired result. If the authentication fails the “AuthenticationFailureResult” will set the HTTP Status Code to 401. There are some slightly different results based on the input:

Without any Authorization-Header: “HTTP 401 Unauthroized”

With an invalid Authorization-Header: “HTTP 401 Invalid credentials”

With an valid Authorization-Header, but “wrong” or unkown username or password: “HTTP 401 Invalid username or password”

For security reasons the service should not return further information, e.g. username found, but password wrong. I hope my sample is correct, if not: Leave a comment. For more information is OWASP.org a good place.

Thanks John Kors for the question!

Pretty simple, right?

The full source code can be found on GitHub.

Happy coding!

Im letzten Teil habe ich meine Motivation beschrieben mit Git zu arbeiten. In diesem Teil Beschreibe ich wie man Effektiv und Sicher mit Git Arbeiten kann. “Sicher” heißt in diesem Fall sauber, agil und mit sehr wenigen Konflikten. Sicher heißt in diesem Fall auch annähernd fehlerfrei. In diesem Teil geht es darum isoliert in Feature-Branches zu arbeiten.

Wer täglich mit Git arbeitet und dabei bereits Freature-Branches anwendet, wird in diesem Blog-Artikel nichts neues erfahren. Ich schreibe das hier hauptsächlich für Leute die keine oder wenig Erfahrung mit Git haben und für Leute die Git wie SVN oder TFS verwenden, also historisch bedingt mit Commits und Branches eher sparsam umgehen.

Branchen geht schnell

Herkömmliche zentralisierte SCM haben alle den Nachteil, dass Branching relativ schwer oder aufwendig ist. In SVN und TFS wird für jeden Branch zumindest ein eigener Ordner angelegt, was ich für recht umständlich halte, zumindest beim häufigen Wechseln der Branches.

Diese Umstände führen dazu, das in zentralisierten SCM unvollständiger Code, unvollständige Features committet wird oder eben nur ein einziges Mal, wenn das Feature fertiggestellt ist. Allerdings sollte man so häufig wie möglich committen, um eine detaillierte Historie zu erhalten und um seine Arbeitsschritte besser nachvollziehen zu können. Ein weiterer Grund für häufiges committen ist die Größe des Change Sets. Je kleiner dieser ist, desto einfacher fällt das Mergen.

In Git und Mercurial ist das nicht der Fall. Der Wechsel der Branches findet immer im gleichen Ordern – dem sogenannten Workspace – statt. Aus .NET Sicht heißt das, ich kann die Branches innerhalb der gleichen Visual Studio Instanz wechseln. Der Wechsel der Branches passiert also sehr schnell und ich muss meine IDE, meinen Workspace nicht verlassen. Der Wille einen Branch zu erstellen ist größer.

Dieser Vorteil kann genutzt werden um mit Feature Branches zu arbeiten. Das heißt es wird für jedes Feature, das zu entwickeln ist ein eigener Branch angelegt und man kann nun isoliert in diesem Branch arbeiten und beliebig oft committen. Ich kann jederzeit in einen früheren Stand wechseln und von dort aus wieder einen eigenen Branch erstellen, wenn es sein muss. Ich kann einen Branch erstellen nur um etwas schnell zu testen und dann wieder zu verwerfen. Der Vorgang des Branchens selbst bei sehr großen Projekten dauert nur einen Bruchteil einer Sekunde.

Für jede Anforderung einen eigenen Branch zu erstellen, erscheint auf dem ersten Blick sicherlich etwas Übertrieben. Allerdings hilft das enorm den Code lauffähig zu halten. Feature Branches sind auch eine Voraussetzung für Pull Requests die ich in einem dritten Teil kurz vorstellen möchte.

Praxis

Hier möchte ich die Arbeit mit einem Pull Request kurz in einem gespielten Szenario anreißen:

Wir wechseln also als erstes in unseren Workspace.

In diesem Workspace gibt es zwei Branches. Der eine ist der “master” der den fertigen, getesteten und abgenommenen Code enthält, der andere ist “dev” welcher der Entwicklungszweig ist. Hier kann unter umständen Code landen der fehlerhaft ist. Auf diesem Branch lauscht ein Build Server mit einem schnellen Continuous Integration Prozess, es wird also gebaut und die Unit Tests werden ausgeführt.

Aktuell befinden wir uns im master-Branch, wechseln wir also in den dev Branch, in dem sich aktuell eine HalloWelt.txt befindet. Das ist nun unser Source Code ;)

Wir haben nun die Anforderung einen neuen Abschnitt mit Infos über Feature Branches anzufügen. Die Anforderungen kommt in Form eines Tickets aus einem Tool wie TFS, Jira, Redmine, etc. Wenn ich einen Feature Branch erstelle habe ich mir angewöhnt meinen Username und einen Ticket Identifier als Branch-Name zu nutzen. In meinem Fall sieht das z. B. so aus: 
juergengutsch/HalloGit-1
<Username>/<Ticket Id>

Die Initialen vorne dran, helfen beim erkennen des Branch Erstellers in einer großen Liste von Feature Braches. Der Slash erzeugt z. B. im SourceTree eine Ordnerstruktur mit den Entwicklerkürzeln als Ordner und darin dann die Liste mit Branch-Namen, bestehend aus dem was nach dem Slash folgt. Diese Schreibweise sorgt also für mehr Übersicht.

Wir erstellen also unseren Branch und wechseln in diesen:

Nun können wir die Datei öffnen und die Anforderung implementieren und abspeichern. Der Cmder zeigt nicht nur den aktuellen Branch an, in den wir uns befinden, sondern zeigt auch noch dessen Zustand. Rot bedeutet der Branch ist unsauber. Wir haben also Änderungen:

Wir fügen die Änderung nun in unser Change Set ein und committen. Der Workspace ist nun wieder sauber:

Wir möchten unsere Änderungen nun in den dev-Branch mergen. Was wir nun aber machen müssen um Merge-Fehler im dev zu vermeiden, ist diesen zuerst in unserem Feature Branch zu mergen.

Wir wechseln also in den dev-Branch und holen uns die aktuellen Änderungen vom entfernten Repository, schließlich könnte ein anderer Entwickler ebenfalls am Code gearbeitet haben:

Wie wir nun sehen, gab es tatsächlich Änderungen. In der Historie können wir sehen was gemacht wurde. Nun wechseln wir wieder zurück in unseren Feature Branch und mergen die letzten Änderungen in den aktuellen Workspace. Sollte die Implementation des Features länger gehen, sollten wir immer wieder mal den letzten Stand aus dem dev-Branch in den Feature Branch holen.

An dieser Stelle müsste jetzt noch ein Review erfolgen. Das passiert bei uns in Form eines Pull Requests auf den ich im nächsten Teil eingehen möchte. Für den Pull Request müsste der aktuelle Feature Branch in das Remote Repository gepusht werden.

Wer der Merge erfolgreich, baut der Code lokal und laufen alle Tests lokal durch, können wir diesen Feature Branch nun nach dev mergen. Vorausgesetzt unser Feature ist fertig:

Anschließend pushen wir diesen Stand in das Remote Repository:

Wir können uns nun dem nächsten Feature widmen :)

Fazit

Was ich hier mit relativ viel Text und Bilder beschrieben habe ist im Alltag viel weniger Aufwand und ist in einigen Sekunden getan. Lediglich Merge-Konflikte – die Dank der Feature-Branches nur noch selten vorkommen – benötigen etwas mehr Aufmerksamkeit.

Für diesen Zweck ist die Konsole auch absolut ausreichend, da die paar Befehle die man hierbei anwendet schnell gelernt sind. Für alles weitere, was eher selten benötigt wird, kann man schnell das Netz konsultieren. Der Cmder ist für Git eine sehr gute Unterstützung.

Jeden Montag ein Foto. Der #fotomontag. Mindestens einmal besucht man mit seiner Kamera auch den Bahnhof. So auch ich und nachfolgend das Ergebnis: Bildinformationen: 35mm ISO 100 f/7.1 1/100. Hast du eine Meinung zum Foto? Ja? Dann lass sie mich doch bitte wissen und bewerte es in den Kommentaren.

The post #fotomontag #16 appeared first on Norbert Eder.

Das Patterns & Practices Team arbeiten schon eine ganze Zeit daran, Empfehlungen für bestimmte Architektur-Fragestellungen, mit Microsoft Azure zu erstellen. Auf GitHub st nun eine erste Version der Azure Architecture Guidance verfügbar. Dieser Leitfaden geht auf verschiedene Aspekte des Entwurfs Azure-basierter Anwendungssysteme ein. Im Einzelnen enthält er folgende Abschnitte:

• API Design
• API Implementation
• Autoscaling Guidance
• Background Jobs Guidance
• Content Delivery Network (CDN) Guidance
• Caching Guidance
• Data Partitioning Guidance
• Monitoring and Diagnostics Guidance
• Retry General Guidance
• Retry Service Specific Guidance
• Scalability Checklist
• Availability Checklist

Weitere Informationen

• Azure Architecture Guidance der Patterns & Practices Group
  https://github.com/mspnp/azure-guidance

My friend T.Roy from CodeMachine, USA (http://codemachine.com), will be visiting Munich to present at the ADC++ conference in May 2015. He will be available during 6 - 8, May, to meet up and discuss the Windows training courses offered by CodeMachine as well as present an hour long brownbag seminar on cool debugging tips and tricks. You can reach him at contact@codemachine.com to schedule a meeting and presentation. Please note that the presentation will be in English.

If you are interested in such deep Dives I highly recommend to contact T.Roy

Chris

Mein Kollege Vildan Softic, mit dem ich gemeinsam an unserem AngularJS-Buch gearbeitet habe, hat vor einiger Zeit in unserer Kolumne bei Heise Onlineüber das Zusammenspiel von AngularJS und EcmaScript 6 geschrieben. Dabei zeigt er, wie man mit dem Transpiler Babel und einem Gulp-Task EcmaScript 6 nach EcmaScript 5, das heute schon in jedem Browser läuft, transpilieren kann.

Als Ergänzung dazu zeige ich hier anhand einer Schritt-für-Schritt-Anleitung, wie man solch ein Projekt einrichtet.

Starter-Kit

Wer die hier beschriebene Schritt-für-Schritt-Anleitung nicht durchmachen, sondern gleich AngularJS und EcmaScript nutzen möchte, findet das Ergebnis dieser Anleitung in Form eines Starter-Kits hier. Die nötigen Informationen zur Nutzung dieses Starter-Kits finden sich in der darin enthaltenen Datei readme.md.

Vorbereitung

Zunächst benötigt man den Package-Manager jspm. Im Gegensatz zu bower hat diese Implementierung die nette Eigenschaft, auch den Modul-Loader System.js zu konfigurieren, sodass er die heruntergeladenen Bibliotheken laden kann. Die Installation erfolgt über npm:

npm install jspm

Anschließend benötigt man noch die Konfigurationsdatei Package.json. Die wird wie folgt erstellt. Die dabei gestellten Fragen kann man mit Enter bestätigen. Um das von uns verwendete Starter-Paket zu bekommen, sollte man lediglich bei der Frage bezüglich des zu nutzenden Transpilers die Option Babel wählen.

npm init
jspm init

[…]
Which ES6 transpiler would you like to use, Traceur or Babel? [traceur]:Babel
[…]

Danach können die benötigten Bibliotheken mit jspm bezogen werden:

jspm install angular --save
jspm install bootstrap --save

Projekt

Um das Ganze zu testen, benötigt man eine einfache AngularJS-Anwendung, die sich auf EcmaScript 6 stützt. Die einzelnen JavaScript-Dateien sind im Ordner src abzulegen. Die Datei index.html sollte im Root der Anwendung platziert werden:

//demo-vm.js
export class DemoVM {
    info;
    constructor($log) {
        $log.log("DemoCtrl has been created ...");
        this.info = "Hallo Welt!";
    }
}

Die Datei app.js importiert AngularJS sowie das View-Model und definiert das Angular-Moduls samt Controller. Darüber hinaus kümmert sie sich um das Bootstrapping von AngularJS mittels angular.bootstrap. Letzteres ist notwendig, da hier AngularJS nicht mit der üblichen Direktive ng-app gestartet werden kann. Der Grund dafür ist, dass der Module-Loader zunächst das Modul der betrachteten Datei app.js laden muss und erst darauf hin AngularJS über import einbindet.

// app.js
import angular from 'angular';
import {DemoVM} from 'demo-vm';

var app = angular.module('angular-es6', []);

app.controller('demoVM', DemoVM);

angular.element(document).ready(function() {
  angular.bootstrap(document, ['angular-es6']);
});

Die Datei index.html bindet System.js sowie die Konfigurationsdatei config.js ein und lädt anschließend das Modul in der Datei app.js mit System.import.

<!--index.html --><!doctype html><html><head><link rel="stylesheet" type="text/css" href="jspm_packages/github/twbs/bootstrap@3.3.4/css/bootstrap.min.css"></head><body><div class="container" ng-controller="demoVM as vm"><h1>Angular-ES6-Demo</h1><p>{{vm.info}}</p><script src="jspm_packages/system.js"></script><script src="config.js"></script><script>
            System.import('app').catch(function(err) { console.error(err); });</script></body></html>

Laufzeit-Transpilierung

Für eine Transpilierung zur Laufzeit ist die Datei config.js anzupassen, sodass sie die nachfolgenden Einträge wiederspiegelt. Wichtig dabei ist die Abbildung von * auf src/*.js. Hieraus geht hervor, dass der Module-Loader sämtliche JavaScript-Dateien im Ordner src findet, sofern kein anderes Mapping angegeben wurde.

System.config({
  "baseURL": "/",
  "transpiler": "babel",
  "babelOptions": {
    "optional": [
      "runtime",
      "es7.decorators"
    ]
  },
  "paths": {
    "*": "src/*.js",
    "github:*": "jspm_packages/github/*.js",
    "npm:*": "jspm_packages/npm/*.js"
  }
});
[...]

Danach kann man die Anwendung starten und index.html aufrufen.

Kompilierung vor Ausführung

Für die Transpilierung vor der Ausführung nutzt das hier gezeigte Beispiel das gulp. Dieses Build-Tool kann samt der benötigten Anweisungen via npm bezogen werden. Die Anweisung gulp-babel delegiert an den Transpiler Babel, gulp-plumber verhindert, dass im Fehlerfall ein Gulp-Task abbricht und gulp-sourcemaps ist für das Erstellen der Source-Maps, dank derer EcmaScript 6 Code in Browsern, wie Chrome oder Internet Explorer debugget werden kann, verantwortlich.

npm install gulp --save
npm install gulp-babel --save
npm install gulp-plumber --save
npm install gulp-sourcemaps --save

npm install lru-cache --save
npm install sigmund --save
npm install core-util-is --save

Den Gulp-Task findet man nachfolgend.

// gulpfile.js
var gulp = require('gulp');
var babel = require('gulp-babel');
var sourcemaps = require('gulp-sourcemaps');
var plumber = require('gulp-plumber');

var babelOptions = {
  modules: 'system',
  moduleIds: true,
  stage: 2,
  optional: [
    "es7.decorators",
    "asyncToGenerator"
  ]
};

var source = "src/**/*.js";
var html = "src/**/*.html";
var css = "src/**/*.css";
var resources = [html, css];
var destination = "app";

gulp.task('default', function () {
  gulp.src(source)
    .pipe(plumber())
    .pipe(sourcemaps.init())
    .pipe(babel(babelOptions))
    .pipe(sourcemaps.write('.'))
    .pipe(gulp.dest(destination));

  gulp.src(resources)
    .pipe(gulp.dest(destination));

});

gulp.task('watch', ['default'], function() {
  var watcher = gulp.watch([source, html, css], ['default']);
  watcher.on('change', function(event) {
    console.log('\n\nFile ' + event.path + ' was ' + event.type + ', running tasks...');
  });
});

Da der Gulp-Task das Ergebnis der Kompilierung im Ordner app ablegt, ist nun noch die Datei config.js anzupassen:

System.config({
  "baseURL": "/",
  "paths": {
    "*": "app/*.js",
    "github:*": "jspm_packages/github/*.js",
    "npm:*": "jspm_packages/npm/*.js"
  }
});
[...]

Danach kann die Kompilierung durch Aufruf von gulp erfolgen. Mit gulp watch kann man hingegen angeben, dass der Ordner src zu überwachen ist. In diesem Fall führt eine Änderung einer Datei in diesem Ordner zu einem erneuten Kompilieren. Zum Testen ruft man die index.html auf.

Nachfolgend der Link zu den Folien und dem Beispiel meines Vortrages, den ich gestern auf der JAX 2015 in Mainz zum Thema AngularJS gehalten habe.

Nachfolgend der Link zu den Folien und den Beispielen meines Vortrages, den ich heute auf der JAX 2015 in Mainz zum Thema 'Fünf Dinge, die Sie beim Erstellen moderner Browseranwendungen wissen sollten' gehalten habe.

Die ADC C++ findet am 5 und 6.Mai statt. Von dem Microsoft C++  Team werden mit dabei sein:

Steve Carroll Visual C++ Team | Principal Group Software Engineering Manager
James McNellis Visual C++ Team | Senior Software Development Engineer

mit folgenden Sessions:

- Keynote: Microsoft Visual C++ Strategy
- What is new in Visual Studio 2015 
- Modernizing Legacy C++ Code
- Cross-platform development with C++ and Visual Studio 2015
- Graphics debugging in Visual Studio 2015

PS: Ich werde mit Gunter Logemann auch vor Ort sein. Gunter ist unser IoT und Windows (10) Spezialist und mein Thema ist ja ALM (TFS, VS, Git, TVCS usw.)  Ihr könnt uns am Microsoft Stand treffen und Eure Fragen mitbringen

Chris

Vom 29. April bis zum 1. Mai findet auch heuer wieder die //build statt. Für alle Entwickler ist die //build ein "Must Event". Das zeigt sich auch Jahr für Jahr daran, dass diese Veranstaltung regelmäßig ausverkauft ist. So auch heuer wieder.

Wie schon in den Blogposts “Live dabei sein mit dem Microsoft //build Keynote-Streaming!” und “Was Spannendes, was zum Rumspielen und was zum Naschen!! …” beschrieben laden wir Euch ein mit uns gemeinsam die Keynote in Kinos in Wien, Linz und Graz zu erleben!

Wo & Wann: 29. April 2015 um 17:15 Uhr im

• //build Keynote-Streaming in Wien (SCHIKANEDER KINO in der Margaretenstraße )
• //build Keynote-Streaming in Linz (Moviemento am OK-Platz.)
• //build Keynote-Streaming in Graz (Schubertkino am Mehlplatz)

Alles was Ihr dazu braucht ist einfach nur einen der folgenden Online-Kurse in der Microsoft Virtual Academy (MVA) abzuschließen. Die kostenlosen Online-Trainings der Microsoft Virtual Academy (MVA) unterstützen Euch dabei, Euer Know-How zu aktuellen Technologien zu erweitern.

• PowerShell: Azure-Automatisierung für Einsteiger
• Application Performance Monitoring

Ein paar von Euch haben gemeint ob sie auch alternativ einen anderen Kurs machen könnten. Klar doch, machen wir gerne für Euch. Wie wäre es denn mit den folgenden:

• Visual Studio Tipps und Tricks
• Visual Studio Tipps & Tricks - Teil 2
• Coding for Kinect with Scratch

Und wenn es wirklich schnell gehen soll:

• Quick Start Challenge: Python and MongoLab
• Get Started with OneNote
• Get the Most out of OneNote
• SharePoint for Staff
• SharePoint for Your Classroom

Als Nachweis bitte einfach Eure absolvierten Kurse im Profil veröffentlichen. Dazu:

1. auf https://www.microsoftvirtualacademy.com/MyMVA/MyProfile.aspx im Abschnitt Persönliche Daten“Meine Profildaten für alle Nutzer freigeben“ und
2. in Mein Status in der MVA die „Tracks“ aktivieren.

Bei der Anmeldung gebt bitte als Einladungscode die Nummer Eures MVA-Profils an. Diese findet Ihr z.B. wenn Ihr Zum öffentlichen Profil navigiert Also z.B. “123456” wenn das Euer Profillink ist: http://www.microsoftvirtualacademy.com/Profile.aspx?alias=123456

Und BITTE: gebt EURE eigene  MVA ID ein. Ja, wir schauen uns Eure Einreichungen echt an.

Bei Fragen, Wünschen und Komplikationen aller Art erreicht Ihr mich wie gewohnt unter meiner E-Mail Adresse.

Wir sehen uns im Kino!

Gerhard Göschl, Marketing Leiter - IT-Spezialisten und Software Entwickler

Microsoft Österreich GmbH
Gerhard.Goeschl@Microsoft.com

PS: Ihr möchtet die Entwicklungsprodukte von Microsoft vorab schon einmal ausprobieren? Im MSDN Evaluierungscenter finden Ihr kostenlose Testversionen aller wichtigen Produkte für Entwickler. Probiert doch auch den kostenfreien Testzugang zu Microsoft Azure