Kazim Bahar: Visual Studio 2015 mit neue Tools und Optimierungen für WPF

Wer hätte das gedacht. Microsoft investiert wieder Zeit für das Tooling des in der Vergangeheit stark vernachlässigten WPF Frameworks. Das...

Fabian Deitelhoff: LEGO Mindstorms EV3: Einsteigerkurs bei der VHS Menden

Am Samstag den 17. Januar 2015 war es mal wieder so weit. Um 09.30 Uhr versammelten sich interessierte Kinder, Jugendliche und Erwachsene, um mehr über den LEGO Mindstorms EV3 zu lernen. Der Kurs, der sich an Einsteiger und Einsteigerinnen jeglichen Alters richtete, ging bis 16.30 Uhr und bot somit reichlich Zeit, etwas über EV3 zu lernen und Neues auszuprobieren. Natürlich kamen auch Diskussionen zwischen den Teilnehmern und Teilnehmerinnen nicht zu kurz.

Dieses Mal war sogar genug Zeit für eigene Roboter-Kreationen, bei denen insbesondere die jüngeren ihrer Kreativität freien lauf lassen konnten. :)

Der Kurs

Die Gruppe bestand, exklusive mir, aus 15 Personen, was eine sehr ordentlich Größe war. Das Feld war durchmischt, sowohl das Alter betreffend, als auch eventuell vorhandene Vorkenntnisse mit dem LEGO Mindstorms EV3. Erfreulicherweise konnte sich die VHS Menden-Hemer-Balve zusätzliche LEGO Mindstorms EV3 ausleihen. Zwei Stück von der VHS Dortmund und drei weitere von der VHS Soest. So hatten wir insgesamt neun LEGO Mindstorms EV3 zur Verfügung, wenn ich mich nicht verrechnet habe. So viele wie in noch keinem Kurs zuvor, den ich geleitet habe. An dieser Stelle noch einmal vielen Dank an die VHS Dortmund und die VHS Soest!

Inhaltliches

Inhaltlich ging es, wie der Titel des Kurses schon vermuten lässt, um eine Einführung in die Welt des LEGO Mindstorms EV3. Dazu zählt ein kurzer Überblick über das LEGO Mindstorms-Universum und grundlegende Eigenschaften der Hard- und Software. Dieser Teil ist Erfahrungsgemäß immer recht schnell vorbei, denn in den Kursen geht es ja darum, den LEGO Mindstorms EV3 aus einem praktischen Blickwinkel kennen zu lernen.

Abb. 1: Teilnehmer und Teilnehmerinnen des LEGO Mindstorms Kurses. Abb. 2: Teilnehmer und Teilnehmerinnen des LEGO Mindstorms Kurses.

Dem EV3 Leben einzuhauen war somit der größte inhaltliche Block dieses Tages. Es gab verschiedene Aufgaben, wie einen Slalom fahren, mittels Sensoren Gegenständen ausweichen, sowie allgemeines zur Programmierung und über die EV3-Entwicklungsumgebung von LEGO. Eine Teilnehmer-Gruppe hat sogar eine Linienverfolgung programmiert. Etwas, was ich so erst in einem fortgeschrittenen Kurs geplant habe. Was wieder einmal beweist, wie viel die Kinder und Jugendlichen auf die Beine stellen können, wenn es spielerisch vermittelt wird.

Hier noch zwei Fotos von eigenen EV3-Kreationen, die von den Kindern während des Kurses gebaut wurden. Immer wieder beeindruckend. Abbildung 5 zeigt auch gleichzeitig den Untergrund mit dem Linienmuster für das Programm zur Linienverfolgung.

Abb. 3: Eigene EV3-Kreation eines Teilnehmers. Abb. 4: Eigene EV3-Kreation eines Teilnehmers. Abb. 5: Eigene EV3-Kreation eines Teilnehmers.

Fazit

Mir hat es wiedereinmal sehr viel Spaß gemacht. Die Teilnehmer und Teilnehmerinnen waren super gelaunt und haben prima mitgemacht. Ganz vorne mit dabei waren wie immer die Kinder und Jugendlichen, von denen auch der ein oder andere Erwachsene noch etwas lernen konnte. ;)

Zwischendrin war sogar die Presse vor Ort. Der Artikel ist online verfügbar.

Manfred Steyer: Folien und Beispiele zu meiner Session über das Erweitern von Entity Framework auf der BASTA! Spring 2015

Nachfolgend findet man die Folien und Beispiele zu meiner Session über das Erweitern von Entity Framework, welche ich auf der BASTA! Spring 2015 gezeigt habe. Die Beispiele zeigen:

  • Die Nutzung von EntityFramework.DynamicFilters zum Implementieren von Soft-Delete
  • Eine Variante des Beispiels, das Rowan Miller auf der TechEd 2015 zum Thema Entity Framework und Soft-Delete gezeigt hat
    • Das Beispiel ist ein wenig leichter verdaulich, als jenes von Rowan, dafür aber auch weniger mächtig
    • Das Beispiel hängt an jede Abfrage einen Filter für das Deleted-Flag an und wandelt DELETE-Anweisungen in INSERT-Anweisungen um
  • Die prinzipielle Nutzung von DbCommandInterceptor
  • Die prinzipielle Nutzung von DbCommandTreeInterceptoren
  • Die Nutzung von EntityFramework.Cache
  • Die Nutzung von EntityFramework.Extended für Batch-Updates
  • Die Funktionsweise von EntityFramework.Extended anhand einer einfachen eigenen Implementierung der Erweiterungs-Methode Delete
  • Die Nutzung eines eigenen SqlMigrationGenerators zum Generieren von Historisierungs-Tabellen


Downloads


Albert Weinert: IdentityServer V3 und eigene Dependency Injection mit OWIN

Der Identity Server v3 ist ein OAuth2 und OpenID Connect Framework welches einem die Serverseitige Implementierung von OAuth2 und OpenID Connect abnimmt. Im Gegensatz zu vorheringen Versionen steht hier das konzept klar auf Erweiterbarkeit und weg vom Monolitischen Ansatz wo Server und Administration vereint sind.

Der IdServerV3 ist eine reine ASP.NET Web API Lösung, und benutzt intern Autofac um selbst ordentlich mit Dependency Injection und IoC arbeiten zu können. Dies stellt jedoch eine kleine Herausforderung dar dies in der bestehenden Anwendung die schon mit IoC arbeitet zu verwenden, da IdServerV3 es nicht erlaubt den bestehenden IoC Container einfach einzustöpseln. Da es ohne Aufwändige IoC Konfiguration laufen soll kann man diese Entscheidung auch nachvollziehen.

TL;DR

Wie schaffe ich es nun mit einem eigenen IoC zu arbeiten?

Füttern des IoC Containers von IdServerV3

Es gibt im IdServerV3 die IdentityServerServiceFactory, damit kann man die Services die man für den Identity Server selber implementieren will oder muss (weil man z.B. eine eigene Administration und Datenhaltung hat).

var factory = new IdentityServerServiceFactory  
{
    UserService = new Registration<IUserService,IdentityServerUserService>(),
    ClientStore = new Registration<IClientStore, IdentityServerClientStore>(),
    ScopeStore = new Registration<IScopeStore,IdentityServerScopeStore>()
};

Hiermit registriert man den UserService, ClientStore und ScopeStore, diese braucht der IdServerV3 auf jedenfall, für den Produktionsbetrieb noch ein paar weitere.

Jedoch wird bei der Service Erstellung nun der interne Autofac Container verwendet. Und nicht der IoC Container der Applikation. Damit die funktioniert kann mann über nun die eigenen Services auch dem internen Container bekannt machen. Und natürlich auch dessen abhängikeiten.

Dazu kann man.

factory.Register(new Registration<IFoo,Foo>())  

verwenden. Dies ist jedoch nicht zu empfehlen, da man so sehr viele eigene Services auch noch im IdServerV3 Container registrieren muss. Jedoch viel wichtiger, weil so das LifeCycle Managment des IoC Containers ausgehebelt wird und man nun effektiv 2 IoC in der Anwendung hat und jeder seinen eigenes LifeCycle Managment hat und eigene Instanzen erzeugt. Dies führt über kurz oder lang zu Problemen.

Lösungansatz

Ein mögliche Lösung ist nun eine Factory Methode bei der Registrierung anzugeben, dies wird dann vom IdServerV3 Containers bei der Erzeugung des Services aufgerufen.

Variante 1 (so nicht verwenden)

var factory = new IdentityServerServiceFactory  
{
    UserService = new Registration<IUserService>(dr => mycontainer.GetInstance<IUserService>()),
    ClientStore = new Registration<IClientStore>(dr =>  mycontainer.GetInstance<IClientStore>()),
    ScopeStore = new Registration<IScopeStore>(dr =>  mycontainer.GetInstance<IScopeStore>())
};    

Dies ist prinzipiell funktionsfähig, jedoch arbeitet man hier mit einer bestimmten Instanz des Container, und war immer mit derselben. Was wieder dem LifeCycle Managment wiederspricht da so nicht der Scoped-Container von WebAPI verwendet wird. Und somit im Zweifel nicht jeder Request seine eigenen Instanzen hat und diese auch nicht beim Ende des Request wieder Disposed werden. Also nicht nachmachen.

Variante 2

Es ist notwendig für die Request die zum IdentityServer gehen einen eigenen Scope des IoC Containers aufzumachen und wieder zuschließen um dann in der Registrierung Methode darauf zuzugreifen. Da jedoch IdServerV3 selbst einen IoC Container verwendet, sollte man dies in einer Form machen die damit nicht zusammstößt.

Eine einfache IdServer-OWIN Konfiguration

app.Map("/identity", idsrvApp =>  
{
    var factory = new IdentityServerServiceFactory
    {
        UserService = new Registration<IUserService,IdentityServerUserService>(),
        ClientStore = new Registration<IClientStore, IdentityServerClientStore>(),
        ScopeStore = new Registration<IScopeStore,IdentityServerScopeStore>()
    };
    idsrvApp.UseIdentityServer(new IdentityServerOptions
    {
        SiteName = "Embedded IdentityServer",
        SigningCertificate = LoadCertificate(container),
        Factory = factory,
    });
});    

Ziel ist es nun in der Registrierung-Methode mit dem Applikations spezifischen Scoped-Container zu bestücken.

Dazu müssen wir in ersteinmal pro Request einen eigenen Scoped-Container haben, dazu erstellen wir eine kleine OWIN Middleware. Damit dies jetzt nicht IoC-Container spezifisch ist, nehmen wir den IDependencyResolver der schon in der WebAPI Verwendung findet.

internal class DependencyResolverMiddleWare  
{
    readonly private Func<IDictionary<string, object>, Task> m_next;
    readonly IDependencyResolver m_resolver;

    public DependencyResolverMiddleWare(Func<IDictionary<string, object>, Task> next, IDependencyResolver resolver)
    {
        m_next = next;
        m_resolver = resolver;
    }

    public async Task Invoke(IDictionary<string, object> env)
    {
        var context = new OwinContext(env);
        using (var scope = m_resolver.BeginScope())
        {
            context.Request.Set("ioc.dependencyScope", scope);
            await m_next(env);
        }
    }
}

Im Endeffekt rufen wir beim Invoke den DependencyResolver.BeginScope um den Scoped Container zu erzeugen, speichern ihn zwischen, rufen den nächsten Schritt in der Pipeline auf (am besten IdentityServer) und disposen den Scope wenn der zurück kommt.

Dieser muss nur noch in der Pipeline vor dem IdentityServer registriert werden. Dann können wir auf den zwischengespeicherten Scope in der Registration-Methode darauf zugreifen.

app.Map("/identity", idsrvApp =>  
{
    // ...
    idsrvApp.Use<DependencyResolverMiddleWare>(container.GetInstance<System.Web.Http.Dependencies.IDependencyResolver>());
    idsrvApp.UseIdentityServer(/*..*/);
});

Jetzt muss man nur noch an den Request spezfischen Scope kommen. Dazu muss man an das OwinEnviroment kommen, das IDictionary wo alles drin steht was man braucht.

Diesen kann man sich nun über den IdentityServer eigenen IDependencyResolver holen, der wird praktischerweise der Registration-Methode übergeben.

var owin = (OwinEnvironmentService)resolver.GetService(typeof(OwinEnvironmentService));  
var value = owin.Environment["keytoget"];  

