ppedv Team Blog: Angular.JS ohne $scope

In Angular ist der Scope die technische Implementierung des Viewmodels. Obwohl einfach zu verstehen und verwenden ist angekündigt mit der Version 2.0 darauf zu verzichten. In der Tat ist ein Fehler in der Scope Hierarchie mitunter schwer zu finden.

Folgender Blog Artikel ist rein akademisch und zeigt zwei Wege auf einen Controller in Angular.js zu schreiben bzw Daten deklarativ in HTML zu binden.

   1:  <form id="form1" runat="server" ng-app="app">
   2:          <div ng-controller="myController">
   3:              <input ng-model="person.name" />
   4:<input ng-click="myclick()" type="button" value="click" />
   5:          </div>
   6:   </form>
   7:   
   8:   <script>
   9:         var app = angular.module('app', []);
  10:          app.controller('myController', ['$scope', function ($scope) {
  11:             $scope.person = { name: 'Hannes' };
  12:             $scope.myclick = function () {
  13:             $scope.person.name = "Franz";
  14:              };
  15:       }]);
  16:   </script>

 

Die Scope freie Alternative: Durch die Nutzung der Controller AS Syntax im HTML Teil entfällt $scope als Instanz des Viewmodels. Im Controller kann kann per this auf Methoden und Eigenschaften zugegriffen werden. Über die Extend Methode wird das JavaScript Objekt erweitert.

   1:  <form id="form1" runat="server" ng-app="app">
   2:    <div ng-controller="myController as alias">
   3:        <input ng-model="alias.person.name" />
   4:        <input ng-click="alias.myclick()" type="button" value="click" />
   5:  </div>
   6:  </form>
   7:   
   8:  <script>
   9:     var app = angular.module('app', []);
  10:     app.controller('myController',myCtrl);
  11:     function myCtrl() { };
  12:     angular.extend(myCtrl.prototype, {
  13:              person : { name: 'Hannes' },
  14:              myclick: function () {
  15:              this.person.name="Frnaz";
  16:          }
  17:     });
  18:  </script>

 

Nach einer weile nachdenken, noch eine einfachere Scope freie Version eines Angular Controllers.

   1:  var app = angular.module('app', []);
   2:          app.controller('myController', [function () {
   3:              var vm = this;
   4:              vm.person = { name: 'Hannes' };
   5:              vm.myclick = function () {
   6:                  vm.person.name = "Franz";
   7:              };
   8:          }]);

 

Den gewöhnlichen Teilnehmer einer Angular Schulung überfordert dies eindeutig. In meinem Angular Training bleibe ich bei der Scope Variante.

Norbert Eder: Software für Fotografen

In der digitalen Fotografie kommt man ohne Software nicht aus. Das beginnt beim Backup, bei Datei-Synchronisationen, Bearbeitung, Verwaltung und vielem mehr. Dieser Beitrag zeigt einige Werkzeuge, die ich - als Hobbyfotograf - einsetze und so auch uneingeschränkt empfehlen kann.

The post Software für Fotografen appeared first on Norbert Eder.

Holger Schwichtenberg: 15%-Rabattcode für die Anmeldung zur BASTA-Konferenz

Vom 23. bis 27. Februar 2015 findet wieder Frühjahrs-Ausgabe der deutsche .NET-Fachkonferenz "BASTA" in Darmstadt statt.

Holger Schwichtenberg: .NET 2015 im Schaubild

Ein Schaubild visualisiert das Verhältnis von .NET Framework 4.6 und .NET Core 5.0, die zusammen .NET 2015 heißen.

Sven Hubert: Wege aus dem Verwaltungschaos

Individualität statt Massenware – diese Motto gilt mehr und mehr auch für Software-Produkte. Doch was bedeutet das für die Entwicklung solcher Produkte? In der Basis sind die Ähnlichkeiten zwischen den Individualisierungen meist so hoch, dass eine Standardisierung nur sinnvoll erscheint. Wird nun also für jeden Kunden ein separater Branch von der Basis-Implementierung erzeugt? Dieses Szenario ist leider nur bei einer kleineren Kunden-Anzahl praktikabel. Zusätzlich stellt sich die Frage, wie Bugfixes und Features zwischen den Branches ausgetauscht werden können. Es muss also auch andere Lösungen geben.

Fest steht, dass individualisierte Lösung maßgeschneiderte Prozesse, eine vorausschauende Strukturierung der Anwendung und der Quellcodeverwaltung benötigen. Nach dem der Vortrag zu dem Thema auf der diesjährigen developer week in Nürnberg auf enorme Resonanz stieß, gibt es die Inhalte nun endlich in gedruckter Form. Lesen Sie mehr über das Thema im Artikel “Wege aus dem Verwaltungschaos” von Benjamin Boost in der aktuellen Ausgabe der dotnetpro 01/2015.

dnp_012015

Wege aus dem Verwaltungschaos is a post from: AIT Blog

Kay Giza [MS]: NORAD Tracks Santa - wo ist der Weihnachtsmann?

Bald ist Weihnachten! Nicht nur Kinder freuen sich auf die ruhige und besinnliche Weihnachtszeit. Wie jedes Jahr seit mehr als 50 Jahren ortet NORAD (das North American Aerospace Defense Command) am 24. Dezember den Weihnachtsmann! Ja - wirklich! Wie genau das geht, woher das kommt, welche Apps es gibt um den Weihnachtsmann zu orten, was Microsoft damit zu tun hat... - das alles steht in dem Blogeintrag auf Giza-Blog.de ... [... mehr 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

Manfred Steyer: Artikelreihe zu AngularJS

Auf den Seiten von Heise-Online findet man nun meine 5-teilige Artikelreihe zu Single Page Applications (SPA) mit AngularJS, die im Laufe der letzten Monate dort nach und nach erschienen ist. Nachfolgend das "Inhaltsverzeichnis" inkl. Links auf die einzelnen Teile.

Artikel 1: Erste Schritte
Artikel 2: Konzepte näher betrachtet
Artikel 3: Unit-Testing
Artikel 4: Validieren und Internationalisierung
Artikel 5: Routing und Deep-Linking

Norbert Eder: Mehr Kraft im Alltag durch Fitnesstracker

Mittlerweile gibt es Fitnesstracker am Markt wie Sand am Meer und in unterschiedlichsten Ausprägungen. Es gibt sie als Schrittzähler, mit oder ohne optischen Pulsmessern, Höhenmessern usw. In diesem Beitrag möchte ich erzählen, wie mir ein Schrittzähler zu mehr Kraft im Alltag verholfen hat.

The post Mehr Kraft im Alltag durch Fitnesstracker appeared first on Norbert Eder.

Holger Sirtl: Umfrage: Informationsbedürfnisse für Ihren beruflichen Erfolg in der Softwareentwicklung

Als Technical Evangelist ist es mir natürlich ein Anliegen, Informationen zu Microsoft Technologien möglichst effizient über die verschiedensten Kanäle (Blogs, Videos, Webcasts, Whitepaper etc.) zu verbreiten. Deshalb ist es mir ein großes Anliegen, eine Initiative des MSDN Teams der Microsoft Deutschland zu unterstützen:

Eine Umfrage zum Thema “Informationsbedürfnisse für Ihren beruflichen Erfolg in der Softwareentwicklung”.

In dieser Umfrage soll ermittelt werden, welche Themen Entwickler über welche Kanäle am liebsten konsumieren. Die Umfrage ist in 5-10 Minuten ausgefüllt und hilft dabei, die Angebote, Leistungen sowie Ressourcen für Entwickler zu optimieren und noch genauer auf die spezifischen Bedürfnisse einzugehen.

Hier geht es zur Umfrage: http://aka.ms/Entwickler-Umfrage.

Die Frage ist leicht geschaltet es spätestens 31.12. oder bis eine repräsentative Anzahl an Teilnehmern erreicht ist.

Dabei werden unter anderem folgende Informationen erhoben:

  • Welche Medien nutzen Sie für welche Art von Inhalten (Nachrichten & News, Informationen, Weiterbildung & Trainings)?
  • Wie viel Zeit verwenden Sie darauf?
  • Welche Technologien sind im Fokus (aktuell, künftig)?

Durchgeführt wird die Umfrage im Auftrag von Microsoft Deutschland, von der techconsult GmbH aus Kassel. Die Umfrage wird vollständig anonym ausgewertet (eine Angabe von Namen oder Firmennamen, E-Mail-Adresse etc. ist gar nicht möglich). techconsult verbürgt sich und garantiert dafür, „dass keine Daten aus dieser Untersuchung weitergegeben werden, die Ihre Person oder Ihr Unternehmen erkennen lassen“.

Microsoft und das Team von MSDN, dem Microsoft Developer Network aus Deutschland, danken Ihnen schon jetzt für Ihre Hilfe & Unterstützung sowie Teilnahme an der Umfrage.

ppedv Team Blog: Stand-by-modus aussetzen

Wie vielleicht jeder schon einmal erlebt hat sorgen Windows Media Player und Co. dafür dass Computer nicht in den Ruhezustand wechseln. Ein C# Programm sorgt für sich genommen nicht dafür das dass Betriebssystem aktiv bleibt.
Hier präsentiere ich eine Möglichkeit den Stand-by-Modus auszusetzen. Dafür muss durch P/Invoke die Funktion SetThreadExecutionState() eingebunden werden.
Dafür ist folgende Einstellung interessant:

ES_SYSTEM_REQUIRED : Bedeutet, das System darf nicht abgeschaltet werden.

Eine Funktion mit diesem Status aufzurufen sorgt nur dafür das etwaige Timer zurückgesetzt werden, eine Dauerlösung ist das nicht.

Um jetzt eine permanentere Lösung zu generieren ist es nötig die Funktion entweder periodisch aufzurufen oder den Status per Oder mit ES_CONTINOUS zu verknüpfen.

Diese kleine Snippet zeigt wie man den Stand-by-Modus dauerhaft aussetzt:


namespace MyWindowsFormsApplication
{
public partial class MyForm : Form
    {
public enum EXECUTION_STATE : uint
        {
            ES_CONTINUOUS = 0x80000000,
            ES_DISPLAY_REQUIRED = 0x00000002,
            ES_SYSTEM_REQUIRED = 0x00000001
        }
        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
static extern EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE esFlags);
.
.
.

private void Form1_Load(object sender, EventArgs e)
        {
            SetThreadExecutionState(EXECUTION_STATE.ES_CONTINUOUS | EXECUTION_STATE.ES_SYSTEM_REQUIRED);
        }
    }
}


Vergleich siehe MSDN

Wie immer viel Spaß beim tüfteln, und wer mehr Wissen will wendet sich an die ppedv.

Sven Hubert: TFS Security: NTLM Vs. Kerberos?

Im ersten Artikel unserer Artikelserie „Sicherheit und TFS“ haben wir die Unterscheidung in Authentifizierung und Autorisierung getroffen. In der Windows-Welt ist die Authentifizierung eines Nutzers über verschiedene Verfahren geregelt, dominierend sind hierbei die Verfahren NTLM und Kerberos.

Lernen Sie im nachfolgenden Beitrag die Unterschiede der beiden Authentifizierungsmechanismen Kerberos und NTLM beim Team Foundation Server genauer kennen.

NTLM (NT LAN Manager) ist eine Sammlung von Sicherheitsprotokollen von Microsoft zur Sicherstellung von Integrität und Authentifizierung. Die Ursprünge reichen zurück bis vor die Windows NT  Ära, in der NTLM als proprietäres Protokoll von Microsoft eingeführt wurde. Bereits mit dem Betriebssystem Windows Server 2000 wurde vor rund 14 Jahren NTLM durch das neuere und sichere Kerberos als das bevorzugte Authentifizierungsprotokoll abgelöst. Primär wird heute NTLM noch aus Kompatibilitätsgründen von neueren Systemen unterstützt.

Was sind die Hintergründe der Ablösung von NTLM ([1]) durch Kerberos ([2])? NTLM nutzt zur Authentifizierung im wesentlichen Hashwerte um sich gegenüber einem Dienst zu authentifizieren. Ein solcher Hashwert stellt am Ende wiederum eine Art Passwort dar. Je nach Situation ist dabei der Hashwert auf dem Server oder dem Domain-Controller hinterlegt. Fängt ein „böser“ Anwender den Hashwert ab, so ist mit einem Passwort-Diebstahl gleichzusetzen. Mit der Unterstützung von Kerberos im Windows Umfeld wurden diese Design-Schwächen adressiert. Kerberos nutzt dabei zur Übermittlung der Authentifizierungsdaten anstatt Hash-Werten temporäre Tickets. Diese Tickets werden dabei von einer zentralen vertrauenswürdigen Instanz ausgestellt und verwaltet. Alle beteiligten Systeme prüfen vereinfacht erklärt, die Gültigkeit der Ticketinformationen mit dieser Instanz. In Windows Netzwerken ist diese zentrale Instanz die Active Directory Infrastruktur mit seinen Domain-Controllern.

Bei den ganzen Vorteilen stellt man sich am Ende die Frage: Warum überhaupt noch auf NTLM setzen? Wenn möglich sollte bei der Wahl des Verfahrens auf das moderne Kerberos gesetzt werden. Kerberos vereint die Vorteile von Performance und erweiterten Mechanismen gegen Manipulation. Mit den Vorteilen geht allerdings eine etwas höhere Komplexität bei der Einrichtung einher. Trotz allem Optimismus kann leider nicht in jeder Situation auf Kerberos gesetzt werden. Unterstützt eines der integrierten Systeme kein Kerberos wird automatisch wieder NTLM verwendet. Wenn das System nicht Mitglied einer Active Directory Domäne ist kann ebenfalls kein Kerberos verwendet werden. In Evaluierungs- und Studien-Umgebungen oder gemischten Netzwerken kann es schnell zu diesem Szenario kommen. Weitere Gründe die wieder zu NTLM führen können ist eine fehlerhafte Kerberos-Konfiguration oder ein fehlender Kerberos-Support in der angesprochenen Anwendung.

Und jetzt die gute Nachricht: Auf den Team Foundation Server selbst trifft keine der Eigenschaften zu, und es spricht nichts gegen die Verwendung von Kerberos. Die schlechte Nachricht: Wir müssen für die korrekte Einrichtung entsprechend Zeit einplanen. Geht es jetzt an die Konfiguration der Kerberos Authentifizierung im TFS Umfeld, so sind primär drei Dienste sehr wichtig: TFS, SharePoint und SQL Server Reporting Services (SSRS).

Jeder der drei beteiligten Systeme ist dabei unabhängig voneinander zu konfigurieren. Die Konfiguration pro System erfolgt aber stets in vier grundlegenden Schritten:

  1. Einrichten eines DNS Alias Namen für jeden Dienst (Bsp.: tfsservice.firmenname.de für TFS, tfsportal.firmenname.de für SharePoint und tfsreports.firmenname.de für Reporting Services)
  2. Aktivieren von Kerberos in jedem Dienst ( während der Installation oder durch nachträgliche Konfiguration möglich) ( [3], [4], [5])
  3. Setzen der Service Principal Names (SPN) (siehe [6]).
  4. Überprüfen der Konfiguration.

Fazit

Es gibt kaum einen Grund Kerberos nicht zu verwenden. Der etwas höhere, dafür aber nur einmalige Einrichtungsaufwand lohnt sich auf jeden Fall. Mehr Sicherheit, schnellere Authentifizierung und nicht zuletzt ein offener Standard machen ihre Infrastruktur dank Kerberos fit für die Zukunft.

Sie möchten Kerberos in Ihrer TFS Landschaft aktivieren? Sprechen Sie uns an!

Weiterführende Informationen

[1] https://en.wikipedia.org/wiki/NT_LAN_Manager

[2] https://en.wikipedia.org/wiki/Kerberos_(protocol)

[3] http://technet.microsoft.com/en-us/library/ee806870(v=office.15).aspx

[4] http://msdn.microsoft.com/en-us/library/dd631919.aspx

[5] http://blogs.technet.com/b/rob/archive/2011/11/23/enabling-kerberos-authentication-for-reporting-services.aspx