Daraus könnte man sich nun direkt den Scope-Container rauspulen, jedoch muss man sich dann die die Keys wühlen und da erstmal zum Request und weiter. Zum Glück gibt es Hilfsklassen die einem den typisierten Zugriff darauf erlauben.

var owin = resolver.Resolve<OwinEnvironmentService>();  
var context = new OwinContext(owin.Environment);  
var scope = context.Request.Get<System.Web.Http.Dependencies.IDependencyScope>("ioc.dependencyScope");  

und schon ist man im Besitz des Scoped-Containers der in der Middleware erzeugt worden ist.

Zwecks einfacher Verwendung kann man dies nun schön in einer Extensionmethod unterbringen.

public static T GetInstanceFromApplicationDependencyResolver<T>(this Thinktecture.IdentityServer.Core.Services.IDependencyResolver resolver)  
{
    var owin = resolver.Resolve<OwinEnvironmentService>();
    var context = new OwinContext(owin.Environment);
    var scope = context.Request.Get<System.Web.Http.Dependencies.IDependencyScope>("ioc.dependencyScope");
    return (T)scope.GetService(typeof(T));
}

so kann man dies dann einfach verwenden.

app.Map("/identity", idsrvApp =>  
{
    var factory = new IdentityServerServiceFactory
    {
        UserService = new Registration<IUserService>(dr => dr.GetInstanceFromApplicationDependencyResolver<IUserService>()),
        ClientStore = new Registration<IClientStore>(dr => dr.GetInstanceFromApplicationDependencyResolver<IClientStore>()),
        ScopeStore = new Registration<IScopeStore>(dr => dr.GetInstanceFromApplicationDependencyResolver<IScopeStore>())
    };
    idsrvApp.Use<DependencyResolverMiddleWare>(container.GetInstance<System.Web.Http.Dependencies.IDependencyResolver>());
    idsrvApp.UseIdentityServer(new IdentityServerOptions
    {
        SiteName = "Embedded IdentityServer",
        SigningCertificate = LoadCertificate(),
        Factory = factory
    });
});

Natürlich müssen die Services und auch der IDependenyResolver im Applikations Container vorhanden sein, aber dies versteht sich von selbst.

Variante 3

Was meinst Du?

codefest.at [MS]: Women Techmakers 2015 und Workshop für Kinder

Rechtzeitig zum Weltfrauentag findet das zweite Women Techmakers Event in Österreich statt. Ziel dieses Events ist es die Awareness in Genderfragen in den STEM Disziplinen (science, technology, math & engineering) und die Sichtbarkeit von Frauen in diesen Bereichen zu erhöhen. Das Event ist offen für alle.

image

Das Event findet am 7. März bei uns im Microsoft Office statt. Es erwarten euch spannende technische Vortrage, Workshops und Diskussionen. Natürlich könnt ihr dabei jede Menge interessante Leute kennenlernen.

Neu ist heuer auch, dass ein Workshop für Kinder angeboten wird, in dem man spielerisch Spieleprogrammierung mit dem am MIT entwickelten SCRATCH lernen kann.

Mehr Infos und Anmeldung findet ihr auf WomenTechmakers.at.

Sebastian Gross: Using Google Open Auth Login in Asp.Net MVC Applications

Introduction

Open Auth is everywhere, maybe you even read my article on how to retrieve calendar events from your google calendar using open auth. In this article i would like to show you a simple way to create an open auth login for your asp.net mvc website.

Basically you can just open up visual studio and create a new asp.net mvc project and select individual user as the authentication template. Visual studio will now create a new project template for you with working examples for Google, Facebook and Microsoft open auth login.
But as you’ll quickly notice this is a very complex example which is only good for authentication, so if you want to have different information about the user (i.e. his picture) or want to perform actions in his name (post to the wall in facebook) you’re out of luck.
This is where this article comes into play. We will create an authentification mechanism which will allow us to have additional rights next to simple authentication while keeping the codebase small and clean.

Token setup

Before you can start writing code you first need to create public and private keys to authenticate your application to google. I covered this topic at my last article, so if you dont have your tokens yet, just follow the link and read through the chapter “API Setup”. Afterwards continue here.

Communication overview

So lets have a look on the order of events which will take place in our application.

  • Our application gets called and checks if the authentication cookie is set. Since its the first call to our application the cookie is not present. The application redirects the user to the login page.
  • The login page offers the user to login using open auth with google as the provider. The user clicks on the link to login via google.
  • The click directs the user to the login url /auth/googlelogin
  • The API takes the user to the google consent screen (you neet to login to your google account first)
  • The user allows our application to access the requested information (basic user info) and is being redirected back to our application
  • Now we’re back in the auth/googlelogin method and can check wether the provided google informations are known to our database. If yes -> login, if no -> signup

Project setup

Open up Visual Studio and create a new Asp.Net MVC (5) project, be sure to select an empty project template without athentication to make sure we start with a clean codebase.

Create an empty MVC Project
New Project temaplate

Create a new (almost) empty MVC Project

Of course you need some kind of database to store your registered users. I won’t cover the topic of setting up a database in this article but i would recommend you to use EntityFramework in order to create a simple database very quickly without a lot of configuration.

Now we can begin to setup our authentication methods, but since we will be using the Google API for this we need to install the Google libraries first. Just start up the NuGet Package Manager Console and install the following packages:

Install-Package Google.Apis.Auth
Install-Package Google.Apis
Install-Package Google.Apis.Auth.Mvc
Install-Package Google.Apis.Plus.v1

NuGet will now download and add the libraries to our project. After NuGet is done you should have (among others) the following libraries under your project references:

Google.Apis
Google.Apis.Auth
Google.Apis.Auth.Mvc4
Google.Apis.Auth.PlatformServices
Google.Apis.Core
Google.Apis.PlatformServices
Google.Apis.Plus.v1

Just that you know, we don’t actually need the Plus.v1 package for successful authentication, but since i would like to know the users name, profile picture and other basic information i added this dependency too. Without this package we (as the application) would only get to know the google account id, which is the E-Mail Address by default. if this is enough for you just don’t add the last package to your project.

Authentication

First we need some Model to hold our user information which (if you use EntityFramework) also can be used as an Entity-Class to access the database. This could look something like this:

public class UserProfile
{
    [Required(ErrorMessage="Please tell us your name")]
    [DisplayName("Your name")]
    public string Name { get; set; }

    [Required(ErrorMessage = "Choose a displayname for you")]
    [DisplayName("Displayname")]
    public string DisplayName { get; set; }

    public string Picture { get; set; }

    [Required(ErrorMessage = "Please enter an E-mail address")]
    [DisplayName("E-Mail-Address")]
    [RegularExpression("([a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z0-9]+)", 
        ErrorMessage = "Please provide a valid E-mail address")]
    public string Email { get; set; }

    [Key]
    [Required]
    public string UniqueId { get; set; }

    public IdentityProvider Provider { get; set; }
}

//maybe we will support more providers later ;)
public enum IdentityProvider
{
    Google = 0,
    Twitter = 1,
    Facebook = 2
}

Nothing special here, just some properties to hold the basic user information including some validation tags to make MVC do the dirty work.

Lets go ahead and create the AuthController with the GoogleLogin method:

public async Task<ActionResult> GoogleLogin(CancellationToken cancelToken)
{
    var result = await new AuthorizationCodeMvcApp(this, 
                    new GoogleAuth()).AuthorizeAsync(cancelToken);

    if (result.Credential == null)
        return new RedirectResult(result.RedirectUri);

    var plusService = new PlusService(new BaseClientService.Initializer
    {
        HttpClientInitializer = result.Credential,
        ApplicationName = "MyApp"
    });
	
    //get the user basic information
    Person me = plusService.People.Get("me").Execute();

    //check if the user is already in our database
    UserProfile account = _db.Users.FirstOrDefault(u => u.UniqueId.Equals(me.Id));
    if(account == null){
        //this is a new user -> register view
        UserProfile profile = new UserProfile(){
            Name = me.Name.GivenName + " " + me.Name.FamilyName,
            Email = me.Emails.ElementAt(0).Value,
            DisplayName = me.DisplayName,
            Picture = me.Image.Url,
            UniqueId = me.Id,
            Provider = IdentityProvider.Google
        };
        TempData["newProfile"] = profile; 
        return RedirectToAction("register", "account");
    }else{
        //this is a registered user -> login
    }
    return RedirectToAction("index", "home");
}

The important part is happening in the first lines of this Action-Method. We create a new AuthorizationCodeMvcApp and provide an new instance of GoogleAuth to it. The GoogleAuth Class extends the FlowMetadata Class provided by the Google API and overrides Flow property which provides the client secret and the needed app privileges to the API.

public class GoogleAuth : FlowMetadata
{
    private static readonly IAuthorizationCodeFlow flow =
        new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
        {
            ClientSecrets = new ClientSecrets
            {
                ClientId = "my-app-client-id.apps.googleusercontent.com",
                ClientSecret = "my-app-client-secret"
            },
            Scopes = new[] {
                PlusService.Scope.UserinfoEmail,
                PlusService.Scope.UserinfoProfile
            },
            DataStore = new FileDataStore("Google.Apis.Sample.MVC")
        });

    public override string GetUserId(Controller controller)
    {
        return "user1";
    }

    public override IAuthorizationCodeFlow Flow
    {
        get { return flow; }
    }
}

The Google API provides an own controller which is responsible for receiving the authentication response. In order to use it we need to provide our implementation of FlowMetadata (see above) to it:

public class AuthCallbackController :
        Google.Apis.Auth.OAuth2.Mvc.Controllers.AuthCallbackController
{
    protected override Google.Apis.Auth.OAuth2.Mvc.FlowMetadata FlowData
    {
        get { return new GoogleAuth(); }
    }
}

And thats basically it. Since the API is doing most of the heavy lifting of redirecting and receiving the callback we’re finished here. Just add a Db-Provider (i.e. EntityFramework) and some Views alongside with some Account-managing-Controller and you’re ready to go.

You can find a working web application using this example in my github repo.

codefest.at [MS]: Neue OneDrive API

Es geht dahin: Microsoft hat die neue OneDrive API veröffentlicht, mit welcher Developer OneDrive in eigene Apps integrieren können. Diese ist für alle größeren Plattformen wie Web, Windows, iOS und Android verfügbar. Mit der neuen RESTful API können so Daten aus und in den Microsoft Cloud Speicher eines Benutzers gelesen und geschrieben werden.

Hier geht es zur Ankündigung im blog.onedrive.com: The new OneDrive API

image

Der Download ist auf GitHub verfügbar: Introducing the new OneDrive API

Microsoft selbst setzt die neue OneDrive API auch für eigene Projekte ein. Developer können so die gleiche Bibliotheken wie Microsoft benutzen und profitieren von neuen Versionen.

Unter aka.ms/OneDriveAPI gibt es die Dokumentation und Code Samples, wie etwa das Beispiel Picker and saver SDKs, welches zeigt, wie man Dateien liest und schreibt.

Cool finde ich auch die interaktive API Console, wo man gleich ausprobieren kann…

image

Hinweis: OneDrive ist nicht ident mit OneDrive for Business – welches den persönlichen Speicher in Office 365 bereitstellt (und eigentlich eine SharePoint Site ist). Dafür gibt es auch schon bereits mit der Office 365 API eine Bibliothek, siehe hier.

Viel Spaß beim Ansehen der neuen OneDrive API!

Manfred Steyer: Folien und Quellcode zu meinem Vortrag über Microservices mit ASP.NET MVC 6 auf der BASTA! Spring 2015

Nachfolgend findet man meine Folien und Beispiele, die ich heute bei meinem Vortrag über Microservices mit ASP.NET MVC 6 und Azure Service Bus auf der BASTA! Spring 2015 verwendet habe:


Code-Inside Blog: FAKE: Running xUnit Tests with FAKE without knowing a tiny bit of F#

This is a follow-up to my first FAKE post “FAKE: Building C# projects without knowing a tiny bit of F#”.

xUnit Test Project

We start with a simple test project, which is basically a normal library project, and add xUnit via NuGet.

x

The actual test is just stupid, but should work for the demo:

public class FoobarTests
{
    [Fact]
    public void DoAStupidTest()
    {
        Assert.True(true);
    }
}

Get the xUnit Runners

Next we need the xUnit runner (to run the tests…), which can be installed via NuGet on the Solution Level.

x

If you do this via the UI you should see a package.config in your solution directory:

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="xunit.runners" version="1.9.2" />
</packages>

Adding the test to the build.fsx script