[6] http://technet.microsoft.com/en-us/library/cc731241.aspx

TFS Security: NTLM Vs. Kerberos? is a post from: AIT Blog

Sven Hubert: TFS ASAP is an official Visual Studio Online Integration

Visual Studio and the overall Team Foundation Server ecosystem provide a lot of options for extensibility. These are widely used to close gaps or address customer specific scenarios. Hence, a a lot of partner solutions have been growing over the last years, including our latest one TFS ASAP Online.

Since we have been working in hundreds of customer projects, we have been seeing a lot of those scenarios. By abstracting customer specific requirements, we have shipped many tools and extensions that mostly address productivity improvements when using Microsoft’s ALM platform Team Foundation Server. Figure 1 gives an overview about some of our solutions (see also AIT tools website).

Figure 1: Overview AIT Tools

Figure 1: Overview AIT Tools

Almost all of the tools and extensions shown in figure 1 are available for free. One of our latest announcements is TFS ASAP Online, which is the Visual Studio Online pendant to TFS ASAP (Automated Servicing and Administration Platform), a platform that enables Team Foundation Server to support more business rule automation than provided out-of-the-box.

In November 2014 we announced the public preview of TFS ASAP Online. Now we can announce that TFS ASAP has been adopted as an official Visual Studio Online Integration. Amid other useful integrations (see figure 2), TFS ASAP extends Visual Studio Online by automating manual and error-prone work. For example certain information on task level like the blocked field (MSF for CMMI Process Template) or state values can be aggregated to parent work items like Requirements, User Stories, or Product Backlog Items.

Figure 2: Visual Studio Online Integrations Website

Figure 2: Visual Studio Online Integrations Website

While TFS ASAP Online integrates with Visual Studio Online, the product TFS ASAP  extends your on-premise Team Foundation Server. Hence, if you are using Visual Studio Online, TFS ASAP Online is the perfect partner to automate some stuff. Otherwise, if you are using an on-premise Team Foundation Server, the locally installable version TFS ASAP is the right choice to get rid of some tasks you could automate.

Feel free to register for TFS ASAP Online or order a free trial of TFS ASAP. In case of any questions, don’t hesitate to ask via tfsasaponline@aitgmbh.de.

Please follow the links below for further information:

TFS ASAP is an official Visual Studio Online Integration is a post from: AIT Blog

ppedv Team Blog: If you pay Peanuts- you get Monkeys

Gerne zitierte Phrase im Zusammenhang mit mäßig motivierten Mitarbeitern. Unabhängig davon das ich den direkten Zusammenhang zwischen Geld und Leistung bisher in der Praxis nicht erfahren habe, stellt sich die Frage, wie korreliert Bezahlung und Motivation genau. Natürlich hat jeder Mensch Grundbedürfnisse, die erfüllt sein müssen. Aber alles was darüber hinaus, geht schlägt sich nicht immer in ein mehr an Motivation nieder. Manchmal sogar ins Gegenteil.

Aus der Sicht des Arbeitgebers stehen allerdings Kosten und Leistung sehr wohl in einer starken Abhängigkeit. Je nach Region und Geschäftsmodell muss der Ertrag eines Mitarbeiters seine direkte Kosten (ca  Jahresbrutto *1,35) mindestens um den Faktor 2-3 übersteigen um überhaupt in die Gewinnzone zu kommen.  Darin unterscheidet sich rein kaufmännisch betrachtet eine menschliche nicht von einer sonstigen Ressource. Wenn die Rechnung nicht stimmt, ist über kurz oder lang jeder Arbeitsplatz weg. Industriebranchen wie Textil oder Stahl gehen an dieser simplen Formel zugrunde.  Folglich muss jedem Berufseinsteiger bewusst sein, je höher sein Verhandlungserfolg, desto wahrscheinlicher sein Scheitern.

Trotzdem klafft häufig eine Lücke zwischen selbst Wahrnehmung und dem Jahres Brutto. Genau dann kommt aus der Mitarbeitersicht der Widerstand auf. Man ist häufiger krank und bringt in der übrigen Zeit den Tag auf Facebook hinter sich. Braucht sich der Chef nicht zu wundern. If you pay Peanuts – you get Monkeys.

Vergeblich habe ich versucht die Quelle oder den Urheber des Zitats zu finden, um den ursprünglichen Kontext wieder herzustellen. Nun werfe ich mal als Gendanken eine alternative Interpretation auf.

Warum machen Menschen irgendwas, in einer in allen Bedürfnissen übersättigten Zeit? Jedes Jahr ein neues iPhone kaufen? Aber Menschen gehen nach wie vor zur Arbeit, sind bei der Freiwilligen Feuerwehr oder helfen einem Freund beim Haus bauen.

Schlicht weil sie es wollen, also intrinsisch motiviert. Wenn man nun jemanden für etwas was er regelmäßig und gerne macht, kleine Belohnungen in Aussicht stellt, wird das Ergebnis ganz kurz besser und dann bestenfalls gleicht gut funktionieren. Wenn die Sonderleistung (die Erdnuss) gestrichen wird, wird sich die Einstellung durchsetzen, in einer Art Trotzreaktion, die Leistung zu verweigern. Unzählige Studien beschäftigen sich mit der Thematik intrinsische und extrinsische Motivation und deren Auswirklungen. Die Ergebnisse deuten alle in die selbe Richtung. Nur wenn der finanzielle Sonderreiz sehr hoch ist, also deutlich mehr als eine Erdnuss, wird sich jemand auch gesondert bemühen.

Wenn man also einem Menschen für bewertbare Leistungen (zb. Rasenmähen), kleine Bonis gewährt (5€) wird der Mensch zum dressierten Affen, der ohne diese Zuwendung passiv wie ein Affe verharren wird.

Moderne Management Systeme versuchen über Ziele und  Kennzahlen die Mitarbeiter zu managen und versprechen dabei bei Erfüllung entweder sehr viel oder aus Sicht des Mitarbeiters lediglich Peanuts. Das ist eine moderne Art von Zirkusdressur. Dagegen wehren sich moderne gebildete Menschen.

Was denkst Du? Follow up an hannesp@ppedv.de

Sven Hubert: Effektive Berechtigungen aus dem TFS auslesen

Ein lange gehegter Wunsch der TFS Community ist das Auditieren der effektiven TFS Berechtigungen. Die Gründe dahinter können sowohl in der firmeninternen Sicherheitsrichtlinie als auch im regulatorischen Umfeld liegen. Es ist eben immer besser zu wissen, wer Zugriff auf welche Daten hat. Durch das komplexe Zusammenspiel von expliziten und vererbten Berechtigungen der einzelnen Bereiche ist es aber oft nicht nur schwer, sondern schier unmöglich dabei den Überblick zu behalten.

Einige der Bereiche, in denen getrennt Berechtigungen vergeben werden können oder gar müssen, sind:

  • Project
  • Version control
  • Build
  • Warehouse
  • Work Items
  • Areas
  • Iterations
  • Workspace

Das gerade veröffentlichte Projekt “Extracting effective permissions from TFS whitepaper and sample” der ALM Ranger zielt genau auf diese Lücke. Mit der ersten öffentlichen Version erhalten wir ein Whitepaper und einen Prototypen, die uns beispielhaft die Verwendung des TFS Objektmodells (TFS OM) zum Auslesen der effektiven Berechtigungen demonstrieren. Der Code in der Beispielapplikation kann dazu verwendet werden, das TFS OM zu durchschauen und an die eigenen Bedürfnisse anzupassen.

clip_image001

Effektive Berechtigungen aus dem TFS auslesen is a post from: AIT Blog

ppedv Team Blog: Warum c#? oder Was will Ich eigentlich?

Wer sich entscheidet eine Softwarelösung zu entwickeln muss im Voraus viele Fragen klären.
Früher oder später wird immer die Frage zu klären sein in welcher Programmiersprache sich denn eine konkrete Aufgabenstellung am schnellsten, elegantesten oder effizientesten lösen lässt.
Also ist in diesem Kontext zu klären für welche Aufgabenstellungen C# das Mittel der Wahl sein kann.

Wer als Entwickler auf Kenntnisse in C, C++ oder COM zurückgreifen kann wird die Möglichkeit jene weiter zu verwenden nicht ungenutzt lassen wollen. Die .NET Common Language Runtime ist selbst bekanntermaßen komponentenbasiert, und C# zielt im Kern darauf ab alle Objekte möglichst einfach als Komponenten darzustellen. Im Vergleich zu einigen anderen Programmiersprachen die auf Objekten basieren sind C# Komponenten vollständig selbstbeschreibend und müssen nicht gesondert registriert werden was besonders in dem zu berücksichtigen ist wenn man an bereits existenten Anwendung arbeitet. C# im Gegensatz zu anderen Hochsprachen ermöglicht durch den unsafe-Modus Lowlevelzugriffe womit man alte performante  Lösungsansätze mit der Eleganz einer modernen Programmiersprache vereinen kann.

Für Annehmlichkeit sorgen die .NET Common Language Runtime mit massiver Bibliotheksunterstützung und Visual Studio als mächtiges und trotzdem recht intuitives Tool. Zwei Features des C# sind besonders hervor zu heben:

LINQ (Language Integrated Query), vereinheitlicht den Zugriff auf externe und interne Quellen auf die man sonst mit jeweils ihren eigenen Methoden zugreifen müsste. Im Unterschied zu SQL kann mit LINQ auch auf hierarchische und Netzwerk-Strukturen zugegriffen werden. Wichtig ist das LINQ Code vom Compiler direkt auf Fehler geprüft werden kann und so die Fehleranalyse massiv vereinfacht.LINQ bsp

Lambda-Ausdrücke, sind anonyme Funktionen mit denen lokale Funktionen geschrieben werden können welche als Argumente übergeben oder als Wert von Funktionsaufrufen zurückgegeben werden können. Auf der linken Seite des Lambda Operators => müssen etwaige Eingabeparameter stehen und auf der anderen der Ausdruck oder Anweisungsblock.
Lambdabsp



Am ehesten muss C# sich also mit Java und C++ vergleichen lassen, in folgenden Blogeinträgen werde ich auf die Unterschiede detaillierter eingehen.
Wer jetzt sofort mehr über C# samt LINQ und Lambda-Ausdrücken erfahren will hat die besten Chancen dazu in einem Kurs der ppedv.

Christian Binder [MS]: Visual Studio Online Extensibility – REST API

Bisher konnte man die TFS .Net API und den Java SDK nutzen, um sich zu integrieren. Nun gibt es als Preview auf VSO eine neue Rest API, OAuth und Service Hooks, die ohne die bisherigen API's eine Integration ermöglichen. Uli Strinweiß und Karsten Kempe haben einen Showcase auf der API gebaut, den wir kurz vorstellen:

image

Im Talk haben wir angkündigt, dazu weitergehende Blogposts zu veröffentlichen- jetzt ist es soweit hier ist der erste  Post.

Danke an Karsten und Uli

Karsten Kempe: Visual Studio Online Extensibility – REST API

Visual Studio Online IntegrateAm 28. Oktober 2014 hat Microsoft ein neues API veröffentlicht, das Daten aus Visual Studio Online zur Verfügung stellt. Benutzt werden hierzu Standard-Web-Technologien wie REST, JSON und OAuth. Dieses API kann als zukünftige Basis-Schnittstelle für Visual Studio Online und Team Foundation Server angesehen werden. Ulrike Stirnweiß und ich haben bereits mit Christian Binder, Senior Evangelist von Microsoft, über die neuen Möglichkeiten gesprochen. Ein Video des Talks könnt Ihr Euch hier ansehen. Zusammen mit Ulli werde ich in einer Artikel-Serie weiterführende Informationen zu diesem API geben. Los geht’s mit dem REST-Service – die REST API.

Natürlich gibt es das REST API schon ein paar Monate länger (Preview seit Mai 2014) und somit konnten Ulli und ich uns schon eine Weile damit beschäftigen. Zusammen mit Marco Richardson haben wir eine Windows App entwickelt, die ihre Daten über die neue Schnittstelle von Visual Studio Online bezieht.RestApi_VSO_Evolution

Abbildung 1: Screenshots aus dem TFS Showcase

Ich werde Euch in diesem Beitrag die Grundlagen der REST API an Hand einer einfachen Konsolenanwendung näher bringen, während Euch Ulli in einem weiteren Beitrag nützliche Tipps und Tricks zur Verwendung der API in einer Windows App liefert.

REST API

Zuerst möchte ich die Frage klären, was man eigentlich unter einer REST API versteht. Der Begriff REST steht für REpresentational State Transfer und API für Application Programming Interface. Demzufolge ist eine REST API also eine Art Beschreibung für eine Schnittstelle einer Web-Anwendung. Ein sog. RESTful Service zeichnet sich unteranderem durch folgende Merkmale aus:

  • er referenziert alle Datenobjekte durch eine eindeutige URL
  • er verwendet die Standard-Methoden des http-Protokolls (GET, PUT, POST und DELETE)
  • er kann angefragte Objekte unter anderem als JSON serialisiert zurückgeben.

Diese drei Eigenschaften machen die REST API von Visual Studio Online relativ leicht benutzbar und ermöglichen einen verständlichen Aufbau. Die URLs folgen dabei folgendem Pattern:

https://{account}.VisualStudio.com/DefaultCollection/_apis[/{area}]/{resource}?api-version=1.0

Der Platzhalter {account} steht für den tatsächlichen Visual Studio Account, in meinem Fall  https://almsports.visualstudio.com. Mit {area} werden dann die tatsächlichen Bereiche von Visual Studio Online referenziert und {resource} beschreibt das Datenobjekt, welches abgefragt werden soll.

Team Projekte

Um z. B. Informationen aus einem Projekte abzurufen, muss folgender Aufruf abgesetzt werden:

https://almsports.visualstudio.com/DefaultCollection/_apis/projects/f2c5c767-36ba-485a-b478-f6de0f8f84b3?api-version=1.0

um das folgende JSON-Objekt als Rückgabewert zu bekommen:

{
 
"id": "f2c5c767-36ba-485a-b478-f6de0f8f84b3",
 
"name": "gitStart",
 
"url": "https://almsports.visualstudio.com/DefaultCollection/_apis/projects/f2c5c767-36ba-485a-b478-f6de0f8f84b3",
 
"description": "Git",
 
"state": "wellFormed",
 
"_links": {
 
   "self": {
 
      "href": "https://almsports.visualstudio.com/DefaultCollection/_apis/projects/f2c5c767-36ba-485a-b478-f6de0f8f84b3"
 
   },
 
   "collection": {
 
      "href": "https://almsports.visualstudio.com/_apis/projectCollections/31360acb-beb3-4404-bfa2-c1d02c0be2d5"
 
   },
 
   "web": {
 
      "href": "https://almsports.visualstudio.com/DefaultCollection/gitStart"
 
   }
 
},
 
"defaultTeam": {
 
   "id": "0c655975-4f18-4a4a-bb28-527cf4e44489",
 
   "name": "gitStart Team",
 
   "url": "https://almsports.visualstudio.com/DefaultCollection/_apis/projects/f2c5c767-36ba-485a-b478-f6de0f8f84b3/teams/0c655975-4f18-4a4a-bb28-527cf4e44489"
 
   }
 
}

Hinweis: Ein sehr nützliches Tool im Umgang mit der VSO REST API oder allgemein mit RESTful Services ist das Browser-Tool POSTMAN, das für den Chrome-Browser als kostenloses Plug-in zur Verfügung steht.

Der Aufbau der Rückgabe-Objekte erfolgt nahezu immer dem gleichen Schema. Das JSON-Objekt enthält die Basis-Daten eines Team-Projektes aus meinem VSO-Account „almsports“ und hält im Property name den Wert „gitStart“. Wie jedes Objekt ist es über eine id eindeutig identifizierbar und beinhaltet in der Property url den kompletten Aufruf für die Ressource. Innerhalb des Datensatzes des Team Projekts wird ein weiteres Objekt mitgeliefert, welches durch das Property defaultTeam beschrieben wird. Es enthält ebenso eine eindeutige id, einen name und eine url.