This time I will only show the important parts for the tests (skipping the targets from the first post).

// include Fake lib
...

// Properties
...
let artifactsTestsDir  = "./artifacts/tests/"

// Targets
Target "BuildTests" (fun _ ->
trace "Building Tests..."
!! "**/*Tests.csproj"
  |> MSBuildDebug artifactsTestsDir "Build"
  |> Log "TestBuild-Output: "
)

Target "RunTests" (fun _ ->
    trace "Running Tests..."
    !! (artifactsTestsDir + @"\*Tests.dll") 
      |> xUnit (fun p -> {p with OutputDir = artifactsTestsDir })
)
...
// Dependencies
"Clean"
  ==> "BuildApp"
  ==> "BuildTests"
  ==> "RunTests"
  ==> "Default"

// start build
RunTargetOrDefault "Default"

This time I added a new property, which points to the build output of the test project:

let artifactsTestsDir  = "./artifacts/tests/"

This path is now used in the build target. With this call I build all projects that ends with Tests.csproj.

Target "BuildTests" (fun _ ->
trace "Building Tests..."
!! "**/*Tests.csproj"
  |> MSBuildDebug artifactsTestsDir "Build"
  |> Log "TestBuild-Output: "
)

Now we need the runner. FAKE already have a xUnitHelper, so we don’t need to call the runner and check the response - so this is really, really easy:

Target "RunTests" (fun _ ->
    trace "Running Tests..."
    !! (artifactsTestsDir + @"\*Tests.dll") 
      |> xUnit (fun p -> {p with OutputDir = artifactsTestsDir })
)

Pointed to the test directory and FAKE will do all the hard work.

The last change is the Build-Dependency-Graph, which now contains the steps for building the test project and run the tests.

// Dependencies
"Clean"
  ==> "BuildApp"
  ==> "BuildTests"
  ==> "RunTests"
  ==> "Default"

In this demo FAKE will build the test project two times, but in real life I would split the source and the test projects in different directories to get a more granular control what I want to build.

Invoke the build.fsx

I don’t need to change anything inside the batch file and can just invoke the batch:

Package "FAKE" is already installed.
C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\.nuget\nuget.exe  "install" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\.nuget\packages.config" "-OutputDirectory" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\packages"
All packages listed in packages.config are already installed.
C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\.nuget\nuget.exe  "install" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\LetsUseFake.Tests\packages.config" "-OutputDirectory" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\packages"
All packages listed in packages.config are already installed.
Building project with version: LocalBuild
Shortened DependencyGraph for Target Default:
<== Default
<== RunTests
<== BuildTests
<== BuildApp
   <== Clean

The resulting target order is:
 - Clean
 - BuildApp
 - BuildTests
 - RunTests
 - Default
Starting Target: Clean
Cleanup...
Deleting contents of .\artifacts\
Finished Target: Clean
Starting Target: BuildApp (==> Clean)
Building App...
... (MSBuild for the Console and Test Project)
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.exe
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.exe.config
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.pdb
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.Tests.dll
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.Tests.pdb
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\xunit.dll
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\xunit.xml
Finished Target: BuildApp
Starting Target: BuildTests (==> BuildApp)
Building Tests...
... (MSBuild for the Test Project) ...
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.dll
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.pdb
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\xunit.dll
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\xunit.xml
Finished Target: BuildTests
Starting Target: RunTests (==> BuildTests)
Running Tests...
C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\packages\xunit.runners.1.9.2\tools\xunit.console.clr4.exe "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.dll"
xUnit.net console test runner (64-bit .NET 4.0.30319.0)
Copyright (C) 2013 Outercurve Foundation.

xunit.dll:     Version 1.9.2.1705
Test assembly: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.dll

1 total, 0 failed, 0 skipped, took 0.512 seconds
Finished Target: RunTests
Starting Target: Default (==> RunTests)
Default Target invoked.
Finished Target: Default

---------------------------------------------------------------------
Build Time Report
---------------------------------------------------------------------
Target       Duration
------       --------
Clean        00:00:00.0219014
BuildApp     00:00:01.3671003
BuildTests   00:00:00.7714649
RunTests     00:00:01.7558856
Default      00:00:00.0007886
Total:       00:00:03.9697467
Status:      Ok
---------------------------------------------------------------------

The resulting build artifact:

x

You can find the complete sample & build script on GitHub

Manfred Steyer: Folien und Beispiele zu meinem Workshop über Entity Framework auf der BASTA! Spring 2015

Nachfolgend meine Beispiele und Folien von unserem Entity Framework Workshop, den wir gestern auf der BASTA! Spring 2015 gehalten haben:

codefest.at [MS]: Neue CTP Versionen von Visual Studio 2015 und Team Foundation Server 2015

Nicht nur das Microsoft Band SDK Preview ist neu, sondern auch die nächste CTP Version 6 von Visual Studio 2015 und CTP des TFS 2015 sind verfügbar, schreibt John Montgomery, Director of Program Management, Visual Studio Platform, im Visual Studio Blog.

CTP Versionen sind nicht für den Produktiveinsatz und nur zum Testen und für Feedback an das Produktteam da. Hier geht es zur Original-Ankündigung: Visual Studio 2015 CTP 6 and Team Foundation Server 2015 CTP Released.

Die Downloads sind auf http://www.visualstudio.com/downloads/visual-studio-2015-ctp-vs verfügbar.

image

Hier geht es zu den Visual Studio 2015 CTP 6 release notes, zu den Bugfixes Visual Studio 2015 CTP 6 KB article und zu den Team Foundation Server 2015 CTP release notes und Bugfixes Team Foundation Server 2015 CTP KB article.

Einige Neuerungen in VS 2015 CTP 6 betreffen Verbesserungen in ASP.NET, Xamarin, den Visual Studio Tools for Apache Cordova, CodeLens, NuGet, XAML UI Debugging, Visual Studio Emulator for Android und die Architecture Tools.

Viel Spaß mit den neuesten CTP Versionen und dem Erforschen der neuen verbesserten Features in Visual Studio 2015!

PS: Developer können Visual Studio Online kostenfrei nutzen, siehe auch What is Visual Studio Online?

Marco Scheel: Links for 2015-02-23 [del.icio.us]

codefest.at [MS]: Microsoft Band SDK Preview ist verfügbar

Microsoft Band Besitzer und Developer werden sich darüber freuen, dass nun das Microsoft Band SDK Preview verfügbar ist! Die Details hierzu findet ihr hier:

http://developer.microsoftband.com/

image

 

“The Microsoft Band SDK Preview gives developers access to the sensors available on the band, as well as the ability to create and send notifications to tiles. Enhance and extend the experience of your applications to your customers' wrists. More at http://developer.microsoftband.com/.” siehe https://www.nuget.org/packages/Microsoft.Band/1.3.10219-preview

Cool ist, dass das Microsoft Band SDK als NuGet Package für Visual Studio verfügbar ist: Einfach in der Package Manager Console installieren:

PM> Install-Package Microsoft.Band -Pre

Danke an Christian Nagel für den Tipp zum SDK via Twitter!

 

Updates:

Laut den ersten Meinungen in den Developer Foren und Social Media kann mit der SDK-Preview jedoch nur Textausgabe am Band erfolgen. Mal die Möglichkeiten erforschen…

Georg Binder hat einige weitere Neuerungen zusammengefasst: Neu ist das hübsche Microsoft Health Dashboard, https://dashboard.microsofthealth.com und das Tracking von Fahrradfahren (das jedoch zuerst als Tile hinzugefügt werden muss). Das Band muss aktualisiert werden, siehe Georgs´ Tipps hier:

image

Das Microsoft Band hat nun auch ein Keyboard bekommen, siehe Überblick von TheVerge:
Microsoft Band just got a major update

…es wird Zeit fürs Update. Zwinkerndes Smiley

Code-Inside Blog: FAKE: Building C# projects without knowing a tiny bit of F#

MSBuild is the default build engine in the .NET world, but if you do more with MSBuild you will find yourself in a XML-mess, so that’s the reason why I tried out FAKE. You can find a couple of MSBuild related posts here.

Enough from MSBuild, now meet FAKE:

  • A DSL for build tasks (e.g. build following projects, copy stuff, deploy stuff etc.)
  • Active community, OSS & written in F#
  • You don’t need to learn F# for using it (at least the basic tasks are easy)
  • You can get FAKE via NuGet
  • Before we begin you might want to check out the actual website of FAKE

Our goal: Building, running tests, package NuGet Packages etc.

Let’s start with the basics: Building

I created a new console application and downloaded the NuGet Command-line utility:

x

The build.fsx script

So, now we get in touch with a very simple build script. (Scroll down to read the description of each section)

// include Fake lib
#r "packages/FAKE/tools/FakeLib.dll"
open Fake

RestorePackages()

// Properties
let artifactsDir = @".\artifacts\"
let artifactsBuildDir = "./artifacts/build/"

// Targets
Target "Clean" (fun _ ->
    trace "Cleanup..."
    CleanDirs [artifactsDir]
)

Target "BuildApp" (fun _ ->
   trace "Building App..."
   !! "**/*.csproj"
     |> MSBuildRelease artifactsBuildDir "Build"
     |> Log "AppBuild-Output: "
)

Target "Default" (fun _ ->
    trace "Default Target invoked."
)

// Dependencies
"Clean"
  ==> "BuildApp"
  ==> "Default"

// start build
RunTargetOrDefault "Default"