In einer .NET Konsolen Applikation kann man relativ einfach die Daten eines Visual Studio Online Accounts abrufen und ausgeben. Dafür genügen wenige Zeilen Code.

Als erstes wird ein HttpClient mit Hilfe eines using Statements erzeugt, um http-Requests absetzen und http-Responses empfangen zu können. Da die REST API von Visual Studio Online bekanntermaßen JSON-Objekte zurückliefert, muss der Accept Header des Aufrufs mit „application/json“ gesetzt werden.

using (HttpClient client = new HttpClient())
{
   //set default RequestHeader
   client.DefaultRequestHeaders.Accept.Add(new 
      System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
 
   //Set alternate credentials
   client.DefaultRequestHeaders.Authorization = 
      new AuthenticationHeaderValue("Basic", Convert.ToBase64String( 
         System.Text.ASCIIEncoding.ASCII.GetBytes(                 
            string.Format("{0}:{1}", _altUsername, _altPassword))));
 
   //do something
}

Die Authentifizierung im obigen Beispiel findet mit den Alternativen Credentials eines VSO-Benutzers statt, dabei wird der AuthenticationHeader auf „Basic“ gesetzt. Aber Achtung: Diese Art der Authentifizierung ist definitiv nicht für den produktiven Einsatz gedacht, da bei jedem http-Aufruf Username und Passwort übertragen werden müssen. Eine bessere Art der Authentifizierung, nämlich OAuth 2.0 für VSO, werde ich einem weiteren Blog-Post vorstellen.

Hinweis: Ein Sample zu den vorgestellten Code-Beispielen steht auf GitHub bereit und kann verwendet werden. Ihr müsst lediglich Euren Account-Namen eintragen und schon könnt Ihr loslegen.

Work Items abrufen

Ein relativ großer Bereich der REST API in Visual Studio Online ist das Work Item Tracking. Mit Hilfe des REST Interface kann auf nahezu alle Bereiche des Work Item Tracking zugegriffen werden. Work Items können erstellt oder editiert, Attachements und Historie können ausgelesen und Tags können vergeben werden.

RestAPI_WorkItems

Abbildung 2: Übersicht der unterstützten Work Item Bereiche der REST API

Work Item-Informationen können über zwei verschiedene Wege abgerufen werden: Entweder man verwendet eine vordefinierte Abfrage (Query) aus einem Team-Projekt, oder man erstellt sich eine eigene Abfrage mit Hilfe der Work Item Query Language (WIQL). Egal welche Methode letztendlich gewählt wird, beide Abfrage-Typen liefern erst nur eine Liste von Work Item IDs zurück. Um detaillierte Work Item Informationen zu erhalten, muss eine zweite Abfrage abgesetzt werden, in der eine der Work Item IDs als zusätzlicher Identifier verwendet werden muss.

string baseUrl = String.Format(constBaseUrl, projectName + "/");
 
//create Json Object with work item query
JObject wiql = JObject.FromObject(new
{
   query = string.Format("SELECT [System.Id], [System.WorkItemType], [System.Title], [System.AssignedTo], [System.State], [System.Tags] " +
   "FROM WorkItemLinks " +
   "Where Source.[System.WorkItemType] IN GROUP 'Microsoft.RequirementCategory' " +
   "AND Target.[System.WorkItemType] IN GROUP 'Microsoft.RequirementCategory' " +
   "AND Target.[System.State] IN ('New','Approved','Committed') " +
   "AND [System.Links.LinkType] = 'System.LinkTypes.Hierarchy-Forward' " +
   "ORDER BY [Microsoft.VSTS.Common.BacklogPriority] ASC, " +
   "[System.Id] ASC MODE (Recursive, ReturnMatchingChildren)")
});
 
//first we only get all work item ids
var responseBody = await Common.PushAsync(client, wiql, 
   String.Format(baseUrl + "/wit/wiql?{0}", constApiVersion));

Anschließend werden in einer zweiten Query, in der die zurückgegeben Work Item IDs zusammen mit einem Where-Statement stehen, die Detailinformationen der Work Items
angefragt. Dabei muss unbedingt darauf geachtet werden, dass kein Projektname in der URL angegeben wird, sonst wird die angefragte Ressource vom Service nicht gefunden und man bekommt eine „404 not found“ Fehlermeldung zurück.

//this time base URL is without projectname!!!
baseUrl = String.Format(constBaseUrl, "");
 
//set fields - which data we want to get
string whereClause =
   string.Format("fields=System.Id,System.Title,System.WorkItemType,Microsoft.VSTS.Scheduling.RemainingWork");
 
//create uri for requesting work item data
string uriString = String.Format(baseUrl + "wit/workitems?ids={0}", workItemStrings), whereClause);

Das JSON der Rückgabe sollte dann wie folgt aussehen und kann z.B. im JSON Visualizer, einem Visualizer des Debugging-Watch-Window von  Visual Studio 2013, überprüft werden.

RestApi_JSON_Response

Abbildung 3: JSON Response der Work Item Query

Ulli Stirnweiss wird in Kürze auf Ihrem Blog einen Artikel posten, in dem sie Euch erklärt, wie man aus einer Windows App heraus Visual Studio Online Daten ausliest.

Stay tuned.

[1] http://almsports.net/visual-studio-integrate-rest-api-oauth-service-hooks/1449/#more-1449

[2] http://www.visualstudio.com/en-us/integrate/get-started/get-started-rest-basics-vsi

[3] https://github.com/almsports/VSORestSample

 

ppedv Team Blog: Bedeutung von Open Source in 2015

Bei einem Bier Gespräch mit Norbert Eder, kam das Thema auf meine aktuelle Meinung zu Open Source. In der Community ist ein Blog Eintrag vor ca zweieinhalb Jahren durchaus heftig diskutiert worden. Fazit daraus, die Verfügbarkeit von Quellcode unter OS Lizenz hat keine Bedeutung für mein Business. In  der Zwischenzeit ist viel passiert, einiges was meine damalige Meinung stützt und anderes was meine Sicht auf die Dinge verändert hat.

Open Source basierte Software ist nicht besser oder sicherer als Closed Source. Dieses Thema hatte ich anlässlich des Sicherheits Problems Heartbleed aufgegriffen. Es fehlt schlicht jeder Beweis für die häufig vertretene These, das hunderte Entwickler den Code prüfen und damit Sicherheitsprobleme sofort auffallen und gelöst werden.

Aus der Sicht als Microsoft Kunde, hat die Veröffentlichung des Quellcodes in der Vergangenheit praktisch meist das Ende des Produktes bedeutet. In jedem Fall wurden Developer Ressourcen abgezogen und die Qualität leidet.

Mein Bedürfnis Quellcode einer Bibliothek zu lesen und vielleicht sogar einen Bug zu fixen hält sich erheblich in Grenzen. Gleiches gilt für Consumer und sicher auf in weiten Teilen für den Enterprise Kunden. Norbert führte ins Feld, das er die Möglichkeit nutzt und auch schon mal Code zurück geleifert hat, neudeutsch contributed. Für mich habe ich dies in den Anfängen von .NET mit ildasm ab und angenutzt um IL Code zurück zu Compilieren und auch mal eine Klasse mit diesem Fragmenten neu zu schreiben. Mit steigender Funktion und Stabilität von .net hat sich dies erübrigt.

Nur ein sehr kleiner Teil der Community ist fähig und willig Code zu contributen. Aus einer konkreten Problemstellung in Angular, kann man auf github nachvollziehen, das es mit der Innovation und den kurzen Zyklen nicht immer so weit her ist. Konkret fehlt eine häufig gewünschte Funktion seit fast drei Jahren.  Angular ist ohnehin ein Spezialfall, weil Google getrieben und bezahlt. Trotzdem wird nur  Support von ca 18 Monaten angekündigt. Im Vergleich dazu bei Microsoft Silverlight zehn Jahre. Wie die Erfahrung zeigt, kann das Ende in jedem Fall schnell und überraschen kommen- in dieser Hinsicht steht es 1:1.

Dabei gibt es durchaus eine Reihe von Leuten die außerhalb des Angular Projektes den Aufwand getrieben haben und dieses fehlende Feature entwickelt haben. Dazu gehöre auch ich. Allerdings findet sich meine Lösung als Blog Beitrag, schlicht weil ich den Aufwand mit Github nicht treiben möchte und auch Zweifel habe ob meine Lösung wirklich optimal ist. Was ich definitiv nicht brauche ist emotionale Diskussion bis hin zum Shitstorm meiner Arbeit, Norbert Eder fordert in diesem Kontext mehr Mut und verspricht sich davon die persönliche weiter Entwicklung.

Welche Auswüchse die Selbstorganisation von Open Source Projekten annehmen kann, sieht man an Node.js oder Angular 2. Erst passiert längere Zeit nichts, dann gibt es eine Abspaltung, Fork genannt und keiner weis so recht, wie es weiter geht. Durchaus häufig Bloggen Core Entwickler Ihren Unmut und die Beweggründe für Ihren Ausstieg, was dem Projekt nicht zuträglich ist. Natürlich kann das bei Unternehmen auch passieren, allerdings sind diese für Ihre Produkte haftbar. Das kann richtig ins Geld gehen. Open Source Projekte sind da fein raus, da haftet niemand. Mitarbeiter sind überdies Vertraglich zur Verschwiegenheit verpflichtet.

OS Bibliotheken werden in der Regel völlig Enthusiastisch von der Community aufgenommen  und über Nacht zum defacto Standard deklariert. Wer Zweifel äußert, hat nicht verstanden oder sich noch nicht hoch genug in die spirituellen Welten begeben.

Wenn Monate später Design oder Performance Ziele nicht erreicht wurden, wird still und heimlich eine neue JavaScript Sau durchs Dorf getrieben. Da bleibt keine Zeit für Manöver Kritik und Analyse des Scheiterns. Hintergründe sind bestenfalls einer Handvoll Insidern bekannt.

In einem User Group Vortrag von Mike Bild zum Thema Microservices, fiel nebenbei die Bemerkung “mit dem alten Zeugs, bekommst schlicht keine Entwickler mehr”.  Das geht sogar soweit, das jeder Service mit einer eigenen Technologie gebaut werden kann. Ein Gedanke der sich mit der generellen Veränderung des Weltbildes der heutigen Berufseinsteiger gut deckt. Mann will selbstbestimmt leben. Ein Pflichtenheft degradiert dabei zum Code Monkey. Das bedeutet das es Technologie Entscheidungen gibt, die die Anzahl der Bewerber erheblich steigern können. Richtig- die ganze Java Script Welt scheint  aus diesen Nektar zu sprießen. Die agilen Methoden liefern genau dafür Management freie Umgebungen. Jeder tut was er kann und will. Der Kontrollverlust ist Horrorvorstellung für fast jeden Entscheider.

Microsoft setzt seit einigen Jahren auf Open Source, weit über das Ajax Control Toolkit hinaus. Man fragt sich warum. Wo wird dadurch Geld verdient? Speziell da sich der Redmonder Hersteller diesen Projekten regelrecht anbiedert und dabei die gestandenen Microsoft Kunden gefühlt im Regen stehen lässt. Seit Windows 8, also schon vier Jahre, werden JavaScript und co propagiert. Der einzige Zweck kann nur sein, Teile der nicht Microsoft Welt abzuholen. Gefühlt ohne große Resultate, dafür aber plötzlich mit einem Migrationspfad, der weg von Microsoft führt. In der Tat sind einige MVP’s in der Zwischenzeit stolze Mac User mit veränderten Entwicklungsfocus.

Gern zitiertes Argument pro Shared und damit Quell Offener Software ist der letztendlich verlorene Kampf der Microsoft Encarta vs Wikipedia. In erster waren viele Entwickler und Autoren beschäftigt und bezahlt. Wikipedia arbeitet kostenfrei und sogar (fast) ohne Werbung.

image

Auch Wikipedia kennt die Community üblichen Grabenkämpfe zwischen der für Reinheit kämpfenden Elite und anderen Autoren. Auch Wikipedia braucht Geld. Das allerschlimmste aber, es ist nur Platz für ein einziges Wikipedia. Es kann keine Konkurrenz und damit auch keine Innovation mehr gegeben. Die Zukunft wird eine Welt der Monopole bringen.

Die Microsoft Openess gipfelt in der Veröffentlichung von Kern Teilen des .NET Frameworks, Ich könnte meinen ASP.NET 5 Code nun teilweise auf einem iOS hosten. Warum sollte ich das? Ich würde mir mehr wünschen, das Silverlight auf iOS oder Android läuft. Aber das ist eine andere Geschichte.

Die neue selbstbestimmte Generation findet also sich und den Shared Gedanken in Open Source wieder. Diese Mitarbeiter sind damit intrinsisch motiviert und schaffen auf Vertrauensbasis. Soweit das Ideal. Allerdings wechselt Motivation und unterliegt der Tagesverfassung. Man hat Sorgen, Krankheit  oder einen blöden Chef der das alles nicht versteht. Produkte müssen trotzdem fertig werden. Den durchaus nicht neuen agilen Gedanken findet man als Vorgehensmodell in SCRUM definiert. Den größten Vorwurf den ich z.B. Scrum mache ist, das von einer idealen Welt ausgegangen wird. Der krank feiernde Kollege existiert darin nicht.

Auch Open Source enthält Übles und wir haben keine Mechanismen damit umzugehen. Paket Manager werfen gnadenlos zehntausende Zeilen Code in das Projekt. Selbst wenn man alles validieren würde, erlauben es die extrem kurzen Zyklen nicht, den Code Fehlerfrei zu halten. Enterprise Kunden stiegen dann aus npm und nuget aus und pflegen ihren veralteten Open Source Code selber weiter. Persönlich erwarte ich den ein oder anderen Sicherheitsgau auf uns zukommen.

Allerdings hat Open Source wesentliche Impulse geliefert um in diesem Umfeld überhaupt Software produzieren zu können. Das öffnen einer Issue List für jedermann, die kurzen Zyklen und das ggf. direkte Eingreifen in den Code findet man in Wasserfall basierenden Modellen nirgends. Diese dafür entwickelten Konzepte erlauben es nun viel schneller Produkte in den Markt zu bringen. Der vorläufige Höhepunkt aus der Open Source Community ist DevOps mit Vermischung von Administration und Programmierung. Die Release Zyklen gehen dabei bis in den Minutenbereich und erlauben dann kaum noch automatisierte Tests.  Codieren sozusagen am offenen Herzen. Nichts desto trotz sind die Vorgehensweisen essentiell beim Fixen on Hot Bugs in stark genutzten Web Anwendungen. Einen mehrstündige Down kann sich eine Azure Cloud nicht leisten.

Open Source wird weiter das Business aufrollen. Getrieben vom Trend der Shareconomy. Persönlich sehe ich das nur als schmalen Aspekt einer tiefgreifenden gesellschaftlichen und wirtschaftlichen Veränderung. Welche Risiken und Veränderungen sich daraus ergeben, lässt sich nicht einmal im Ansatz abschätzen. Bei weiten Teilen der Community spielt Risiko Betrachtung aktuell gar keine Rolle mehr. Letztendlich bleibt auch die Frage offen wie unsere Geschäftsmodelle der Zukunft aussehen werden, wenn plötzliche keine Software Lizenzen  mehr verkauft werden.

ppedv Team Blog: Windows Server 2012 R2: WSUS automatisch bereinigen

Mit der Zeit sammeln sich auf einem WSUS (Windows Server Update Service) einige Updates an. Da können auch schnell mehrere hundert Gigabyte an Daten zusammenkommen. Nicht jedes Update, welches auf dem WSUS gespeichert ist, wird aber noch benötigt. Daher ist es aus Gründen der Speicherplatzeffizienz sinnvoll, von Zeit zu Zeit etwas aufzuräumen. Dafür gibt es schon seit längerem einen passenden Assistenten in der WSUS-Konsole:

wsus_cleanup_00