The top line is a reference to the FAKE helper libraries (included via the #r keyword) and a ‘using’:

#r "packages/FAKE/tools/FakeLib.dll"
open Fake

The next important line is the RestorePackages()-line. With this line all NuGet packages will be restored from NuGet.org or your own NuGet-Repository. If you check-in your NuGet packages then you don’t need this.

Then I define some general properties, e.g. my build output folders:

let artifactsDir = @".\artifacts\"
let artifactsBuildDir = "./artifacts/build/"

Now the interesting part: Like in MSBuild you define a couple of “Targets”:

Target "Clean" (fun _ ->
    trace "Cleanup..."
    CleanDirs [artifactsDir]
)

Target "BuildApp" (fun _ ->
   trace "Building App..."
   !! "**/*.csproj"
     |> MSBuildRelease artifactsBuildDir "Build"
     |> Log "AppBuild-Output: "
)

Target "Default" (fun _ ->
    trace "Default Target invoked."
)

The first target cleans the artifactsDir via the FileHelper. The next one is responsible for calling MSBuild (which builds the actual project) (via MSBuildHelper). This is maybe the most awkward part of the build script for a C# dev, but this “pipelining” is part of F#’s nature. I can’t explain it right now, but it works (I didn’t lie when I said that I have not a tiny bit of knowledge about F#).

At the end of the file you define the dependency graph for each target:

"Clean"
  ==> "BuildApp"
  ==> "Default"

After that we invoke the ‘Default’ target with this line:

RunTargetOrDefault "Default"

Invoke the build.fsx

Now that we have our project in place and a valid FAKE script we need to invoke the script. The easiest option on Windows is a batch file like this:

@echo off
cls
".nuget\NuGet.exe" "Install" "FAKE" "-OutputDirectory" "packages" "-ExcludeVersion"
"packages\FAKE\tools\Fake.exe" build.fsx

First we need to load FAKE via NuGet and after that we invoke our build.fsx file with Fake.exe.

Now you or any build machine can invoke the batch file and start the build!

Our first FAKE script!

The output is very well formatted and should explain the mechanics behind it good enough:

Package "FAKE" is already installed.
Building project with version: LocalBuild
Shortened DependencyGraph for Target Default:
<== Default
<== BuildApp
<== Clean

The resulting target order is:
- Clean
- BuildApp
- Default
Starting Target: Clean
Cleanup...
Creating C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\
Finished Target: Clean
Starting Target: BuildApp (==> Clean)
Building App...
Building project: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\LetsUseFake\LetsUseFake.csproj
... (standard MSBuild output, nothing special...)

Time Elapsed 00:00:01.24
AppBuild-Output: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\build\LetsUseFake.exe
AppBuild-Output: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\build\LetsUseFake.exe.config
AppBuild-Output: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\build\LetsUseFake.pdb
Finished Target: BuildApp
Starting Target: Default (==> BuildApp)
Default Target invoked.
Finished Target: Default

---------------------------------------------------------------------
Build Time Report
---------------------------------------------------------------------
Target     Duration
------     --------
Clean      00:00:00.0032838
BuildApp   00:00:01.5844651
Default    00:00:00.0007512
Total:     00:00:01.6153969
Status:    Ok
---------------------------------------------------------------------

The resulting build artifact:

x

You can find the complete sample on GitHub

Kazim Bahar: Mobile Computing vor 22 Jahren und heute

Neulich hatte ich wieder mal meine Retro-Rechnern entstaubt, u.a. meinen ersten mobilen Rechner, den Toshiba T6400DXC. Damals war das einer...

Golo Roden: Unscharf: Den Nagel im Heuhaufen suchen

Shell-Skripte zu schreiben ist eine der einfachsten Aufgaben unter Node.js und io.js, Module wie commander und buntstift übernehmen die schwierigen Aufgaben: das Zerlegen und Auswerten von Parametern und das Formatieren der Konsolenausgabe. Doch wie steht es um das Erkennen von unbekannten Kommandos?

Uli Armbruster: Aus der Praxis – Wie sich unser Unternehmen durch Social Media verändert hat

Social Media ist nur ein Trend

Ich bin vor einigen Monaten aus unserer Social Media Gruppe (meine früheren Berichte zu unserer Arbeit) ausgetreten. Nicht weil ich darin keinen Sinn mehr gesehen oder weil ich nichts mehr hätte beisteuern können. Vielmehr liegen meine Stärken mehr darin Ideen zu entwickeln und einzuführen, als diese bis zum Schluss zu begleiten. Schluss bedeutet hierbei bis die letzten Kollegen „überzeugt“ wurden. Die Autorinnen Rising Linda und Mary Lynn sprechen in ihrem tollen Buch Fearless Change von sogenannten “Innovators” und “Early Adopters”  (einen Einführungs-Podcast dazu gibt es hier). Mit Laggers werden übrigens Persönlichkeitstypen bezeichnet, die nicht zu überzeugen sind. Dazwischen reihen sich die Early Majority und Late Majority ein.

Nachdem vor kurzem die Gruppe überein kam sich aufzulösen, sprach mich eine Kollegin an. Sie ist der Meinung, dass viele Ideen respektive Ansätze dabei sind, bei denen es sich lohnt diese weiterzuführen. Zum Beispiel unsere Textwerkstätten. Sie wollte wissen, wie ich über die Entscheidung denke und ob ich einen Vorschlag hätte, um die Gruppe neu auszurichten. Vor allem da sich die bisherigen Ergebnisse sehen lassen konnten und sie die Art der interdisziplinären Kollaboration im Vergleich zur (homogenen) Abteilungsarbeit spannend fand.

Nun wird der ein oder andere Leser vermutlich denken: Das war doch klar. Social Media und Unternehmen passen nicht zusammen. Das ist ein vorübergehender Trend, den jeder früher oder später abhaken muss!

Halte an deinen Zielen fest, bleibe dabei aber flexibel

Mein Sicht darauf war dann doch eine andere, was ich meiner Kollegin wie folgt erklärt habe: Das Ende der Social Media Gruppe ist lediglich dem Namen und der Beschränkung auf eine festgelegte Personengruppe geschuldet. Die Idee dahinter hat längst bei uns Wurzeln geschlagen. Denn inzwischen machen wir unternehmensweite Open Spaces, bei denen die “Lehrer” und “Schüler” Rollen kontinuierlich wechseln und die Agenda von allen Mitarbeitern mitbestimmt wird. Am Vormittag erzählt noch der Kollege aus Berlin umfassend über ein neues Produkt und die Kollegin aus Nürnberg hört zu, am Nachmittag werden die Rollen getauscht und die Kollegin referiert über Werkstoffe und deren Einsatzszenarien.

Die Meetings unserer Marketing- & Einkaufs-Abteilung sind inzwischen für alle geöffnet. Durch gezielte Einladungen abteilungsfremder Kollegen soll das gefördert werden. Themen- und Projektvorschläge werden in den Wochen zuvor von allen Mitarbeitern im Wiki zusammengetragen. Jedem „Stakeholder“ ist freigestellt Input zu liefern.

Ein weiteres Beispiel ist unser Arbeitsplatztausch, bei dem jeder Mitarbeiter mindestens 1x jährlich in eine andere Abteilung wechselt, um über den eigenen Tellerrand hinaus zu schauen. Und natürlich schreibt der Kollege seinen Erfahrungsbericht in unseren Corporate Blog. Stephan ist übrigens kein Mitglied der Social Media Gruppe! Damit ist er einer von vielen, die bereits gebloggt haben.

Mir fallen auf Anhieb noch viele weitere Ausprägungen ein, doch unser Erfolg zeigt sich meiner Meinung nach am besten darin, dass ich kürzlich beim Vorbeigehen nicht umhin kam zu hören, wie der Einkaufsleiter in Nöttingen am Telefon einer Kollegin aus Frankfurt wie selbstverständlich mitteilte: “Das kannst du alles im Wiki nachlesen und dann ggf. ergänzen”. Dass der Einkaufsleiter noch ein paar Wochen zuvor seine Mitarbeiterin – selbige ist Teil der Social Media Gruppe und daher bestens geschult im Umgang mit dem Wiki – gefragt hat wie der Inhalt einzupflegen ist, brachte mich dann doch zum Schmunzeln. Mit einem Video zur Integration der Wiki-Inhalte in unser Warenwirtschaftssystem habe ich die Vernetzung bei uns bereits illustriert.

Neben einigen weiteren Beispielen wies ich meine Kollegin noch darauf hin, dass sie selbst erst kürzlich gegenüber dem Vorgesetzten den Wunsch geäußert hat in ihrer Abteilung regelmäßige Retrospektiven zur Verbesserung der Prozesse umzusetzen. Ebenfalls ein Ansatz, den wir bei der Social Media Gruppe einsetzten.

tree-200795_1280

Quelle: http://pixabay.com/de/baum-struktur-netzwerke-internet-200795/

Fazit:

Nur diejenigen, die Social Media nicht auf Werkzeuge wie Facebook und Twitter reduzieren, sondern die Ansätze und Gedanken dahinter verstehen, können das der Sache inhärente Potential nutzen. Die Schulungs-Agenda sollte eben nicht mehr nur vom Abteilungsleiter definiert oder Geschäftsprozesse durch die Geschäftsleitung festgelegt werden. Stattdessen muss sich eine Kultur etablieren, bei der die Fähigkeiten aller genutzt werden und das Wissen der Masse kontinuierlich geteilt wird. Dadurch entsteht eine Lernkultur, bei der Informationen nach Belieben beigesteuert und herausgezogen werden können. Social Media ist insofern auch keine neue Idee, jedoch sind inzwischen viele digitale – teils populäre, teils weniger bekannte – Werkzeuge auf dem Markt. Mit dem inzwischen signifikanten und noch weiter steigenden Anteil der sogenannten Wissensarbeit ist nicht mehr die Frage, ob man auf den Zug aufspringen sollte. Die Herausforderung liegt darin die passenden Werkzeuge zu evaluieren und eine entsprechende Unternehmenskultur zu etablieren. Denn wer nicht mit der Zeit geht, geht mit der Zeit.

Wie stehts bei euch um Change Management, Social Media und Innovationen? Welche Werkzeuge nutzt ihr? Seid ihr schon auf einem guten Weg oder springt ihr gar nicht auf den Zug auf?


Einsortiert unter:CIO Topics, German, Projects Tagged: Social Media

Marco Scheel: Links for 2015-02-22 [del.icio.us]

Code-Inside Blog: ESENT Database Viewer: ESENT Workbench

I already blogged about the ancient old ESENT Database, which is still supported and will also be available in Windows 10, so you are safe to use it. Also the ManagedESENT project is alive and somewhat in active development.

With the ManagedESENT project you can store your data inside a ESENT database very easy*, but what if you want to look inside the ESENT database?

* … well… the interface is still awkward for a C# dev, but it is possible to build a nice abstraction around it. Here can you see a sample from the project.

ESENT Database Viewer: ESENT Workbench

I found a very promising OSS project called ESENT Workbench. You can build the source yourself or just use the release.

x

x

Hope this helps and if you know any other useful tools around the ESENT database just write it in the comments.

Marco Scheel: Links for 2015-02-20 [del.icio.us]

Sven Hubert: Microsoft meets embedded world

Bei den Themen embedded Software und Software im industriellen Umfeld denken die wenigsten Menschen sofort an Microsoft. Diejenigen die es tun, reagieren meist mit Ablehnung oder zumindest wenig begeistert – und das völlig zu unrecht. Gehören Sie in eine der beiden genannten Gruppen? Falls ja besuchen Sie uns auf der embedded World in Nürnberg Halle 4 / 4-240 und lassen Sie sich vom Gegenteil überzeugen.

 

Mit dem Team Foundation Server bietet Microsoft ein ALM Werkzeug, welches nicht nur im Bereich der Applikations-Entwicklung eingesetzt werden kann. Lesen Sie hierzu im Vorfeld unsere Fallstudien zum Einsatz des TFS bei den Firmen CLAAS und SIEMENS. Welche Innovationskraft im Einsatz von Microsoft Technologien im industriellen Umfeld steckt, wird im MC6-Bedienkonzept der Industrieroboter vom Spritzgussmaschinenanbieter KraussMaffei sichtbar (Case Study KraussMaffei).

Microsoft meets embedded world is a post from: AIT Blog

codefest.at [MS]: Rasch über ASP.NET vNext informieren

Für .NET und ASP.NET Developer werden die Neuerungen in ASP.NET vNext (bzw. ASP.NET 5) sehr spannend.

Natürlich gibt es hierzu viele Fragen… Was ist Neu und was ändert sich? Welche Runtimes gibt es? Wird es ASP.NET Webforms auch in Zukunft geben? Wie sieht es mit der angekündigten Interoperabilität aus? Was bedeutet HTTP2? Wird ASP.NET vNext tatsächlich schneller? Und vieles mehr…

Diese grundsätzlichen Fragen über ASP.NET vNext beantwortet das freie Mini-eBook von Tools-Hersteller Telerik kurz und bündig, downzuladen von dieser Webseite:

http://www.telerik.com/campaigns/aspnet/vnext

image

Es ist nur eine Angabe des Namens, einer E-Mail Adresse und des Landes erforderlich, dann startet der Download des knackigen 1.4MB eBooks mit 25 Seiten. Rasch informieren!

Viel Spaß damit!

codefest.at [MS]: Kostenloses Azure Essentials eBook

Das 246-starke eBook (eng.) deckt in 9 Kapiteln sowohl Themen für Entwickler als auch für IT-Microsoft Azure Essentials: Fundamentals of AzureProfessionals ab. Behandelt werden: Azure Übersicht, Azure Websites & Cloud Services, Azure Virtual Machines, Azure Storage, Azure Virtual Networks, Databases, Azure Active Directory, Management Tools und Business Cases.

Erschienen am: 12. Feb. 2015

Microsoft Azure Essentials: Fundamentals of Azure

Marco Scheel: Links for 2015-02-18 [del.icio.us]

codefest.at [MS]: Eine Beispiel-Webapplikation für Microsoft Azure in 150 Min. kompakt erklärt

.. Interesse ?

Unser Partner ANECON Software Design und Beratung GmbH hat sich einige Gedanken gemacht wie unterschiedliche Aspekte bei der Entwicklung einer Cloudapplikation anschaulich an einem Beispiel erklärt werden können. In drei Vortragsteilen die die Bereiche Anforderungen (User Stories), Umsetzung/Test und Betrieb/Performance abdecken schlüpfen die Vortragenden ANECON Experten in die Rollen des Entwicklers, Testers oder Product Owners um Praxisnah die Umsetzung eines solchen Projektes zu demonstrieren.

Wir würden uns freuen wenn Sie uns bei der Entstehung der Applikation, am 3.3.2015 (Vormittags) begleiten: Anmeldung

Christian Binder [MS]: Neue Features in C# 6.0

Mein TechTalk  mit Patric zun den neuen C# 6.0 Features :

image

und hier der Blogpost dazu.

Chris Smile

Christian Binder [MS]: TechTalk - Word to TFS

Mein TechTalk mit Thomas Rümmler zur Word to TFS Integration.

image

Chris

Marco Scheel: Links for 2015-02-17 [del.icio.us]

Code-Inside Blog: Developer Conference in Berlin: Spartakiade

So this is now more or less a “pure” blog in English, but this post might be more interesting for German-Speaking developers, so I will switch to German, but don’t be shy: If you are interested in one of the conference workshops just get in touch with the conference organizers.

x

Spartakiade 2015, Berlin / März

Die Community-Konferenz Spartakiade vom 21.–22. März 2015 in Berlin bietet Workshops zum Mitmachen an. Bei der Spartakiade kennt man keinen Zeitdruck und lässt Teilnehmer sich ausführlich und intensiv mit einem Thema beschäftigen. Die Dauer der Workshops geht weit über die Vortragsdauer der üblichen 60–90 Minuten auf “klassischen” Konferenzen hinaus, die meisten Workshops sind ganztägig. Und weil das wie beim Sport herausfordernd werden kann, heißt die Konferenz “Spartakiade” – namentlich auch bekannt als Sportveranstaltung.

Workshops sind für jeden Schwierigkeitsgrad aus der Softwareentwicklung dabei – etwas für Leichtathleten, Kraftsportler oder Mehrkämpfer und die ganze Mannschaft. Inhaltlich geht es um Agile Games, Event Storming, Git, Node.js / AngularJS, Raspberry Pie, Funktionale Programmierung, Microsoft Lync und vieles mehr.

Die Anmeldung ist ab sofort möglich unter: spartakiade.org

Ich selbst bin leider nicht dabei, aber ich hatte die Gelegenheit letztes Jahr ein paar Stunden da zu verbringen und ich habe vollstes Vertrauen in die Workshop Leiter. Wer Zeit hat: Hingehen!

Johannes Renatus: JavaScript Unit Tests mit Jasmine und Visual Studio (Resharper oder Cutzpah)

Bisher habe ich Unit Tests nur für .Net (C#) geschrieben, inzwischen nimmt aber auch der Clientseitige Code in Webanwendungen durch Frameworks wie AngularJS immer bessere Strukturen an, die sich ebenfalls sehr gut testen lassen. Außerdem gibt es sehr gute Plugins für Visual Studio (VS) die einem das Ausführen von JavaScript Unit Tests direkt im VS […]

Uli Armbruster: Nachgefragt – Clean Code Interview mit Ralf und Stefan

In einem Online Interview habe ich Ralf Westphal und Stefan Lieser, die Gründer der Clean Code Developer School, zum Thema Clean Code befragt. Herausgekommen ist eine Aufnahme, die es jetzt auf YouTube gibt. Die Fragen wurden nicht vorab abgesprochen, um eine Gesprächsatmosphäre zu schaffen, wie es sie bei einer Kaffeepause gibt.

Es war ein toller Gedankenaustausch. Danke nochmal ihr zwei!

Zum Video

Zum Video

Fragen

  • Wenn ihr euch für eine Konferenz entscheiden müsstet, welche wäre das?
  • Community vs. Freizeit: Wie ist das vereinbar
  • Wann ist Clean Code noch sinnvoll und wann verschlimmbessere ich nur noch?
  • Macht Clean Code Sinn, wenn die Kollegen nicht mitziehen?
  • Wird das Schreiben von gutem Code mit der Zeit einfacher?
  • Ist guter Code relativ?
  • Was erwartet ein Arbeitgeber, wenn er Clean Code in der Stellenausschreibung aufführt?
  • Was kann ich von einem Bewerber erwarten, wenn er Clean Code in der Stellenausschreibung aufführt?
  • Verschiedene Ansätze für bessere Architektur, z.B. Flow Design
  • Brauche ich für Flow Design einen IoC Container?

Für die Zukunft sind weitere Interviews geplant:

  • Mit Daniel Marbach zu Machine.Specifications
  • Mit Tilman Börner zur dotnet pro
  • Mit Steffen Forkmann zur paket

Falls ihr noch Ideen habt, dann schreibt sie in die Kommentare.


Einsortiert unter:Development, German Tagged: Clean Code, Interview, Video

codefest.at [MS]: Coding for Office 365

Letzte Woche machte die Microsoft Office 365 Summit Roadshow Stopp in Amsterdam. Der Summit und Mitglieder der Microsoft Office-Produktgruppe informierte an zwei Tagen in über 60 Sessions IT-Pros und Developer über den aktuellen Stand der Entwicklung in Office 365, siehe http://summit.office.com/events/office-365-summit-amsterdam.

image

Der Office 365 Summit

Die Veranstaltung fand nahe des Amsterdam City Centers in der “Passenger Terminal Station” und im Mövenpick Hotel mit fast 1.300 Teilnehmern statt, hier ein paar visuelle Eindrücke vom Event.

amsterdam_summit amsterdam_summit_registration
WP_20150212_025 WP_20150212_024

Office 365 als Software-as-a-Service

Die aktuellen Zahlen von Office 365 sind immer wieder beeindruckend: Derzeit laufen die Office 365 Services auf mehr als 1 Million (!) Servern in weltweit mehr als 100 Microsoft Datacentern. Der Aufwand für den Betrieb und den Software-Release Cycle sind ebenfalls eindrucksvoll. Das Bild rechts zeigt einen Server-Container mit tausenden Servern wo gerade eine Klimaanlageneinheit montiert wird. In Datacentern dieser Generation sind solche Container sind in wenigen Stunden montiert und rasch einsatzbereit.

datacenters datacenters2

Unter anderem waren einige interessante Informationen aus der Keynote zu erfahren. Microsoft hat gelernt dass alle Dienste voll automatisiert ablaufen müssen. Um die 99.9% Verfügbarkeit der Services zu garantieren, beträgt die mögliche Wartungszeit nur etwa 40 Minuten pro Monat – ein ziemlich kleines Wartungsfenster.

Ein interessanter Aspekt ist, dass ein durchschnittlicher Office 365 Server (etwa Exchange od. SharePoint) nur zwei Wochen lang “lebt” und danach neu instanziert wird. Das bedeutet, offensichtlich wird im Regelfall kein Patching betrieben, sondern regelmäßiges neues Erstellen von Servern aus Images. Somit gibt es sehr kurze Release-Zyklen von teilweise nur zwei Wochen für eine neue Office 365 Version. Ein weiterer Vorteil ist, dass so alle Server weltweit mehr oder minder am gleichen Stand sind.

Für Software Entwickler

Für Developer bietet Office 365 als SaaS eine Vielzahl an Möglichkeiten die Dienste zu nutzen und selbst Applikationen mit Integration zu Office 365 zu schreiben. Wir haben hier im Blog bereits über einige Möglichkeiten von SharePoint und Office Apps (siehe u.a. hier) und die neue Office 365 APIs (siehe hier) beschrieben.

Eine gute Gelegenheit hier den aktuellen Status zusammenzufassen:

  • Die Office 365 APIs sind seit letztem Dezember final verfügbar. Hier geht es zum Download:
    Microsoft Office 365 API Tools for Visual Studio 2013
    image
    Im Vergleich zu den Preview Versionen wird nun kein Beispiel Code für den Zugriff auf Mail, Calendar und Contacts mehr generiert. Hier geht es zur Dokumentation im MSDN.
  • Die Office Developer Tools for Visual Studio enthalten SDKs mit Bibliotheken für .NET und JavaScript, die einen Wrapper für Office 365 REST Services bereitstellen. So ist ein einfacher Weg möglich, um auf Office 365 Daten zuzugreifen. Die SDKs sind für ASP.NET MVC, ASP.NET Web Forms, WPF, Win Forms, Universal App, Cordova und Xamarin Projekte in Visual Studio verfügbar.
  • Eine wirklich tolle Quelle für Beispielprojekte für den Zugriff auf Office 365 ist auf GitHub zu finden, nämlich unter OfficeDev: 
    https://github.com/officedev/
    Hier sind viele, sehr aktuelle Samples für den Zugriff auf die Dienste frei verfügbar.
    image
    …und vieles mehr!
  • Mein Tipp lautet vor allem die Beispiele von “Office365 Developer Patterns and Practices” anzusehen. Hier sind viele interessante Beispielprojekte enthalten:
    https://github.com/OfficeDev/PnP
    image

Sicherheit in der Cloud

Datensicherheit gehört natürlich auch zum Betrieb von Office 365 und Azure – gerade auch für Developer.

Wie Gerwald auch hier angekündigt hat möchte ich ebenso auf ein tolles Event hinweisen:
Ende Februar findet bei Microsoft Österreich die Veranstaltung Event: So sicher ist die Cloud! statt.

image

Wer kann sollte sich die Zeit nehmen und daran teilnehmen!

Nächste Schritte

Für alle an Office 365 Interessierten empfehle ich die Teilnahme am Yammer Network mit aktuellen Neuigkeiten über Office 365 und Development unter https://www.yammer.com/itpronetwork.

Unter http://roadmap.office.com/en-us stellt Microsoft die Office 365 Roadmap öffentlich bereit.

Weitere Office 365 Neuigkeiten werden wir wohl bei den nächsten beiden großen Microsoft Konferenzen Build und Igniteerfahren!

Viel Spaß beim Experimentieren und beim Apps bauen mit den umfangreichen Office 365 Beispielen auf GitHub!

Manfred Steyer: Slides and Source-Code of my AngularJS/OAuth2-Talk at ng-NL in Amsterdam

Below you find the links to my slides and source code I've used at my talk about Authentication with AngularJS and OAuth2 at ng-NL in Amsterdam in February, 13th 2015.

Sven Hubert: Introduction to Database Lifecycle Management and why it is important for ALM

Today we are proud to have an interview between Stephanie Herr from Redgate and Stefan Mieth from AIT to talk about Database Lifecycle Management (DLM) and Application Lifecycle Management (ALM). While Microsoft gives us the SQL Server Data Tools (SSDT) as a good tooling for developing databases and the ability to store them into Team Foundation Server Version Control, it is only a entry point into the whole DLM process. Even though we already have successfully finished several database projects using this toolset and because we are always looking for better and more efficient tools, this is sometimes just not enough…

 

image

&

image

 

Stephanie is a DLM Expert, and will tell us what DLM is and how it integrates into our application development and Application Lifecycle Management.

 

Stephanie, nice to see you! Could you short introduce yourself, tell us a little about what makes you tick and what you’re focused on?


StephanieHerr

Stefanie Herr, Redgate

Thanks Stefan. I wouldn’t call myself an expert, but I’m trying to be. I still have a lot to learn…

I was a software/database developer years ago before joining Redgate. I worked on large waterfall projects that were 10 years long, and I also worked on agile projects, which I love. When I started at Redgate 6 years ago, I joined as the Project Manager for SQL Source Control. Since then, my focus has been on all Redgate’s SQL Tools and how they fit together into this process called Database Lifecycle Management. I’m particularly looking at our integrations with Microsoft, such as TFS for source controlling your database, and Team Build for bringing your database into a continuous integration process. Lately we’re also looking at Release Management for automating database deployments, while still giving teams the opportunity to review SQL scripts so that DBAs can be confident that deployments to production are safe and secure.

What makes me tick? I loved doing database development and I feel so lucky to be working on software that helps other database developers and DBAs. I also love working with great people on agile teams that can respond to users quickly.

Sounds like a good fit for everyone! So, today’s topic is DLM – Database Lifecycle Management is very important for all who try to develop their own application with a Database at the back, but I don´t think everybody is familiar with DLM. Can you give us a short description of what DLM is?

Stephanie

Database Lifecycle Management is a set of processes and tools that include the database in Application Lifecycle Management. That sounds a little too simplified… It’s all about making changes to your database and delivering those database changes to your users using a reliable, repeatable process that is integrated with the rest of your software development.

It’s important that the database is not a bottleneck when it comes to releasing your applications, especially in the world of agile development and frequent releases. We want to use tools for our database development like version control, continuous integration, and automated testing. Application developers have been taking advantage of these for years and it’s time we took advantage of them for the database. Some teams we’ve seen are even taking this to the next step and doing automated deployments or easing the deployment process by having a “one-click” process that’s repeatable and doesn’t rely on manually following a huge document (and accidentally missing a step.)

We want to make deployments simple and less scary. We want to test deployments across multiple environments that mimic production as closely as possible, so that you’re more confident that a release will go well. If possible, we want to let DBAs and Ops Teams go home at normal hours and not worry about a huge scary release that must be deployed during late maintenance windows!

Sorry, that was a bit of a longer description. There’s just so much to say about DLM…  I could go on!

Maybe just a little more. It sounds like DLM is actually very similar to ALM. However, at a more detailed level, thinking of ALM as an arch spanning from the very first vision right up until the retirement of your product, including requirements gathering, planning, development and so on… where do you think DLM should be placed in the big world of Software Development? On which interfaces can it be integrated into our existing ALM processes?

Stephanie

DLM is focused on the database and bringing it into your ALM processes. I think if your application relies on a backend database, then DLM needs to go hand in hand with ALM. Therefore, it integrates into every interface where changes to the code base are either decided or implemented (from requirements gathering through to monitoring). Our DLM tools integrate with a lot of tools that exist for ALM. For database source control, we integrate with Subversion, Team Foundation Server, Git, Mercurial, and more. For database continuous integration, we integrate with Team City, Microsoft Team Build, and more. For releases, we integrate into Octopus Deploy, Microsoft Release Management, and other release management tools. Our thinking is that you already have tools for your application. We want to leverage these and bring your database into these tools and processes to make your deployments easier.

Database deployments are hard and we think it’s not often talked about when people talk about ALM, but it needs to be. Your application isn’t going to work very well if the database doesn’t exist or if it’s not at the right version that your application needs. The database is hard because of the data that needs to persist and also because of security concerns around this data.

You cannot lose data during a deployment. You have to worry about current connections and data consistency. You also have to worry about the security of that data. In a lot of areas, developers may not be able to have a copy of production data because of privacy issues. This makes it slightly harder because you’re testing scripts against something that is similar to production, but not production, so anything could happen when it comes time for the production release.

It’s really great if you can have a staging environment that matches production exactly, so that upgrades can be run and verified there before applying them to production. You also need to make sure that no changes were made to production between when you tested the deployment on staging and when you’re ready to run it on production. We describe a change to a database from an expected state as “drift”. There are many reasons this can happen and some are very valid, such as a hotfix to production. You need to know about this drift so you can incorporate it back into your development environment, making sure it doesn’t get overwritten the next time you do a deployment.

By the way, we have a brand new tool called SQL Lighthouse that provides a great dashboard of your database environments, and can alert you about changes and drift. This tool is currently a free beta and we’re looking for people to try it out and give us feedback before the full release. We have a lot of great ideas on our backlog for this tool that I’m really excited about. It would be great to hear from your readers and get their thoughts on the beta and what else they would like to see it do.

So anyway, there’s a lot to think about when it comes to the database. You need to think about server configurations, schema, and reference data. Reference data drives the application, so it needs to be versioned alongside the application and database schema and should be released in the same process. You also need a plan for what happens if a deployment doesn’t go as expected. This could be restoring a backup, having a rollback script, reverting a snapshot, or even rolling forward a “fix,” especially if you have a great process in place that makes releasing the fix easy.

 

Wow – that´s pretty extensive. What’s the simplest thing readers could do immediately to improve their ALM / DLM processes?

Stephanie

The first step in DLM is getting your database in source control. There’s most likely a source control system that your application developers are using. Find out where the related application code is stored and put your database code there. (Yes, database is code.) You also want to source control any configurations and reference data that should be tracked and deployed alongside the schema as well.

Ok, but my application developers are using Microsoft’s Team Foundation Server, and my Database developer uses SQL Server Management Studio. How can these environments fit together?

Stephanie

They actually fit together really nicely. Redgate’s SQL Source Control is a plug in to SSMS that integrates with existing source control systems like TFS. It allows you to continue to work on your database in SSMS, and to commit those changes to TFS. When you commit, you can associate the changes to a TFS work item ID, which could represent a user story or a bug. This is great because then you can see why the change was made and any other changes that were associated with the work item in one place.

Once your database is in source control, then you can use other TFS features like TFS Team Build and Redgate SQL CI to automate your builds and even do continuous integration for both your application and your database. The next step is putting database unit tests into this process to give you fast feedback about the state of your database and also provide solid regression testing as you’re making changes to the database.

Finally, TFS Team Build can kick off a release in Microsoft’s Release Management. Using a tool like Redgate SQL Release, this can deploy the database to other environments (like test or QA) to run additional tests. This could also include populating the database and running load and/or performance tests against the database automatically. How cool is that?

 

Impressive! We have all the tools integrated, and bringing the team one step closer together – that’s awesome! I’m just thinking of the possible performance boost for our projects, and it’s amazing. One last question for the endless debate: Can database development be agile? (hint: the answer has 3 letters Winking smile )

Stephanie

Absolutely. Wait, that isn’t 3 letters… 

To me, it seems like Database Development has to be agile to support an agile development process. You don’t want the database to be the bottleneck. You want it to be integrated into your development processes. You want it to be tested automatically to give you confidence in the changes and check for regressions. You want it to be as easy as possible to release the changes to production. You want your developers and DBAs to be spending time on things that are hard and truly valuable, not the things than can be reliably automated.

That said, it’s definitely tricky. Especially if multiple applications use the same database. Refactoring for one application can be a challenge because you want to make sure that the other applications still work, but loosely coupled applications and libraries are already facing similar challenges, so we should be able to learn from them. There may also be reports or data warehouses that need to be considered, which is fairly unique to databases.

So yeah, it is tricky, but definitely possible and something to work towards.

So, if you develop your application using an agile approach, you should consider developing your database using agile techniques as well. I think that’s a good conclusion to end our today’s talk. Thank you for your time, and looking forward to our next conversation!

Stephanie

Thank you so much! I really enjoyed our talk and hope your readers do too. I’m happy to talk more on twitter @SQLStephanie. Or, if you want to learn more about DLM, visit us at http://www.red-gate.com/products/dlm.

Introduction to Database Lifecycle Management and why it is important for ALM is a post from: AIT Blog

codefest.at [MS]: Event: So sicher ist die Cloud!

Am 26. Februar findet von 09:00 Uhr bis 13:30 Uhr bei Microsoft Österreich eine Veranstaltung rund um das Thema Datenschutz und Datensicherheit in der Microsoft Cloud statt. Die Veranstaltung richtet sich dabei an IT Entscheidungsträger, Sicherheits- und Datenschutzbeauftragte und Juristen von Unternehmen und soll helfen, ein gemeinsames Bild zur Entwicklung einer Cloud Strategie zu bekommen und sich über die Rahmenbedingungen zu informieren.
Wenn Sie als Entwickler unternehmensintern einen Diskussionsbedarf zu diesem Thema sehen dann weisen Sie bitte Ihre Kollegen auf diese Veranstaltung hin.

image

Cloud Computing ist in aller Munde, eröffnet neue Möglichkeiten, hilft Unternehmen neue Strategien und Entwicklungsmöglichkeiten zu finden. Gleichzeitig schürt es Ängste und diese müssen sachlich adressiert werden.

Die Dynamik der Cloud-Angebote verlangt ein Umdenken. Dazu gehört auch, dass Verantwortungsbereiche neu abgesteckt und die transnationalen Regeln in Bezug auf Datensicherheit (Zuverlässigkeit), Datenschutz (Zugangskontrolle) und Transparenz (durch EU-konforme Standardvertragsklauseln) strikt eingehalten werden; und die Einsicht, dass Datenschutz bereits innerhalb des Unternehmens beginnt.

Microsoft hat eine transparente Kommunikation, was Regelwerk und rechtliche Rahmenbedingungen betrifft.  In diesem Expertenbriefing erhalten Sie die Möglichkeit rechtliche Aspekte, behördliche Vorgaben, technische Details und Best Practices kennen zu lernen und sich mit Juristen und Experten zum Thema auszutauschen.

Die Agenda:

09:00 – 09:30 Keynote, Harald Leitenmüller

09:30 – 10:15 Patriot Act, Datenschutz und Compliance – alles neu?, Dr. Winklbauer

10:15 – 11:00 Datenschutz, Privatsphäre und Compliance bei Microsoft Online-Diensten für Unternehmen, Martin Zimmermann/Alfred Ecker/ Dr.Winklbauer

11:00 – 11:30 Pause

11:30 – 12:30 Datensicherheit bei Microsoft Azure und Office 365, Rainer Stropek MVP/Martina Grom MVP/ Harald Leitenmüller

12:30 – 13:30 Paneldiskussion (Q&A), alle Sprecher

Kommen Sie vorbei und nutzen Sie diese Gelegenheit, sich über den heutigen Stand der Sicherheit in Microsoft Cloud Diensten zu informieren. Hier geht es zur Anmeldung!

Lars Keller: DNUG Braunschweig Treffen - Einstieg in die Hybrid App Entwicklung

Die DNUG Braunschweig trifft sich am 11.12.2015 um 19:00 im Restaurant Zucker (Tagungsraum). Dieses Mal kommt uns Gregor Biswanger besuchen:

Die Entwicklung von Apps ist nicht einfach und jede "Systemwelt" hat ihre eigenen Tools und Anforderungen. Ob mit Java und Eclipse für Android, mit Objective-C und Xcode für iOS, oder mit den Microsoft-Tools für die Windows-Welt. Bei diesem Vortrag lernen Sie die vielfältigen Möglichkeiten der App-Entwicklung für alle gängigen Plattformen mit nur einer Programmiersprache kennen: HTML5 und JavaScript. Sie steigen mit den Grundlagen des kostenlosen Intel XDK und Apache Cordova ein und werden dann mit den wichtigsten Frameworks und Vorgehensweisen vertraut gemacht. Mit diesen Infos steigen Sie rasch zum versierten Cross-Plattform Entwickler auf.

Wie immer ist die Veranstaltung kostenlos!
Weitere Informationen zur DNUG Braunschweig können hier gefunden werden: http://www.dotnet-braunschweig.de

Marco Scheel: Links for 2015-02-10 [del.icio.us]

Jürgen Gutsch: SPDY wird Geschichte sein…

… die Zukunft heißt nun HTTP/2.0 :)

http://www.golem.de/news/google-chrome-will-spdy-schnell-durch-http-2-ersetzen-1502-112261.html

Warum mich das freut?

Letztes Jahr hatte hatte ich zusammen mit Golo Roden ein fünfteiliges Battle “NodeJS gegen .NET” in der dotnetpro (06/2014) veröffentlicht. Das Battle hat mir sehr großen Spaß gemacht, auch wenn sich .NET im letzten Teil eindeutig geschlagen geben musste.

Einer dieser Gründe für die Niederlage war eben jenes SPDY-Protokoll, das Google initiiert und implementiert hat und das auch von einigen weiteren Plattformen eingesetzt wird. Als ich die letzte Aufgabe gesehen habe, bat ich darum, statt SPDY eben HTTP/2.0 einsetzen zu dürfen. Leider wurde auf SPDY bestanden, da es wohl als Quasy-Standard für die Nachfolge von HTTP/1.1 angesehen wurde ;)