Dieser Assistent ließ sich “früher” (also z.B. unter Windows Server 2008 R2, WSUS 3.0 SP2) nur manuell oder über komplizierte Skripte ausführen.

wsus_cleanup_01

wsus_cleanup_02

Seit Windows Server 2012 lässt sich WSUS aber auch über PowerShell steuern. Hier gibt es ein passendes Commandlet “Invoke-WsusServerCleanup”, welches die Bereinigung durchführt. Als Parameter kann verwendet werden:

Invoke-WsusServerCleanup [-CleanupObsoleteComputers] [-CleanupObsoleteUpdates]

[-CleanupUnneededContentFiles] [-CompressUpdates] [-DeclineExpiredUpdates]

[-DeclineSupersededUpdates] [-UpdateServer <IUpdateServer> ] [-Confirm] [-WhatIf]

 

Damit lässt sich unkompliziert steuern, welche Komponenten beräumt werden sollen.

wsus_cleanup_03

Dieses PowerShell-Commandlet kann nun z.B. im Rahmen eines kleinen Skriptes regelmäßig und automatisch (z.B. per Aufgabenplanung) ausgeführt werden. Damit spart man sich die regelmäßige, manuelle (aufwändige) Bereinigung mit Hilfe des Assistenten.

Die komplette Syntax zum angesprochenen PowerShell-Commandlet findet sich hier: http://technet.microsoft.com/en-us/library/hh826162.aspx

Sven Hubert: Zeitgesteuertes Stoppen von Windows Azure VMs

Jedem MSDN Abonnenten stellt Microsoft ein Azure Freikontingent zur Verfügung. Abhängig vom Typ der Subscription beläuft sich dieses auf 75 € (Premium) oder 115 € (Ultimate). Dies ist ausreichend um einen wirklich performanten virtuellen Rechner mit 4 Kernen, 14 GB RAM und 250 GB SSD einen Monat zu betrieben. Zumindest wenn man daran denkt, die Maschine am Feierabend herunterzufahren. Sonst läuft der Zähler einfach weiter und schon nach 7 Tagen ist das gesamte Monatsbudget aufgebraucht. Lässt sich da nicht etwas automatisieren?

Ein zeitgesteuertes Stoppen lässt sich am einfachsten mit Hilfe der Microsoft Azure Automatisierung umsetzen.

Hierzu sind folgende Schritte erforderlich.

Schritt 1: Erzeugen eines Management Zertifikats

Um über PowerShell auf Windows Azure zugreifen zu können ist eine Authentifizierung notwendig. Dies funktioniert über Nutzername und Passwort. Sicherer ist die Verwendung eines Zertifikats.

Dieses kann über die Kommandozeile erzeugt werden.

makecert -sky exchange -r -n "CN=Azure Start/Stop Management Certificate" -pe -a sha1 -len 2048 -ss My "D:\Temp\Azure_StartStopManagement_Certificate.cer"

Über die Management Console ist im Anschluss ein Exort des Zertifikats (incl. Private Key) möglich.

Nach den gezeigten Schritten stehen im Verzeichnis D:\Temp die Dateien Azure_StartStopManagement_Certificate.cer und Azure_StartStopManagement_Certificate.pfx zur Verfügung.

Schritt 2: Hinterlegen des Management Zertifikats

Das Zertifikat muss nun im Bereich Einstellungen -> Verwaltungszertifikate im Azure Management Portal hinterlegt werden.

Wer über den Private Key des Zertifikats verfügt kann nun über PowerShell auf den Azure Account zugreifen.

Schritt 3: Anlegen der Automatisierung

Für die Hinterlegung eines Skripts muss ein Automation-Konto angelegt werden.

Schritt 5: Hinzufügen von Ressourcen

Für die Ausführung der Skripte (siehe Schritt 6) werden verschiedene Informationen benötigt. Hierzu gehören der Name und die ID der Subscription sowie das im ersten Schritt erstellten Zertifikat für die Authentifizierung.

Die ID und der Name der Subscription werden als Variablen eingefügt.

Die relevanten Informationen hierzu sind unter Einstellungen des Azure Accounts zu finden.

Das Zertifikat wird als Anmeldeinformation eingefügt. Zusätzlich wird dessen Name als Zeichenfolge hinterlegt. Dies ermöglicht später eine flexiblere Steuerung mehrerer Azure Accounts.

Nach dem Vornehmen der Einstellungen werden diese in der Übersicht unter Ressourcen angezeigt.

Schritt 4: Hinterlegen der PowerShell Skripte

Das Skript, welches die Logik enthält, wird als Runbook hinterlegt.

workflow StopVM

{

   Param 

   ( 

       [parameter(Mandatory=$true)][String] $VMName,     

       [parameter(Mandatory=$true)][String] $ServiceName 

   ) 

 

   $subscriptionName = Get-AutomationVariable -Name "SubscriptionName" 

   $subscriptionID = Get-AutomationVariable -Name "SubscriptionID" 

   $certificateName = Get-AutomationVariable -Name "CertificateName"

   $certificate = Get-AutomationCertificate -Name $certificateName 

   

   Set-AzureSubscription -SubscriptionName $subscriptionName -SubscriptionId $subscriptionID -Certificate $certificate 

   Select-AzureSubscription $subscriptionName 

   

   Stop-AzureVM -Name $VMName -ServiceName $ServiceName -Force

}

Ein Test des Skripts ist direkt im Portal möglich.

Hierbei muss als Parameter der Name der VM bzw. der des Service angegeben werden der angehalten werden soll.

Die Ergebnisse des Tests werden nach einigen Sekunden im Ausgabebereich angezeigt.

Wurden alle Einstellungen korrekt vorgenommen wird als Ergebnis „Succeeded“ angezeigt.

Schritt 5: Verknüpfen eines Zeitplans

Für ein zeitgesteuertes Ausführen kann nun ein Zeitplan hinterlegt werden.

Der Zeitplan ist im Anschluss direkt aktiv. Die Ergebnisse der Ausführungen sind unter Aufträge einzusehen.

clip_image060

Durch die gezeigte Automation können gezielt einzelne VMs gestoppt werden. Durch leichte Anpassungen des PowerShell Skripts ist auch ein Stoppen aller VMs möglich.

Über diesen Weg lässt sich ein Vergessen des Stoppens einer VM am Feierabend sicher verhindern. Damit hat man mehr von seinem freien Windows Azure Kontingent.

Zeitgesteuertes Stoppen von Windows Azure VMs is a post from: AIT Blog

Code-Inside Blog: Microsoft Account Auth and Profile Data via LiveSDK in ASP.NET

In this blogpost I will take a deeper look at the LiveSDK to authenticate users by their Microsoft Accounts and display some profile information of the given user.

Didn’t ASP.NET Identity try to solve this problem?

If you only need the “Authentication”-Part, this might be true (here is one quick walkthrough. In theory you are only one checkbox away from the solution with the new Identity system.

But if you need deeper integration and want to retrieve data from OneDrive, OneNote or Outlook.com then you need to take a look at the LiveSDK. Maybe you can use the auth token from the ASP.NET Identity part and use this for the LiveSDK - but I’m not sure on this. Another point is that the ASP.NET Identity stuff feels so bloated and the database part is scary.

Our Mission: Pure LiveSDK, no magic.

Before you start: Setup the Domain and get the API Key & Secret

The setup flow is the same as for Twitter/Facebook/Google Auth, but with one (stupid) limitation.

First step: Create an App in the Microsoft Developer Center.

Second step: Enter the Root & Redirect Domain for the App. You will need a “real” URL - localhost is not accepted (d’oh).

Because real URLs are always kinda painful while developing you have two options:

  • a) Manipulate your hosts file (%SystemRoot%\system32\drivers\etc\hosts)
  • b) Use a service like localtest.me

I will stick to b) with the blogpostsample.localtest.me URL. To setup the binding I will also commit a Powershell file called “Enable-LocalTestMe.ps1” - this should ramp up everything on your development machine and make VS & IIS Express happy. After that you can F5 to your WebApp and it will open at “blogpostsample.localtest.me”. Yay!

So, my registration inside the DevCenter looks like this:

x

ASP.NET & LiveSDK

Next step: Create a new ASP.NET MVC app without any authentication provider and get the Live SDK for ASP.NET NuGet package.

The LiveSDK has two main parts:

  • LiveAuthClient: For the authentication part.
  • LiveConnectClient: After successful authentication interact with the service.

To learn more about the LiveSDK follow this MSDN link.

My sample code doesn’t store any token on the client or does any other clever mechanics and it even has hardcoded URLs in it, but this should work for the demo ;).

Trigger Authentication Flow

You need to list all “needed” scopes for the authentication flow. The scopes are documented here. The API uses OAuth2 for the authorization flow.

private static readonly string[] scopes =
    new string[] { 
        "wl.signin", 
        "wl.basic", 
        "wl.calendars" };

private readonly LiveAuthClient authClient;

public AuthController()
{
    authClient = new LiveAuthClient("0000000044121F5D", "b6lolb9jiF-zaMtp8KXcRNJ7ACz37SuK", "http://blogpostsample.localtest.me/Auth/Redirect");
}

public async Task<ActionResult> Index()
{
    LiveLoginResult loginStatus = await this.authClient.InitializeWebSessionAsync(HttpContext);
    switch (loginStatus.Status)
    {
        case LiveConnectSessionStatus.Expired:
        case LiveConnectSessionStatus.Unknown:
            string reAuthUrl = authClient.GetLoginUrl(scopes);
            return new RedirectResult(reAuthUrl);
    }

    return RedirectToAction("Index", "Home");
}

This code will initialize the authentication flow and create the “LiveAuthClient” and (hopefully) redirect the browser to the Microsoft Account Login.

x

On the first login the user needs to consent the desired “scopes”.

x

After this step the user will be redirected to the redirect url (in my case …/Auth/Redirect).

Get Microsoft Account Data

So, now this part is a bit magic, but I guess the “ExchangeAuthCodeAsync” will load the token from the Request and validate it. If everything is correct the status should be “Connected”.

public async Task<ActionResult> Redirect()
{
    var result = await authClient.ExchangeAuthCodeAsync(HttpContext);
    if (result.Status == LiveConnectSessionStatus.Connected)
    {
        var client = new LiveConnectClient(this.authClient.Session);
        LiveOperationResult meResult = await client.GetAsync("me");
        LiveOperationResult mePicResult = await client.GetAsync("me/picture");
        LiveOperationResult calendarResult = await client.GetAsync("me/calendars");

        ViewBag.Name = meResult.Result["name"].ToString();
        ViewBag.PhotoLocation = mePicResult.Result["location"].ToString();
        ViewBag.CalendarJson = calendarResult.RawResult;
    }

    return View();
}

The LiveConnectClient is a relatively thin layer on top of the REST API.

Result:

x

Mission accomplished!

The code so far was trivial, but will run (but maybe not in the most robust way).

If you want to learn more, the LiveSDK is on GitHub and the Interactive Live SDK might be useful for you.

The source code is available on our GitHub-Samples-Repo.

I also posted a short blogpost in German about Microsoft Account Authentication ASP.NET Identity some month ago.

Hope this helps!

Kay Giza [MS]: Developer-Umfrage: Informationsbeduerfnisse fuer Ihren beruflichen Erfolg – Danke fuer Ihre Mithilfe

Gerne möchten wir, das MSDN Team von Microsoft Deutschland, Sie einladen, an einer Umfrage zum Thema Informationen für Ihren beruflichen Erfolg in der Software-Entwicklung teilzunehmen. Die Umfrage ist in 5-10 Minuten ausgefüllt und hilft uns, unser Angebote, Leistungen sowie Ressourcen für Sie als Entwickler zu optimieren und noch spezieller auf Sie einzugehen. Danke im Voraus... [... mehr 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

Norbert Eder: Weniger Demotivation, mehr Motivation

Zum Thema Motivation gibt es ja hunderte, wenn nicht gar tausende Bücher und Ratgeber. Was findet sich nicht an Tipps wie man sich selbst und andere motivieren kann. Das klingt hilfreich, aber: Selbst motivieren kann sich nur, wer ohnehin schon einen gewissen Grad an intrinsischer Motivation mitbringt. Andere Menschen zu motivieren ist weitaus schwieriger. Sie müssen begeisterungsfähig sein und ebenfalls über einen ausreichend starken Motivations-Motor verfügen. Da dies alles nur sehr schwer steuerbar ist, empfiehlt es sich an einer einfacheren Stelle zu investieren: Demotivation verhindern.

The post Weniger Demotivation, mehr Motivation appeared first on Norbert Eder.

Marco Scheel: Links for 2014-12-07 [del.icio.us]

Marco Scheel: Links for 2014-12-05 [del.icio.us]

Golo Roden: Kommentar: Ist io.js das neue Node.js?

Nach einem Jahr des Stillstands kommt durch einen Fork endlich wieder Bewegung in die einst so rege Node.js-Community. Das hat Node.js bitter nötig, aber es besteht nun immerhin wieder Hoffnung.

Kay Giza [MS]: Jetzt Plaetze sichern: Microsoft WebCamps in Muenchen und Koeln im Dezember 2014

Nach dem Erfolg des Web Summits Anfang 2014 und der Web Camps im Juni bietet sich zum Ausklang des Jahres 2014 noch einmal die Möglichkeit auf zwei kostenlosen eintägigen WebCamps, sich einen kompakten Überblick über die Webplattform und -werkzeuge von Microsoft zu verschaffen. Teilnehmer erfahren u.a. mehr zu ASP.NET, JavaScript Frameworks, Cloud Hosting, der Integration von Open Source... [... mehr 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

Sven Hubert: TFS Security: Schützen Sie ihr Kapital

Schon längst ist Software ein integraler Bestandteil in nahezu jedem neuen Produkt. Eine Kaffeemaschine ohne Produktwahl-Display, eine Waschmaschine ohne Verschmutzungsgrad-Sensor und Bluetooth oder das Mediacenter im Auto. Selbst an den Tintenfüllstands-Chip in Druckerpatronen oder den „Apple Autorisiert“-Chip im iPhone Ladekabel haben wir uns bereits gewöhnt. Für die Hersteller der Produkte sind diese Maßnahmen zum "Schutz" oft notwendig, stellt doch die hierfür entwickelte Software einen Großteil des unternehmenskritischen Kapitals dar. Und wie es mit Kapital eben mal so ist: Wir bekommen ein Problem wenn es uns einer wegnimmt, oder kaputt macht. Und beides kann mehr oder weniger auch bei Software zutreffen.

Im Fall der Industriespionage könnte ein Konkurrent den Quellcode heimlich kopieren und sich die Entwicklungskosten sparen. Je nach Intention des Konkurrenten kann er sich nun die besten Teile „abschauen“ oder einfach das vollständige Produkt kopieren. Was zwar sehr offensichtlich wäre, aber auch mindestens ebenso schwer vor Gericht nachzuweisen, wenn er neben dem Release-Stand auch die historischen Entwicklungsdaten vorweisen kann.

Weitaus gefährlicher ist die Angelegenheit aber noch wenn wir uns überlegen, dass ein Angreifer den Code gar nicht selbst nutzen möchte. Seine Motivation kann der Kick, Schadenfreude oder eingeschleuster Code sein. Ein Virus im neu entwickelten Online-Game schadet dem Ruf unserer Firma enorm, aber ein Backdoor in der Banking-Software füllt darüber hinaus auch noch fremde Konten.

Bei der Installation einer neuen Systemkomponente im modernen firmenweiten Netzwerk stellt sich unweigerlich und schnell die Frage nach deren Sicherheit. Sicherheit wird gerne unpräzise und allgemein als Oberbegriff für die Absicherung von Software und Rechnern verstanden. In den nachfolgenden Artikeln reden wir über die Aspekte Authentifizierung und Autorisierung.

Authentifizierung adressiert dabei die Sicherstellung der Vertraulichkeit in die Kommunikation. Eine Vertraulichkeit wird beispielsweise durch das Unterbinden der Einsicht von unautorisierten Dritten in die Daten durch Verschlüsselungs-Technologien erreicht. Ein weiterer Aspekt ist die Erkennung und präventive Verhinderung von Manipulation durch geeignete Maßnahmen. Ein Beispiel aus dieser Kategorie sind Prüfsummen bei der Datenübertragung.

Autorisierung im Gegensatz dazu stellt sicher das nur berechtige Personen Zugriff auf Ressourcen erlangen können. In der Praxis tritt der Anwender in Form von Nutzernamen und Passwörtern sowie komplexen Berechtigungssystemen für diverse Systeme in Kontakt. Wie man hier erahnen kann, müssen Authentifizierung und Autorisierung nicht zwingend zusammenfallen. Ein sicheres System adressiert jedoch beide Bereiche.

Gerade wenn es sich um sensible Softwareentwicklungsdaten wie Quellcode oder Planungsdaten im TFS handelt möchten wir gerne sicherstellen, dass die Kommunikation weder abgehört noch manipuliert wird und schon gar kein unbefugter Zugriff erlangen kann.

Eine alte auf die IT übertragene Weisheit besagt „Ein Netzwerk ist nur so sicher wie seine Einzelteile“ – Erfahren Sie in den nächsten Artikeln, wie Sie diese „Einzelteile“ Ihres TFS gezielt absichern können.

TFS Security: Schützen Sie ihr Kapital is a post from: AIT Blog

Christian Binder [MS]: ALM Days 2015 - Software Engineering war nie spannender

Die Anmeldung zu den ALM Days 2015 am 11&12.3 2015 ist ab jetzt unter www.alm-days.de möglich. Mehr Informationen zum Event und den Tracks gibt es in folgendem Video:

image

Software Engineering war nie spannender

Historisch war es für Software Teams nie einfacher Produkte am Markt zu platzieren. Was vor Jahren noch eine große Herausforderung war, ist heute durch die Cloud und AppStores deutlich vereinfacht. Das Resultat – die Dynamik der Software Industrie hat stetig zugenommen und Innovationszyklen haben sich verkürzt. Das Engineering, wie wir es kennen, muss sich deshalb kontinuierlich weiterentwickeln, um den Anforderungen dieser Dynamik gerecht zu werden. Agile, als etablierter Ansatz für kurze zyklische Entwicklung hat sich schon in vielen Teams etabliert. DevOps  – die logische Konsequenz der kontinuierlichen Evolution von Agile in den Betrieb der Software lässt sich gut durch Schlagworte wie Continuous Delivery, Continuous Monitoring und Continuous Learning beschreiben, meint aber auch organisatorische Veränderung. Die daraus resultierende enge Verzahnung von Entwicklung und Betrieb ermöglicht es, Kunden neue Innovationen so schnell wie sinnvoll zur Verfügung zu stellen und so der Marktdynamik folgen zu können. Continuous Learning etabliert in diesem Kontext eine neue Kultur mit dem Ziel, eine kundenzentrische Entwicklung zu etablieren, die unter anderem eine auf Telemetriedaten basierende Innovationssteuerung ermöglicht. Diese spannenden und herausfordernden Themen greifen wir auf dem ALM Days 2015 in mehreren fokussierten Tracks auf.

Viel Spass
Chris

Maik Hanns: Exam 70-499 Recertification for MCSD: Application Lifecycle Management

Auch wenn noch ein paar Monate Zeit waren habe ich heute mal die Rezertifizierung für die Prüfung den MCSD Application Lifecycle Management (Prüfung 70-499) absolviert. Link: https://www.microsoft.com/learning/en-us/exam-70-499.aspx

Ich hatte 43 Fragen zu beantworten und es sind viele ähnliche Fragen aus den Prüfungen 70-496, 70-497 und 70-498 wieder aufgetaucht. Mit fast 20 Fragen war Microsoft Test Manager (MTM) am meisten vertreten (Inhalte von 70-497). Ansonsten gab es wieder Fragen zur Installation, Administration, Version Control, Build Definitionen, Scrum, Process Templates…

Entgegen meiner Erwartungen gab es keine Frage wo ich TFS 2013 Wissen benötigt hätte. Git steht zwar in einem Punkt der Prüfungsinhalte, tauchte aber gar nicht auf. Release Management steht gar nicht erst in den Prüfungsinhalten. In einer Frage wurde sogar TFS Preview erwähnt, was bekanntlich schon lange Visual Studio Online heißt. Und das obwohl die Prüfung im August 2014 veröffentlicht wurde, schade. Highlight war dann die letzte Frage, wo auch nach 10-mal lesen Antwort A und C identisch waren. Zum Glück hat es trotzdem gereicht ;-)

Wer also die Prüfungen 70-496, 70-497 und 70-498 geschafft hat sollte mit der Rezertifizierung keine riesigen Probleme haben.

Sven Hubert: AIT Apply Company Policy goes Open Source

After the EF Oracle Identity Patch, we publish the Apply Company Policy (ACP) project as SDK on GitHub. Based on that repository, you can customize an ACP package to suit your needs. This way you can still profit from any new updates we publish in the ACP SDK and easily include the changes from the original ACP SDK in your customized package.In the first step you have to create and initialize your own repository where you customize the ACP package.

Therefore create a team project (configured with Git as version control system) on your TFS. In Visual Studio, connect to your just created project:

image

Then clone the repository to your local machine:

image

image

 

Your branch overview should look like this:

image

Note that your repository is completely empty and the master branch is not published yet. In order to finish initialization, you have to add at least one file, commit and push the changes to the TFS by publishing the branch. The easiest way to do this is to open the command prompt in your local repository.

image

Then create the file “README.md” using the “touch” command. This file already exists in the ACP SDK repository on GitHub and will just be updated when you pull the current version.

image

The file should appear now in Visual Studio in the “Changes” tab under “Untracked Files”. Hit “Add All” to add the file to the repository.

image

Enter a commit message and commit your changes.

image

Now you can publish the master branch.

image

After this operation, your local and the remote repository are in sync.

 

The second step is to get the current version of the ACP SDK. Therefore, open again the command prompt in your local repository. Enter the following command:

git remote add ACPOrigin https://github.com/AITGmbH/AIT-Apply-Company-Policy-SDK.git

This operation adds another remote to your local repository with the name “ACPOrigin” that points to the ACP SDK repository on GitHub. The default remote is always called “origin” and you have already initialized this default remote by initializing the repository (remember: clone, commit changes, publish branch). You can see all your remotes using the command:

git remote

Using the “pull” command, you can pull files from a remote repository. If you don’t specify a remote name, you always pull from the default remote “origin”. But with the following command, you can pull from the master branch of the just created remote “ACPOrigin”:

git pull ACPOrigin master --no-tags

Note the option “–no-tags”. If you don’t include this option, the tags are fetched from the remote as well. However, if you want to apply tags to commits indicating a new version of your customized package, it might be better to ignore the tags from the ACP SDK.

image

This pull operation automatically merges the files and immediately commits the changes with a generated message. In the “Unsynced Commits” tab, you can see that the latest commit refers to the pull operation, all other commits are fetched from the ACP SDK repository.

image

Synchronize the commits. Then click on the Home icon in the Team Explorer and open the solution.

image

Now you are ready to customize your ACP package and push it to your TFS.

Whenever there is a new version of the ACP SDK, run the pull from ACPOrigin command again:

git pull ACPOrigin master --no-tags

Any conflicts can be resolved in Visual Studio. Then you can push again to your TFS and release a new version of your ACP package.

 

Once the first initialization steps are done, this is an easy method to profit from new ACP SDK Releases and still keep your customizations.

AIT Apply Company Policy goes Open Source is a post from: AIT Blog

ppedv Team Blog: Boostrap Toogle Switch mit Angular Direktive

Was Jquery Mobile mit dem Flipswitch kennt, sucht man bei Bootstrap vergeblich.

image

Da es ziemlich naheliegend ist, fordert die Community auf Github von Bootstrap seit drei Jahren das Feature. Irgendwie vergeblich. Da Open Source, kann man das natürlich selber schreiben und ins Projekt einchecken. Viele tun das scheinbar nicht. Man findet jede Menge Lösungen offsite, die allerdings in Funktion und Qualität nicht ganz den Ansprüchen genügen. Also selber machen.

Das Layout könnte im HTML Code z.B. so gelöst werden

   1:  <div class="btn-group">
   2:       <a class="btn btn-xs btn-primary active">Wert</a>
   3:       <a class="btn btn-xs btn-default">Wert2</a>
   4:  </div>

Ist optisch nicht ganz ein Flipswitch, aber leicht anpassbar.

image

Für den Zustandswechsel wird ein Stück JavaScript benötigt, das die Klassen btn-primary und btn-default austauscht.

Hier wird aber weiter gedacht. Der Wert soll an ein Viewmodel eines Angular.js Controllers gebunden werden.

   1:    .controller('myController', ['$scope', function ($scope) {
   2:                 $scope.wert = true;

 

Der HTML Teil wird mit einer Angular Direktive erstellt. Als Parameter werden die beiden Beschriftungen übergeben.

   1:  <div class="btn-group" 
   2:     my-toggle my-text1="meins" my-text2="public" model="wert">
   3:  </div>

 

In meinem Angular Trainings lernt man die genauen Details zu Direktiven. Auf einige Angular Stolpersteine soll hier aber hingewiesen werden.

Mit dem Template wird HTML Code in der Page erzeugt, der die beiden Buttons enthält. Komplizierter ist die Gültigkeit des Scope, der das Viewmodel aus dem Controller hält und letztendlich den checked Wert enthält. Wie kann man aus einer Direktive auf den Scope des Controllers zugreifen und diesen auch verändern? Da es mehrere geschachtelte Scopes gibt, somit auf den Parent Scope.

Mit Chrome und der Batarang Erweiterung kann die Internas der Scope Hierarchie auch darstellen.

image

image

Im HTML Code wurde vorher das Attribut model eingeführt, das auf die Property wert (also $scope.wert) bindet. Leider verhält sich die Bindung auf den my-text obwohl optisch ident völlig anders.

In der Direktive wird gesteuert, welche Attribute (@) und Bindungen (=) in den privaten Scope übernommen werden. Nun kann in der Click Funktion des DIV! der Parent Scope ($scope.wert) per Child Scope (scope.model) geändert werden, weil das = eine zwei Wege Bindung bewirkt.

   1:  .directive('myToggle', function () {
   2:         return {
   3:                    restrict: 'A',
   4:                      scope: {
   5:                             model: '=',
   6:                             myText1: "@",
   7:                             myText2: "@"
   8:                         },
   9:                         template: '<a class="btn btn-xs active" 
ng-class="model ? \'btn-primary\' : \'btn-default\'">{{myText1}}</a>'
+
  10:                        ' <a class="btn btn-xs " 
ng-class="model ? \'btn-default\' : \'btn-primary\'">{{myText2}}</a>'
,
  11:                         link: function (scope, element, attr) {
  12:                             element.bind('click', function () {
  13:                                 scope.model = !scope.model;
  14:                                 scope.$apply();
  15:                             });
  16:                 }
  17:           }
  18:     })

Code-Inside Blog: Simple WebApp Deployment with WebDeploy and MSBuild in TFS & co.

With this blogpost I will show you how you can trigger WebDeploy to deploy your WebApp - without complicated scripts or scary build workflow systems.

WebDeploy, MSBuild - what?

This is not a introduction blogpost about MSBuild or WebDeploy, but I will try to give you a very short description.

MSBuild: Every time you open a .csproj file you work with MSBuild. MSBuild is XML-based and the primary build “language” for .NET projects.

WebDeploy: WebDeploy is a modern alternative to FTP - the WebDeploy Packages contains the WebApp (in most cases a ASP.NET WebApp) and configuration details for IIS, connections to database etc.

The hardest challenge might be to get WebDeploy running. In theory it is not hard, but there are some tricky problems in certain situations. I already have a couple of posts about WebDeploy-Setup on this Blog.

MSBuild Parameter to trigger WebDeploy

The typical MSBuild call is:

msbuild app.csproj /p:configuration=Release

To trigger MSBuild there are a couple of MSBuild arguments:

/p:DeployOnBuild=True
/p:DeployTarget=MsDeployPublish
/p:MSDeployServiceURL=https://<server name>:8172/msdeploy.axd
/p:DeployIISAppPath=”TestSiteForDeploy”
/p:CreatePackageOnPublish=True
/p:MsDeployPublishMethod=WMSVC
/p:AllowUntrustedCertificate=True
/p:UserName=*****
/p:Password=*****

Most of these properties are listed here.

So you just need to apply all parameters to your MSBuild call and it should build the package (you also may need the OutputPath and Configuration property) and publish it via WebDeploy.

TFS and other Build Systems

If you just have simple requirements you could just add the deployment arguments to your CI-Build and everything should work. In the TFS World you can specify additional MSBuild args. You can do similar things in TeamCity and other Build Systems.

x

As I said in the beginning - it is simple and I found this solution on this Blog, but just to remind me better next time I reblogged it here with my own words.

Hope this helps!

ppedv Team Blog: Hyper-V VMs werden angehalten, wenn der Speicherplatz knapp wird

Auch wenn die Tatsache selbst nicht neu ist möchte ich den folgenden Fakt etwas genauer beleuchten, da immer mehr Unternehmen Hyper-V für produktive Virtualisierungszwecke verwenden.

Eine Hyper-V VM wird vom System angehalten, wenn der Speicherplatz auf dem Laufwerk, welches von der VM für die virtuelle Festplatte verwendet wird, knapp wird. Dies geschieht in erster Linie nur dann, wenn die VM mit einer dynamisch wachsenden VHD oder VHDX arbeitet. Auf Grund eines Bugs waren aber bei früheren Hyper-V Versionen (2008 / 2008 R2) auch VMs mit statischen VHDs betroffen.

Das Anhalten der VM geschieht, um einen Absturz des Gastbetriebssystemes auf Grund von Speicherplatzmangel zu vermeiden (die VM “glaubt” noch reichlich Speicherplatz zu haben und versucht, diesen zu belegen, u.a. auch für die Auslagerungsdatei, in Wahrheit ist der Speicherplatz auf dem Datenträger bereits fast vollständig belegt).

Das Anhalten der VM wird dann mit dem Status “Angehalten – Kritisch” markiert (“Paused – Critical” auf englischen Systemen):

HVFreeSpace01

Insbesondere wenn viele VMs mit dynamisch wachsenden VHDs das selbe Plattensystem nutzen ist das Risiko, dass dies geschieht, relativ groß.

Glücklicherweise kündigt sich das bereits vorab an:

HVFreeSpace03

Im Ereignisprotokoll wird unterhalb von “Microsoft / Windows / Hyper-V-VMMS / Admin” ein Ereignis 16050 protokolliert, welches auf den zur Neige gehenden Speicherplatz hinweist.

Das Problem dabei: Dies geschieht erst, wenn der freie Speicherplatz unter 2GB fällt und benötigt auch einige Sekunden nach dem diese Grenze erreicht wurde, bis der Eintrag protokolliert wird.

Wenn der Speicherplatz dann noch knapper wird und eine oder mehrere VMs angehalten wurden wir dies ebenfalls vermerkt:

HVFreeSpace04

Hier wird im selben Protokoll das Ereignis 16060 vermerkt. Dieses weist nun also auch auf die Tatsache hin, dass eine VM angehalten wurde. Dies geschieht allerdings erst, wenn nur noch 200MB oder weniger zur Verfügung stehen!

HVFreeSpace02

(Hinweis: Die Screenshots stammen von einem Testsystem; Es wird ausdrücklich nicht empfohlen, Hyper-V Daten auf dem Betriebssystem-Laufwerk abzulegen!)

Wenn man mit Snapshots / Checkpoints arbeitet, dann sollte man noch beachten, dass die Daten nach dem Snapshot evtl. auf einem anderen Laufwerk abgelegt werden als vorher!

Mittels “Aufgabe an dieses Ereignis anfügen…” kann man z.B. ein Skript oder eine E-Mail auslösen, wenn die betreffenden Ereignisse eintreten:

HVFreeSpace05

(Dazu muss dann das betreffende Ereignis mittels Rechtsklick angeklickt werden, im Screenshot habe ich ein beliebiges anderes Ereignis gewählt)

ppedv Team Blog: Bootstrap mehrfach Navbar

Einige Zeit habe ich über der Usability einer Web Anwendung gegrübelt. Aktuell verwenden wir das Projekt um Realtime Feedback, vor während und nach Konferenz Sessions, zu bekommen. Die Idee ist einen lernen-wissen-teilen Zyklus weit über die eigentliche Konferenz hinaus zu etablieren.

Nächste Woche auf der GUI&DESIGN in Berlin, wird das Projekt wieder eingesetzt. Da wir unter anderem mobile Devices mit dieser Web App adressieren, folgt das UX dem responsive Design Paradigma. Framework ist Bootstrap.

Jede Konferenz Session kann einzeln von Teilnehmer  mit bis 5 Sternen bewertet oder mit Text Kommentaren versehen werden. Das Problem ist der begrenzte Bildschirm. Wie präsentiert man bis zu 30 Sessions gleichzeitig auf einem Smartphone? Nach einem Pair UX Review mit Martin Hoppe von Maximago, kam der Gedanke auf, das von der Bedienung wie eine Bootstrap Navar zu lösen.

Damit waren folgenden Anforderungen definiert

  • Mehrstufige Navbar
  • Navbar Toogle Button dauerhaft anzeigen
  • Menüpunkte nur bei Drop Down
  • Menü schließen bei Auswahl
  • mehrspaltiger Navbar Collapse Bereich

Da fertige UI auf einem iPhone Emulator

image

Und der nicht ganz perfekte multi drop down Navbar Anwendungsfall

image

Die Steuerung des AufZu einer Navbar, wird über ein UI Element mit dem Attribut data-toggle ausgelöst. Das Ziel ist eine Klasse oder ID eines DIV Elements, hier als collapse2 bezeichnet um einen Unterschied zu navbar-collapse des Top Menüs zu haben. Der Z Index  ermöglicht der Top Navbar sich über die zweite Reihe Navbar zu entfalten. Der Abstand top entspricht der Höhe der Top Navbar.

   1: <nav class="navbar navbar-inverse navbar-fixed-top always-open" 
style="top: 50px;z-index:999;">
   2:    <div class="navbar-header">
   3:      <a class="navbar-brand" href="#">Room {{target}}</a>
   4:        <button type="button" class="navbar-toggle"
   5:           data-toggle="collapse" data-target=".navbar-collapse2">
   6:           <span class="icon-bar"></span>
   7:           <span class="icon-bar"></span>
   8:           <span class="icon-bar"></span>
   9:       </button>
  10:     </div>
  11:              
  12:  <div class=" navbar-collapse2 collapse" >

Die ASPX Seite setzt sich aus einer Masterpage und einer Content Page zusammen. In der Content Page (gern auch View) wird das CSS  von Bootstrap in einem Style Block überschrieben und ergänzt. Ziel ist es das Verhalten der Second Navbar zu ändern (always-open). Diese ist dann nicht mehr Responsive, sondern verhält sich so wie eine Navbar im Smart Device Modus.

   1:  .navbar {
   2:     margin-bottom: 0 !important;
   3:          }
   4:  .navbar.always-open {
   5:     border-radius: 0;
   6:           }
   7:  .navbar.always-open .navbar-header {
   8:     float: none;
   9:           }
  10:  .navbar.always-open .navbar-toggle {
  11:     display: block;
  12:           }
  13:  .navbar.always-open .navbar-collapse {
  14:     border-top: 1px solid transparent;
  15:     box-shadow: inset 0 1px 0 rgba(255,255,255,0.1);
  16:            }
  17:  .navbar.always-open .navbar-collapse.collapse {
  18:     display: none !important;
  19:            }
  20:  .navbar.always-open .navbar-nav {
  21:     float: none !important;
  22:     margin: 7.5px -15px;
  23:             }
  24:  .navbar.always-open .navbar-nav > li {
  25:             float: none;
  26:             }
  27:  .navbar.always-open .navbar-nav > li > a {
  28:     padding-top: 10px;
  29:     padding-bottom: 10px;
  30:             }
  31:  .navbar-collapse2 {
  32:     padding-right: 15px;
  33:     padding-left: 15px;
  34:     overflow-x: visible;
  35:     -webkit-overflow-scrolling: touch;
  36:     border-top: 1px solid transparent;
  37:     -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .1);
  38:     box-shadow: inset 0 1px 0 rgba(255, 255, 255, .1);
  39:           }
  40:   
  41:  body {
  42:     padding-top: 100px !important;
  43:          }

 

Die beiden Attribute Data-Toggle und data-target werden dann in den einzelnen Listen Einträgen verwendet, um die Navbar nach Selektion auch wieder einzuklappen. Die Navbar Collapse Liste setzt sich dabei in der Regel aus UL und LI Elementen zusammen. Die LI Element werden einfach in der Breite geschrumpft. Für drei  spaltig auf einen Wert <33% und auf block formatiert.

   1:  <li  title="<%#Item.roomname%>" style=" width:32.6%; display: inline-block">
   2:  <a href='/chat#<%#HttpUtility.UrlEncode(Item.shortname)%>'
   3:  data-toggle="collapse" data-target=".navbar-collapse2"

 

und so sieht der normale Browser Benutzer die Web App

image

Viel Freude damit.

codefest.at [MS]: Azure IaaS for IT Pros – Halbzeit auf Channel 9

clip_image002

Seit Montag habt ihr die Möglichkeit Einblick in Microsofts Cloud Lösung Azure zu bekommen. Jeden Tag werden euch 5 Stunden an geballter Information zu euch nach Hause gestreamt. Das Ganze noch “bei freiem Eintritt” heute und morgen, immer ab 18:00 live bei channel9.msdn.com mit hochkarätigen Vortragenden.

Für all jene von euch, die sich auf die Zertifizierung 70-533: Implementing Microsoft Azure Infrastructure Solutions vorbereiten ist das sicherlich eine gute Gelegenheit Insider-Informationen abzustauben. An dieser Stelle noch einmal der Hinweis für die Gutscheine um die Prüfung gratis abzulegen, ihr könnt euch bis zu 5 Stück per email zusenden lassen, einfach hier vorbeischauen und die Prüfung bis Ende Dezember über Prometric buchen und in einem Testcenter eurer Wahl ablegen.

Ich persönlich finde den Online-Event bisher sehr gelungen. Es ist immer wieder eine Freude, wenn Mark Russinovich zur Höchstform aufläuft, sobald detaillierte Fragen zu Azure gestellt werden. Er ist einfach ein CTO mit ungeheurem Wissen und Format. Rick Claus führt sehr gekonnt durch die Sessions und ist immer mit hilfreichen Kommentaren zur Stelle, wenn es doch einmal zu sehr in die Tiefe geht, fast so als könnte er spüren, wann die Audienz nur noch staunend vor dem Monitor sitzt und kaum noch folgen kann. Generell lässt sich aber sagen, dass die Vorträge leicht verständlich sind, trotzdem aber die notwendige Tiefe bereitstellen, damit wirklich jeder etwas mitnehmen kann. Sei es, weil man „nur“ einen Überblick bekommen möchte, oder aber wirklich verstehen möchte wie die einzelnen Azure Services und darunter liegenden Technologien funktionieren und zusammenspielen.

Herausragend – aus Entwicklersicht - war hier meiner Meinung nach der zweite Tag mit den Vorträgen über Azure Networking, Azure Storage und Azure Automation. Aber wie gesagt, jeder kommt auf seine Kosten, sowohl Entwickler, Administratoren und Entscheidungsträger.

Sehr gut finde ich die einzelnen Hinweise und Tipps, wie man das spezielle Azure Service auf einfache Art und Weise einsetzt und dies dann später weiter ausbaut. Damit ist es möglich die Dienste zu testen und „bei Gefallen“ die Anwendung zu perfektionieren.

Für all jene, die den bisherigen Live-Stream verpasst haben, hier findet ihr bereits die Aufzeichnungen der ersten beiden Tage – die Präsentationen sollten ebenfalls demnächst verfügbar sein:

Tag 1:  Establish the Foundation: Core IaaS Infrastructure Technical Fundamentals

Tag 2:  Dive Deep into Networking, Storage and Disaster Recovery Scenarios

Heute ist Linux und Docker Tag, schaut einfach ab 18:00 bei channel9.msdn.com vorbei!

Ich wünsche euch für die beiden kommenden Tage weiterhin viel Spaß mit Azure!
clip_image003 

Berndt Hamböck ist seit 2007 MCT, darüber hinaus befasst er sich mit Lösungen für komplexe Anwendungsszenarien mit den neuesten Microsoft Technologien. Die Erfahrungen aus der Projektarbeit gibt er in Vorträgen und Trainings weiter und begleitet Entwicklerteams in Softwareunternehmen bei Projekten im Microsoft Umfeld.

Das ist ein Gastbeitrag. Die Meinung des Autors muss sich nicht mit jener von Microsoft decken. Durch den Artikel ergeben sich keinerlei Handlungsempfehlungen. Microsoft übernimmt keine Gewähr für die Richtigkeit oder Vollständigkeit der Angaben.

Christian Giesswein: DDC Kompakt 2014 - Roslyn

Heute fand in Köln die DDC Kompakt 2014 statt auf der ich meinen Vortrag „Die neue .NET Compiler Plattform Roslyn“ hielt. In dem Vortrag drehte sich vieles um den Begriff Roslyn und was Roslyn ausmacht, als auch welche Neuerungen wir Softwareentwickler im nächsten Jahr erwarten können. Zusätzlich zu den geplanten Neuerungen im C#/VB.NET 6.0 Umfeld ging ich auch kurz auf die Möglichkeit von eigenen Code Fixes ein die mithilfe von Visual Studio 2015 auch nahtlos integrieren lassen. Die Slides finden sich auf SlideShare und können per sofort heruntergeladen werden.

Die wichtigsten Links dieser Session:

 

ppedv Team Blog: Azure News

Auditing für SQL-Database

Mittels Auditing kann man nun sämtliche Events (sämtliche CRUD-Operationen) die in einer Azure Datenbank stattfinden protokollieren. Auditing stand bislang nur über das Preview Portal zur Verfügung. Nun ist es allgemein verfügbar und kann mittels dem normalen Portal aber auch mittels PowerShell-Befehlen verwaltet werden. Das Protokoll wird in einem Azure Storage-Konto, für das natürlich Kosten anfallen, gespeichert. Weitere Informationen erhalten Sie unter: http://azure.microsoft.com/de-de/documentation/articles/sql-database-auditing-get-started/

Operational Insights in der öffentlichen Vorschau

Mit Azure Operational Insights steht ein Analysedienst zur Verfügung mit dessen Hilfe Administratoren schnell Einblick in lokale sowie auch cloudbasierte Umgebungen erhalten können.  Für die Datenanalyse stehen dabei von Microsoft und der Community entwickelte Muster zur Verfügung. Operational Insights enthält Suchfunktionen um Fehler schneller analysieren zu können. Problembehebungen können automatisiert über verschiedene Datenquellen hinweg durchgeführt werden. Somit können Adminsitratoren auf einfache Art und Weise und ohne eine einzige Zeile Code zu erstellen sehr schnell interaktive Ergebnisse. Nehr Informationen erhalten Sie unter: http://azure.microsoft.com/en-us/services/operational-insights/. Die Preisdetails finden Sie unter http://azure.microsoft.com/en-us/pricing/details/operational-insights/

Abkündigung von Diensten

Die beiden Dienste Windows Azure Media Packager und Azure Media Encryptor sind nur noch bis zum 1. November 2015 verfügbar. Kunden die diese Dienste nutzen haben nun fast ein Jahr Zeit auf andere Dienste umzustellen, da nach dem 1.11.2015 eine vollständige Deaktivierung der Services stattfindet. Die Dienste wurden bislang verwendet um Dateipaketformate zu konvertieren und zu Verschlüsseln. Diese Aufgabe übernimmt jetzt die dynamische Paketkomponente von Azure Media Services. Mehr Informationen dazu erhalten Sie unter http://msdn.microsoft.com/de-de/library/azure/jj889436.aspx.

Änderungen bei Azure Verträgen

Seit November werden die Azure Verträge im Microsoft Online Services Agreement (MOSA) zusammengefasst. Somit haben Kunden die auch andere Onlinedienste wie Office 365, Dynamics Online verwenden eine einheitliche Vertragsplattform.

codefest.at [MS]: Erste Schritte mit Docker-Teil 3

Nach der Ankündigung von Microsoft Docker in der nächsten Version von Windows Server und (natürlich) in Microsoft Azure zu unterstützen macht es als Developer Sinn, sich mit dieser Art von Applikationsbereitstellung zu befassen.

Was ist Docker – und wie funktionierts?

In Teil 1 dieser Artikelserie haben wir uns angesehen, was Docker ist und wie das Konzept der Applikationsplattform funktioniert. Teil 2 informiert darüber, wie sich Docker anfühlt und wie man das System grundsätzlich per Commandline verwenden kann und zeigt die wichtigsten Commands wie docker pull, docker run usw.

Nun, in Teil 3, wollen wir Docker nicht nur online testen, sondern einmal selbst installieren und das Cloudservice ausprobieren.

Mehr über Docker

Zur Erinnerung: Docker basiert auf dem Host OS und verwendet Container um Apps laufen zu lassen. Somit ist Docker sehr schnell und “leichtgewichtig”, da es auf dem bestehenden System läuft und auf (aufeinander aufbauender) Image-Technologie basiert.

Docker selbst ist eigentlich nur die Verwaltungsebene der Container, welche wiederrum eine Fähigkeit des Linux oder Windows Kernels sind, Prozesse nebeneinander zu ”sandboxen”.

Die Grafik aus “What is Docker?” visualisiert die Unterschiede zwischen einer virtuellen Maschine mit eigenem OS und Docker mit seinen Images.

image

Jede App läuft in einem Container, auf einem physischen System können auch hunderte oder tausende Container laufen.

Docker ist übrigens 100% kostenfrei und ist ein Open Source Projekt. Somit kann jeder kostenfrei Docker nutzen. Weitere Infos zu Docker siehe auch in den Docker FAQ.

Docker installieren

Derzeit läuft Docker nur auf Linux. Bald (voraussichtlich Mitte 2015) wird Docker auch auf Mac OS X und Microsoft Windows lauffähig sein (siehe Ankündigung hier).

Um Docker schon jetzt auf Windows laufen zu lassen, kann eine VM in einer Virtual Box verwendet werden. In der VM läuft dann eine kleine Linux Distribution Boot2Docker.

Hier gibt es die Installationsanleitung für Mac OS X und Microsoft Windows. Für andere Betriebssysteme (wie Ubuntu, Red Hat, CentOS, Debian, Amazon EC2, Fedora, openSUSE etc.) hilft ebenso die Docker Installationsanleitung.

Der Download erfolgt von der GitHub Seite boot2docker/windows-installer. Das exe-Paket ist 121MB groß. und enthält Boot2Docker 1.3.2 (Docker v1.3.2, Linux v3.16.7), das Boot2Docker Management Tool v1.3.2, VirtualBox v4.3.18-r96516 und msysGit v1.9.4-preview20140929. Natürlich steht dort auch der komplette Quellcode als ZIP zum Download zur Verfügung.

Das Video Boot2Docker Windows Install auf YouTube zeigt Schritt für Schritt den Installationsvorgang. Nach Starten von docker-install.exe und Restart wird die Installation von VirtualBox fortgesetzt.

image

Darin wird die virtuelle Maschine Boot2Docker erstellt und gestartet. Der Docker Client kann sofort verwendet werden, die VM startet mit dem Docker-Prompt.

Ausprobieren

Darin können nun Container über die Docker Client-Funktionen geladen und ausgeführt werden. Das Demo verwendet docker run busybox echo Hello Docker! um das Image (und alle darunterliegenden Images) aus dem Docker Hub downzuloaden und einen Prozess im Container zu starten.

image

Das Command wurde in gelb eingefärbt, der Output für das Laden der Images blau und die Ausgabe in grün, um die Prozesse besser sichtbar zu machen (bzw. das kurze Video ansehen). Man sieht sehr schön an den IDs, dass das Image weitere Images automatisch nachlädt.

Dies ist die grundsätzliche Anwendungsweise von Docker: Images (eine App) laden und starten. Und natürlich verwalten…

Installation mit Hyper-V

Zur Installation noch ein wichtiger Hinweis: Solange unter Windows noch keine Virtualisierungs-Software installiert ist, läuft der Betrieb von Oracle´s Virtual Box meist problemlos.

Wenn bereits Hyper-V installiert ist (z.B. durch Visual Studio mit Windows Phone Emulator), können beide VM-Systeme (Hyper-V und Virtual Box) nicht gleichzeitig laufen!

In solchen Szenarien wäre es natürlich fein, wenn man Boot2Docker anstelle von Virtual Box in Hyper-V laufen lassen könnte. Netterweise hat Shawn Cicoria in seinem MSDN-Blog einen Artikel darüber geschrieben, wie das funktioniert. Interessierte finden in Getting Docker Running on Hyper-V 8.1/ 2012 R2 die Anleitung hierfür. Ich selbst hatte noch keine Zeit, das auszuprobieren, werde das aber in den nächsten Tagen mal testen.

Verwenden von Docker

Wenn dann mal die Docker-Umgebung läuft, kann das System einmal ausprobiert werden.
Hierbei hilft der Docker User Guide, der online verfügbar ist.

image

…und natürlich die Basis Commands aus unserem Teil 2.

Docker Hub

Um öffentlich verfügbare Docker Images aus dem Docker Repository, dem “Docker Hub”, zu verwenden, ist eine einmalige Benutzerregistrierung erforderlich. Die Registrierung erfolgt unter https://hub.docker.com/account/signup/ - oder man verwendet GitHub zur Authentifizierung.

Einmal die email-Adresse bestätigen und schon geht es los…

SNAGHTML120e7fec

Docker Hub ist ein Cloud-Service, wo man eigene Images (Apps) uploaden kann und auch Workflows zur Automatisierung verwenden kann. Es gilt also ein neues Development Ökosystem zu entdecken. Zwinkerndes Smiley

Die Spielwiese ist eröffnet…

Aus meiner Sicht bietet die Architektur von Docker viele Möglichkeiten. Die Fähigkeit (in Zukunft auch unter Windows), fertig installierte Apps in kleinen, schlanken und performanten Containern auszuliefern ist sehr reizvoll und kann auf lange Sicht das Konzept, wie Unternehmen Apps deployen, ändern.

Viel Spaß mit Docker und dem Entdecken der "App-Container"!

Quicklinks:

Roberto Bez: React

Gefühlt jeden Tag entsteht ein neues JavaScript Framework, aber es sind nur wenige, die das Interesse von genügend Entwicklern wecken, um auf dem hartumkämpften Markt eine Chance zu haben. Während gestern noch von Angular und Ember die Rede war, setzten viele heute auf React. Und es ist nicht nur, weil Facebook hinter dem JavaScript-Framework steht, sondern weil React ein paar Eigenschaften mitbringt, die bei den Konkurrenten vermisst wurden.

React wurde von Facebook ins Leben gerufen und wird nicht nur vom Erfinder eingesetzt, sondern auch andere Plattformen wie Instagram sind komplett in React entwickelt. Das Framework soll helfen, interaktive, zustandsorientierte und wiederverwendbare UI Komponenten zu erstellen.

React beats SEO

Das Isomorphe Framework kann nicht nur auf dem Client, sondern auf auf dem Server verwendet werden – was für viele ein großer Knackpunkt sein kann – denn auch wenn Suchmaschinen wie Google mittlerweile JavaScript verstehen und interpretieren können, leben alle bloß von der Theorie.

Wenn eine Webseite von Zugängen aus Google abhängig ist, wird hoffentlich niemand auf die Idee kommen, diese komplett auf dem Client zu laden. Vielleicht ändert sich diese seit Jahren kritisierte Theorie, aber solang das nicht der Fall ist, muss gewünscht oder nicht, die Webseite auf dem Server gerendert werden.

Virtual DOM

React versucht DOM Manipulationen so gering wie möglich halten. Mit dem Virtual DOM werden nur bestimmte Unterbäume von Knoten anhand von State-Änderungen gerendert. Das lässt sich am Besten anhand eines konkreten Beispiels erklären:

Angenommen es gibt ein Model. Und mit Model ist ein (nicht-so-top) Model á la Heidi Klum gemeint. Alle relevanten Eigenschaften dieses Models (Augen, Maße, …) werden auf den aktuellen State des Objekts gespiegelt. Dies ist prinzipiell genau das, was React mit dem DOM macht.

Möchte dieses Model nun wirklich ein Top-Model werden und dabei nicht auf bestimmte Eingriffe und einem strengen Fitnessprogramm verzichten, dann würde React wie folgt damit umgehen: Erst werden alle Änderungen, welche gerade stattfanden, identifiziert (Reconcilation). Anschließend wird das DOM mit den Änderungen aktualisiert.

React würde aber nicht ein komplett neues Model erstellen, sondern nur bestimmte Teile des Körpers ändern. Soll ein DOM Element neu gerendert werden, sich aber sein Elternelement nicht verändert hat, so wird dieses nicht angefasst.

React arbeitet aber immer mit einem fake-DOM, was auch das Rendern auf dem Server ermöglicht.

Getting started

Auf der getting started Seite von React kann ein Starter Kit geladen werden, oder noch auch direkt auf JSFiddle losgelegt werden.

Auf der eigenen Seite reicht es, react.js und JSXTransformer.js einzubinden. Die JSX-Komponenten werden in einem Script block mit type="text/jsx" erstellt.

<!DOCTYPE html>
<html>
  <head>
    <script src="build/react.js"></script>
    <script src="build/JSXTransformer.js"></script>
  </head>
  <body>
    <div id="example"></div>
    <script type="text/jsx">
      React.render(
        <h1>Hello, world!</h1>,
        document.getElementById('example')
      );
    </script>
  </body>
</html>

Der React JSX-Code kann (und sollte) in getrennten Dateien ausgelagert werden. Dabei bietet sich webpack oder Browserify an.

React’s Konzept basiert auf Komponenten. Zum Beispiel:

React.renderComponent(
  React.DOM.h1(null, 'Hello, world!'),
  document.getElementById('example')
);

Oder mit JSX:

/** @jsx React.DOM */
React.renderComponent(
  <h1>Hello, world!</h1>,
  document.getElementById('example')
);

Das mischen von JavaScript und HTML sieht erstmal sehr eigenartig aus, wird aber nach einigen Beispielen immer schöner.

JSX – Javascript XML Syntax

Es sind nicht reale HTML-Elemente, sondern nur XML-ähnliche Darstellungen. Da es aber immerhin JavaScript ist, werden Attributnamen, die in XML nicht empfohlen werden, wie class oder for durch das JSX äquivalent className und htmlFor ersetzt (JSX Gotchas).

React JSX transformiert den XML-ähnlichen Syntax zu nativem JavaScript. Erkennt und transformiert werden aber nur Snippets, welche mit folgendem Kommentar beginnen:

/** @jsx React.DOM */

Beispiel für die Transformierung von XML zu JavaScript:

var AComponent;
// Input (JSX):
var app = <AComponent text="Hello" />;
// Output (JS):
var app = React.createElement(AComponent, {text:"Hello"});

Komponenten

Eigene Komponenten werden mit der createClass-Methode erstellt:

var AComponent = React.createClass({
    render: function(){
        return (
            <h1>Hello, world!</h1>
        );
    }
});

Die Komponente kann als erstes Argument in der bereits gezeigten renderComponent-Methode angegeben werden:

React.renderComponent(
    <AComponent/>,
    document.getElementById('example')
);

React macht aber mehr Spass, wenn den eigenen Komponenten Attribute (Props) hinzugefügt werden. Innerhalb der Komponente können diese mittels this.props verwendet werden:

var DayComponent = React.createClass({
    render: function(){
        return (
            <h1>Today is {this.props.day}!</h1>
        );
    }
});

React.renderComponent(
    <DayComponent day="Sunday" />,
    document.getElementById('example')
);

Komponenten Specs & Lifecycle

In React.createClass() muss eine Objekt-Spezifikation mitgegeben werden. Diese enthält neben der einzigen Pflichtangabe render, noch weitere optionale Methoden für die Komponentenspezifikation:

  • getInitialState: Die Rückgabe wird als anfänglicher State verwendet.
  • getDefaultProps:: Wenn props nicht verwendet werden, gelten diese als Fallback.
  • mixins: Ein Array von Objekten, um Funktionalität auf mehreren Komponenten zu bringen.

Und auch für den Komponenten Lifecycle:

  • componentWillMount: Wird auf client und server vor dem Rendern einmalig aufgerufen.
  • componentDidMount: Wird nur auf dem client nach dem Rendern einmalig aufgerufen. An diesem Punkt, hat die Komponente bereits die DOM-Repräsentation auf welche mit this.getDOMNode() zugegriffen werden kann.
  • shouldComponentUpdate: Soll die Komponente aktualisiert werden? Wird vor dem rendern aufgerufen, wenn sich props oder state ändert.
  • componentWillUpdate: Direkt vor dem rendern.
  • componentDidUpdate: Direkt nach dem rendern – Um Operationen am DOM direkt nach dem Update durchzuführen.
  • componentWillUnmount: Wird vor dem unmounten der Komponente vom DOM aufgerufen – soll für das Aufräumen von DOM Elementen, die in componentDidMount erstellt wurden, verwendet werden.

Es gibt auch noch weitere Methoden, detailliertere Informationen dazu in der React Component Specs Doku.

State

Der anfängliche State wird mit getInitialState gesetzt.
Mit der setState-Methode wird dieser aktualisiert und triggert dabei ein UI-Update.

var DayComponent = React.createClass({
    getInitialState: function(){
        return {
            day: "Tuesday"
        }
    },
    render: function(){
        return (
            <h1>{this.state.day}</h1>
        )
    }
});

Events

React verwendet SyntheticEvent, ein Cross-Browser Wrapper um die Nativen Browser-Events. Mit dem Selben Interface wie die nativen Events (stropPropagation(), preventDefault, …) sollen sie in allen Browsern identisch funktionieren.

Events werden in React den Komponenten als Eigenschaften hinzugefügt und triggern beim Auslösen eine in der Objektspezifikation definierte Methode:

var DayComponent = React.createClass({
    getInitialState: function(){
        return {
            day: "Tuesday"
        }
    },
    setSunday: function() {
        this.setState({
            day: "Sunday"
        });
    },
    render: function(){
        return (
            <h1>{this.state.day}</h1>
            <button onClick={this.setSunday}>Set sunday</button>
        )
    }
});

Data Flow

Im Gegensatz zum two-way-binding von Frameworks wie Angular, fließen die Daten bei React ganz wie nach Von Neumann model of computing unidirektional vom owner zum child. Das heißt, dass die Elternkomponente den State der ganzen Kette unter sich via this.props weitergeben muss.

Selbst wenn ein two-way-binding in React möglich ist, sollte es vorsichtig verwendet werden (zum Beispiel bei Formularen – wenn sich der State nach Eingabe des Users anpassen muss).

Um dieses Szenario abzubilden, würde React auf ein change-Event hören, darin die Informationen (normalerweise) vom DOM auslesen und es der Komponente mit setState() übergeben.

/** @jsx React.DOM */

var DayComponent = React.createClass({
  getInitialState: function(){
     return {
       initialItems: [
         "Monday",
         "Tuesday",
         "Wednesday",
         "Thursday",
         "Friday",
         "Saturday",
         "Sunday"
       ]
     }
  },
  componentWillMount: function(){
    this.setState({items: this.state.initialItems})
  },
  render: function(){
    return (
      <div>
        <DayList items={this.state.items}/>
      </div>
    );
  }
});

var DayList = React.createClass({
  render: function(){
    return (
      <ul>
      {
        this.props.items.map(function (item) {
          return <li>{item}</li>
        })
      }
      </ul>
    )  
  }
});

React.renderComponent(<DayComponent/>, document.getElementById('example'));

Aufgepasst: Innerhalb der map-Funktion bezieht sich this nicht mehr auf die Komponente, sondern auf die übergebene anonyme Funktion und somit window. Wenn jedoch ein click-Event auf eine in der Komponente definierte Methode gebunden werden soll, so kann der Kontext mit .bind(this) am Ende der anonymen Funktion, oder mit setzen von einer Variable _this ausserhalb gemacht werden:

handleDayClick: function(i) {
  console.log(this.props.items[i]);
},
render: function(){
  return (
    <ul>
    {
      this.props.items.map(function (item, i) {
        return (
          <li onClick={this.handleDayClick.bind(this, i)}>
            {item}
          </li>
        )
      }.bind(this))
    }
    </ul>
  )  
}

Oder mit _this:

render: function(){
  var _this = this;
  return (
    <ul>
    {
      this.props.items.map(function (item, i) {
        return (
          <li onClick={_this.handleDayClick.bind(this, i)}>
            {item}
          </li>
        )
      })
    }
    </ul>
  )  
}

Fazit

Es gibt viele gute Javascript Frameworks und viele weitere, noch bessere werden kommen. Vor ein paar Jahren war es noch nicht denkbar, eine komplexe, große Webanwendung komplett in Javascript zu entwickeln. Gerade Isomorphe Frameworks wie React, welche auf Client und Server laufen können, lösen diese Denkweise komplett auf. Und solange Google nicht komplett Javascript interpretieren kann (will), bleibt keine andere Möglichkeit als auf dem Server zu rendern und auf dem Client zu erweitern.

Dieser Überblick soll ein paar Grundsätze von React zeigen, es gehört aber sehr viel mehr dazu. Im nächsten Teil wird genauer auf server-side-rendering und Kommunikation eingegangen!

Note: There is a rating embedded within this post, please visit this post to rate it.

ppedv Team Blog: Call 4 Papers – SharePoint konferenz 2015

Am 10 und 11.3.2015 findet in Erding (München) die SharePoint konferenz 2015 statt.

Wir erwarten wieder großes Teilnehmerinteresse und dementsprechenden Andrang. Heuer steht die Konferenz unter dem Motto “Building Solutions with SharePoint”.

Ich lade alle ein, Sessions einzureichen. Die Auswahl wird in den Weihnachtsfeiertagen erfolgen.

Bitte schickt mir die Session-Vorschläge mit Abstract und einer kurzen Bio-Information über euch an meine Email-Adresse: marting at ppedv.de. Die Sessiondauer ist bei dieser Konferenz 60 Minuten.

Sessions die zum Motto der Konferenz passen, werden bei der Auswahl bevorzugt. Das sind heuer in erster Linie Session mit hohem Coding-Anteil.  Je mehr Visual Studio (und andere Coding-Werkzeuge) desto besser.

Die 2015er Konferenz wird die wahrscheinlich größte SharePoint-Developer Konferenz in DACH!

 

Danke und beste Grüße,

Martin Groblschegg
CTO ppedv ag.

www.sharepointkonferenz.de

ppedv Team Blog: Neuigkeiten aus der Cloud

Microsoft hat sich ja die letzten Wochen mit Open Source und Interoperabilität mit Linux und MacOS förmlich überschlagen. Aber auch in Azure gibt es ein paar Neuigkeiten die ich hier zusammenfassen möchte, damit Sie auch nicht untergehen.

Zum Einen gibt es neue Services die mittlerweile der Allgemeinheit zur Verfügung stehen:

  • Azure Automation: Mittels einer zuverlässigen Workflogengine kann man nun Ressourcen in einer Azure Umgebung erstellen lassen, diese dann deployen, monitoren und warten. Auf diese Weise können zeitraubende Jobs in Azure automatisiert und mit Drittanbietersystemen synchronisiert werden um Kosten zu sparen.
  • Runbook Gallery ist ein neuer Dienst der bestehende Automationbeispiele zur Verfügung stellt und Unterstützung bietet um schneller den Automatisierungsprozess zu erstellen.
  • Azure EventHubs ist ein hoch skalierbarer, verwalteter Echtzeitservice für die Aufnahme von Datenströmen. EventHubs ermöglicht es in einer Platform As A Service Umgebung Datenverteilung anhand eines Publisher-Subscribers Verfahren skalierbar zu implementieren.
  • Microsofts Antimalware ist für Clouddienste und Virtuelle Maschinen verfügbar und soll Viren, Spyware und andere schadhafte Software erkennen und entfernen, Dieser Service ist kostenfrei.
  • Azure WebSites Webjobs  und WebJobs SDK sind jetzt auch allgemein verfügbar. Damit können sehr einfach Hintergrundarbeiten und andere Dienste in einer Website ausführen. Sie können fast jedes Skript und jede ausführbare Anwendung als Webjob hochladen. Dieser WebJob kann dann fortlaufend ausgeführt werden oder auch zeitgesteuert gestartet werden. Mit dem SDK haben Sie ein Framework um mit minimalen Code die Jobs zu definieren

In der öffentlichen Vorschau gibt es folgende neuen Dienste:

  • Im neuen Azure Preview Portal gibt es neue Visualisierungstools zum Verwalten von SQL-Datenbanken hinsichtlich Replikation
  • Azure Batch, ein Dienst der es Ihnen ermöglicht langlaufende parallele Applikationen in der Cloud zu verwalten, steht in der Vorschau bereit.
  • Strean Analytics ist ein eventgesteuerte Engine um in Echtzeit Erkenntnisse über Geräte, Sensoren Cloudinfrastruktur zu erkennen. Dieser Service kann problemlos mit EventHubs integriert werden.
  • DataFactory ermöglicht es Ihnen vertrauensvolle Informationen durch die Erstellung von Datenpipelines auf der Basis von Hadoop zu erstellen.
  • Und auch der Microsoft Azure Marketplace ist öffentlich verfügbar. Hier können Kunden auf eine ganze Reihe von Lösungen zugreifen um die Azure Plattform zu erweitern.
  • Für Big Data Hadoop Applikationen stehen zwei vorkonfigurierte Linux VM-Images zur Verfügung. Eine auf der Basis von CCloudera Enterprise, die andere auf der Basis von Hortonworks HDP.

Desweiteren ist es jetzt auch möglich ihre Azure Website in ein virtuelles Netzwerk einzubinden. Somit kann die Website auf Ressourcen zugreifen die über das virtuelle Netzwerk zur Verfügung gestellt werden.

Holger Schwichtenberg: Aufzeichnungen des Microsoft Technical Summit in Berlin verfügbar

Microsoft hat nun alle Video-Aufzeichnungen der Vorträge sowie die Vortragsfolien kostenfrei im Internet bereitgestellt.

Thomas Bandt: Node.js: Abweichende Konfiguration für Tests

Ich schreibe für meinen Datenzugriff in Node.js gegenwärtig Tests, die dann tatsächlich auch auf die Datenbank zugreifen. Um nicht die eigentliche Datenbank meiner Anwendung mit Testdaten zuzumüllen, brauchte ich einen Weg, während dieser Tests auf eine abweichende Konfiguration zurückzugreifen.

Den Grundstock bildet meine config.js, in der ich alle möglichen Einstellungen der Anwendung ablege, unter anderem auch den Namen der Datenbank und den Connection-String:

var config = {
    debug: {
        database: {
            connectionString: "mongodb://localhost:27017/node-simple-blog-dev",
            databaseName: "node-simple-blog-dev"
        }
    },
    database: {
        connectionString: "mongodb://localhost:27017/node-simple-blog",
        databaseName: "node-simple-blog"
    }
};

module.exports = config;

(Ob das so der beste Weg ist, wird sich noch zeigen ;-).)

Um nun während der Tests auf die -dev-Datenbank zuzugreifen, muss nun also irgendwo ein “Switch” integriert werden.

Ich habe mich dafür entschieden, das über eine Umgebungsvariable zu machen:

process.env.DEBUG = false;

Diese setze ich zu Beginn der Anwendung in meiner app.js, die der Startpunkt ist.

An der Stelle, an der ich den Connection-String auslese, kann ich nun einfach darauf prüfen:

var connectionString = process.env.DEBUG === "true" ?
        config.debug.database.connectionString :
            config.database.connectionString;

Was mich ein paar Minuten gekostet hat: persistiert und damit auch ausgegeben werden hier Strings, folglich liefert die Variable kein Boolean false, sondern einen String “false” zurück.

In meinem Gulp-Task kann ich nun die Variable einfach auf true setzen, und somit die Debug-Konfiguration aktivieren:

gulp.task("mocha", function() {
    process.env.DEBUG = true;

    return gulp.src([
        "*Spec.js",
        "data/**/*Spec.js"])
        .pipe(mocha({reporter: "spec"}));
});

That’s it.


| Kommentieren | © 2014 Thomas Bandt

Johannes Renatus: Highcharts mit .NET erstellen und mit AngularJS “wrapper” darstellen

Wer seine Daten mit Charts visualisieren muss hat im Web eine große Auswahl an Anbietern die Chartbibliotheken zur Verfügung stellen. Ich habe dafür bisher immer Google Charts oder Highcharts verwendet. Leider habe ich bisher noch keine alternative Chartbibliothek für AngularJS gefunden, die genauso umfangreich ist wie z.B. Highcharts. Das schöne an Highcharts, ist das sich […]

Roberto Bez: Chrome DevTools: Command Line API

Die Chrome Developer Tools sind ein beliebtes Werkzeug bei vielen Entwicklern, doch manchmal ist gar nicht bewusst, was dieses Tool eigentlich alles kann.

Die Command Line API ergänzt die Console in Chrome mit einigen nützlichen Features, mit denen es nicht nur möglich ist, Elemente im DOM zu untersuchen, sondern auch den Profiler zu steuern oder DOM Events zu überwachen.

$_

Gibt den Wert des zuletzt verwendeten Ausdrucks zurück. Wenn zum Beispiel der letzte Ausdruck 3 + 3 ist, dann enthält $_ den Wert 6.

> 12 * 12
  144
> $_
  144

Wenn gerade ein Array mit einer Länge von 15 verwendet wurde, dann kann mit $_.length die länge (15) des Arrays ausgegeben werden. Aber aufgepasst: einmal abgefragt, wird $_.length zum zuletzt verwendeten Ausdruck und somit ergibt $_ gleich 15.

>  array = [ 1, 2, 3, 4 ]
   [1, 2, 3, 4]
>  $_
   [1, 2, 3, 4]
>  array.length
   4
>  $_
   4

$0-$4

Wenn in den Chrome Developer Tools DOM Elemente selektiert wurden, dann bieten $0, $1, $2 und $3 Zugriff darauf. Dies ist besonders praktisch, wenn einmal schnell ein Element selektiert werden soll:

Zuletzt selektierte Element mittels $0 in den DevTools

Wird nach dem .content das .sidebar-Element selektiert, dann wird letzteres mit $0 und .content mit $1 referenziert:

Zuletzt selektierte Element mittels $1 in den DevTools

$(selector)

Diese Funktion ist im Prinzip ein Äquivalent zur document.querySelector() Funktion und gibt eine Referenz zum ersten gefundenen Element.

> $("a").href

Chrome DevTools querySelector

$$(selector)

Diese Funktion ist ein Alias für document.querySelectorAll() und gibt alle gematchten Elemente zurück.

> links = $$("a")

Chrome DevTools querySelectorAll

$x(path)

Diese Funktion gibt ein Array von DOM Elementen zurück, welche die angegebene XPath-Expression matchen:

> $x("//ul[li]");

Chrome Developer Tools - XPath

debug(function)

Mit debug wird ein Breakpoint in die angegebene Funktion gesetzt. Wird diese aufgerufen, so öffnet sich der Debugger im Source-Panel und erlaubt den Code der aktuellen Funktion durchzusteppen:

> debug(sum)
  sum( 1, 2 )

Chrome DevTools Console - Debug

Das Debugging kann mit undebug(function) wieder beendet werden.

Inspect(object/function)

Beim Aufruf von inspect öffnet sich das Elements Panel mit dem selektierten Element:

> inspect(document.body.firstChild)

inspect in Chrome Developer Tools

getEventListeners(object)

Gibt alle registrierten Listeners auf das angegebene Objekt zurück. Die Rückgabe ist ein Objekt welches pro registrierten Event-Typ (zum Beispiel scroll oder keydown) ein Array beinhaltet:

>  document.onscroll = function() {
      console.log( window.pageYOffset );
   }

>  getEventListeners(document)
   Object {scroll: Array[1]}

keys/values (object)

keys gibt ein Array mit allen Namen der Properties zurück – values macht das Selbe mit den Werten:

> fruit = { name: "banana", color: "yellow" }
> keys(fruit)
  ["name", "color"]
> values(fruit)
  ["banana", "yellow"]

monitor(function)

Dabei wird in eine Message geloggt, wenn die angegebene Funktion aufgerufen wird.

> function sum(a, b) { return a + b; }
> monitor(sum)
> sum( 1, 2 )
  function sum called with arguments: 1, 2 

Die Ausgabe beinhaltet den Funktionsnamen und die mitgegebenen Argumente.
Das Monitoring kann mit unmonitor(function) wieder abgestellt werden.

monitorEvents(object[, events])

Wenn ein oder mehrere Events auf das angegebene Objekt getriggert werden, wird das Event in der Console ausgegeben:

monitorEvents(window, "scroll")

Chrome Developer Tools - Monitor events

Dies funktioniert auch mit mehreren Event-Angaben und auf alle gängigen Event-Typen wie mousedown, keydown, touchstart, change usw.:

monitorEvents(window, ["scroll", "resize"])

Das Event-Monitoring kann mit unmonitorEvents(objects[, events]) wieder beendet werden:

unmonitorEvents(window, "scroll")
unmonitorEvents(window)

profile([name])

Startet eine JavaScript CPU Profiling Session mit einem optionalen Namen-Parameter. Die Session kann mit profileEnd([name]) wieder beendet werden:

Chrome Developer Tools - profile starten und beenden

table(data[, columns])

Diese Funktion kann hilfreich sein um Daten schnell und übersichtlich darzustellen und erklärt sich von selbst:

Chrome Dev Tools - Tabellen formatieren

copy(object)

Kopiert das angegebene Objekt als String in die Zwischenablage:

> copy($0);

clear

Was das wohl macht ;-) ?

Note: There is a rating embedded within this post, please visit this post to rate it.

Ralf Westphal: Die Nachwuchskatastrophe - 0% der Mädchen wollen in die Softwareentwicklung

Der Nachwuchs für die Softwareentwicklung ist männlich. Zu 100%. So scheint es derzeit nach einer Umfrage des Allensbach-Instituts. 0% der befragten Mädchen zeigte Interesse daran, einen Beruf im “Computer, IT-Bereich” zu wählen. Das betrifft auch die Softwareentwicklung. Das ist eine Katastrophe! Gründe zur Sorge Warum ist das eine Katastrophe? Ich sehe da mindestens zwei Gründe: Software ist

Marco Scheel: Links for 2014-11-28 [del.icio.us]

Norbert Eder: Freilichtmuseum Stübing

Einen Einblick in vergangene Zeiten liefert das Freilichtmuseum Stübing in der Steiermark. Dieser Beitrag zeigt einige Impressionen der erhaltenen Gebäude und Einrichtungen. Ein Besuch lohnt sich auf jeden Fall.

The post Freilichtmuseum Stübing appeared first on Norbert Eder.

Thomas Bandt: Weshalb ich Node-Module und Bower-Pakete einchecke

Hilfreich um Libraries von einem zentralen Ort laden zu können, ja. Aber zuverlässig genug, um die Pakete auch wiederherzustellen? Niemals nicht.

Also nutze ich NuGet in .NET seitdem genau für diesen einen Zweck: Pakete zu laden, mehr nicht. Die von mir wirklich benötigten Assemblies ziehe ich mir dann raus und packe sie in einen /dependencies-Ordner in meiner Solution. Wo sie dann auch eingecheckt und versioniert werden.

Nun dreht sich in Node.js seit einigen Jahren aber ziemlich genau alles um Pakete, die über NPM verwaltet und bezogen werden.

Nachdem einer der häufig zitierten Grundsätze der ist, dass man NPM die Paketverwaltung überlassen soll und /npm_modules deshalb in die .gitignore gehört, habe ich das zunächst auch so übernommen. Man will sich ja den neuen Konventionen anpassen.

Der Vorteil erscheint offensichtlich: Da man in Node.js ja nicht von fertig kompilierten Assemblies spricht, sondern alles und jedes im Quellcode vorliegt und noch dazu häufig seine eigenen Abhängigkeiten eine Ebene tiefer mit “installiert”, kommen schnell mehrere tausend Dateien zusammen, die das eigene Repository aufblähen.

Doch je länger ich darüber nachgedacht habe, desto mehr Zweifel sind mir gekommen. Letztendlich habe ich mich dann gestern Abend dafür entschieden, alle von extern geladenen Teile meiner Anwendung doch einzuchecken. Hier kommt, warum:

1. Zukunftssicherheit

Wenn ich heute ein altes ASP-Projekt aus 2001 öffne, dann läuft das out of the box. Auch ein .NET—1.1-Projekt aus 2003 bekomme ich mit einem aktuellen Visual Studio ziemlich sicher zum Laufen.

Was aber ist mit einem Node.js-Projekt von 2014, das ich in 2024 noch einmal bauen muss, weil mir zwischenzeitlich der Server mit der 10 Jahre laufenden Installation abgeraucht ist? Dann muss ich beten, dass NPM und Bower noch existieren, dass alle referenzierten Pakete noch da sind, und dass sich in ihnen keine Breaking Changes ergeben haben (Alternative für NPM).

Ein bisschen viel gute Hoffnung für meinen Geschmack. Zu viel.

2. Referenzierte Module sind Teil der Anwendung

Das erste Argument wird Kritikern häufig sogar im Enterprise-Kontext zugestanden. Doch ich denke nicht, dass das nur ein Enterprise-Thema ist.

Denn ein ebenfalls gravierender Punkt ist, dass der Code, der beispielsweise in einer Node-Webanwendung mit Express mitkommt, ein elementarer Bestandteil der eigenen Applikation ist.

Deshalb wäre es doch wünschenswert, dass man Änderungen an diesem Bestandteil mitbekommt. Wie soll das aber funktionieren, wenn man ein gutes Dutzend oder mehr Module referenziert? Soll man von jedem dieser Module regelmäßig das Changelog, so es denn existiert, lesen?

Das geht einfacher: In dem Moment, wo jedes Modul versioniert ist, lassen sich alle Änderungen daran Zeile für Zeile nachvollziehen. Und ggf. rückgängig machen. Langfristig dürfte das viel Zeit bei der Suche nach lästigen und plötzlich auftretenden Fehlern sparen.

3. Kein Internet, kein Build

Ich nehme hier immer das Bild vom Entwickeln im Zug - was in Deutschland weiter schwierig ist, wenn man auf eine stabile Internetverbindung angewiesen ist.

Doch in Überschneidung mit dem ersten Punkt kann man hier auch anführen, dass einmal NPM oder Bower abrauchen könnten. Und wenn es nur für wenige Stunden ist – in dieser Zeit ist dann kein Build möglich. Das ist dann nicht erst in 10 Jahren blöd, sondern schon in zwei Wochen, wenn gerade ein wichtiges Update raus müsste, der Build-Prozess aber hängenbleibt.

Fazit

So gut es sich anfühlt, die Abhängigkeiten wie von Geisterhand über NPM und Bower zu laden, für ernsthafte Projekte abseits von fixen Prototypen, ist es in meinen Augen schlicht fahrlässig, sich davon abhängig zu machen.


| Kommentieren | © 2014 Thomas Bandt

friends header

bloggers headline

links header

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