Microsoft hingegen bestand schon damals auf ein HTTP/2.0 als Nachfolge von HTTP/1.1, allerdings mit SPDY als Grundlage.

Um diesen Teil der Aufgabe zu meistern, hätte ich theoretisch eine experimentelle HTTP/2.0 Implementation für Katana einsetzen können: https://github.com/MSOpenTech/http2-katana

Schade nur dass es bis dato keinen Browser gab, der HTTP/2.0 unterstützt und die Lösung zur Aufgabe nur schwer hätte getestet werden können.

Aktuell unterstützen Firefox ab Version 34, sowie IE11 unter Windows 10 wohl HTTP/2.0 über TLS, sowie der aktuelle Chrome und (wie es wohl scheint) alle zukünftigen Versionen. http://en.wikipedia.org/wiki/HTTP/2#Browser_support

Golo Roden: Fehlerhaft: Private GitHub-Repositories mit npm installieren

Die Paketverwaltung npm kann Module nicht nur aus der öffentlichen Registry herunterladen und installieren, sondern auch von GitHub. Das funktioniert aufgrund eines Fehlers in npm unter Node.js 0.12 und io.js allerdings nur bedingt. Wie lässt sich das Problem lösen?

Code-Inside Blog: Human readable and editable config files with YAML

YAML ( Y AML A in’t M arkup L anguage, or in the beginning Y et A nother M arkup L anguage) is a pretty common config language in the Ruby world. Because of it’s clear nature it is a perfect fit for human readable configuration files. For example take a look at the Jekyll Configuration:

source:      .
destination: ./_site
plugins:     ./_plugins
layouts:     ./_layouts
data_source: ./_data
safe:         false
include:      [".htaccess"]
exclude:      []
keep_files:   [".git", ".svn"]
encoding:     "utf-8"
...

Not bad, right?

Why using YAML and not XML or JSON?

As you can see above (hopefully…), it’s pretty small in contrast to heavy markup of XML ( < HeavyStuff > … < / HeavyStuff > ) and more readable than JSON ( { { { … } } } - you know what I mean.), so for a config, which should be readable for humans, it’s really useful.

YamlDotNet & Sample Code

The easiest way to use and parse YAML in the .NET world is to use the YamlDotNet NuGet Package. It is OSS and can be found on GitHub

In my sample scenario I will serialize and deserialize the following config structure:

public class DemoConfig
{
    public int Foo { get; set; }
    public string SimpleItem { get; set; }
    public List<string> SimpleList { get; set; }
    public List<DemoConfigSettingElement> ComplexList { get; set; }
}

public class DemoConfigSettingElement
{
    public string Name { get; set; }
    public List<string> Attributes { get; set; }
    public string Test { get; set; }
}

As you can see, we have simple and complex types and lists - this should cover most cases. My sample program is a simple console app, serializing the object, writing it to the Console output and to a file and later reading this file. Pretty simple:

class Program
{
    static void Main(string[] args)
    {
        DemoConfig sample = new DemoConfig();

        sample.SimpleItem = "Hello World!";

        sample.Foo = 1337;

        sample.SimpleList = new List<string>();
        sample.SimpleList.Add("Foobar 1");
        sample.SimpleList.Add("Foobar 2");
        sample.SimpleList.Add("Foobar 3");
        sample.SimpleList.Add("Foobar 4");

        sample.ComplexList = new List<DemoConfigSettingElement>();

        DemoConfigSettingElement element1 = new DemoConfigSettingElement();
        element1.Name = "Element 1";
        element1.Attributes = new List<string>();
        element1.Attributes.Add("Foobarbuzz 1");
        element1.Attributes.Add("Foobarbuzz 2");
        element1.Attributes.Add("Foobarbuzz 3");
        element1.Attributes.Add("Foobarbuzz 4");
        element1.Attributes.Add("Foobarbuzz 5");
        sample.ComplexList.Add(element1);


        DemoConfigSettingElement element2 = new DemoConfigSettingElement();
        element2.Name = "Element 2";
        element2.Attributes = new List<string>();
        element2.Attributes.Add("Foobarbuzzi 1");
        element2.Attributes.Add("Foobarbuzzi 2");
        element2.Attributes.Add("Foobarbuzzi 3");
        element2.Attributes.Add("Foobarbuzzi 4");
        element2.Attributes.Add("Foobarbuzzi 5");
        element2.Test = "Only defined in element2";
        sample.ComplexList.Add(element2);

        YamlDotNet.Serialization.Serializer serializer = new Serializer();
        StringWriter strWriter = new StringWriter();

        serializer.Serialize(strWriter, sample);
        serializer.Serialize(Console.Out, sample);

        using (TextWriter writer = File.CreateText("test.yml"))
        {
            writer.Write(strWriter.ToString());
        }

        using (TextReader reader = File.OpenText(@"test.yml"))
        {

            Deserializer deserializer = new Deserializer();
            var configFromFile = deserializer.Deserialize<DemoConfig>(reader);
        }


        Console.Read();

    }
}

Result: The test.yml file:

Foo: 1337
SimpleItem: Hello World!
SimpleList:
- Foobar 1
- Foobar 2
- Foobar 3
- Foobar 4
ComplexList:
- Name: Element 1
  Attributes:
  - Foobarbuzz 1
  - Foobarbuzz 2
  - Foobarbuzz 3
  - Foobarbuzz 4
  - Foobarbuzz 5
- Name: Element 2
  Attributes:
  - Foobarbuzzi 1
  - Foobarbuzzi 2
  - Foobarbuzzi 3
  - Foobarbuzzi 4
  - Foobarbuzzi 5
  Test: Only defined in element2

When should you not use YAML?

In my opionion YAML is really great if the content needs to be human readable or editable. For machine to machine communication, interface definitions or more “complex” definitions XML, JSON or any other format might be better. The strength of YAML is based on the easy to read and edit fact, thats all.

Thanks to Antoine Aubry for the awesome work!

The complete demo code can also be found on GitHub

Hope this helps!

codefest.at [MS]: Anecon & Microsoft Praxisupdate 2015: {Create} Test Azure

Anecon & Microsoft Praxisupdate 2015

{Create} Test Azure  

Befürworter oder Skeptiker? Cloud-Lösungen in Unternehmen polarisieren oft. In ihnen steckt aber tatsächlich enormes Potential – wir zeigen Ihnen die Vorteile auf!  

Bei der Entwicklung von Software sind heute vor allem zwei Aspekte wichtig: Qualität und Wirtschaftlichkeit. Es wird erwartet, in immer kürzeren Zyklen qualitativ hochwertige Software zu liefern. Qualität und Geschwindigkeit werden dabei stark durch den Entwicklungsprozess getrieben. Cloud Computing bietet Möglichkeiten und Antworten, wie Verfügbarkeit, Ausfallsicherheit und Skalierbarkeit mit Wirtschaftlichkeit verbunden werden können.  

Die Experten von ANECON zeigen Ihnen, wie man mit Visual Studio und Microsoft Azure den gesamten Applikationszyklus abdeckt - und sogar noch mehr. Anhand eines durchgängigen Beispiels erstellen wir mit Visual Studio live eine Webapplikation, die auf Basis von Last- und Performancetests optimiert wird - und das alles in und mit der Cloud!  

Anmeldung und weitere Infos

Datum: Dienstag, 3. März 2015
Zeit: 08:30 – 11:30
Location: Microsoft Österreich GmbH, Am Euro Platz 3, 1120 Wien
Es handelt sich um eine Informationsveranstaltung mit Weiterbildungscharakter und fachlichem Hintergrund. Die Teilnahme ist kostenlos. Anmeldung erforderlich.

Freuen Sie sich auf einen spannenden Vormittag!

Christian Binder [MS]: ALM in the Cloud with Visual Studio Online and Azure

Rainer Stropek hat sehr guten Talk zu ALM in the Cloud auf Ch9 bereitgestellt. Inhaltlich zeigt er, wie man mit VSO und Git bis hin zu Continuous Delivery auf Azure alles in der Cloud abbilden kann. Ein sehr guter Einstieg in das Thema Smile

image

Viel Spass
Chris

Kay Giza [MS]: Was genau ist die Microsoft Virtual Academy (MVA)? Microsofts Online-Schulungsplattform?

Häufig wurde ich in letzter Zeit gefragt, was genau die MVA von Microsoft sei. Gerne gehe ich hier etwas genauer darauf ein... Die Microsoft Virtual Academy, oder kurz: MVA - stellt die zentrale und offizielle Online-Learning Plattform von Microsoft dar. In der MVA findet man kostenfreie und von Microsoft Experten durchgeführte Live- und Online-Kurse zu Microsoft Produkten, -Services und –Technologien. Diese kostenlosen Kurse können als Weiterbildungsangebot, Vorbereitungskurs zu Microsoft Prüfungen und -Zertifizierungen oder als schlicht als Online-Schulung zu bestimmten neuen oder zu vertiefenden Themen genutzt werden.... [... mehr in diesem Blogeintrag auf Giza-Blog.de]


This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
© Copyright 2006-2013 Kay Giza. All rights reserved. Legal

Karsten Kempe: Visual Studio Online Extensibility – Service Hooks

VSO IntegrateDen vorerst letzten Beitrag der Serie “Visual Studio Online Extensibility” widme ich der Integration von externen Diensten an ein VSO Team Projekt. Der dazu notwendige Baustein nennt sich „Service Hooks“. Service Hooks ermöglichen die Benachrichtigung von externen Diensten bei spezifischen Ereignissen innerhalb eines Projekts. In diesem Beitrag zeige ich Euch, wie Ihr Trello und Slack mit Euren Visual Studio Online Account verbinden könnt.

Service Hooks

Service Hooks bieten die Möglichkeit, dass sich externe Dienste von Visual Studio Online benachrichtigen lassen, wenn ein bestimmtes Ereignis in einem Team Projekt eingetreten ist. Der Hook kann beispielsweise so konfiguriert werden, dass für alle neu angelegten Work Items in einem Team Projekt eine neue Karte in Trello erzeugt wird und zusätzlich eine Nachricht in mein firmeninternes Kommunikationswerkzeug Slack geschrieben wird. Auch kann man sich über Build Zustände oder über Änderungen in der Versionskontrolle informieren lassen.

Bisher gibt es etwas mehr als ein Dutzend Dienste, die sich über Service Hooks integrieren lassen. Unter Ihnen sind Anbieter wie Jenkins, HipChat, Slack, UserVoice, Trello, etc. Eine genauere Liste könnt ihr unter VisualStudio.com einsehen.

Integration von Trello & Slack

Äußerst positiv ist mir aufgefallen, dass die Integration externer Services ziemlich einfach und sich auch sehr ähnlich ist. Sowohl Trello als auch Slack konnte ich in wenigen Minuten in Visual Studio Online integrieren.

Der Ausgangspunkt der Integration ist die Service Hooks Seite im administrativen Bereich eines Team Projekts.

01_Create_ServiceHook

Über den Link Create the first subscription for this project und danach über das Pluszeichen in der Menüleiste, gelangt man zu einem Installationsassistenten, der bei der Anlage des Service Hooks behilflich ist.

Als erstes wählt man aus einer Liste den gewünschten Dienst aus und konfiguriert dann einen sogenannten Trigger. Damit ist gemeint, welcher Event innerhalb eines Team Projekts eine Action auslösen soll. Die für Trello unterstützten VSO Events lassen sich aus der Grafik entnehmen.

02_Trello_ServiceHook

Für meinen Test habe ich das Work item created Event und im nächsten Abschnitt die Aktion Create a card ausgewählt, die in Trello durch dieses Ereignis ausgeführt werden soll.

03.1_Trello_Action_ServiceHooks

Um die Konfiguration zu vervollständigen und um eine sichere Kommunikation mit Trello zu ermöglichen, muss ein „Trello“-Token angegeben werden. Dieser Token wird von Trello bereitgestellt, nachdem die Anwendung für den Zugriff auf einen Visual Studio Online Account berechtigt wurde. (Diese Art der Authentifizierung habe ich in meinem Beitrag zum Thema OAuth 2.0 näher beschrieben.) Außerdem muss noch in den Settings hinterlegt werden, in welchem Board und in welcher Liste eine neue Karte erstellt werden soll und ob diese ggf. ein bestimmtes Label bekommt.

Wenn man die Kommunikationsplattform Slack mit VSO verbinden möchte, macht man dass am Besten in dem man Visual Studio Online als zusätzlichen Dienst zu seinem Slack Account hinzufügt. Dazu loggt man sich in Slack ein und geht in den Bereich Integrations. Dort lässt sich dann Visual Studio Online als Service hinzufügen. Nach der Angabe eines VSO-Accounts und der Verknüpfung des Accounts mit einem Slack Channel, erhält man eine sogenannte Webhook URL, die später im Installationsassistenten von VSO als Empfängeradresse für alle konfigurierten VSO Ereignisse benötigt wird. Der zweite Service Hook in diesem Demo-Projekt soll alle Work Item Änderungen des Team Projekts an Slack übermitteln und im Channel #vsonline veröffentlichen.

04.1_Slack_WebhookUrl_ServiceHooks

Work Item Änderungen

Nach der Integration beider Dienste in das Team Projekt, konnten Änderungen an den bestehenden Work Items vorgenommen werden. Die Änderungen wurden dann unmittelbar in den beiden Plattformen angezeigt.

05_Trello_NewCard_ServiceHooks

 06_Slack_VSOUpdate_ServiceHooks

Fazit

Die Integration von externen Diensten wie Trello oder Slack ist sehr einfach und zügig durchzuführen. Die Ergebnisse werden in den einzelnen Werkzeugen auch unmittelbar nach Auftreten des Ereignisses angezeigt.

Für die Zukunft wünsche Ich mir allerdings, dass die Aktualisierung von Ereignissen bald aus beiden Richtungen möglich ist. Denn die aktuelle Version der Service Hooks unterstützt keine Synchronisation zurück aus einer externen Anwendung zum Team Projekt in Visual Studio Online. Änderung die direkt auf Trello-Kärtchen gemacht werden, bleiben leider nur in Trello und gelangen nicht zum Work Item in VSO. Das dürft für alle Trello-Fans eher suboptimal sein.

Auch die Integration von Slack halte ich für Ausbaufähig, da z.B. die erstellten Nachrichten nicht editierbar sind und nur den Work Item Titel beinhalten. Somit ist man immer gezwungen die Work Item Maske in Visual Studio Online zu öffnen, um Details zu sehen.

Trotz diesen fehlenden Möglichkeiten hat der Dienst großes Potential. Schon alleine deswegen, weil man sowohl eigene Services (Web Hooks), als auch Azure Service Bus oder Azure Storage anbinden kann. Ulli Stirnweiss wird auf ihrem Blog einen Beitrag zum Thema Web Hooks veröffentlichen, in dem sie beschreibt wie sie für unsere TFS-App einen eigenen Service geschrieben und in VSO integriert hat.

Stay tuned.

[1] http://www.visualstudio.com/get-started/integrating-with-service-hooks-vs

[2] www.trello.com

[3] www.slack.com

Ralf Westphal: Co-location als kontraproduktiv erachtet

Wo ein Entwicklungsteam noch an einem Ort sitzt, sollte es verteilt werden. Entwicklungsteams, die gebildet werden sollen, fangen am besten gar nicht erst an, sich an einem Ort zu versammeln. Verteilte Teams sollten der Default sein. Die Sonne lacht in Hamburg, ein frischer Wind weht an der Alster. Ein guter Tag, um sich unbeliebt zu machen :-) Deshalb diese Vorschläge. Irgendwann muss ich damit

Dirk Primbs [MS]: Rich, Thin, Fat, Native… uhm… Client.

Let me start by admitting something: I’m old. Well, not really but by the standards of my kids and many startups or developers I meet these days I definitely am. 39 years means that I’ve seen the industry for about 25 years. There, I said it. Quarter a century. Oh boy.

Well, now that this is established, let me state something the truly old (not me, I’m referring to the ancient ones of course) keep re-iterating all the time: We’re repeating ourselves more often than not.

“Gamora: History repeating itself?

Warlock: History doesn’t repeat itself, Gamora, but sometimes it rhymes.”
― Dan Abnett, Guardians Of The Galaxy, Vol. 1: Legacy

A particular pattern that I’ve seen over and over again is the tale of the rich client. When I joined Microsoft 1999 it was this very notion that informed much of the debate and I had groundhog day moments ever since because it never really passed…

The age of the mighty computer

The general idea dates back to the first computer networks when it became possible to build distributed software architectures. In essence it refers to the division of work between the networked systems. In the early days systems were built with all the logic in a powerful (well…) central computer and the clients connected through terminal applications with very limited functionalities.

The network connection was of course a performance bottleneck, but after all the actual workload was handled on the server side and only the results were transferred as text to the terminals. This had clear performance advantages and ensured data protection since all data was ultimately stored and computed at a well-defined place. The world was simple back then, thin clients, fat servers…

But soon the personal computer introduced the idea of independent computing and became more and more functional. This offered a chance to remove the network bottleneck. Applications were written that enabled local computing. Users marvelled at their local systems and servers were all of the sudden mostly storage and query machines. Again, the world was simple back then, but different… Now it was the client that was fat and the server that got slim. Roles swapped. Of course that posed some problems. For starters it became a challenge to transfer data back to the datacenters. Secondly this posed a security issue for most applications. And thirdly, of course, there were limits how far you can go with local computing. This gave birth to a number of networking architectures, all dedicated to splitting workload, dataload and security burden intelligently.

One of the first seeds were systems dedicated to distributed data access like query engines and text transfer systems. It was this stem of technology that brought us the internet and world wide web…

The age of the platform provider

Back then another important player, Microsoft, started it’s massive technology landscape. Initially following a product logic with a constant release cycle it became important to put more and more functionalities into local applications to give customers a reason to buy new versions. Microsoft had unlocked a mass market of software buyers and they also became the engine for a growing personal computing industry. Both were striving on the idea of putting more and more functionality into the client side to drive the need for performance, hardware and new software.

From early on Microsoft also managed to unlock the potential of a professional developer market. Development tools and programming interfaces melted the products into a large powerful software developer platform. Of course the aforementioned architectures were in Microsoft’s radar as well, but ideally it should be just for communication and easy data access. All other elements needed to be locally driven, because product sales were the lifeblood of Microsoft and these sales were driven by an ever increasing need for more performance and a thriving ecosystem producing more and more high quality applications.

Microsoft eventually came to a conclusion: Platform lock-in tactics are important. The more reasons developers have to use native functionalities, the better it is for the platform, because – once optimised – these apps were likely to stay locked in and the developers will continue serving this particular technology hive. The rest is history. Because the internet was a massive thread to that idea, Microsoft engaged in the browser wars (some argue that a browser is actually in essence not much more than a very fancy terminal emulator). Java started building it’s own breed of distributed technology architecture and Microsoft engaged in an implementation race there.

All the time the arguments went like this:

Rich client:

+ Better performance through native hardware access, local security,  richer functionalities.
- Less compatibility with other platforms, local vulnerability, imposed performance and storage limits,, hard to develop.

Thin client

+ Fast if network is good, low demand of local hardware, flexible, easy to support, easy to write.
– Limited functionality, limited local performance, network connection required

Today

7 years ago Steve Jobs brought us the smart phone (well…). And actually not very surprisingly: The landscape didn’t change a bit. Today it is about native apps vs. mobile web pages. It is about implementing HTML5/JS based functionalities vs. using frameworks such as Java on Android or Swing on iOS or .NET on Microsoft’s platform. It is about the integration of the cloud and the idea of running productivity apps completely remote instead of individual computers. It is about using a tablet for everything vs. dedicated work laptops.

And instead of fighting over the PC the industry is fighting over mobile device platforms.

But one thing is accepted since the 80s – we’re always in a hybrid world. It is not Client vs. Server… it is just the question of how much and what part of the architecture is dedicated to each.

History clearly rhymes…

 

Picture credit: Torkild Retvedt

The post Rich, Thin, Fat, Native… uhm… Client. appeared first on Dirk Primbs Online.

Johannes Renatus: Resharper “Code Template” für Lambda Ausdruck “x => x.” erstellen

Wenn ich Lambda Ausdrücke verwende steht am Ende häufig “x=<x.” in der Codezeile. Das nervt auf Dauer doch etwas, vor allem wenn man Unit Tests schreibt und beim Mocken doch sehr oft auf die Lambda “Definition” zurückgreifen muss. Hier hat mir zum Glück Resharper mit seinen Code Templates weitergeholfen, die man selbst beliebig erweitern kann. […]

Sven Hubert: Wie sicher ist „die Cloud“?

Mit dieser Frage war ich letztes Wochenende konfrontiert als ich jemanden, der nicht im IT Umfeld tätig ist, sein neues Smartphone einrichten sollte. Erst kürzlich hat sie im Radio gehört, dass die Cloud voller Sicherheitsrisiken sei und man da sehr aufpassen müsse. Es wurde sogar davor gewarnt, „die Cloud“ zu verwenden. Wenn ich aber ein modernes Smartphone und dessen Möglichkeiten und Komfort nutzen möchte, komme ich eigentlich nicht drum herum, „die Cloud“ zu benutzen. Will ich das nicht, dann sollte ich ein Nokia 6210 einsetzen, das kann telefonieren, und sonst nix. Es ist deshalb auch das beliebteste Gerät der Drogenmafia.

Das Beispiel zeigt insbesondere, das im Allgemeinen noch sehr wenig Verständnis dafür vorhanden ist, was „die Cloud“ ist. Und das deshalb allerseits, und insbesondere von den Medien viel Verunsicherung betrieben wird. Aber selbst unser Digitaler EU Kommissar Günther Oettinger beschäftigt sich schon mit der Cloud

Gehen wir der Frage und den damit verbundenen Ängsten aber etwas auf den Grund, erkennen wir, dass das grundlegende Verständnis dafür, was „die Cloud“ ist, meist fehlt. Denn genau so könnten wir auch Fragen „Ist das Auto unsicher?“ Und obwohl wir wissen, dass die Benutzung des Autos ein Risiko für unser Leben und das Leben anderer ist, benutzen es die meisten von uns täglich. Denn wir haben gelernt das Risiko einzuschätzen und im Austausch gegen den damit verbundenen Komfort und Nutzen zu akzeptieren. Allerdings unterscheidet sich das Risiko, das ich dabei eingehe auch dadurch, ob z.B. ein 10 Jahre altes Auto, das den nächsten TÜV wohl nicht mehr überlebt, oder einen modernen Mittelklassewagen eines deutschen Herstellers verwende. So wie „das Auto“ nicht gleich „das Auto“ ist, ist auch „die Cloud“ nicht gleich „die Cloud“.

Kommen wir aber zurück zur Ausgangsfrage. Um der Person „die Cloud“ und deren Risiken besser zu erklären habe ich nach einem Vergleich aus „dem richtigen Leben“ gesucht. Spontan ist mir dabei die Analogie zu einem Bankschließfach eingefallen. Ein Bankschließfach ist ein Service, den mir ein externer Dienstleister anbietet, und genauso verhält es sich auch mit der Cloud. Welche Risiken habe ich also, wenn ich den Familienschmuck nicht zu Hause in der Zuckerdose, sondern in einem Bankschließfach aufbewahre?

1. Wie vertrauenswürdig ist die Bank? Hat sie einen Zweitschlüssel zu meinem Schließfach und kann mich ein Bankangestellter deshalb um den Inhalt meines Schließfaches erleichtern?
2. Wie gut ist die Bank abgesichert? Wie gewährleistet sie, dass niemand (auch nicht der Staat) in die Bank einbricht und mein Schließfach leert?
3. Wie sicher bin ich auf dem Weg zur Bank wenn ich den Schmuck ins Schließfach bringe oder von dort geholt habe? Auch hier trage ich das Risiko, dass ich auf dem Weg überfallen und beraubt werde.

Ein Cloud Service wie z.B. ein Online Speicher verhält sich im Grunde genauso wie dieses Bankschließfach und auch hier muss ich mir genau dieselben Fragen stellen:

1. Wie vertrauenswürdig ist der Anbieter? Was ist sein Geschäftsmodell? Verdient er sein Geld dadurch, dass er mir gute Produkte und Services verkauft oder verdient er es damit, dass er mir kostenlose Services anbietet und dann meine Daten verkauft oder mich mit Werbung belästigt? Wie wahrscheinlich ist es, dass es den Anbieter auch in Zukunft noch geben wird?
2. Wie gut sind meine Daten abgesichert, welche Verschlüsselungs- und Authentifizierungsmethoden verwendet der Anbieter? Und vor allem, wie transparent legt er mir dar, welche Methoden er verwendet, damit ich bewerten kann, ob diese sicher sind?
3. Stellt der Anbieter die Verschlüsselung der Daten auf dem kompletten Weg vom Endgerät bis zum Cloud Service und wieder zurück sicher?

„Die Cloud“ ist also heute nichts Mystisches mehr und kann uns sowohl im privaten, als auch im geschäftlichen Umfeld großen Nutzen bringen. Meist ist sie auch viel sicherer als die heimische Zuckerdose. Wichtig ist aber, dass wir mündig damit umgehen und genau überlegen, welchem Anbieter wir unser Vertrauen schenken, dann ist sie irgendwann für uns genauso selbstverständlich wie Autofahren.

P.S.: Gerade frage ich mich warum noch keine Schweizer Bank dieses Geschäftsfeld erkannt hat und Cloud Services anbietet?

Wie sicher ist „die Cloud“? is a post from: AIT Blog

Golo Roden: Falsch aufgezäumt: Joyent startet Node.js Incubator Program

Joyent, das Unternehmen hinter Node.js, hat ein Programm zur Unterstützung von Entwicklern ins Leben gerufen, die Node.js-Anwendungen entwickeln. Die seit dem 13. Januar 2015 verfügbare Alternative io.js schließt Joyent explizit aus. Was bedeutet das für die beiden Projekte?

Ralf Westphal: Bessere Resultate ohne Abhängigkeit

Wie arbeiten Sie am liebsten, wenn Sie etwas schaffen wollen oder müssen? Was fördert Ihre Konzentration? Die Menschen sind ja verschieden. Der eine möchte Ruhe haben, die andere Musik hören, der nächste ein Räucherstäbchen anzünden… Fenster auf, Fenster zu, mehr Licht, weniger Licht… Man kann es kaum allen recht machen, oder? Eine Konstante gibt es jedoch hinter all dieser Verschiedenheit: den

friends header

bloggers headline

links header

 
Don't contact us via this (fleischfalle@alphasierrapapa.com) email address.