Marco Scheel: Links for 2016-12-04 [del.icio.us]

Marco Scheel: Links for 2016-12-03 [del.icio.us]

Marco Scheel: Links for 2016-12-02 [del.icio.us]

AIT: Neu in Visual Studio und TFS "15": Exploratives Testen

Im Rahmen unserer Blogserie “Neu in Visual Studio und TFS 15” haben wir bereits allgemeine Eigenschaften der Browser Extension ‘Test & Feedback’ vorgestellt.  In diesem Beitrag möchten wir nun Neuerungen der Extension für das explorative Testen mit TFS 2017 hervorheben.

Explore Work Item

Die Funktion ‘Explore Work Item’ erlaubt es eine explorative Testsession für ein bestimmtes Work Item, welches sich auf Portfolio- oder aber Requirements-Ebene befindet, auszuführen. Dies hat zur Folge, dass alle entstehenden Artefakte wie z.B. während der Session erzeugte Bugs oder Test Cases automatisch mit dem ausgewählten Work Item verlinkt werden. Bisher war diese Funktion zwar verfügbar, jedoch konnte das entsprechende Work Item nur über Eingabe der Work Item ID in der Extension verlinkt werden. Mit TFS 2017 können nun explorative Testsessions für ein Work Item direkt aus dem TFS heraus gestartet werden. Hierfür sind verschiedene Einstiegspunkte definiert: Zum einen kann eine explorative Testsession direkt aus dem Kontextmenü eines Work Items innerhalb der Backlogs (vgl. Abb. 1 (1)) oder aber der Boards (vgl. Abb. 1 (2)) heraus angestoßen werden. Des Weiteren kann eine explorative Testsession direkt aus Requirements-based Test Suiten im Test Hub heraus initiiert werden (vgl. Abb. 1 (3)).

image

Abb. 1: Explore Work Item aus Backlog (1), Board(2) oder dem Test Hub (3) heraus

Unabhängig vom gewählten Einstiegspunkt erscheint nach Auswahl des jeweiligen Kontextmenü-Eintrages ‘Do exploratory testing’ eine Meldung unterhalb der Navigationsleiste im TFS, welche den Nutzer auffordert die Extension über das Symbol in der Toolbar des Browsers zu öffnen um fortzufahren (vgl. Abb. 2). Wie gewohnt kann die Testsession dann über den Button ‘Start session’ in der Extension (vgl. Abb. 3) begonnen werden.

image

Abb. 2: Meldung

image

Abb. 3: ‘Start session’

 

Informationsgewinnung während der Testausführung

Eine weitere Neuerung für das explorative Testen ist die Möglichkeit beim Anlegen eines Bugs aus der Extension heraus ein Image Action Log in die Repro Steps automatisch miteinzubinden (vgl. Abb. 4). Dies beschreibt alle ausgeführten Schritte des Testers innerhalb von Web Apps, welche zu dem Bug geführt haben, als Bilderserie mit entsprechenden Textbeschreibungen. Die Schritte umfassen dabei alle Aktionen, welche über die Maus, die Tastatur oder aber Touch ausgeführt wurden und können im Nachhinein bearbeitet werden.

image

Abb. 4: Image Action Log-Option beim Anlegen eines Bugs

 

Eine weitere neue Option beim Anlegen eines Bugs ist ‘Page load data’ (vgl. Abb. 5 (1)). Während der Ausführung einer explorativen Testsession werden im Hintergrund Ladezeiten von Web Apps gemessen und gespeichert. Mit Hilfe der neuen Option kann gesteuert werden, ob die gespeicherten Daten dem Bug angefügt werden sollen. Ist die Option ausgewählt, so werden die Daten zum einen kurz zusammengefasst als Bilderserie in die Repro Steps des Bugs eingefügt (vgl. Abb. 5 (2)) und zum anderen werden detaillierte Ladezeiten-Reports dem Bug angehängt (vgl. Abb. 6). Dieses neue Feature liefert wichtige Performanceinformationen, welche bisher nur mit Hilfe weiterer Tools gemessen werden konnten.

image

Abb. 5: Page Load Data-Option beim Anlegen eines Bugs

image

Abb. 6: Page Load Report

 

Im Zusammenhang der zuvor beschriebenen Image Action Log-Funktionalität steht ein weiteres neues Feature. Aus den Daten des Image Action Logs einer explorativen Testsession können nun auch direkt Test Cases angelegt werden (vgl. Abb. 7). Dabei werden die Testschritte automatisch mit zugehörigen Bildern auf Basis der Daten eingefügt (vgl. Abb. 8). Der Tester kann dann die bestehenden Informationen des Test Cases anpassen und ergänzen. Weiterhin müssen auf diese Weise entstandene Test Cases im Nachhinein in einen Test Plan entsprechend eingeplant werden, da sie zunächst unabhängig von der Test Plan-Struktur erzeugt werden.

image

Abb. 7: Erzeugen eines Test Cases aus explorativer Testsession

image

Abb. 8: Erzeugen eines Test Cases auf Basis von Image Action Log-Daten

 

Auswertung explorativer Testsessions

Ein großer Schritt zur übersichtlichen Auswertung von explorativen Testsessions bringt die neue Ansicht ‘Recent exploratory sessions’, welche im Test Hub im Abschnitt ‘Runs’ zu finden ist (vgl. Abb. 9 (1)). Die gesamte Ansicht kann dabei nach verschiedenen Kriterien gefiltert werden (vgl. Abb. 9(2)). Zum einen kann definiert werden, ob alle Sessions oder aber nur die eigens Durchgeführten angezeigt werden sollen. Des Weitereren kann nach dem Zeitraum gefiltert werden. Zur Auswahl stehen dabei die letzten 7, 14, 30, 60 oder aber 90 Tage. Nicht zuletzt kann eine Query als Filter hinterlegt werden.

image

Abb. 9: ‚Recent exploratory sessions‘-View

Gefiltert auf die entsprechenden Parameter stellt die ‘Recent exploratory sessions’-Ansicht dann eine Vielzahl an Informationen zur Verfügung:

  • Die ‘Summary View’ (vgl. Abb. 9 (3)) gibt eine übersichtliche Darstellung über…
    • … Work Items, welche mit einer explorativen Testsession untersucht wurden
    • … Work Items, welche während explorativen Testsessions erzeugt wurden
    • … die Anzahl der Sessions aufgeteilt nach Session Owner
    • … die Zeit, welche für explorative Test Sessions aufgewendet wurde
  • Die ‘Group-by’-View (vgl. Abb. 9 (4)) stellt eine Ansicht zur Verfügung, welche Artefakte gruppiert und gefiltert darstellt. Dabei kann nach Work Item Typ gefiltert werden.Außerdem kann gruppiert werden nach Explored Work Item, Unexplored Work Item, Session, Session Owner oder None. Ist die Gruppierung Unexplored Work Item ausgewählt, so muss beachtet werden, dass im oberen Bereich (vgl. Abb. 9 (2)) eine Query als Filter hinterlegt sein muss.
  • Die ‘Details’-View (vgl. Abb. 9 (5)) stellt detaillierte Informationen zur Verfügung, welche abhängig von der in der ‘Group-by’-View getroffenen Auswahl ist. Beispielsweise wird für ein Work Item, welches bereits mit Hilfe einer explorativen Test Session untersucht wurde, in der ‘Details’-View angezeigt, wieviele zugehörige explorative Testsessions existieren, die zugehörige Gesamtlaufzeit aller Sessions, die verschiedenen Session Owners sowie in der Session angelegte Bugs, Task und Test Cases aufgeschlüsselt nach Priorität und Status.

Fazit

Die vorgestellten Neuerungen der ‘Test & Feedback’-Extension für das explorative Testen bringen erhebliche Verbesserung in diesem Bereich mit. Sie stellt somit einen weiteren großen Schritt auf dem Weg zu durchgängiger Nachvollziehbarkeit und erleichterter Auswertbarkeit dar. An diesem Feature zeigt sich einmal mehr der Trend Funktionalität ins Web zu verlagern, auch wenn es sich hier um eine Extension und kein originäres Produktfeature handelt.

Marco Scheel: Links for 2016-12-01 [del.icio.us]

MSDN Team Blog AT [MS]: Microsoft Adventkalender

Unsere kreativen Kollegen aus dem Marketing, dem Mittelstands- und Partnerbereich haben einen Adventkalender gestaltet. Viel Spaß damit ….

Microsoft Adventkalender

MSDN Team Blog AT [MS]: Nachlese zur IDC & Microsoft Enterprise OSS Roadshow

Letzte Woche hat in den Räumlichkeiten von Microsoft die überaus gut besuchte IDC Enterprise Open Source Software Roadshow in Wien Station gemacht. Neben interessanten Keynotes von crate.io, IDC & Microsoft hat es auch zahlreiche Fachvorträge mit Open Source Partner wie Canonical, cloudbees, cloudera, elastic, Postgres, GitHub, Hortonworks, Kinme, MariaDB, Mesosphere, puppet, redislabs und suse gegeben.

Präsentationen (soweit diese von den Vortragen zur Verfügung gestellt wurden).
Fotos zur Veranstaltung.

Marco Scheel: Links for 2016-11-30 [del.icio.us]

AIT: Neu in Visual Studio und TFS „15“: Web Test Runner

In früheren Beiträgen unserer Blogserie über das neue Major Release des Team Foundation Servers wurde bereits eine Vielzahl an Neuerungen im Bereich des Testens beschrieben. Auch der Web Test Runner bringt neue Features mit sich, die wir Ihnen im Folgenden gerne vorstellen möchten.

Bevor wir jedoch inhaltlich einsteigen noch ein kurzer Einschub zur Benennung der neuen TFS- und Visual Studio-Versionen. Der Eröffnungsblogpost der Blogserie stellt heraus, dass die Bezeichnung TFS und Visual Studio “15“ die interne Versionsnummer enthält und nicht die endgültige Namensbezeichnung ist. In der Zwischenzeit wurde die neue TFS-Version veröffentlicht und auch der offizielle Name bekanntgegeben. Das nun aktuelle Release, welches bisher mit der internen Versionsbezeichnung “15“ gekennzeichnet wurde, läuft unter dem Namen Visual Studio und TFS 2017.

Aber widmen wir uns nun wieder dem Web Test Runner des TFS 2017. Bislang war es in einer Browser-Testsession out of the box nur möglich den Testablauf durch Screenshots oder Screen Recordings zu dokumentieren. Die bereits aus MTM und der Test & Feedback Extension bekannte Funktion, ein Image Action Log zu erzeugen, gab es bisher jedoch nicht. Dies ändert sich mit TFS 2017, denn nun können auch im Web Test Runner alle Interaktionen eines Testers innerhalb des Browsers als Bilderserie aufgezeichnet werden (vgl. Abb. 1.)

Abb 1.: Erzeugen eines Image Action Logs im Web Test Runner

Abb 1. : Erzeugen eines Image Action Logs im Web Test Runner

Die gesammelten Informationen werden anschließend automatisch dem zu Grunde liegenden Testfällen , den zugehörigen Testergebnissen sowie auch Bugs, welche aus dem Testlauf heraus erzeugt werden, als Attachement angefügt (vgl. Abb. 2).

Abb 2.: Anhängen von Image Action Logs an einen neuen Bug

Abb 2.: Anhängen von Image Action Logs an einen neuen Bug

Unter Verwendung von Chrome sind aber nicht nur die bereits erwähnten Aufnahmen von Interaktionen innerhalb des Browsers möglich. Auch wurde eine weitere Funktion aus MTM und der Test & Feedback Extension zur Aufnahme von Benutzer-Interaktion in Desktop-Apps während der Session integriert. Hierbei werden die gesammelten Informationen am Ende wieder dem Test, den Ergebnissen und eventuellen Bugs als Attachement angefügt.

Die bereits aus dem MTM bekannte Option ‚Run with Options‘ steht im TFS 2017 nun ebenfalls auch im TFS Web Access für alle Browser zur Verfügung. Sie bietet dem Anwender unter anderem die Möglichkeit ein Build auszuwählen, der mit den während der Testausführung erstellten Bugs und den Testergebnissen verknüpft wird. Weitere Einstellmöglichkeiten, z.B. manuelle Run Options, stehen hier jedoch nicht zur Verfügung (vgl. Abb. 3).

Abb 3.: Test Durchlauf mit Optionen

Abb 3.: Test Durchlauf mit Optionen

Ist ihr Interesse geweckt oder haben Sie sich schon intensiver mit den vielen Neuerungen auseinandergesetzt? Sind Ihre Überlegungen vielleicht sogar schon konkret, sich von Ihrem alten TFS zu verabschieden und auf den neuen TFS 2017 zu wechseln? Sprechen Sie uns gerne an.

Marco Scheel: Links for 2016-11-29 [del.icio.us]

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

AIT: WordToTFS 5.2 sim-shipped with TFS 2017

Just in time with TFS 2017 we have released version 5.2 of WordToTFS, the connector between Word and TFS or VSTS. In the new version there is a bunch of new things we’d like to explain in this blog post. A lot of the new features make document generation smarter or increase support for users working in a regulated environment. Beside this a list of bug fixes is added after the feature description. Due to security reasons, we changed the download location which has an impact on auto updates. This is explained at the end of this blog post.

Console Extension User Notifications

A lot of user notifications and error messages in command line mode in some cases did not provide as much information as needed to enable the user to find the root cause if something unexpected happened (please find details on how to automate WordToTFS via command line in the user documentation in section Console Extension, pp. 51) This is due to the fact that in interactive mode the user can click a message and WordToTFS navigates to the affected work item, which is not possible in command line mode. For this reason the user notifications have been extended, e.g. by the affected work item id, if a work item specific issue occurred.

In that context some other messages in command line mode have been aligned with those in interactive mode. Furthermore, to improve usability of user notifications and error messages in command line mode, these messages are now written in different colors, indicating error, warning, and information.

No post operations in case of an error

In case of an error during document generation, the post operations are not executed anymore. This makes it easier to identify a document as incomplete especially after an unattended creation e.g. in command line mode.

Working with variables

Variables functionality for test reporting

Working with variables makes the configuration of WordToTFS templates more flexible and simplifies their management. E.g. when a user wants to use a specific value in different work item types in Word, she can define a variable in the WordToTFS template and assign the appropriate value. This variable can then be referenced within the same w2t-file. A good starting point for using variables is the user documentation at page 38, section Defining Variables.

In former versions, the usage of variables in WordToTFS templates was available with Get Work Item functionality, only. This now has been extended to all test reporting features.

System Variables functionality introduced

In addition to the variables that can be defined in WordToTFS templates and can be assigned with values in that templates a new mechanism has been introduced to provide compile time information in a similar way. The first system variable that is the only one, yet, provides the WordToTFS version number. This enables the user to store the version information of WordToTFS used for document generation in the document, which is a requirement especially in regulated environments. How to configure this feature is outlined in the user documentation at pp. 30, section FieldValueType Attribute under BasedOnSystemVariable.

Enhanced field updates in post operations

The post operation „RefreshAllFieldsInDocument“ (see section Customizing the template configuration: w2t file in the user guide at page 25) updates any Word field used in the document. This also affects table of contents and table of figures.

Whenever table of contents or table of figures was updated by a post operation in former versions of WordToTFS, only the page numbers were refreshed. Now the complete tables are updated which also adds new items if necessary.

Support for Requirements Based Suites

WordToTFS now fully supports Requirements Based Test Suites for all test specifications and test reports.

UI improvements

Saved Query Selector

The display behavior of the selector for work item queries is now configurable. By default, the tree view showing work item queries is expanded, which equals the behavior by now. If users have a lot of queries they may find it difficult to navigate through the complete tree structure. Therefore, it is possible to add the attribute CollapsQueryTree=”true” to the xaml tag MappingConfiguration to show a collapsed tree view initially. This configuration affects both occurrences: “Get Work Items” and “Test Specification Report By Query”.

image

Builds in alphabetical order

When creating a test result report the user now sees the available builds in alphabetical order. This makes manually finding and selecting the desired build much easier, especially if the list is very long due to a huge amount of builds.

image

Bugfixes

  • WordToTFS templates got minor updates, e.g. to correct misspellings.
  • The Work Item Link Viewer, that enables adding a hyperlink to a work item in test specifications and test reports did not work properly and has been fixed.
  • In some cases a test result report threw a null reference exception when a linked build was selected. The root cause has been fixed and the exception will not be thrown anymore.
  • Fixed bug that finding latest test result threw an exception for the root test suite.
  • OLE Handling for Office files (e.g. embedded Excel or Visio documents) did not work due to image scaling issues. Any special treatment of images due to scaling has been deactivated for embedded OLE objects.

Download location changed

The download location of WordToTFS has been moved behind the scenes. To provide a secure download it now uses an SSL encrypted https-source, instead of a non-encrypted http-source before.

For any user who initially downloads WordToTFS from the download area of our website under http://www.aitgmbh.de/wordtotfs, this change is fully transparent and the user does not need to do any different than before. Just register or login and start the download.

All users having WordToTFS installed already, can get the this new version 5.2 via the auto update in WordToTFS. Those installations download the new version from the unsecured http-location. For a grace period we will provide updates at the http-location by end of February 2017. After that point in time, we remove the http-update-location. Those installations need to be reinstalled manually. However, if users do not want to install an update, they can keep using the installation as it is.

Johannes Renatus: Meine lieblings C# 6 Sprachfeatures

Man freut sich immer darüber wenn C# neue Features hinzugefügt werden und hofft das man so viele wie möglich davon auch verwenden wird, denn die meisten vereinfachen einem das Programmieren und sparen Codezeilen ein. Außerdem kann man die neuen Features auch in älteren Projekten verwenden, wichtig ist nur das VS 2015 oder TFS 2015 für […]

Wolfgang Kinkeldei: mein Browser versteht F#

zugegeben – die Überschrift lügt. Aber dank einiger Werkzeuge ist ein zunächst umständlich klingender Weg von F# zu JavaScript machbar und hat Vorteile gegenüber der direkten Programmierung in JavaScript.

  • F# wird zunächst mit dem fable Compiler in einen Syntaxbaum konvertiert.
  • diese Datenstruktur wird mit babel dann zu JavaScript umgewandelt.
  • wahlweise werden zahlreiche JavaScript Dateien mittels webpack zu einer Datei, was den Ladevorgang beschleunigt und vereinfacht.

Warum will man das tun?


Abgesehen davon, dass ich damit endlich einen Grund habe, mich mehr mit F# zu befassen, kann es durchaus Vorteile haben, in F# zu programmieren und die Starrheit bzw. den präzisen Umgang von F# mit Datentypen zu genießen. Gegenüber JavaScript bietet F# nämlich mindestens diese Vorteile:

  • F# ist stark typisiert. Arithmetische Operationen wie "5" + 2 compilieren gar nicht erst anstelle unerklärbares Verhalten wie in JavaScript zu präsentieren.
  • F# bietet algrabraische Datentypen: Bei einem Record müssen alle Felder gefüllt sein und eine discriminated Union benötigt pro Alternative nur die dafür definierten Werte, diese aber vollständig.
  • Der Umgang mit "null" oder "undefined" ist kein Thema für einen F# Entwickler, dafür nutzt man die sogenannten Options-Typen, die das Fehlen eines Wertes explizit modellieren. Werden diese Typen eingesetzt, ist eine Behandlung eines fehlenden Wertes zwingend notwendig damit das Programm compiliert.
  • Der Compiler bietet zwar Typ-Inferenz (der Datentyp von Parametern wird typischerweise nicht angegeben sondern aufgrund der Verwendung erkannt), besteht aber darauf, dass eine Funktion immer nur in der vorgesehenen Weise verwendet wird.
  • Fallunterscheidungen müssen vollständig sein – fehlende Behandlung von Alternativen führen zu Compiler-Fehlern.
  • Viele Datentypen sind unveränderlich (immutable) und garantieren damit, dass jeder Empfänger auch die gleichen Daten erhält.
diese Liste lässt sich noch beliebig verlängern. Selbstverständlich kann man mit der Kneifzange auch Konstrukte im Quellcode haben, die obige Einschränkungen umgehen, aber bei typischer Verwendung kann man durchaus die Vorteile von F# genießen und wird damit übliche Probleme bei der direkten Verwendung von JavaScript vermeiden.

Gibt es in F# programmierte Frameworks?

Selbstverständlich – und was für welche :-) Inspiriert von der Programmiersprache Elm gibt es mehrere Implementierungen der Elm Architektur für F#. Eine davon ist fable-elmish, der ich mich für den Rest dieses Artikels widmen möchte.

Berühmt geworden ist die Elm-Architektur durch ihre Einfachkeit. Eine damit programmierte Single-Page (oder auch iOS- bzw. Android-native) Applikation wird in typischerweise kleine Komponenten aufgeteilt, die durch geeignete Komposition dann zu einer zunehmend größeren Anwendung wachsen. Das ist bei funktionaler Programmierung ja nichts neues, für Leute, die eher an klassische JavaScript Frameworks denken erfordert es etwas Umdenken.

Jede Komponente besitzt hierbei

  • Einen Datentyp [Msg] für alle Nachrichten, die von oder zu dieser Komponente gesandt werden. Das ist meist eine discriminated Union mit allen notwendigen Alternativen nebst zusätzlichen Transport-Daten.
  • Ein weiterer Datentyp [Model] stellt die möglichen Zustände dar. Von einem leeren Datentyp für zustandslose Komponenten über einfache Typen wie boolsche Werte oder Zahlen bis hin zu Records ist hier alles denkbar. Was auch immer notwendig ist, den internen Zustand der Komponente zu speichern wird hier deklariert.
  • Eine Initialisierungs-Funktion [init] (wahlweise mit oder ohne Parameter) erzeugt eine basierend auf dem Parameter definierte initiale Befüllung für das Model sowie (falls notwendig) nach der Initialisierung abgesandter Nachrichten.
  • Eine Aktualisierungs-Funktion [update] erhält eine Nachricht und den bisherigen Zustand des Models und liefert einen neuen Wert für das Model sowie im Anschluß zu versendende Nachrichten.
  • Eine Anzeige-Funktion [view] erhält ein Model und liefert eine optische Repräsentation des Models. Das kann via VirtualDom Implementierungen oder durch den Einsatz von React passieren. Die Folge davon ist die Aktualisierung der Anzeige im Browser.


Besonders interessant an diesem Ansatz ist, dass jede Komponente ausschließlich für sich selbst sorgt und bestenfalls zusätzliche Dinge an Kind-Komponenten delegiert. In meinen Beispielen werden sämtliche Nachrichten und Modelle in der jeweiligen Komponente gespeichert, ein zentrales F#-Modul dafür wäre genau so gut denkbar und findet sich in zahlreichen Beispielen.

Hinter den Kulissen arbeitet im Kern der Fable-Elmish Anwendung ein F# MailboxProcessor (die F# Standard-Bibliothek Variante einer Actor-Model Implementierung) sämtliche auftretenden Nachrichten ab und koordiniert die notwendigen update- und view-Aufrufe.

Die Vorbereitung ist ein steiniger Weg

Um ein neues Projekt zu beginnen, sind eine Reihe von Dingen notwendig.

  • Anlegen eines F# Projektes (optimalerweise mit .fsproj Datei)
  • Erzeugung eines F# Moduls für die Haupt-Komponente (weitere dann später)
  • Erstellung einer package.json Datei und Installation diverser node.js Module
  • Um Tipparbeit zu sparen Hinterlegung zweier Konfigurations-Dateien für den fable-Compiler (fableconfig.json) und das Web-Pack (webpack.config.js). Letzteres ist sinnvoll, damit als Ergebnis des Compilierungs-Schrittes nur eine JavaScript Datei entsteht.
  • Bearbeitung einer index.html Datei über die das JavaScript in den Browser gelangt

Ein Anfang mit all diesen Dateien vorbereitet ist hier als Repository vorhanden.
Danach kann erstmals der Compiler angeworfen werden und unsere einfache Applikation kann gestartet werden. Selbstverständlich lässt sich die erzeugte JavaScript Datei auch mit anderen Web-Servern als denen von node.js (ASP.NET MVC oder Web API zum Beispiel) ausliefern. Spätestens wenn man JSON Daten via Web API laden möchte wird das erforderlich sein.

Eine zusätzliche Komponente aufnehmen

Gilt es eine bestehende Applikation zu erweitern, benötigen wir lediglich ein weiteres F# Modul für die weitere Komponente. 
  • die .fsproj Datei muss um den Pfad zu dieser Datei erweitert werden. Hierbei an die Compile-Reihenfolge denken und diese Datei vor der Haupt-Applikation compilieren. Visual Studio übernimmt das automatisch, andere Editoren erfordern diesen Schritt.
  • die Haupt-Applikation greift auf die neue Komponente zu und muss in ihren Funktionen init, update und view an entsprechenden Stellen auf die gleichnamigen Funktionen der Komponente delegieren.
  • Das Model der Haupt-Applikation muss ebenfalls den zustand der neuen Komponente mit speichern und dementsprechend erweitert werden.
Die Änderungen, die dafür notwendig sind, habe ich für eine relativ einfache Komponente im "add_component" Branch eingecheckt. Um es nicht zu einfach zu machen hat die Komponente zumindest ein simples Model sowie ein einfaches Verhalten, welches einen Ladevorgang (dieser müsste allerdings noch implementiert werden) simuliert.


War's das?

Keineswegs. Wir haben in diesem Artikel lediglich an der Oberfläche gekratzt. Dadurch dass die einzelnen Lebenszyklen und Verhaltensweisen auf puren Funktionsaufrufen basieren, sind sehr viele Erweiterungen denkbar. Für einige gibt es bereits fertige Module, die man in seine Programme einbinden kann. Zum Beispiel:

  • Aktualisieren der Browsernavigation beim Wechsel einer Seite. Umgekehrt führt eine eingegebene URL zum Ansteuern der gleichen Seite
  • Nachrichten können auch außerhalb der Komponenten erzeugt werden (z.B. Timer oder Websocket-Nachrichten) und gezielt an einzelne Komponenten weiter gegeben werden.
  • Nachrichten lassen sich mitlesen, zum Loggen zum Beispiel

Ich hoffe ich habe einigen von euch Appetit auf Fable gemacht und möchte allen Leuten, die hinter dem Fable-Projekt stehen einmal meinen Respekt und Dank aussprechen. Ich persönlich würde mich über Veröffentlichungen zu Erweiterungen, Tipps, Tricks und Anregungen rund um Fable sehr freuen!

MSDN Team Blog AT [MS]: SQL Server 2016 ISV Accelerator Program

Die Connect(); Konferenz hatte ja auch einige Neuigkeiten zum Microsoft SQL Server zu bieten. Sei es inhaltlich mit neuen Funktionen aber auch zusätzlichen Plattformen (SQL Server on Linux) die adressiert werden.

Neu ist auch das SQL Server 2016 ISV Accelerator Program zu dem ab sofort Anmeldungen möglich sind. Die internationalen Aktivitäten starten mit einem Webinar am 7. Dezember 2016.

Stefan Henneken: IEC 61131-3: Namespaces

The third edition of IEC 61131-3 introduces the concept of namespaces. Namespaces group elements such as variables, function blocks, data types and libraries into coherent units. This means that elements are no longer identified solely using their names, but additionally using the associated namespace.

I first started looking at this issue in late 2010 in CoDeSys V3. The following examples have been created using TwinCAT 3 and illustrate the various areas in which namespaces have an effect.

Libraries

Identifiers for function blocks, functions and data types must be unambiguous. This applies equally to elements loaded into a project from a library. The use of multiple PLC libraries from different sources is a common cause of naming conflicts. To avoid this, library developers generally insert a prefix in front of each POU or data type identifier (e.g. MC_MoveAbsolute). The aim here is to minimise the likelihood of a naming conflict.

In TwinCAT 3 this problem is resolved by using namespaces. A namespace can be defined as part of the project information for each PLC project (and also therefore PLC libraries). Namespaces are not case sensitive.

Very often, a library’s namespace will simply be the name of the library (but note, however, that this is not the case in this example). If the namespace field is left blank, the namespace defaults to the library name (in the Title field).

Pic01

If libraries containing elements with identical names are added to a PLC project, namespaces can be used to resolve this naming conflict.

Example:

Two PLC libraries both containing an FB_Foo component are added to a project. Any attempt to create an instance of this component will necessarily throw up an error message. For the compiler, it is not clear which of the identically-named components from the two libraries should be used.

Pic02

Adding in the namespace for the relevant library allows this conflict to be resolved.

If no namespace is entered, the compiler will first search within the local PLC project. It is therefore possible to instance an FB_Foo POU contained within the current PLC project. In this case, whether or not a namespace has been entered in the project information panel is irrelevant.

PROGRAM MAIN
VAR
  fbFoo1 : MyNamespace01.FB_Foo;
  fbFoo2 : MyNamespace02.FB_Foo;
  fbFoo3 : FB_Foo;
END_VAR

init_namespace attribute

The init_namespace attribute is a useful tool. If a STRING or WSTRING type variable has this attribute set, the variable is initialised with the name of the current namespace.

FUNCTION_BLOCK PUBLIC FB_Foo
VAR_INPUT
END_VAR
VAR_OUTPUT
  {attribute 'init_namespace'}
  sNamespace : STRING;
END_VAR
VAR
END_VAR

This permits the relevant namespace to be determined at runtime:

Pic03

Sample 1 (TwinCAT 3.1)

Modifying namespaces

The namespace for a library is also shown in the reference properties:

Pic04

Should a namespace be ambiguous, it can be modified in these reference properties.

This makes it possible for a project to load multiple versions of the same library.

Pic05

Modifying the namespace enables the required elements from different library versions to be addressed directly.

PROGRAM MAIN
VAR
  eAdsErr01 : Tc2_System_A.E_AdsErr;
  eAdsErr02 : Tc2_System_B.E_AdsErr;
END_VAR

Although the E_AdsErr enum has the same structure in both PLC libraries, they are two different data types. In the above example, this means that the eAdsErr01 and eAdsErr02 variables are not mutually compatible.

eAdsErr01 := eAdsErr02;

This assignment is rejected by the compiler with the following error message:

Implicit conversion from one enumeration type (E_ADSERR
(tc2_system, 3.4.14.0 (beckhoff automation gmbh))) to
another (E_ADSERR (tc2_system, 3.4.13.0 (beckhoff automation
gmbh)))

Global Variable List

A Global Variable List (GVL) is used to declare global variables. The name of the GVL must be unambiguous within the project. The name is not case sensitive. Each GVL is a self-enclosed space (namespace) in which global variables can be declared independently of other GVLs.

In the following example, we declare three variables. All three are called var01. Two are declared in separate GVLs (GVL01 and GVL02), the third locally in MAIN.

Pic06

To allow these variables to be addressed unambiguously, the name of the GVL must additionally be placed in front of the variable name, separated by a dot.

GVL01.var01 := 1; // global variable in GVL01
GVL02.var01 := 2; // global variable in GVL02
var01 := 3;       // local variable in MAIN

If the variable var01 exists only in a single GVL, there is no need to prefix the variable name with the GVL. If, however, there is also a local variable with the same name, then the GVL name does have to be included. Alternatively, you can also prefix the variable name with just a dot on its own. This designates the global namespace.

.var01 := 1; // global variable
var01 := 3;  // local variable

The dot in front of the variable name indicates that we wish to access the global variable called var01. In this case, however, the variable must again be present in just a single GVL.

qualified_only attribute

The name of the GVL should always be used, even where it is not strictly required. If the qualified_only attribute is present in the GVL, an error message will be output if an attempt is made to address a variable without prefixing it with the GVL name.

{attribute 'qualified_only'}
VAR_GLOBAL
  var01 : INT;
  var02 : INT;
END_VAR

It is therefore always necessary to include the name of the GVL when addressing a global variable. This makes the program easier to read and makes it easier to avoid side effects between local and global variables.

Sample 2 (TwinCAT 3.1)

GVLs in libraries

If a GVL is in a library, in addition to the GVL name it is also possible to use the namespace of the library.

In the following example, three variables, all called var01, are declared in different places:

  • in GVL01 in a library with the namespace MyNamespace01
  • in GVL01 in the local PLC project
  • in the local POUTo address the required variable, the library’s namespace can be used in addition to the GVL name:
    MyNamespace01.GVL01.var01 := 1; // global variable of the GVL inside the library
    GVL01.var01 := 2;               // global variable of the local GVL
    var01 := 3;                     // local variable
    

    If the qualified_only attribute is not used in the local GVL, the GVL can be omitted:

    MyNamespace01.GVL01.var01 := 1; // global variable of the GVL inside the library
    .var01 := 2;                    // global variable of the local GVL
    var01 := 3;                     // local variable
    

    Similarly, the GVL name for the library can also be omitted if the qualified_only attribute is not used in that GVL.

    MyNamespace01.var01 := 1; // global variable of the GVL inside the library
    .var01 := 2;              // global variable of the local GVL
    var01 := 3;               // local variable
    

    If the GVL names are unambiguous, the namespace can also be omitted:

    GVL01.var01 := 1; // global variable of the GVL of the library
    .var01 := 2;      // global variable of the local GVL
    var01 := 3;       // local variable
    

    The final example illustrates the point that omitting namespaces reduces readability of the program. It is harder to identify where the referenced variables are declared. Consequently, it is best to include the qualified_only attribute in every GVL and to use the namespace when using elements from libraries.

    The namespace should also be entered when defining function blocks derived from function blocks from a library and when using interfaces from a library:

    FUNCTION_BLOCK FB_MyFoo EXTENDS MyNamespace01.FB_Foo IMPLEMENTS MyNamespace01.I_Foo
    VAR_INPUT
    END_VAR
    VAR_OUTPUT
    END_VAR
    VAR
    END_VAR
    

    The dialog for creating new FBs supports this process:

    Pic07

    Sample 3 (TwinCAT 3.1)

    Enumerations

    When accessing an enumerator from an enumeration, the relevant enumerator can be used directly. To enable enumerated constants to be addressed unambiguously, the type name can also be added.

    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    
    PROGRAM MAIN
    VAR
      eFoo01 : E_Foo01;
    END_VAR
    eFoo01 := eErrorA;
    eFoo01 := E_Foo01.eErrorA;
    

    If the identifier for an enumerated constant is found in multiple type definitions, the type name must be used when addressing it. This allows constants with the same name to be used in multiple enumerations. The result is that it is no longer necessary to add a prefix to every enumerated constant to avoid naming conflicts.

    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    
    TYPE E_Foo02 :
    (
      eNoError := 0,
      eError1 := 1,
      eError2 := 2
    );
    END_TYPE
    
    PROGRAM MAIN
    VAR
      eFoo01 : E_Foo01;
      eFoo02 : E_Foo02;
    END_VAR
    eFoo01 := E_Foo01.eNoError;
    eFoo02 := E_Foo02.eNoError;
    

    If the type definition is in a library, you can also additionally use the library namespace:

    eFoo01 := MyNamespace01.E_Foo01.eNoError;
    

    qualified_only attribute

    Similarly to GVLs, the qualified_only attribute can be used to force the use of the type name:

    {attribute 'qualified_only'}
    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    

    Sample 4 (TwinCAT 3.1)

    strict attribute

    The strict attribute is not directly relevant to namespaces, but can be used to improve program readability. We will therefore consider it briefly here.

    A variable with an enumerated type is treated internally as an INT. Consequently, arithmetic operations can be carried out on enumerations and values can be assigned which are not defined by the enumeration. The following example assigns the variable eFoo01 the value 3. The enumeration E_Foo01 does not, however, include this value.

    eFoo01 := E_Foo01.eErrorA + 2;
    

    If the strict attribute is used in the definition of an enumerated type, variables of this type are only able to take values specified by the enumerators.

    {attribute 'strict'}
    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    

    The strict attribute also means that it is no longer possible to perform arithmetic operations which would result in values which are not specified by the enumerators. This affects the following operations:

    Assignment of constants which are not specified by the enumerators
    eFoo01 := 5;
    
    Arithmetic operations with enumerators
    eFoo01 := E_Foo01.eNoError + E_Foo01.eErrorA;
    
    Assignment of variables which are not of the enumerated type
    nVar := 1;      // variable nVar is a INT
    eFoo01 := nVar;
    

    Summary

    Namespaces represent a useful mechanism for avoiding naming conflicts. They remove the need to add prefixes to function and data type identifiers. This makes element names more compact and makes code more readable.


  • Norbert Eder: Mehr Zeit für die Arbeit

    In 11 Tipps um Meetings zu verbessern habe ich meine Gedanken zur Verbesserung von Meetings im Allgemeinen zur Sprache gebracht. Meetings stehen an der Tagesordnung und neigen dazu, Überhand zu gewinnen. Ehe man sich versieht, sitzt man den ganzen Tag in Meetings und die eigentliche Arbeit bleibt auf der Strecke. Welche Möglichkeiten gibt es nun, dem Herr zu werden?

    “Nein” sagen

    Nicht jeder kann “Nein” sagen. Dadurch übergibt man die Steuerung über sich selbst an andere. So ist es ~~fast~~ unmöglich, seinen Tagesablauf zu planen. Am Abend geht man unverrichteter Dinge (und zudem höchst unbefriedigt) nach Hause.

    “Nein” zu sagen bedeutet selbst Prioritäten zu vergeben.

    “Nein” zu sagen bedeutet Prioritäten zu vergeben. Die wenigsten Problemstellungen sind so akut, dass sie keiner Aufschiebung bedürfen. Diese müssen natürlich sofort behandelt werden. Alles andere kann den eigenen Prioritäten angepasst/untergeordnet werden – und muss es auch.

    Für andere hat deren Arbeit immer höchste Priorität, das ist auch verständlich. Würde man niemals “Nein” sagen, übernähme man lauter Prio 1-Aufgaben mit vermutlich sofortiger Fälligkeit. Das führt zum Einen zu Stress, sorgt dafür, dass keine der Aufgaben zeitgerecht fertig werden oder sie überhaupt nur geschafft werden können, indem sie nur “so lala” ausgeführt wurden. Das hilft in Wirklichkeit niemandem.

    Meetings nicht automatisch zusagen

    Bevor man eine Besprechungseinladung annimmt, gilt es zu prüfen, ob man zu diesem Meeting etwas beitragen kann. Manchmal soll man einfach nicht übergangen werden und landet deshalb auf der Teilnehmerliste, oder falls es Fragen gibt.

    Im ersteren Fall bietet es sich an, freundlich abzulehnen und um das Besprechungsprotokoll zu bitten. Im zweiten Fall kann man ja anbieten, telefonisch erreichbar zu sein, sollte tatsächlich eine Frage auftauchen, die sofort geklärt werden muss.

    Meetingfreie Zeiten

    Ah, da ist noch eine Lücke, da bekommen wir das Meeting noch hinein. Ehe man sich versieht, sind alle Tage verplant. Zeit für die notwendige Arbeit bleibt nicht, oder muss zu später Stunde oder gar am Wochenende verwendet werden.

    Damit man in Ruhe seiner Arbeit nachgehen kann, empfiehlt es sich, Zeiten genau dafür zu reservieren. So kann man beispielsweise immer dienstags Nachmittag und Donnerstag im Terminkalender belegen. Zusätzlich sollte man seinen Kollegen Bescheid geben. Nun liegt es an einem selbst, diese Zeit dann auch einzufordern. In der Regel funktioniert das gut. Ausnahmen sollte man vermeiden, denn darüber schleicht sich eine Aufweichung ein, die dann oftmals nicht mehr aufzuhalten ist.

    Manche lösen es auch so, dass sie beispielsweise nur vormittags Meetings annehmen und an Nachmittagen ihrer regulären Arbeit nachgehen – oder auch umgekehrt. Welches System es auch ist, es muss für einen selbst stimmig sein und durchgezogen werden.

    Bitte nicht vergessen: Das Telefon in der meetingfreien Zeit läuten lassen oder gleich stumm schalten.

    Homeoffice

    In manchen Fällen empfiehlt es sich Homeoffice zu nehmen. Natürlich müssen die Umstände zu Hause (oder wo immer man die Zeit auch verbringt) so sein, dass man seiner Arbeit nachkommen kann. Entgegen der üblichen Meinung, im Homeoffice ständig erreichbar sein zu müssen (quasi als Kontrolle), sollte genau das Gegenteil der Fall sein. Denn nur so kann der Arbeit konzentriert nachgegangen werden. Aus diesem Grund wurde schließlich Homeoffice genommen.

    Im Homeoffice sollte man tunlichst nicht erreichbar sein – sonst könnte man auch im Büro bleiben.

    Wenn denn wirklich einmal der Hut brennt, sollte man dies aber schon mitbekommen können (meist kommt die Info dann ohnehin über mehrere Kanäle).

    Fazit

    Für die eigene Effizienz ist es äußerst vorteilhaft, sich zusammenhängende Zeit zu verschaffen. Nur so kann man Kontextwechsel und damit vergeudete Zeit gering halten. Das bedeutet aber auch, dass man “Nein” sagen muss, und sich eine meetingfreie Zeit tatsächlich reserviert und diese dann auch durchsetzt. Als Ergebnis kann man sich auf seine Arbeit konzentrieren und diese auch gewissenhaft (ohne Ablenkung) erledigen.

    The post Mehr Zeit für die Arbeit appeared first on Norbert Eder.

    Holger Sirtl: Azure News on Friday (KW46/16)

    Auch diese Woche gab’s wieder viele Nachrichten zur Microsoft Azure Plattform. Stets aktuelle News, Videos, Tools, MVA-Kurse, und vieles mehr zu Azure auf dem Azure Infohub unter http://aka.ms/azureinfohub. Hier sind nähere Infos dazu…

    Aktuelle Neuigkeiten

    Datum Nachricht
    17.11. Microsoft R Server for HDInsight is now generally available
    Microsoft R Server für HDInsight jetzt allgemein verfügbar
    17.11. Announcing the public preview of Azure Advisor
    Azure Advisor in einer Public Preview – Empfehlungen für Sicherheit, Performance etc. eigener Cloud Workloads
    17.11. Kafka for Azure HDInsight now public preview
    Kafka für Azure HDInsight jetzt allgemein verfügbar
    17.11. Azure Data Lake Store is now generally available
    Azure Data Lake Store jetzt allgemein verfügbar – der universelle Cloud Speicher für Big Data
    16.11. General availability: R Server on HDInsight
    R Server auf HDInsight jetzt allgemein verfügbar
    16.11. Four simple steps to Backup VMware VMs using Azure Backup Server
    Backups von VMware Maschinen über Azure Backup erstellen
    16.11. Azure Data Lake Store now generally available
    Azure Data Lake Store jetzt allgemein verfügbar
    16.11. General availability of Azure Application Insights
    Azure Application Insights jetzt allgemein verfügbar
    16.11. Free local development using the DocumentDB Emulator plus .NET Core support
    Weitere Details zum DocumentDB Emulator für eine lokale Entwicklungsumgebung
    15.11. Announcing general availability of Azure Functions
    Azure Functions jetzt allgemein verfügbar – serverless computing in Azure
    15.11. App Service on Linux now supports Containers and ASP.NET Core
    Azure App Service unterstützt unter Linux jetzt auch Container und ASP.NET Core
    15.11. Azure N-Series: General availability on December 1
    Azure N-Series Virtual Machines sind ab 01.12.2016 allgemein verfügbar – GPU-Power in der Cloud
    14.11. Service Bus client 3.4.2 is now live
    Neue Version der Service Bus Client Library (in Version 3.4.2) verfügbar
    11.11. Service Fabric Community Q&A 6th Edition
    Öffentliche Q&A Session zur Azure Service Fabric am 17.11. – einfach reinschauen, Fragen stellen, Antworten bekommen

    Neue Kurse in der MVA

    Datum Nachricht
    14.11. Deep Dive into Azure App Service: A Platform to Build Modern Applications
    Neuer kostenloser MVA-Kurs zum Azure App Service – Themen u.a.: Web Apps, Mobile Apps, Azure Functions, …

    Neue Videos

    Datum Nachricht Video
    18.11. SQL Server on Linux: overview
    Überblick über SQL Server auf Linux
    18.11. Enterprise Integration with Azure Logic Apps
    Überblick und Neuigkeiten zu Azure Logic Apps – neue XML und B2B Features
    18.11. DocumentDB Updates: Local Emulator and .NET Core Preview SDK
    Neues zu DocumentDB – Lokaler Emulator für die Entwicklung und ein .NET Core SDK für den Zugriff
    17.11. Architecting your Azure Solution
    Architekturentwurf für Azure Lösungen – Virtual Machines, App Service, Azure Functions – wann nehme ich was?
    17.11. Making an ARM template from SCRATCH
    Ein Azure Resource Manager Template von Grund auf neu erstellen – hier wird gezeigt, wie man’s am besten angeht.
    17.11. What’s new in Azure DevTest Labs
    Neues in Azure DevTest Labs – hier ein Überblick
    15.11. Tuesdays with Corey: Azure Active Directory Domain Services
    Corey Sanders über Azure AD Domain Services – Domain Controller as a Service
    15.11. Azure Datacenter Video
    Die Rechenzentren von Microsoft Azure im Video vorgestellt

    AIT: TFS in der Cloud – Migration leicht gemacht

    Viele unserer Kunden betreiben einen im eigenen Rechenzentrum  gehosteten Team Foundation Server (TFS). Seit geraumer Zeit lässt sich Microsofts DevOps Plattform auch als cloudbasierte Lösung unter dem Namen Visual Studio Team Services (VSTS) nutzen. VSTS unterstützt viele Funktionen meist wesentlich eher als sein On Premise Pendant. Jedoch war es bislang eher schwierig vom lokalen TFS in die Cloud “umzuziehen”. Nun hat Microsoft eine neue Tür geöffnet.

    Diese Woche hat Microsoft eine interessante Möglichkeit für den Weg zu VSTS veröffentlicht. Mittels eines Migrationswerkzeugs und einem zugehörigen Service kann man seine lokale TFS Datenbank nach VSTS importieren. Dafür gibt es eine ausführliche Beschreiben in Form des Migration Guides.

    Das Verfahren besteht aus fünf vorbereitenden Schritten (siehe nachfolgende Abbildung), bei denen mittels des Migrationswerkzeugs die Kompatibilität der lokalen TFS Datenbank mit VSTS geprüft wird. Als sechster und abschließender Schritt wird die Migration selbst durchgeführt.

    migration-steps

    Trotz aller Werkzeuge bleibt eine wesentliche Aufgabe zu erledigen: Anhand der Analyseergebnisse müssen die Team Projekte in der lokalen TFS Datenbank so modifiziert werden, dass sie VSTS kompatibel werden. In der gehosteten Variante des TFS gibt es einige technische Einschränkungen, z.B. bei den Berechtigungen. Solange die lokalen Team Projekte solche Dinge nutzen, welche inkompatibel zu VSTS sind, ist die Migration noch nicht möglich.

    Mit Kollegen der führenden Microsoft DevOps Partner weltweit haben wir als einer der wenigen Partner in Europa am ersten Bootcamp in Redmond teilgenommen, um uns für diese Migrationsaufgaben vorzubereiten und unseren Kunden die bestmögliche Beratung bieten zu können. Seitens Microsoft werden wir auf der Microsoft DevOps Partner Website als Partner für die VSTS Migration empfohlen.

    Derzeit kann man von TFS 2015.3 oder TFS 2017 aus den Weg in die Cloud antreten. Wer noch eine ältere Version des TFS im Einsatz hat, findet im Migration Guide eine übersichtliche Darstellung der Wege, zu einer der beiden Versionen (siehe nachfolgender Screenshot, entnommen aus dem Migration Guide, S. 23).

    image

    Haben Sie sich bereits VSTS angeschaut? Sind Ihre Überlegungen vielleicht sogar schon konkret, sich von Ihrem lokalen TFS zu verabschieden und auf den Online Service VSTS zu wechseln? Sprechen Sie uns gerne an.

    AIT: Neu in Visual Studio und TFS "15": Test Auswertung

    In einem unserer vorhergehenden Blogbeiträge haben wir bereits vorgestellt, mit welchen Neuerungen der TFS 15 im Test Management aufwartet. Darunter fällt natürlich auch die Test Auswertung, jedoch möchten wir die Neuerungen gesondert in diesem Blogbeitrag vorstellen.

    Schon seit jeher ist es möglich ein und denselben Test Case in mehreren Test Suiten einzuordnen, jedoch wurde der Test Status (Pass, Fail, Not Applicable, Blocked, Active) eines Test Cases nicht in die anderen Test Suiten propagiert. Mit dem neuen TFS 15 kann dieses Verhalten geändert werden. Es kann nun konfiguriert werden, ob der Test Status eines Test Cases über alle Test Suiten unter demselben Test Plan hinweg weitergegeben werden soll oder nicht. Dieses Verhalten ist nicht nur begrenzt  auf den jeweiligen Test Plan, sondern auch auf die Test Konfiguration. Dies bedeutet, dass wenn ein Test Case sich zwar in zwei Test Suiten des selben Test Plans befindet jedoch mit unterschiedlichen Konfigurationen versehen ist, so wird der Test Status nicht zwischen den Test Suiten geteilt. Ferner wird der Status Active nicht zwischen den Test Suiten ausgetauscht.

    Um das beschriebene Verhalten zu konfigurieren gibt es zwei Möglichkeiten: Zum einen kann im Test Hub über das Kontextmenü eines Test Plans die Option Configure test outcomes settings ausgewählt werden. Im aufkommenden Dialog kann das gewünschte Verhalten konfiguriert werden (vgl. Abb. 1). Zum anderen lässt sich das Verhalten über die Kanban Board Settings im Unterpunkt Tests einstellen. Standardmäßig ist die neu eingeführte Option für alle Test Pläne deaktiviert.

    image

    Abb. 1: Konfiguration der Einstellungen für die Test Ergebnisse im Test Hub

    Eine weitere Neuerung, welche die Auswertung von Test Cases vereinfacht, betrifft die Test Results Pane für Test Cases die sich in mehreren Test Suiten / Test Plänen befinden. Diese enthält mit dem neuen Release vier neue Spalten, um auf dem ersten Blick die Test Suite und den Test Plan erkennen zu können unter welchem der Test Case ausgeführt wurde (vgl. Abb. 2). Dies war bisher nur durch Öffnen des jeweiligen Test Results möglich. Damit bleibt ein zeitaufwendiges Durchsuchen der Test Ergebnisse in Zukunft erspart.

    image

    Abb. 2: Neue Spalten in der Recent test results Pane

    Doch nicht nur in der Test Results Pane spiegelt sich die Entwicklung hin zu einer erhöhten Traceability wieder. Auch im Test Run und der Test Result Summary existieren einige Neuerungen, welche auf eine durchgängige Traceability abzielen. So werden für Tests, welche in einem Release Workflow ausgeführt werden, in den Properties des Test Runs und der Test Result Summaries das entsprechende Release und Environment angezeigt. Desweiteren sind in der Test Result Summary für manuell ausgeführte Tests der zugehörige Test Plan, Test Suite sowie der Test Case enthalten (vgl. Abb. 3). All die beschriebenen, neuen Eigenschaften sind als Links dargestellt. Mit nur einem Klick ist es möglich zum jeweiligen verknüpften Artefakt zu navigieren.

    image

    Abb. 3: Test Result Summary

    Die letzte Neuerung im Bereich Test Auswertung wird durch zwei neue Widgets in der Widget Gallery dargestellt. Das erste Widget Test results trend kann verwendet werden, um den Trend im Bezug der Testergebnisse der 30 aktuellsten Builds für eine bestimmte Builddefinition darzustellen. Dabei ist es möglich das Widget in vielerlei Hinsicht zu konfigurieren. So kann neben der Builddefinition bspw. auch die Art des Diagramms, wie z.B. ein Liniendiagramm, etc. definiert werden. Das zweite Widget Requirements quality stellt eine Ansicht zur Verfügung, wie man sie bereits von früheren TFS Versionen aus dem SSRS Report Requirements Overview kennt. So zeigt es zu einer bestimmten Menge von Requirements jeweils die aktuelle Qualität ausgedrückt durch verlinkte bestandene bzw. fehlgeschlagene Tests für eine ausgewählte Build-Definition oder aber für ein ausgewähltes Release (vgl. Abb. 4).

    Abb. 4: Neues Widget Requirements quality

    Stefan Henneken: IEC 61131-3: Namensräume

    Mit der 3rd Edition der IEC 61131-3 wurde das Prinzip der Namespaces (Namensräume) eingeführt. Namespaces gruppieren Elemente wie Variablen, Bausteine, Datentypen und Bibliotheken in zusammengehörige Einheiten. Ein Element wird dadurch nicht mehr nur durch seinen Namen, sondern auch durch seinen zugehörigen Namespace benannt.

    Mit diesem Thema hatte ich mich bereits Ende 2010 beschäftigt. Damals noch unter CoDeSys V3. Die folgenden Beispiele wurden mit TwinCAT 3 erstellt und stellen die verschiedenen Bereiche vor, in denen Namespaces zum Tragen kommen.

    Bibliotheken

    Bezeichner von Funktionsblöcken, Funktionen und Datentypen müssen eindeutig sein. Das betrifft auch die Elemente, die aus Bibliotheken in ein Projekt eingebunden werden. Sollen mehrere SPS-Bibliotheken von unterschiedlichen Quellen zum Einsatz kommen, können aber genau hier Namenskonflikte auftreten. Um dieses zu vermeiden, wurde meistens vom Entwickler der Bibliothek vor jedem POU- oder Datentypbezeichner ein Prefix gestellt (z.B. MC_MoveAbsolute). Hiermit wird versucht, die Wahrscheinlichkeit eines Namenkonflikts möglichst gering zu halten.

    Bei TwinCAT 3 wird dieses Problem mit Namespaces gelöst. Bei jedem SPS-Projekt, und somit auch bei SPS-Bibliotheken, kann ein Namespace bei den Projektinformationen definiert werden. Groß- und Kleinschreibung wird nicht berücksichtigt.

    Sehr häufig entspricht der Namespace einer Bibliothek auch dem Namen der Bibliothek (in diesem Beispiel ist dieses nicht der Fall). Bleibt das Feld für den Namespace leer, so wird als Namespace der Name der Bibliothek (das Feld Title) benutzt.

    Pic01
    Werden zu einem SPS-Projekt Bibliotheken hinzugefügt, in denen Elemente gleich benannt worden sind, so kann mit Hilfe der Namespaces dieser Namenskonflikt aufgelöst werden.

    Beispiel:

    Zwei SPS-Bibliotheken enthalten jeweils den Baustein FB_Foo. Diese beiden Bibliotheken werden einem Projekt hinzugefügt. Der Versuch, eine Instanz eines dieser Bausteine anzulegen führt zwangsläufig zu einer Fehlermeldung. Für den Compiler ist es nicht eindeutig, aus welcher Bibliothek er den Baustein nehmen soll.

    Pic02
    Wird der Namespace der jeweiligen Bibliothek zusätzlich angegeben, so wird dieser Namenskonflikt aufgelöst.

    Ohne die Angabe eines Namespace wird erst im lokalen SPS-Projekt nach dem jeweiligen Element gesucht. Somit lässt sich ein POU FB_Foo instanziieren, welcher im aktuellen SPS-Projekt enthalten ist. Ein in den Projektinformationen angegebener Namespace, ist hierbei ohne Bedeutung.

    PROGRAM MAIN
    VAR
      fbFoo1  :  MyNamespace01.FB_Foo;
      fbFoo2  :  MyNamespace02.FB_Foo;
      fbFoo3  :  FB_Foo;
    END_VAR
    

    Attribut init_namespace

    Hilfreich ist das Attribut init_namespace. Wird eine Variable vom Typ STRING oder WSTRING mit diesem Attribut dekoriert, so wird diese Variable mit dem Namen des aktuellen Namespace initialisiert.

    FUNCTION_BLOCK PUBLIC FB_Foo
    VAR_INPUT
    END_VAR
    VAR_OUTPUT
      {attribute 'init_namespace'}
      sNamespace  :  STRING;	
    END_VAR
    VAR
    END_VAR
    

    Somit kann zur Laufzeit der jeweilige Namespace ermittelt werden:

    Pic03

    Beispiel 1 (TwinCAT 3.1)

    Namespace anpassen

    Der Namespace einer Bibliothek wird auch bei den Eigenschaften der Referenz angezeigt:

    Pic04

    Sollte der Fall eintreten, dass auch der Namespace nicht eindeutig ist, so kann dieser in den Eigenschaften der Referenz angepasst werden.

    Dadurch ergibt sich auch die Möglichkeit, verschiedene Versionen der gleichen Bibliothek in ein Projekt einzubinden.

    Pic05

    Sofern der Namespace angepasst wurde, so kann gezielt auf die gewünschten Elemente der Bibliothek zugegriffen werden.

    PROGRAM MAIN
    VAR
      eAdsErr01  :  Tc2_System_A.E_AdsErr;
      eAdsErr02  :  Tc2_System_B.E_AdsErr;
    END_VAR
    

    Obwohl in beiden SPS-Bibliotheken der Enumeration E_AdsErr gleich aufgebaut ist, handelt es sich um zwei verschiedene Datentypen. Das bedeutet, dass in dem oberen Beispiel die Variablen eAdsErr01 und eAdsErr02 nicht miteinander kompatibel sind.

    eAdsErr01 := eAdsErr02;
    

    Diese Zuweisung wird vom Compiler mit der folgenden Fehlermeldung ablehnt:

    Implicit conversion from one enumeration type (E_ADSERR (tc2_system, 3.4.14.0 (beckhoff automation gmbh))) to another (E_ADSERR (tc2_system, 3.4.13.0 (beckhoff automation gmbh)))

    Global Variable List

    Eine Globale Variable List (GVL) dient zum Deklarieren von globalen Variablen. Der Name der GVL muss in einem Projekt eindeutig sein, wobei Groß- und Kleinschreibung nicht von Bedeutung ist. Jede GVL ist ein in sich abgeschlossener Bereich (Namespace), in dem, unabhängig von anderen GVLs, globale Variablen deklariert werden.

    Im folgenden Beispiel sind drei Variablen deklariert. Alle drei Variablen haben den Namen var01, wovon zwei in getrennten GVLs (GVL01 und GVL02) deklariert werden und eine lokal in MAIN.

    Pic06

    Um den Zugriff auf die Variablen wieder eindeutig zu machen, muss zusätzlich der Name der GVL vor den Variablennamen, getrennt durch einen Punkt, gestellt werden.

    GVL01.var01 := 1;    // global variable in GVL01
    GVL02.var01 := 2;    // global variable in GVL02
    var01 := 3;          // local variable in MAIN
    

    Existiert die Variable var01 nur in einer GVL, so kann die Angabe der GVL auch entfallen. Gibt es allerdings eine lokale Variable mit dem gleichen Namen, so muss der Name der GVL wieder angegeben werden. Alternativ kann vor dem Variablennamen auch nur ein Punkt gestellt werden, welches den global Namespace kennzeichnet.

    .var01 := 1;     // global variable
    var01 := 3;      // local variable
    

    Der Punkt vor dem Variablennamen gibt an, dass auf die globale Variable mit dem Namen var01 zugegriffen werden soll. In diesem Fall darf die Variable aber auch nur in einer GVL existieren.

    Attribut qualified_only

    Der Name der GVL sollte immer mit angegeben werden, auch dann, wenn es nicht unbedingt notwendig ist. Befindet sich in der GVL das Attribut qualified_only, so wird eine Fehlermeldung ausgegeben, wenn bei einem Zugriff auf eine der Variablen die Angabe der GVL fehlt.

    {attribute 'qualified_only'}
    VAR_GLOBAL
      var01  :  INT;
      var02  :  INT;
    END_VAR
    

    Wird auf eine der globalen Variablen zugegriffen, so muss der Name der GVL mit angegeben werden. Das Programm wird dadurch lesbarer und Seiteneffekte zwischen lokalen und globalen Variablen können besser vermieden werden.

    Beispiel 2 (TwinCAT 3.1)

    GVLs in Bibliotheken

    Befindet sich eine GVL in einer Bibliothek, so kann neben den Namen der GVL auch noch der Namespace der Bibliothek genutzt werden.

    In dem folgenden Beispiel wurden drei Variablen mit den Namen var01 an verschiedenen Stellen deklariert:

    – In der GVL01 einer Bibliothek mit dem Namespace MyNamespace01
    – In der GVL01 des lokalen SPS-Projektes
    – Im lokalen POU

    Für den Zugriff auf die jeweilige Variable kann, neben den Namen der GVL, noch zusätzlich der Namespace der Bibliothek benutzt werden:

    MyNamespace01.GVL01.var01 := 1;  // global variable of the GVL inside the library
    GVL01.var01 := 2;                // global variable of the local GVL
    var01 := 3;                      // local variable
    

    Wird in der lokalen GVL das Attribut qualified_only nicht verwendet, so kann auf die Angabe der GVL verzichtet werden:

    MyNamespace01.GVL01.var01 := 1;  // global variable of the GVL inside the library
    .var01 := 2;                     // global variable of the local GVL
    var01 := 3;                      // local variable
    

    Auch kann auf die Angabe der GVL der Bibliothek verzichtet werden, wenn dort das Attribut qualified_only nicht zum Einsatz kommt.

    MyNamespace01.var01 := 1;  // global variable of the GVL inside the library
    .var01 := 2;               // global variable of the local GVL
    var01 := 3;                // local variable
    

    Wären die Namen der GVLs eindeutig, so könnte auch der Namespace entfallen:

    GVL01.var01 := 1;   // global variable of the GVL of the library
    .var01 := 2;        // global variable of the local GVL
    var01 := 3;         // local variable
    

    Die letzten Beispiele verdeutlichen, das durch den Wegfall der Namespaces die Lesbarkeit des Programms abnimmt. Es ist schwerer zu erkennen, wo die referenzierten Variablen deklariert wurden. Daher sollte in jeder GVL das Attribut qualified_only enthalten sein und bei der Verwendung von Elementen aus Bibliotheken der Namespace benutzt werden.

    Auch bei der Definition von FBs die von einem FBs aus einer Bibliothek erben, als auch bei der Verwendung von Interfaces aus Bibliotheken sollte der Namespace angegeben werden:

    FUNCTION_BLOCK FB_MyFoo EXTENDS MyNamespace01.FB_Foo IMPLEMENTS MyNamespace01.I_Foo
    VAR_INPUT
    END_VAR
    VAR_OUTPUT
    END_VAR
    VAR
    END_VAR
    

    Der Dialog zum Anlegen von neuen FBs bietet hierzu entsprechende Unterstützung an:

    Pic07

    Beispiel 3 (TwinCAT 3.1)

    Enumerationen

    Sofern auf die Werte einer Enumeration zugegriffen wird, kann der entsprechende Wert direkt benutzt werden. Um einen eindeutigen Zugriff auf eine Enumerations-Konstante zu gewährleisten, kann zusätzlich noch der Typ-Name hinzugefügt werden.

    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    
    PROGRAM MAIN
    VAR
      eFoo01  :  E_Foo01;
    END_VAR
    eFoo01 := eErrorA;
    eFoo01 := E_Foo01.eErrorA;
    

    Ist ein Bezeichner für eine Enumerations-Konstante in verschiedenen Typ-Definitionen enthalten, so ist der Typ-Name beim Zugriff notwendig. Dadurch können Konstanten gleichen Namens in mehreren Enumerationen verwendet werden. Somit ist es nicht mehr notwendigen jede Enumerations-Konstante mit einem Prefix zu erweitern, um Namenskonflikte zu vermeiden.

    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    
    TYPE E_Foo02 :
    (
      eNoError := 0,
      eError1 := 1,
      eError2 := 2
    );
    END_TYPE
    
    PROGRAM MAIN
    VAR
      eFoo01	  :  E_Foo01;
      eFoo02	  :  E_Foo02;
    END_VAR
    eFoo01 := E_Foo01.eNoError;
    eFoo02 := E_Foo02.eNoError;
    

    Befindet sich die Typ-Definition in einer Bibliothek, ist die Angabe des Namespace zusätzlich noch möglich:

    eFoo01 := MyNamespace01.E_Foo01.eNoError;
    

    Attribut qualified_only

    Ähnlich wie bei den GVLs, kann durch das Attribut qualified_only die Angabe des Typ-Namens erzwungen werden:

    {attribute 'qualified_only'}
    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    

    Beispiel 4 (TwinCAT 3.1)

    Attribut strict

    Das Attribut strict hat keinen direkten Bezug zu Namespaces. Es kann aber ebenfalls dazu dienen ein Programm lesbarer zu machen. Deshalb soll es hier kurz vorgestellt werden.

    Eine Variable vom Typ einer Enumeration wird intern wie ein INT behandelt. Somit sind mit Enumerationen arithmetische Operationen möglich oder es können Werte zugewiesen werden, die nicht durch die Enumerationen definiert wurden. Das folgende Beispiel weist der Variablen eFoo01 den Wert 3 zu. Die Enumeration E_Foo01 enthält jedoch keinen entsprechenden Wert.

    eFoo01 := E_Foo01.eErrorA + 2;
    

    Wird das Attribut strict bei der Definition einer Enumeration angegeben, so wird sichergestellt, dass Variablen von diesem Typ nur Werte annehmen können, die durch die Enumeration auch definiert worden sind.

    {attribute 'strict'}
    TYPE E_Foo01 :
    (
      eNoError := 0,
      eErrorA := 1,
      eErrorB := 2
    );
    END_TYPE
    

    Durch das Attribut strict sind keine Operationen mehr erlaubt, die Werte zur Folge haben, die nicht durch die Enumeration definiert worden sind. Dieses betrifft folgende Operationen:

    Zuweisung von Konstanten die nicht durch die Enumeration definiert wurden
    eFoo01 := 5;
    
    Arithmetische Operationen mit Werten der Enumeration
    eFoo01 := E_Foo01.eNoError + E_Foo01.eErrorA;
    
    Zuweisen von Variablen die nicht vom Typ der Enumeration sind
    nVar := 1;        // variable nVar is a INT
    eFoo01 := nVar;
    

    Zusammenfassung

    Namespaces bieten einen guten Mechanismus um Namenskonflikte zu vermeiden. Entsprechende Prefixe in den Bezeichnern von Funktionen und Datentypen sind somit nicht mehr notwendig. Die Elementnamen werden dadurch kompakter, der Quelltext besser lesbar.


    Code-Inside Blog: Enable SSL with custom domains on GitHub Pages via Cloudflare

    Two weeks ago I decided (finally!) that I should enable SSL on this blog.

    Problem: GitHub Pages with a custom domain

    This blog is hosted on GitHub Pages with a custom domain, which currently doesn’t support SSL out of the box. If you stick with a github.io domain SSL is not a problem.

    Cloudflare to the rescure

    I decided to take a deeper look at Cloudflare, which provides DNS, CDN and other “network”-related services. For the “main” service Cloudflare serves as the DNS for your domain and is like a proxy.

    With this setup you have some nice benefits:

    • A free SSL certificate (AFAIK you can also use your own cert if you need)
    • A CDN cache
    • DDOS protection
    • “Analytics”

    Be aware: This is just the free plan.

    And everything is pretty easy to manage via the web interface.

    Setup

    The first step is to register at Cloudflare & setup your domain. After the first step you need to change the name server for your domain to Cloudflares server.

    All your domain belonging can now be managed inside Cloudflare:

    x

    Setting up some rules

    When your DNS changes are done (which can take a couple of hours) you might want to introduce some basic rules. I use these settings, which enforces HTTPS and Cloudflare cache:

    x

    Done… or nearly done.

    Now we have done the “Cloudflare-part”. The next step is to make sure that everything on your page uses HTTPS instead of HTTP to avoid “mixed content”-errors.

    Some notes from my own “migration”:

    • If you have Google Analytics - make sure you change the property-settings to the HTTPS URL
    • If you use Disqus you need to migrate your comments from the HTTP url to the HTTPS URL. There is a migrate tool available, which uses a CSV file.

    Other solutions…

    As far as I know there are other, similar, providers out there and of course you can host the page yourself.

    Cloudflare is an easy solution if you are willing to hand of the DNS settings of your domain.

    Hope this helps!

    AIT: Neu in Visual Studio und TFS „15“: die nächste Evolutionsstufe des Kanban Boards

    Bereits im letzten Release des TFS gab es eine Vielzahl an neuen Features im Kanban-Board. Im Detail sind sie im Beitrag Neu in TFS 2015 – das Kanban Board wird erwachsen aufgeführt. In der aktuellen Version steht nun die nächste Evolutionsstufe zur Verfügung. Was alle Neuerungen auszeichnet ist, dass sie einzeln betrachtet recht unscheinbar wirken. Durch die Summe aller neuen Features hingegen, können nun Anwendungsfälle umgesetzt werden, bei denen es bisher zu Schwierigkeiten kam.

    Doch beginnen wir von Vorn. Wenn die Rede von Kanban Boards ist, sind die Boards für Epics, Features und, je nach Prozess Template, Requirements, User Stories oder Product Backlog Items gemeint. Alle vier großen Neuerungen (1 – 4) sind rechts oben in der Ansicht, unterhalt des Cumulative Flow Chart, zu finden.

    tfs15-kanbannews

    Suchen im Board (#1)

    Die Suchfunktion ist kein neues Feature, der Vollständigkeit halber soll sie kurz erwähnt werden. In einem Kanban Board werden grundsätzlich alle Items des jeweiligen Backlogs dargestellt. In der ersten und letzten Spalte werden standardmäßig die ersten 20 Items angezeigt. Dies dient der besseren Übersicht des Boards. Auf Knopfdruck können jedoch stückweise alle weiteren Items geladen werden. Um in dieser großen Menge an Elementen gezielt ein Work Item finden zu können, existiert nun eine Suchfunktion. Diese Suche berücksichtigt dabei alle im Board sichtbaren Felder. Wird zum Beispiel des Öfteren nach dem Area Path gesucht, bietet es sich an diesen als zusätzliches Feld anzuzeigen.

    Filtern im Board (#2)

    Neben der Suche existieren nun Filter, welche dauerhaft (im Benutzerkontext) für ein Board definiert werden können. Wie in der obenstehenden Abbildung zu sehen, existieren Filter für die Felder Assigned To, Iteration Path, Work Item Type, Tags und Parent Work Item Type. In den Filtern können neben expliziten Werten auch Makros (@Me oder @CurrentIteration) ausgewählt werden. Diese Funktion unterstützt besonders Teams, welche für ihr Daily Standup Meetings nicht das Task Board nutzen. Über die oben dargestellte Filterung sind nur Work Items des aktuellen Sprints zu sehen, wodurch das Daily Meeting wesentlich besser unterstützt wird.

    Live-Update (#3)

    Wird über den Button 3 die Live Update Funktion im Board aktiviert, kann ein Daily Meeting mit Remote-Teilnehmern nun ohne Screen-Sharing durchgeführt werden. Sobald ein Item auf dem Board geschoben wird, findet eine automatische Aktualisierung auf allen bereits geöffneten Boards statt. Das Update bezieht sich ausschließlich auf den Status des Items und die eingeblendeten Felder. Änderungen in den verknüpften Tasks und Tests führen nicht zu einer Aktualisierung. Durch diese Funktion kann diese Ansicht nun auch genutzt werden, um ein gemeinsames Board mit dem aktuellen Fortschritt auf einem zentralen Monitor im Büro für alle zu visualisieren.

    Annotations (#4)

    Hinter dem Einstellungsbutton für die Kanban-Boards verstecken sich noch weitere neue Funktionalitäten. Die bisher nur von Backlog Items bekannten Task Annotations wurden erweitert.  Über die Task Annotions konnten bisher direkt im Kanban Board Tasks für Backlog Items erstellt und als erledigt markiert werden. Nun sind auch auf Epic- und Feature-Ebene die entsprechenden Annotations für Child Work Items vorhanden.

    Annotations in Kanban-Boards

    Wie in der obenstehenden Abbildung zu sehen, sind auf Backlog Items neben den Task Annotations auch Test Annotations verfügbar. Damit ist es möglich im Kanban Board Test Cases für Backlog Items anzulegen. In den dazugehörigen Testeinstellungen wird der Testplan definiert, in welchem die über die Annotation erstellen Test Cases eingefügt werden. Über Test Annotations können Test Cases jedoch nicht nur angelegt werden. Es ist auch möglich einen Test zu starten oder direkt das Ergebnis für einen Test Case zu editieren. Ein Test Case kann, wie bisher auch in mehreren Test Suiten genutzt werden. Über die Checkbox in den Testeinstellungen wird das Verhalten beim Ändern des Testergebnisses angepasst. So kann definiert werden, dass die Änderung des Ergebnisses sich auf alle Verwendungen innerhalb eines Testplans auswirkt, sofern sie die gleiche Konfiguration haben.

    Test-Annotations im Kanban-Board

    Mehr zum Thema Testen mit dem TFS „15“ kann in folgenden Blogposts nachgelesen werden:

    · Neu in Visual Studio und TFS „15“: Test Management

    · Neu in Visual Studio und TFS „15“: Test und Feedback Erweiterung

    Durch die erläuterten Anpassungen wird der Einsatzbereich der Kanban Boards nun deutlich breiter. Teams welche ohne bisher bereits Taskboard arbeiten, werden es lieben und alle anderen sollten es mal probieren! Durch die Filter wird die Ansicht übersichtlicher, Live Updates machen physische Boards im Raum überflüssig und Testfälle können direkt im Board angelegt werden. Wenn also keine Stunden auf Tasks gepflegt werden müssen, stellt sich also langsam die Frage, ob ein Taskboard überhaupt noch nötig ist. 😉

    MSDN Team Blog AT [MS]: Webinars: Web and [Mobile] API back-ends on Azure

         
           
         
           
      Western Europe Webinar series:

    Web and [Mobile] API back-ends on Azure

     

     

    In English language

           
      The series “API and App back-ends on Azure” consists of three webcasts that introduce you to Azure App and API Services. These are platform services that allow developers to focus on code and use the platform to take care of hosting, deployment, scaling and securing the code to run for you. While we will show a few slides, we spend more time in demo mode. Whether Windows or Mac, developing in .NET, Node.je, PHP or Java, this series gives you a good overview of the options you have while staying platform agnostic.  
      .  
      November 9, 2016 11:00 – 12:00

    Session 1: Modern APIs and Apps Platform on Azure

     

    (Recording available)

     
      APIs are the engine of innovation today. Taking an API first approach, we’ll dive into the benefits of leveraging Azure App Service for hosting our (mobile) API which is going to back our apps. During the session we’ll go from creating a simple API to having it hosted on Azure. You’ll learn what this platform offers you so much out of the box that can help you accelerate your (mobile) development and hosting.  
      .    
      November 23, 2016 11:00 – 12:00 Session 2: DevOps with App Service  

    (Register here)

     
      Continuing on our first episode, we’ll further dive into the features that Azure App Service provides us for easing development & operations. We look at Continuous Integration, rolling upgrades, A/B testing, performance monitoring. Options for deployment and release managements are also addressed.  
      .    
      December 7, 2016 11:00 – 12:00

    Session 3: API Management

     

    (Register here)

     
      Having addressed App Service for the hosting of our Web, Mobile Apps and APIs, manageability and integration of these APIs become a key element for supporting faster innovation. In this session we’ll look at options for exposing, securing, managing and sharing our APIs with Mobile developers, partners and internal users.  

    Fabian Deitelhoff: Mini-Review: LEGO WeDo 2.0 Probepäckchen

    Auf der Bildungsmesse Didacta 2016 wurden zahlreiche Probepäckchen des WeDo 2.0 Pakets und des Workshop Kit Freewheeler verteilt. Dieser Beitrag ist ein sehr kleines Mini-Review dieser Pakete, die mir wirklich gut gefallen. Leider bin ich aktuell noch nicht in die Situation gekommen, mal ein WeDo 2.0 Set ausführlich zu testen. Sobald das geklappt hat, gibt es zu dem Paket ein ausführlicheres Feedback.

    Das WeDo 2.0 Set richtet sich ganz allgemein an Grundschulen mit einem vereinfachten Lernkonzept, wenn es mit dem LEGO Mindstorms Education EV3 verglichen werden soll. Es sind auch Motoren mit an Bord, die über eine grafische Oberfläche (+ grafische Programmiersprache) angesteuert werden können. Alles in allem ist das Set weniger komplex als der LEGO Mindstorms Education EV3. Im Probepäckchen sind ein paar LEGO-Steine und etliche Infos zu den Unterrichtsmaterialien vorhanden.

    Abb. 1: WeDo 2.0 Probepäckchen. Abb. 2: LEGO-Modell des WeDo 2.0 Probepäckchens.

    Das Freewheeler Paket ist ähnlich aufgebaut. Eine Anleitung, einige LEGO-Steine zusätzlich und wieder viele Infos zu den angebotenen Unterrichtsmaterialien. Mit dem Freewheeler-Set sind schon deutlich komplexere Aufgaben möglich, die alle in die Richtung von Mechanik und Co. gehen. Die Programmierung scheint hier nicht mit inbegriffen zu sein.

    Abb. 5: Der Freewheeler-Bausatz. Abb. 4: Verpackung der Freewheeler LEGO-Steine. Abb. 3: Inhalt des Freewheeler Probepäckchens.

    Ich hoffe, dass ich in naher Zukunft ein WeDo 2.0 Set ausprobieren kann, um ein ausführliches Review zu schreiben. Was ich darüber gelesen und teilweise gesehen haben, verspricht schon mal sehr viel.

    Holger Sirtl: Azure News on Friday (KW45/16)

    Auch diese Woche gab’s wieder viele Nachrichten zur Microsoft Azure Plattform. Stets aktuelle News, Videos, Tools, MVA-Kurse, und vieles mehr zu Azure auf dem Azure Infohub unter http://aka.ms/azureinfohub .

    Hier weitere aktuelle News Infos…

    Aktuelle Neuigkeiten

    Datum Nachricht
    10.11. Azure big data services host Ask Me Anything session
    Ask me Anything Session des Azure Big Data Teams am 17. November 2016 von 19:00 bis 23:00 Uhr
    08.11. General availability: Azure API Management SOAP pass-through
    Azure API Management SOAP Pass-Through jetzt allgemein verfügbar
    07.11. Resource Manager Homepage
    Resource Manager Homepage
    07.11. Azure Container Registry preview
    Preview der Azure Container Service Registry verfügbar – Images für alle unterstützten Container bereitstellen

    Neue Videos

    Datum Nachricht Video
    11.11. Migrate Azure IaaS Solutions from ASM to ARM Using migAz, Part 1
    Tipps zur Migration von Azure Virtual Machines vom ASM Modell ins Resource Manager Modell mit migAz
    08.11. Predictable Performance with DocumentDB
    Tipps für stabile und hohe Performance bei Azure DocumentDB Apps
    08.11. Securing Azure HDInsight
    Azure HDInsight sicher nutzen – hier gibt’s Tipps
    08.11. Tuesdays with Corey: Azure Event Hubs Archive goodness
    Corey Sanders zu Event Hubs Archive – Nachrichten sicher in Azure Storage archivieren
    04.11. Episode 218: DDD and CQRS on Service Fabric with MediaValet
    Domain Driven Design (DDD) and Command and Query Responsibility Segregation (CQRS) with Azure Service Fabric

    Stefan Lieser: Unit Tests in C++ mit CppUnit

    Auch in C++ Projekten gehören automatisierte Unit Tests dazu. Mein Cheatsheet hilft Ihnen bei den ersten Schritten mit Unit Tests in C++.

    Der Beitrag Unit Tests in C++ mit CppUnit erschien zuerst auf Refactoring Legacy Code.

    AIT: Neu in Visual Studio und TFS "15": Test Management

    Im Rahmen unserer Blogserie “Neu in Visual Studio und TFS 15” möchten wir auch die Neuerungen für das Test Management vorstellen. Diese bringen einige lang ersehnte Features mit sich und betreffen im Wesentlichen die folgenden drei Bereiche:

    • Testreihenfolge
    • Konfigurationsmanagement
    • Test Management über das Kanban Board

    Testreihenfolge

    Für das Anordnen von Tests bringt der TFS 15 zwei wesentliche Änderungen mit sich, welche seit geraumer Zeit auf der Liste der gewünschten Features für den TFS auf der Visual Studio User Voice Webseite zu finden sind.

    Die erste Änderung adressiert das User Voice Element “Add ability to order test suites”. Bisher wurden Test Suiten innerhalb eines Test Plans alphabetisch angeordnet. Damit war es nur über Workarounds in der Benennung  der Test Suiten möglich eine eigene Reihenfolge zu definieren. Dies ändert sich nun. Durch simple Drag & Drop-Funktionalität können im Test Hub die Test Suiten unterhalb eines Test Plans angeordnet werden (vgl. Abb. 1). Dabei kann nicht nur die Reihenfolge von Test Suiten auf derselben Hierarchieebene geändert werden, sondern auch die Eltern-Kind-Beziehungen neu definiert werden.  D.h. Test Suiten lassen sich in in andere Test Suiten verschieben.

    image

    Abb. 1: Sortieren von Test Suiten per Drag and Drop

    Die zweite wesentliche Änderung für das Anordnen von Tests löst das User Voice Element “Enable changing the order of test cases on the web gui and let them be tested in this order for manual tests”. Microsoft kommt damit dem Wunsch der User nach eine Reihenfolge für manuelle Test Cases innerhalb einer Test Suite (unabhängig vom Test Suite Typ) zu definieren, welche als Ausführungsreihenfolge verwendet werden kann. Damit existiert nun nach langem Warten eine Möglichkeit einfache Abhängigkeiten von Test Cases über die Reihenfolge abzubilden.

    Möchte man nun manuelle Test Cases anordnen, so navigiert man im Test Hub in die entsprechende Test Suite und aktiviert die Funktion ‘Order tests’ (vgl. Abb. 2 (1)). Im Folgenden kann man dann die Test Cases per Drag & Drop oder über das Kontextmenü (vgl. Abb. 2 (2)) in die gewünschte Reihenfolge bringen. Soll die neue Reihenfolge gespeichert werden, bestätigt man die gemachten Änderungen mittels des Knopfes ‘Done’ (vgl. Abb. 2 (3)). Über den ‘Cancel’-Button werden die Änderungen verworfen und die ursprüngliche Reihenfolge beibehalten (vgl. Abb. 2 (4)).

    image

    Abb. 2: Sortieren von Test Cases

    Für Requirements-based Test Suiten können darüber hinaus die enthaltenen Test Cases nicht nur im Test Hub sortiert werden, sondern auch direkt per Drag & Drop auf der entsprechenden Requirements-Karte auf dem Kanban Board (vgl. Abb. 3). Die gemachten Änderungen auf dem Kanban Board werden in den Test Hub synchronisiert und umgekehrt.

    image

    Abb. 3: Sortieren von Test Cases auf Kanban Board

    Unabhängig davon ob die Sortierung der Test Cases im Test Hub oder auf dem Kanban Board vorgenommen wurde können Test Cases anschließend im Test Hub nach dem ‘Order’-Feld sortiert und in der definierten Reihenfolge ausgeführt werden.

    Konfigurationsmanagement

    Bereits seit einiger Zeit verlagert Microsoft mehr und mehr Funktionalität in den TFS Web Access, welche bisher noch gar nicht oder nur im Microsoft Test Manager (MTM) vorhanden war. Dies spiegelt sich auch im TFS 15 wieder. Mit dem neuen Tab ‘Configurations’ innerhalb des Test Hubs wird das Verwalten von Konfigurationen für Tests auch im TFS Web Access möglich (vgl. Abb. 4). Alle durch den MTM bekannten Funktionen wie z.B. das Anlegen neuer Konfigurationen und Konfigurationsvariablen können jetzt auch webbasiert durchgeführt werden.

    image

    Abb. 4: Neuer Tab ‘Configurations’

    Zusätzlich wird das Zuweisen von Konfigurationen zu Test Plänen, Test Suiten und Test Cases im Test Hub erleichtert. Im jeweiligen Kontextmenü können über den Punkt ‘Assign configurations …’ (Test Case: ‘Assign configurations’ / Test Suite: ‘Assign configurations to test suite’ / Test Plan: ‘Assign configurations to test plan’) Konfigurationen zugewiesen werden (vgl. Abb. 5).

    image

    Abb. 5: Neuer Tab ‘Configurations’

    Test Management über das Kanban Board

    Wie bereits in den Visual Studio Team Services erkennbar wurde, werden die Requirements-Karten auf dem Kanban Board mit immer mehr Funktionalität versehen. Diese Entwicklung zeigt sich nun auch im TFS 15. Dieser bringt verschiedenste neue Möglichkeiten im Bereich Testing auf dem Kanban Board. Eine davon, nämlich das Sortieren von Test zugehörig zu einem Requirement, wurde bereits im  Abschnitt ‘Testreihenfolge’ vorgestellt.

    Darüber hinaus sind folgende Funktionalität aus den Requirements-Karten heraus auf dem Board möglich:

    • Anlegen neuer Test Cases, welche mit dem entsprechenden Requirement durch einen ‘Tests-Tested By’-Link verknüpft werden (vgl. Abb. 6 (1))
    • Öffnen von verknüpften Test Cases
    • Verschieben von Test Cases zu anderen Requirements per Drag & Drop
    • Kopieren desselben Test Cases zu einem anderen Requirement per STRG + Drag & Drop
    • Setzen des Test Status (Pass, Fail, Not Applicable, Blocked, Active)
    • Ausführen von Tests
    • Testfortschrittsüberwachung für einzelne Requirements durch einen zusammenfassenden Status-Indikator (vgl. Abb. 6 (2))

    image

    Abb. 6: Ausgewählte Funktionalität aus den Requirements-Karten auf dem Kanban Board

    Außerdem lassen sich mittels der Settings für das Kanban Board verschiedene Einstellungen treffen, wie sich das Board und die darauf enthaltenen Requirements-Karten verhalten und angezeigt werden. Diese wurden erweitert um die Möglichkeit für Tests, welche direkt über die Karten des Boards für ein Requirement erstellt werden (mittels ‘Add Test’), den übergeordneten Test Plan festzusetzen (vgl. Abb. 6). Wird kein Test Plan spezifiziert, bleibt das bisherige Standardverhalten bestehen. D.h. neu angelegte Tests werden zu einem neuen, automatisch erstellten Test Plan hinzugefügt, welcher denselben Area- und Iterationsknoten wie das dem Test zugehörige Requirement besitzt. Existiert bereits ein solcher Test Plan, so wird dieser verwendet.

    image

    Abb. 6: Konfigurationen von Test Settings auf Kanban Board

    Fazit

    Wie in dem Blogartikel dargestellt, bringt das neue TFS Release einige spannende Neuerungen im Test Management mit sich. Doch das ist noch längst nicht alles im Bereich des Testens. Freuen Sie sich auf weitere Artikel zu Neuerungen, beispielsweise für die Test Auswertung und das explorative Testen.

    Stefan Lieser: Unit Tests mit NUnit unter .NET Core

    Inzwischen ist NUnit unter .NET Core lauffähig. Im Detail gibt es ein paar Dinge zu beachten. In loser Folge aktualisiere ich diesen Blogbeitrag um meine Erkenntnisse.

    Der Beitrag Unit Tests mit NUnit unter .NET Core erschien zuerst auf Refactoring Legacy Code.

    MSDN Team Blog AT [MS]: kostenloses Mobile DevOps Training (24. und 25.11.)

    kostenloses Mobile DevOps Training (24. und 25.11.)

    Am 24 und 25. November findet bei Microsoft Österreich ein kostenloses 2 tägiges Mobile DevOps Training statt.

    Wir zeigen agile mobile App Entwickliung mit Visual Studio, Xamarin & Microsoft Azure. Das Training wird in deutscher Sprache abgehalten.

    Jetzt zum Mobile DevOps Training am 24. und 25.11. anmelden!!

    Software-Engineering-Methoden haben sich in den letzten Jahren drastisch verändert. Agile Praktiken, DevOps, Cloud Computing, Open Source und ähnliche Entwicklungen haben ihre Wirksamkeit bewiesen. Microsoft Plattformen für Software-Entwicklung und Cloud Computing haben ebenfalls diese Konzepte angenommen und sind ihrem Bereich an der Spitze in cross-Plattform und mobile App-Entwicklung.

    In diesem zweitägigen Kurs lernst du wie mobile Software Entwicklung mit Microsoft Tools und Sprachen arbeitet.

    Auf Basis eines durchgängigen Beispieles lernst Du:

    • Einrichten einer Entwicklungsumgebung für eine mobile Anwendung mit den neuesten Versionen von Visual Studio und Visual Studio Team Services
    • eine einfache Android App mit Xamarin zu entwickeln,
    • von den neuesten Entwicklungen in der Visual Studio C#-IDE (z.B. PerfTips, live code Analyse, CodeLense, Diagnose-Tools, etc..) zu profitieren
    • die Visual Studio Team Services zu verwenden um Deine Qualitätssicherungs-Prozesse zu automatisieren
    • Deine Tests mit der Xamarin Test Cloud auf über 2.000 echten Geräten zu automatisieren
    • die Bereitstellung mit Visual Studio-Release-Management zu automatisieren und
    • aussagekräftige Berichte und Feedback von Deinen Benutzern in der HockeyApp zu sammeln

    Tag 1:

    • Microsoft Developer Plattform und mobile Entwicklung
    • Mobile Anwendungen mit Xamarin erstellen
    • Wie Visual Studio Team Services und mobile App-Entwicklung zusammen funktionieren
      (Build, Release-Management, kontinuierliche Bereitstellung usw.).

    Tag 2:

    • Automatisierte Tests mit der Xamarin Test Cloud
    • Integration von HockeyApp für Absturz-Berichterstattung und Benutzer-Feedback
    • Bereichern Deiner Mobilanwendung mit Cloud-Services

    Wichtige Voraussetzung: Du benötigst Deinen EIGENEN LAPTOP für die praktischen Übungseinheiten!

    Weitere Details hier herunterladen: https://1drv.ms/w/s! AqM7MHvEOS1jipcxNNyLyvxqsIH37w

    Jetzt zum Mobile DevOps Training am 24. und 25.11. anmelden!!

    Eure Trainer sind:

    Rainer Stropek Roman Schacherl
    Rainer Stropek, MVP Roman Schacherl, MVP

    Holger Sirtl: Azure News on Friday (KW44/16)

    Auch diese Woche gab’s wieder viele Nachrichten zur Microsoft Azure Plattform. Stets aktuelle News, Videos, Tools, MVA-Kurse, und vieles mehr zu Azure auf dem Azure Infohub unter http://aka.ms/azureinfohub .

    Hier weitere aktuelle News Infos…

    Aktuelle Neuigkeiten

    Datum Nachricht
    07.11. Resource Manager Homepage
    Resource Manager Homepage
    02.11. General availability: Azure cool blob storage in additional regions
    Azure Cool Blob Storage jetzt auch in den deutschen Azure Rechenzentren allgemein verfügbar
    01.11. Azure Functions portal and host improvements
    Verbesserungen im Azure Portal zu Azure Functions
    01.11. Site Recovery Limits
    Site Recovery Limits
    01.11. Azure Backup supports encrypted Azure virtual machines using Portal and PowerShell
    Azure Backup unterstützt jetzt auch verschlüsselte Azure Virtual Machines
    31.10. #AzureAD B2B Invitation API is now in public preview!
    Azure AD B2B jetzt via API ansprechbar – Benutzer via Programmcode ins eigene Corporate Azure AD einladen
    28.10. DocumentDB: Expanded geospatial support, including automatic indexing of Polygon and LineString objects
    Neue Möglichkeiten im geospatial Indexing in Azure DocumentDB – Abfragen mit Polygonen und LineString Objekten

    Neue Videos

    Datum Nachricht Video
    02.11. Getting started with the new Azure Active Directory management experience
    Azure AD im neuen Azure Portal – ein Schnellüberblick
    02.11. Azure Functions and the Evolution of Web Jobs
    Überblick über Azure Functions als Alternative zu WebJobs
    31.10. PowerBI Embedded GA
    PowerBI Embedded jetzt allgemein verfügbar – hier ein Überblick
    28.10. Episode 217: Azure Active Directory B2C with Swaroop Krishnamurthy
    Guter Überblick über Azure AD B2C – Registrierung und Authentifizierung in eigenen Apps über Social Identities
    28.10. Create a Linux Virtual Machine
    Anlegen einer Linux VM in Azure via Virtual Machines in 4 Minuten
    28.10. Get Started with Azure Monitor
    Schnelleinstieg in den Azure Monitor Service

    MSDN Team Blog AT [MS]: IDC & Microsoft: Open Source Roadshow für Kunden

    IDC & Microsoft möchten Sie gerne zu einer europaweiten Roadshow mit dem Schwerpunktthema Open Source Software einladen. Die Veranstaltung richtet sich an mittelständische und große Unternehmen.

    Neben Top-Vorträgen von IDC konnten wir auch das österreichische Unternehmen crate.io und den CTO Jodok Batlogg für eine Keynote gewinnen. crate.io entwickelt eine NoSQL Open Source Datenbank die natürlich auch moderne Cloud-Konzepte unterstützt. Dazu hat crate auch eine besonderen Lasttest mit 1001 8-core nodes in Azure durchgeführt und dokumentiert.

    IDC Senior Research Analyst, Julia Neuschmid wird über “Getting IT right: Wie Cloud und Open Source die digitale Transformation ermöglichen” referieren.

    Des weiteren sind fast alle bekannten Enterprise Open Source Lösungen Teil der Roadshow: Canonical, cloudbees, cloudera, elastic, Postgres, GitHub, Hortonworks, Kinme, MariaDB, Mesosphere, puppet, redislabs und suse.

    Eventseite & Anmeldung: IDC OSS Roadshow, 24. November 2016, Wien

    Detaillierte Agenda

    MSDN Team Blog AT [MS]: Countdown für Connect(); 2016

    Unser zweiter großer Entwicklerevent (nach der //build Konferenz) steht vor der Tür.connect

    Die Connect(); findet am 16. und 17. November statt. Alle Vorträge werden live übertragen und sind danach auch on-demand verfügbar.

    Viel Spaß!!

    Johannes Renatus: Kommerzielle Ui Framworks für Angular 1 / 2 (Telerik, DevExpress, …)

    Es gibt zwar eine Menge kostenlose Ui Frameworks für AngularJs, diese beinhalten aber meist nur die Standardkomponenten und z.B. kein richtiges Data Grid. Da ich aber ein richtiges Data Grid benötigte, musste ich mich also nach kommerziellen Lösungen umsehen. Bei den kommerziellen Lösungen habe ich leider keines finden können welches Nativ in AngularJs 1.x geschrieben […]

    AIT: Neu in Visual Studio und TFS "15": Multivalue Control Extension

    Seit langer Zeit steht der Wunsch nach einem Multivalue Control auf der Liste der gewünschten Features für den TFS auf der Visual Studio User Voice Webseite. Mit TFS „15“ kommt Microsoft diesem Wunsch in Form einer Marketplace-Extension nach und löst damit den bisherigen Workaround in Form des Custom Work Item Controls von CodePlex ab. In diesem Blogpost stellen wir Ihnen vor, wie die Extension installiert werden kann, wie das Multivalue Control in Teamprojekten verwendet werden kann und was es sonst noch darüber zu wissen gibt.

    Über die Suche im Marketplace kann die Extension gefunden und installiert werden. Wie bisher auch für die Legacy Extensions üblich, wird die Extension auf Collection-Ebene installiert  (vgl. Abb. 1). Möchte man darüber hinaus im Nachhinein für weitere Collections das Multivalue Control verfügbar machen, kann dies über die Seite ‘Manage Extensions’ (http://<server>/tfs/_gallery/manage) erreicht werden.

    image

    Abb. 1: Installation der Multivalue Control-Extension

    Nach der Installation der Extension kann das Multivalue Control dann in Teamprojekten der Collection verwendet werden. Dabei gilt es zu beachten, dass dies nur für Teamprojekte  gilt, welche die neue Work Item Web Form aktiviert haben und damit in den Work Item Definitionen des Prozess Templates den neuen Knoten WebLayout besitzen. Ist dies gegeben, so kann das Prozess Template entsprechend angepasst werden, um das Multivalue Control zu verwenden.

    Dazu exportiert man wie gewohnt die Work Item Type Definition des zu bearbeitenden Work Items aus dem Team Projekt (per Witadmin oder Visual Studio). Dieses enthält nun im Bereich WebLayout alle, für die weiteren Schritte notwendige Informationen der Extension, wie z.B. die ID der Extension (vgl. Abb. 2 (1)) und die ID des ControlContributionElements (vgl. Abb. 2 (2)).

    image

    Abb. 2: Extension-Informationen

    Mit diesen Informationen kann nun die Work Item Type Definition angepasst werden, um die Multivalue Control zu verwenden. Im ersten Schritt wird ein neuer Extension-Knoten im Bereich WebLayout/Extensions eingeführt, um die Extension in der Work Item Form verfügbar zu machen (vgl. Abb. 3). Die angegebene ID muss dabei wie in den Extension-Informationen spezifiziert angegeben werden (vgl. Abb. 2 (1)).

    image

    Abb. 2: Extension-Knoten

    Im zweiten Schritt kann dann das neu einzufügende Feld im Bereich FIELDS definiert werden . Die Werte, welche im Multivalue Control zur Verfügung stehen sollen, werden als SUGGESTEDVALUES angeführt, wobei das Attribute expanditems den Wert true besitzen muss (vgl. Abb. 3).

    SNAGHTML514675

    Abb. 3: Feld-Definition

    Schlussendlich wird dann das zuvor neu definierte Feld im WebLayout an gewünschter Stelle platziert. Hierzu wird ein ControlContribution-Element verwendet, welches dazu dient eine Work Item Extension auf Feld-Ebene in einem Work Item darzustellen (vgl. Abb. 4). Dabei gilt es zu beachten, dass das Attribut Value des Elements Input mit dem Refname des definierten Feldes übereinstimmen muss und die ID des ControlContributon-Elements  der in den Extension-Informationen spezifizierten entsprechen muss (vgl. Abb. 2 (1)).

    SNAGHTML5bce71

    Abb. 4: Definition des ControlContribution-Elements

    Nach den Anpassungen wird die Work Item Type Definition wieder in das Teamprojekt importiert und das lang ersehnte Multivalue-Control erscheint in dem entsprechenden Work Item an definierter Stelle (vgl. Abb. 5). Ist die Liste der Optionen eingeklappt, so werden alle ausgewählten Optionen als Kacheln dargestellt.

    image

    Abb. 5: Multivalue-Control

    Ist das Feld nun also in Verwendung so kann es auch über Queries abgefragt werden. Dabei wird der Contains-Operator verwendet. Sollen mehrere Optionen abgefragt werden, so können mehrere Contains-Klauseln verkettet werden. Diese Abfragelogik basiert darauf, dass die ausgewählten Werte im Hintergrund als Semikolon-separierte Liste abgespeichert sind (vgl. Abb. 6).

    image

    Abb. 6: Abfragen eines Multivalue-Feldes

    Nicht zuletzt sei darauf hingewiesen, dass der Source Code für die Multivalue-Extension auf GitHub zur Verfügung steht.

    Manuela Rink: Moved - to new address

    Just to try out something new - I moved my blog to a new address which you might all already now: medium :)

    So find me there for new thingies!

    https://medium.com/@codeprincess 

    Manuela Rink: The Serverless Connector

    Use Azure Functions to connect Slack as the input source for your mobile app’s data!


    Slack is a great tool to connect … yeah … tools :D That’s why developers love it, right? You can use it as a notification sink as well as a super nice collaboration tool team wide. Sure there are other tools and yet a revolution might have been already started (https://slackhq.com/dear-microsoft-8d20965d2849#.a5yawwiag) :D But this post concentrates on Slack for now. Period.

    As I am playing around a lot with Azure Functions I tried to use it as a connector for different worlds - or as someone might call it “heterogenous systems”. I wanted to use Slack to fill data into my mobile app’s backend database. So how to do this? Is this even possible with low effort? Or will the experiment be aborted because of the high concentration of WTFs in the process?

    Attention: Spoiler alert! It works like a charm :D

    image

    So what we want to do is the following:

    1. Create an Azure Mobile App
    2. Create an Azure Function
    3. Setup the mobile app
    4. Attach a binding in the function to the mobile app’s “database” or EasyTable
    5. Configure an outbound webhook for a certain Slack channel and attach the Azure Function’s URL to it
    6. And write the incoming Slack data into the mobile app’s table 

    Sounds complicated? No worries, it isn’t :) So let’s get started!

    Disclaimer

    What is NOT covered in this tutorial is the creation of the native iOS app which grabs the data from the mobile table and shows it in a UITable - coming soon!

    Create an Azure Mobile App

    First we create a new mobile app in Azure. Just hit the “+” sign at the top of the left sidebar and search for “mobile app”. Enter a name for your app, create a new resource group also and if you don’t have an active app plan already, create a new one too. For the sake of just prototyping here choose the “Free” plan in the pricing :)

    image
    image


    Create an Azure Function

    While the mobile app is deployed we can create the Azure Function in the meantime. Hit the “+” button again and search for “function”. Find the “Function App” and create a new one. Be sure to choose the resource group you just created and if you don’t have a storage yet use the chance to create a new one. Choose the “dynamic” plan and let’s go for 128MB memory for now. This can be changed later on if you need more memory for you function if it will be heavily used.

    image

    After the function is deployed enter it and create a new instance of “HttpTrigger-NodeJS”, choose a neat name and keep the authorisation level on it’s default called “function” (generates a token which needs to be added to the url when calling the function). Hit create!

    image

    Now we have a mobile app and a function. Let’s connect them!

    Setup the mobile app

    For being able to provide data to our mobile app we need to store them somewhere. So let’s create a table very quickly - as an easy table. Open your mobile app and scroll down until you see the menu entry “Easy Tables”.

    If you didn’t create a database before, you will need to to this at this point. Just follow the instruction from the assistant and create a new database and server - and select the “Free” tier for the database :)

    image

    Your data connection is then created for you - which might take a couple of seconds. Right afterwards you can choose and attach it to your mobile app.

    image

    Now you have a valid database for working with Easy Tables and Easy APIs. So create a new Easy Table by selecting the “+ Add” option in the menu bar. Give your table a nice name - remember it! - and hit “Create”. Tata! A new table is now available for you.

    image

    Attach the binding to connect the function with the app!

    Let’s recall shortly what we want to achieve here. We get data from Slack via the HTTP body. This data shall somehow be dumped to our mobile backend’s table. So we create a new binding for an output for our function. This can be done in the “Integrate” section.

    To create a new output binding just hit the “New Output” button and select “Azure mobile table record”. The following screen should be visible right afterwards.

    image

    We need a name for the parameter we will use in the source code. This is the “Record parameter name”. Then we have to add the name of the table we just created. 

    And last but not least we need the URL to our mobile app - but not the plain URL. We need to set the URL as a value for a application settings key directly to the mobile app. So let’s go to the “Function app settings” in the Azure Function right at the bottom of the left menu.

    image

    Then select, again right at the bottom, the option “Go to App Service Settings”.

    image

    Copy the URL of the mobile app - use HTTPS instead of the HTTP - and then enter the “Application settings” of the app. There you see a section called “App settings” where you add the URL you just copied as a value to a key you have to define like “MobileAppURL”.

    image

    Remember this key! This needs to be added to your Azure Functions output binding as the “Mobile App URL lookup”.

    image

    So now you should be ready! You connected your function to your application’s mobile table :) Hooray!

    Configure an outbound webhook in Slack

    Go to your Slack channels settings “Apps & Integrations”. In the web interface select “Manage” and then “Custom Integrations”. There we have to setup an “Outgoing Webhook”.

    image

    First choose a “channel” which you want to monitor for the outgoing events. Then add a trigger word e.g. “mytodo” or something you are not using normally in your wording. Upon this trigger the webhook will fire! So choose carefully.

    Then add the URL of your Azure Function to the URL field. And that is basically it. You have a few more possibilities of configuration, but those are all optional. Save it! 

    Go back to your Slack channel and type something in your defined channel with the start trigger word you chose. You should see your Azure Function in the Azure portal already firing - in the logs. Congrats! :)  It works.

    So now let’s do the last bit - write the Slack message to the mobile table :)

    Write incoming Slack data into the mobile app’s table

    This is easy. You just have to filter the data, which Slack sends to your function and get the message out of it. And then write the message to your table by using your defined output binding.

    You can find the source code for the filtering of the message right here:

    https://gist.github.com/codePrincess/9009724c774cb611ba5c15bf18d3d5e5

    Just add it to your Azure Functions code editor field and save it :)

    Most important is this part of the source code:

    context.bindings.output = {
           title: slackText,
           details: “from” + userName,
           completed: false
     }

    Here you are using your defined “output” binding - be sure to use the exact name you defined for it. You are writing values into columns which match your defined keys. So for example the above call creates a new row in your table with the value “slackText” in the column “title” and so on.

    Wrap it up!

    And then you are done! So what did you do?

    • You created a mobile app
    • Created a database server and attached a database to it
    • Created a new table in this database
    • Created an Azure Function
    • Initialised a new instance of an HTTPTrigger Node function
    • Defined an output binding to connect the function to your mobile app’s database table
    • And configured Slack to trigger an outgoing webhook event to send data to your function

    So now you are able to fill your mobile backend data by just using Slack. Great huh?

    Happy coding!

    Uli Armbruster: Session Die 4 tierischen Menschentypen

    Eine spannende Session mit dem Namen „Die 4 tierischen Menschentypen“ gab es dieses Jahr beim Developer Open Space. Das Video habe ich euch in meinem YouTube Kanal zur Disposition gestellt.

    Leider bin ich ein wenig zu spät eingestiegen, sodass ein Teil der Einführung fehlt. Macht nichts, denn hier hat Tobias Beck das toll erklärt.

    Feedback ist wie immer willkommen. Wenn euch das Video gefällt, dann teilt/liked diesen Beitrag. Wer noch den Link zum Online Self Test möchte, kann mir das in die Kommentare schreiben. Den Blog von Gregor gibt es hier.


    Einsortiert unter:CIO Topics, Events, German, Personalführung Tagged: Open Space, Video

    AIT: Neu in Visual Studio und TFS „15“: Test und Feedback Erweiterung

    Im Rahmen unserer Blogserie “Neu in Visual Studio und TFS 15” möchten wir heute eine Browser-Erweiterung vorstellen. Die Test and Feedback Extension unterstützt den Anwender dabei, das Verhalten einer Anwendung aufzuzeichnen und Feedback-Meldungen zu erstellen, welche später z.B. als Work Items weiterverarbeitet werden.

    Der Vollständigkeit halber sei hier erwähnt, dass es sich genau genommen nicht um  ein Produktfeature handelt, welches im neuen Release des TFS verfügbar ist. Zeitlich passt die Veröffentlichung jedoch gut zum neuen TFS Releasekandidaten. Man kann die Extension jedoch auch mit einem TFS 2015 im Hintergrund verwenden.

    Als erstes fällt bei dieser Extension auf, dass man sie nicht im TFS oder VSTS installiert. Es handelt sich hierbei vielmehr um eine Browsererweiterung, die dem User elegante Interaktionsmöglichkeiten bietet.

    image

    image

    Durch Klick auf den Installationsbutton im Visual Studio Marketplace gelangt man in den Chrome Web Store. Von dort aus kann man die Extension, Google Chrome vorausgesetzt, direkt installieren. Nach der Installation steht sie direkt über einen Button oben rechts neben der Adresszeile des Browsers zur Verfügung.

    image

    Vor der ersten Verwendung muss man sich noch entscheiden, in welchem der beiden unterstützten Modi man arbeiten möchte. Im Standalone Mode arbeitet völlig losgelöst von TFS oder VSTS.

    image

    Dennoch ist das Tool dann gut geeignet eine Abfolge an Schritten inkl. Screenshots und Annotationen zu dokumentieren. Diese kann anschließend als Ergebnis-Report in Form einer html-Datei mit einem eigenen Bereich für erfasste Bugs exportiert werden . Insbesondere die Darstellung entlang einer Zeitachse ist dabei eine hilfreiche Darstellung.

    image

    Im Connected Mode hingegen arbeitet man mit einem TFS oder VSTS im Hintergrund.

    image

    In diesem Fall stehen noch weitere Helfer zur Verfügung. So werden beispielsweise Klicks im UI automatisch aufgezeichnet und im Falle eines anzulegenden Work Items mit den manuell erstellten Screenshots gemeinsam eingefügt.

    image

    Im Falle der Test Case Erstellung geht die Unterstützung noch einen Schritt weiter. Hier werden mittels der aufgezeichneten Daten Test Steps inkl. einer ganz brauchbaren Beschreibung automatisch erstellt.

    image

    Als kleiner Ausblick soll hier noch die Anbindung an die Dienste der Web-Test-Dienste von Perfecto genannt werden. Weitere Infos rund um die Extension gibt es u.a. im MSDN Blog Post von Adhar Surange sowie auf der Visual Studio Marketplace Seite. Dort gibt es auch ein kurzes Intro-Video dazu.

    Code-Inside Blog: Writing loops in T-SQL

    The topic is quite old, but I found it really helpful, so be warned.

    Scenario: Iterate over a result set and insert it in a new table in T-SQL

    I had to write a SQL migration script to move date from an old table into a new table with a new primary key.

    Update! I discovered that my problem would have been solved with a much simpler SQL script (INSERT INTO x …(SELECT … FROM Y)). So my example here is pretty dumb - sorry if this confuses you, but I will keep the blogpost to show the mechanics. Thanks Mark!

    Here was/is my resulting script using T-SQL Cursors:

    DECLARE @TemplateId as uniqueidentifier;
    DECLARE @UserId as uniqueidentifier;
    
    DECLARE @OldTemplateFavCursor as CURSOR;
    
    SET @OldTemplateFavCursor = CURSOR FOR
    SELECT UserTemplate.[Template_Id], UserTemplate.[User_Id] FROM UserTemplate;
     
    OPEN @OldTemplateFavCursor;
    FETCH NEXT FROM @OldTemplateFavCursor INTO @TemplateId, @UserId;
     
    WHILE @@FETCH_STATUS = 0
    BEGIN
     INSERT INTO dbo.[UserFavoriteTemplate]
               ([Id]
               ,[TemplateId]
               ,[UserId])
         VALUES
               (NEWID()
               ,@TemplateId
               ,@UserId)
    
    FETCH NEXT FROM @OldTemplateFavCursor INTO @TemplateId, @UserId;
    END
     
    CLOSE @OldTemplateFavCursor;
    DEALLOCATE @OldTemplateFavCursor;
    

    Explanation

    In the first couple of lines we just declare some variables.

    In this particular script we want to move the “TemplateId” & “UserId” from the table “UserTemplate” into the target table “UserFavoriteTemplate”, but I also want to store an additional GUID as Id.

    This line will select our current data into the cursor:

    SET @OldTemplateFavCursor = CURSOR FOR SELECT UserTemplate.[Template_Id], UserTemplate.[User_Id] FROM UserTemplate;
    

    With the “OPEN”, “FETCH NEXT” and “CLOSE” we move the cursor and inside the “WHILE” we can do our migration.

    The syntax seems (from a C# perspective) strange, but works well for this scenario.

    Performance consideration

    I wouldn’t recommend this approach for large scale migrations or actual production code because I heard that the performance is not as great as some clever joins or other T-SQL magic.

    Make sure you really need this

    You can do some clever joins with SQL - make sure you really need this approach. My example here is not a clever one, so use this feature wisely. (again - thanks to Mark for the comment!)

    Thanks Christopher for your help!

    Albert Weinert: React Native, gesundes Arbeiten und .NET Core 1.1 bei der .net user group Köln am 8. November 2016

    Am 8. November 2016 startet die .net user group Köln nach einer kreativen Pause ;) wieder mit regelmäßigen Treffen. Und dies ist dann direkt das 90. Treffen was wir veranstalten. Also wer den besonderen Anlass sponsoren möchte, bitte schön ;)

    Wir haben folgende Themen

    • Reactive Native
    • .NET Core Status und Zukunft
    • Gesundes Arbeiten mit dem Steharbeitsplatz

    Ab 19 Uhr im Microsoft Office in Köln.

    Anmeldung bitte unter http://www.meetup.com/net-user-group-koeln/events/235218015/

    Kay Giza [MS]: Meetup in Muenchen: Gaming 2.0 – Welcome to the VR und AR Age am 17. November 2016

    Letzt Woche habe ich mit einigen über das Meetup am 17. November 2016 gesprochen, dort trifft sich zum ersten Mal der TUM Computer Science Club. Zum Start widmet sich das Meetup dem Thema Gaming 2.0. Dabei werden die neuesten Entwicklungen in der Spieleindustrie vorgestellt – AR und VR. Dabei kam die Frage auf, welche interessanten Meetups man noch so empfehlen könnte. Neben Meetups und User Group-Treffen gibt es natürlich noch zahlreiche weitere Events bzw. Veranstaltungen, auf die man hinweisen könnte. Meine Kollegen von TechWiese.de berichten regelmäßig über anstehende Community-Treffen. Daher hier auf Grund der Diskussion mal einige Beispiele, was so auf TechWiese.de zu finden ist... [... mehr auf Giza-Blog.de]


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

    Stefan Lieser: Cheatsheet zu Flow Design

    Das Cheatsheet zu Flow Design zeigt alle Symbole der Entwurfsmethode. Ferner erläutert es die Übersetzung der Entwürfe in C#.

    Der Beitrag Cheatsheet zu Flow Design erschien zuerst auf Refactoring Legacy Code.

    MSDN Team Blog AT [MS]: Prozedural generierte Universen in der Nussschale

    Von künstlicher Intelligenz erstellte Inhalte in Spielen sind kein neues Phänomen, haben aber durch Games wie Minecraft oder No Man’s Sky ein Revival erlebt. Für Entwickler stellt Procedural Content Generation (PCG) eine besondere Herausforderung dar, beginnend beim Design (Welche Algorithmen können herangezogen werden?) über die Testphase (Wie kann garantiert werden, dass prozedural generierte Level lösbar sind?) bis zur Evaluation (Wie lässt sich messen, ob automatisch erstellte Level gut sind?). Dieser blogpost liefert einen Leitfaden und eine Einführung in PCG und zeigt auch: Ohne menschliche Kreativität geht oft die Würze verloren.

    Planeten, Tiere, Musik: Alles ist generierbar!

    Es galt als eines der meisterwarteten Spiele dieses Jahres und wurde für viele zu einer bitteren Enttäuschung: No Man’s Sky wartete mit einem schier unendlichen Universum mit 18 Trillionen (1.8*10^19) verschiedenen Planeten auf, die völlig computergeneriert sein sollten, vom Terrain über die Pflanzen bis zu den Tieren. Auch wenn die Entwickler letztendlich etwas zu viel versprachen und so den Zorn der Spielergemeinschaft auf sich zogen, ist das Konzept gut durchdacht und das Ergebnis beeindruckend, wenn auch kein Alleinstellungsmerkmal. Bereits Infiniminer und daraus folgend Minecraft setzten auf PCG um (quasi-)unendliche Welten voller Blöcke zu generieren. Etwas früher hatte ein Indie-Entwicklerstudio mit Dwarf Fortress ein kostenloses ASCII-basiertes Spiel veröffentlicht, bei dem der Spieler eine Gruppe an Zwergen in einer zufällig generierten Welt anleiten musste. Auch die Forschung hat sich dem Thema PCG bereits früh angenommen, die Universität Texas etwa experimentierte mit Neuroevolution um im Spiel NERO eine Armee an Roboter zu trainieren, die gegen Feinde kämpft und mit der Zeit immer komplexere Manöver lernt.
    Wie diese Beispiele zeigen, ist der Einsatz von PCG in Spielen sehr vielschichtig, grundsätzlich lassen sich vier “Pfade” unterscheiden, die man verfolgen kann:

    1. Prozedural generierte Spielwelten. Das kann ein dreidimensionaler dungeon sein, ein 2D platformer auf Basis einer tilemap oder sogar Geschicklichkeits- bzw. Geduldsspiele. Je nach Abstraktionsgrad kann die Generierung nur einzelne Elemente innerhalb der Welt umfassen (zB. Terrain, Pflanzen, Gebäude, Fahrzeuge, Waffen) oder ganze Planeten und Sonnensysteme.
    2. Prozedural generierte Missionen und Ziele. In solch einem Szenario werden nicht nur die Spielwelten künstlich erzeugt, sondern auch die Missionen und Ziele, die im Spiel erreicht werden müssen.
    3. Prozedural generierte NPC (Non-player character). Dieser Fall überschneidet sich thematisch mit künstlicher Intelligenz für Computergegner und ist einer der am häufigsten anzutreffenden Anwendungsfälle in Spielen.
    4. Prozedural generierte spielbegleitende Materialien (zB. Musik im Spiel).

    Die Gründe für den Einsatz von PCG sind vielfältig. Offensichtlich ist, dass prozedurale Generierung die Möglichkeit bietet, mit vergleichsweise geringem Einsatz von Ressourcen und Entwicklern sehr umfangreiche Spiele zu erschaffen – das Entwicklerteam hinter No Man’s Sky etwa umfasste nur 16 Personen. Ein weiterer Grund ist, dass PCG basierte Spiele längeren Spielspaß versprechen, weil “Walkthrough”- oder “Let’s play”-Videos und “Lösungsguides” nie den vollen Umfang eines solchen Spiels zeigen können – immerhin sieht dieses dank prozeduraler Generierung für jeden Anwender anders aus. Nicht unterschätzen sollte man als Entwicklerstudio auch die publicitiy, die man mit einem gut gemachten PCG Spiel generieren kann: Künstliche Intelligenz oder Machine Learning gelten als die aktuellen Top-Themen in der IT. Entwickelt man Spiele, die auf Techniken aus diesen Bereichen aufbauen, kann man damit enormes mediales Echo erzeugen. Doch, bevor die DVD gepresst oder der “Download”-Button gedrückt werden kann, stehen zunächst viele Stunden an Arbeit an und die entscheidende Frage lautet: Wie startet man am besten?

    Im Anfang war der Graph

    Wer den Nintendo 64-Klassiker “Zelda: Ocarina of Time” gespielt hat, wird sich vielleicht noch mit Schaudern an den Wassertempel erinnern. Es war sehr einfach in dem Gewirr an Gängen, Rätsel und Gegner die Orientierung zu verlieren und oft half nur entweder ein Freund oder ein Lösungsbuch (Internet war damals rar). Die Tempel in der Zelda-Reihe sind nach einem grundsätzlich sehr einfachen Schema aufgebaut: Es ist eine Aneinanderreihung von Gängen und Räumen, in denen Gegner besiegt und Rätsel gelöst werden müssen um danach Schlüssel, neue Waffen oder Objekte zu erhalten, die in anderen Räumen eingesetzt werden können. So kämpft man sich Schritt für Schritt bis zu einem Zwischen- oder Endboss durch und steigert nach erfolgreichem Abschluss der Mission seine Lebens- oder Erfahrungspunkte bis man in den nächsten Tempel vordringt und sich das Prozedere wiederholte. J. Dormans hat sich in diesem interessanten paper näher mit der Struktur solcher Level aus der Adventure-Sparte beschäftigt und geschlossen, dass Tempel wie jener aus Zelda prinzipiell als gerichteter Graph dargestellt werden können, wobei der Startknoten den Eingang in den Tempel darstellt und der Endknoten den Endboss (oder Ausgang).

    Mission Space

    Um einen solchen Graph (und damit einen gesamten Tempel) prozedural zu generieren, gibt es verschiedene Strategien, eine Möglichkeit stellen so genannte Generative Grammatiken dar. Generative Grammatiken stammen ursprünglich aus der Linguistik und werden dort verwendet, um natürliche Sprache zu modellieren. Sie beinhalten eine Menge an Regeln, die nach dem Puzzleteil-Prinzip kombiniert werden können, um daraus komplexere Sätze zu erzeugen. Angewendet auf die Generierung von Spielwelten bedeutet das, dass von den Entwicklern eine Grammatik festgelegt wird, auf Basis derer Schritt für Schritt ein Graph gebaut wird – man spricht hierbei von Graph Grammar. Die Knoten und Kanten des Graphen können dabei je nach Spiel für verschiedene Dinge stehen, etwa für Gänge und Räume aber auch für Hindernisse und Gegner. Prinzipiell läuft die Generierung wie folgt ab: Man definiere einen Anfangs- und End-Graph und eine Menge an Ersetzungsregeln. Eine Ersetzungsregel tauscht Teile eines Graphen gegen andere Teile aus. Das nachfolgende Bild zeigt eine solche Grammatik wobei Teile die links des Pfeiles stehen durch Teile die rechts des Graphen stehen getauscht werden können:

    Graph production rules

    Eckige Knoten stellen in diesem Beispiel  jene Anknüpfungspunkte dar, die durch andere Graphteile ausgewechselt werden. Beginnend mit der “start rule” kann beispielweise die Knotenfolge 2:C –> 3:G mit der parallel ablaufenden Kette 1:CP –> 2:G oder aber auch der linearen Kette 1:CL –> 3:CL –> 2CL ersetzt werden (welche Regel ausgewählt wird, wird zufällig bestimmt). Runde Knoten sind “Räume”, in denen bestimmte Objekte auffindbar sind oder Hindernisse warten (e = Eingang/Startknoten, k = Schlüssel, der eine Tür aufsperrt, l = versperrte Tür, g = Ausgang/Ende, etc).
    Durch eine so definierte Grammatik kann zB. der folgende Graph generiert werden:

    Graph sample

    Von Graphen zu Formen

    Ein Missionsgraph ist schön und gut, allerdings noch weit von einem tatsächlichen Spiel entfernt. Um aus dem Modell Räume und Objekte zu generieren, gibt es eine Fülle an Möglichkeiten und welche eingesetzt werden können oder sollen, hängt stark vom Typ und Charakter des Spiels ab. No Man’s Sky etwa nutzte eine von Johan Gielis veröffentliche Formel, die den demütigen Namen Superformula bekam. Mit ihr ist es möglich, durch vergleichsweise wenig Rechenschritte natürlich wirkende zweidimensionale Formen prozedural zu generieren. Eine JavaScript-Implementierung besagter Formel namens Supershape.js wurde auf Github veröffentlicht.

    supershape.js

    Wer von Grammatiken noch nicht genug hat, kann auch einen Blick auf sogenannte Shape Grammars werfen. Wie auch bei den Graph Grammars werden Regeln definiert, anhand derer einfache Formen zu komplexeren Gebilden zusammengefügt werden. Ein einfaches hier entlehntes Beispiel: Im folgenden Fall sind zwei Regeln definiert (a), die ein Quadrat mit Punkt entweder zu zwei verschachtelten Quadraten mit Punkt oder zu einem einfachen Quadrat ersetzt. Ausgangspunkt ist ein Quadrat mit Punkt (b).

    Shape grammar

    Zufällig wird nun die erste oder zweite Regel angewendet, um aus (b) eine komplexere Form zu kreieren. Angenommen, zunächst wird zufällig Regel 1 ausgewählt – aus dem Quadrat mit Punkt entstehen zwei verschachtelte Quadrate mit Punkt. Danach wird nochmals Regel 1 angewendet – aus dem zweifach verschachtelten Quadrat wird ein dreifach verschachteltes Quadrat. Zuletzt wählt der Algorithmus zufällig Regel 2 aus – aus dem Quadrat mit Punkt wird ein Quadrat ohne Punkt und aus dem anfänglichen Quadrat mit Punkt ist eine komplexere Form entstanden.

    Shape grammar production rule

    Was hier in einem simplen Beispiel veranschaulicht wird, kann zu umfangreicheren Algorithmen erweitert werden, die in der Lage sind, dreidimensionale Häuser oder ganze Städte zu generieren. Eine Einführung dazu gibt es unter anderem hier.

    Anwendungsbeispiel: Who Dies?

    Soweit die Theorie, jetzt zur Praxis: Inspiriert durch die vielfältigen Möglichkeiten die PCG bietet, habe ich vor einigen Monaten selbst begonnen, ein Spiel zu entwickeln, dessen Welten praktisch gänzlich prozedural generiert werden. Die App nennt sich “Who Dies?” und wurde vollständig in Visual Studio 2015 mit Apache Cordova Support umgesetzt. Es gab zwei Hauptgründe, warum ich dieses setup bevorzugt habe: Erstens erlaubt Cordova die plattformunabhängige Entwicklung von Apps – das bedeutet, es ist nur eine Codebasis erforderlich, aus der die App (mit wenigen Adaptionen) für alle möglichen Plattformen veröffentlicht werden kann – von Android über iOS bis zu Windows. Zweitens basiert Cordova auf JavaScript und es existieren eine Fülle an JavaScript libraries, die die Spieleentwicklung vereinfachen. Ich habe für “Who Dies?” jQuery, openFB (für die Facebook-Integration) und Phaser verwendet. Phaser ist eine komplett in JavaScript geschriebene Spiele-Engine, die unter anderem verschiedene Physik-Systeme unterstützt und Support für tilemaps liefert.

    In “Who Dies?” muss der User in einer Welt, die aus Blöcken, Objekten, Monster und Steinen besteht, erraten, welches Monster von einem Stein getroffen wird oder von der Plattform fällt, sobald Gravitation einwirkt. Tippt der Spieler richtig, bekommt er dafür Punkte, für Punkte gibt es Level-Upgrades und je höher das Level eines Spielers, desto komplexer werden die Welten. Alle Welten werden dabei durch einen Algorithmus erzeugt, der auf Markow-Ketten beruht. Eine Markow-Kette ist eine Menge an Zuständen, die durch Übergänge verknüpft sind, wobei das System nach einem selbst definierten Zeitraum von einem Zustand in den anderen wechselt. Für jeden Übergang kann eine Wahrscheinlichkeit angegeben werden, mit der dieser Übergang beim nächsten Zustandswechsel gewählt wird. Der Algorithmus durchläuft dabei die folgenden Phasen:

    Schritt 1: Die Wahl des Rechtecks
    Jede Welt besteht aus einer 35×20 Grid, in der Objekte platziert werden können. Zunächst wird in dieser Welt zufällig eine Startposition bestimmt und darin ein Rechteck definiert, das eine zufällige Breite und Höhe hat. In dem im nachfolgenden Bild dargestellten Beispiel wurde das Rechteck an die Startposition (0,7) gesetzt mit einer Breite von 7 und einer Höhe von 4. Das Rechteck ist für den Spieler nicht sichtbar sondern definiert nur intern den Bereich, in dem im nächsten Schritt die Blöcke platziert werden.

    Who Dies? - Physics Puzzle

    Schritt 2: Auswahl der Objekte
    In “Who Dies?” gibt es verschiedene Objekte: Blöcke, Spins, Sprungfedern, Kisten, etc. Welche Objekte platziert werden, wird durch Markow-Ketten bestimmt. Im Spiel sind verschiedene Markow-Ketten implementiert, die abhängig vom Level des Spielers verwendet werden. Die Markow-Kette für die Level 1 bis 5 sieht wie folgt aus:

    Markow-Kette

    Der Algorithmus startet in Zustand S und kann nun in einen von 3 Zuständen übergehen. In welchen, wird bei der Generierung der Welt entschieden, wobei die Wahrscheinlichkeit abhängig von der Position des in Schritt 1 definierten Rechtecks ist. Ist das Rechteck eher in der linken Seite des Bildschirms angesiedelt (xPos <= 17), ist die Wahrscheinlichkeit, dass eine Stufe nach rechts entsteht höher (60%), als das die Stufen nach links führen (10%).

    Schritt 3: Adaption der Objekte
    Ist ein Objekt ausgewählt, wird dieses leicht verändert, damit nicht stets die gleichen Formen generiert werden. Es existieren je nach Objekt verschiedene Modifizierungsarten, bei Blöcken sind dies: Strecken (dabei wird die letzte Ebene auf die Länge des Rechtecks erweitert), Stückeln (dabei werden zufällig Löcher in die Treppe eingefügt), Stauchen (dabei wird die Stufe verkürzt) oder Erweitern (dabei werden Blöcke hinzugefügt). Ist das Objekt ein Startobjekt (also das erste im Level hinzugefügte Objekt), wird auch ein Stein zufällig oberhalb des Rechtecks hinzugefügt.
    Angenommen, der Algorithmus hat Block-right und Strecken ausgewählt, die bisher generierte Welt würde danach so aussehen:

    Who Dies? Tileset

    Schritt 4: Berechnung des Lösungspfades
    Im letzten Schritt wird der Lösungspfad berechnet. Das ist jener Pfad, den die Kugel vermutlich nehmen wird, wenn Gravitation auf sie einwirkt. Der Lösungspfad ist im nachfolgenden Bild als punktierte Linie eingezeichnet und für den Nutzer natürlich ebenfalls nicht sichtbar:

    Who Dies? Solution path

    Der Endpunkt des Lösungspfades ist der Ausgangspunkt für ein neues Rechteck. Zwischen Ende des Lösungspfades und Beginn des neuen Rechtecks wird noch ein offset Wert eingefügt, der eine Höhe und Breite zwischen 0 und 4 annehmen kann (das verhindert, dass der neue Block stets dicht am alten klebt). Der Algorithmus folgt nun wieder den Schritten 1 bis 4, wobei der aktuelle Zustand der Markow-Kette gespeichert bleibt. Das bedeutet: Die Wahrscheinlichkeit, dass nun erneut ein Block-right folgt, liegt bei 30%. Die Wahrscheinlichkeit, dass nun ein Block-middle folgt jedoch bei 70%. Der Algorithmus endet, wenn entweder ein zuvor definierte Anzahl an Durchläufe erreicht wird (bis Level 5 werden maximal 2 Runden ausgeführt) oder ein Rechteck eine Grenze der Welt erreicht. Die bis Level 5 verwendete Markow-Kette beinhaltet nur Blöcke, ab Level 6 kommen auch andere Objekte wie Spins oder Sprungfedern dazu, die das Modell etwas komplexer machen.

    Who Dies? Level

    Ist die Welt generiert, werden die Monster platziert. Das passiert – sehr unspektakulär – durch Zufall, eingeschränkt durch eine Menge an Regeln (zB. werden Monster nicht so platziert, dass sie sofort nach unten fallen, übereinander liegen oder sich gegenseitig blockieren). Am Ende werden jene Blöcke, die die untere Bildschirmgrenze berühren als Graslandschaft dargestellt und die Welt mit Hintergrundobjekten wie Bäumen oder Zäune verschönert.

    Who Dies? World complete

     

    Fazit: Ohne menschliche Kreativität geht es nicht

    Obwohl der von mir verwendete Algorithmus äußerst simpel ist, war die Implementierung schwieriger als gedacht. Es gab 3 große Herausforderungen:

    1. Die Komplexität der Welten abhängig vom Level
    Ein gutes Spiel sollte eine kontinuierlich steigende Lernkurve haben, sodass Anfänger sehr schnell vorankommen und sich erfahrene Spieler nicht langweilen. In “Who Dies?” wird die Komplexität definiert als Anzahl der Entscheidungsweichen multipliziert mit der Anzahl an Steinen. Eine Entscheidungsweiche ist jeder Punkt im Spiel, in dem es für den Spieler nicht sofort offensichtlich ist, welchen Weg der Stein nehmen wird. Die Herausforderung liegt nun darin, gezielt einfache oder komplexe Level zu erstellen, abhängig davon, wie erfahren der Spieler ist. Bei der Generierung der Welten lässt sich allerdings nicht immer einfach bestimmen, ob eine Entscheidungsweiche für den Spieler offensichtlich ist oder nicht – insbesondere nicht für einen Algorithmus.

    2. Gutes Design ist wichtig, eine gute Teststrategie noch wichtiger
    Da PCG auf Modellen und Algorithmen beruht, kann jeder kleine Fehler in diesen Strukturen enorme Auswirkungen haben. Erschwerend hinzu kommt, dass Fehler oft nicht sofort entdeckt werden, da keine Welt wie der anderen gleicht und man eventuell tausende einwandfreie Welten generieren kann, die 1001. jedoch das Spiel zum Absturz bringt. Aus diesem Grund sollte man die Implementierung der Algorithmen mehrmals überprüfen und sich gleich zu Beginn eine Strategie überlegen, wie man das Spiel testen kann. Die Entwickler von No Man’s Sky etwa kreierten eigene Bots, die auf Planeten umherwanderten und Fotos der Landschaft machten – diese wurden dann vom Test-Team auf Inkonsistenzen überprüft.

    3. Diversität der Welten
    Einer der größten Herausforderungen war und ist, einen Algorithmus zu entwickeln, der interessante Welten generiert. Interessant heißt im Fall von “Who Dies?”, dass der Weg, den der Stein nimmt, nicht offensichtlich ist, dass die Monster intelligent platziert sind (und getroffen werden können) und Objekte nicht dort platziert werden, wo sie niemals in Kontakt mit einem der Steine kommen können. “Who Dies?” erreicht dieses Ziel nur teilweise, denn nach gewisser Zeit merkt der Spieler, dass sich bestimmte Konzepte wiederholen. Das ist natürlich nicht verwunderlich, denn hinter dem Spiel steckt keine schwarze Magie sondern immer die gleichen Modelle (die Markow-Ketten) sodass auch der Output (die Welt) deterministisch ist. Für die Spielehersteller besteht hier das hohe Risiko, dass Spieler aufgrund der fehlenden Abwechslung abspringen und die App nicht weiter verwenden. Und hierbei offenbart sich ein Dilemma, denn wenn ein Spiel wirklich völlig zufällig ohne jegliche Regeln generiert wird, ist es aller Voraussicht nach nicht spielbar (oder es macht zumindest keinen Spaß). Steht aber ein Regelset hinter dem Algorithmus, gibt es nur eine endliche Anzahl an Strukturen, die generiert werden können. Es gibt verschiedene Ansätze, um diesem Problem Herr zu werden, die Hoffnung ruht dabei für viele auf künstlicher Intelligenz. Die Forschung im Bereich AI schreitet zwar immer weiter voran, aber was einem Computer fehlt (und was auch in absehbarer Zeit nicht künstlich geschaffen werden kann), sind menschliche Kreativität und ein Gespür für Harmonie und Schönheit. Spielwelten-Designer können auf ihren Erfahrungsschatz und ihre Visionen bauen, wenn sie Level konstruieren – Computer können sich nur stur an Regeln halten, die ihnen vorgegeben wurde. Aus diesem Grund sollte PCG mehr als Unterstützung und Erweiterung unserer Möglichkeiten gesehen werden, aber nie als allmächtiges Werkzeug, das Menschen über kurz oder lang ersetzen kann. Richtig eingesetzt und gut implementiert haben solche Spiele jedoch das Potential, Spieler zu begeistern und andere Entwickler zu inspirieren, ihr eigenes prozedural generiertes Universum zu erschaffen.

    AIT: Neu in Visual Studio und TFS „15“: Xamarin 4.1

    Mit der Veröffentlichung von Visual Studio 15 Preview 5 wurden auch die Xamarin Erweiterung auf die Version 4.1 aktualisiert, welche bei der Installation als zusätzliches Feature hinzugefügt werden kann. Das Paket selber besteht aus den Komponenten Xamarin.iOS 9.8  und Xamarin.Android 6.0.

    Nichts desto trotz ist das Xamarin Paket auch für bisherige Veröffentlichungen von Visual Studio verfügbar und kann über den Menüpunkt Options unter dem Register „Xamarin -> Other“ nachträglich aktualisiert werden.

    Folgenden Änderungen und Neuerungen hielten Einzug mit Xamarin 4.1

    • Erweiterung des iOS Assets Catalog um Sprite Atlas, Data Set und Image Sets
    • tvOS Support durch neue Projekt-Templates
    • Erweiterung des Android XML Editors
    • SSL/TLS Implementierung als Auswahl in den Build Optionen bei iOS
    • HttpClient Selektor für den iOS Build

    Erweiterung des Android XML Editors

    Der integrierte XML Editor von Visual Studio wurde auch für die Bearbeitung von Android XML Dateien (.axml) angepasst und verbessert, zu welchem folgende Punkte zählen:
    – Intellisense Unterstützung (noch nicht vollständig)
    – Farbliche Markierungen der Android Layout Komponenten
    – Bisher gewohnte Funktionen des XML Editors wie Suchen/Ersetzen und auch die vertikale Selektion des Codes.

    SSL/TLS Implementierung Build Option bei iOS

    In den Build Einstellungen von Xamarin.iOS Projekte lässt sich nun SSL/TLS Implementierung festlegen. Dabei steht entweder Mono’s eigene TLS (Version 1.0) oder aber auch Apples TLS (Version 1.2) Implementierung im Dialog zur Auswahl. Weitere Möglichkeiten zur Anpassung der TLS Implementierung finden sich unter dem Xamarin Developer Guide (https://developer.xamarin.com/guides/cross-platform/transport-layer-security/).

    xamarin_tls

    HttpClient Selektor für den iOS Build

    Eine weitere Option innerhalb der iOS Build Einstellungen betrifft die Auswahl der HttpClient Implementierung. Standardmäßig wird der HttpClient auf Basis von HttpWebRequest genommen, aber es besteht nun auch die Möglichkeit zur Auswahl der nativen iOS Implementierungen CFNetwork (iOS 6 oder höher) oder NSUrlSession (iOS 7 höher), so dass eine in Code Implementierung nicht notwendig ist. Diese führen zu einer verbesserten Performance durch kleinere Binaries wie auch Nutzung der nativen Verschlüsselung auf Kosten der Wiederverwendbarkeit bei plattformübergreifenden Projekten.

    xamarin_httpclient

    Zu beachten gilt, dass die erweiterten Einstellungen unter den iOS Build Optionen (SSL/TLS Implementierung und der HttpClient Selektor) erst mit einer aktiven Verbindung zu einem Mac Agent zur Verfügung stehen, da diese abhängig von der verwendeten iOS SDK sind. Eine genaue Auflistung der behobenen Bugs lässt sich unter der Ankündigung des Updates nachlesen.

    Manuela Rink: The cloud evolution

    There’s been happening a lot over the last years to what we use to call “cloud”. After dealing with different aspects of the cloud over the last years I thought I have a good understanding what IaaS, PaaS and the cloud itself are. But I was wrong. I wasn’t able to distinguish e.g. PaaS from “Serverless” properly and what the heck is this new FaaS. So I thought it’s time to put all important facts of this cloud journey together into one image to really see the change. That’s what I always do, if i don’t understand something properly. I draw :D

    We’ve come a long long way together. The concept of a server, a machine hosting a service, is nearly as old as computer science itself.

    A lot of things got much more interesting with the dawn of “the internet”. Suddenly people like me and you wanted to host their services aka websites for being present in “the internet” aka www. This was the time when IaaS - Infrastructure as a Service - joined the party - and changed the game. I could rent hardware to host my applications from there. I just had to take care of setting up the machine properly and deploy my services there. Sure, for greater applications hosted from different machines it was mandatory to have a solid architecture in place. But my focus was not on hardware anymore, it was on the operating system and the services it ran. The hardware got abstracted with IaaS. Nevertheless I had to maintain the whole virtualized machinery which means updating and taking care of the VMs and everything which ran within them. All this was part of my own responsibility.

    Surely this was just the start into “a new world”. A couple of years later this theory got proof with PaaS - Platform as a Service - emerged. Now things got easier - again? From now on I don’t have to care about setting up my VMs and maintain OS versions. The OS gets abstracted. The platform offers me services which I can use and connect to make them interact and form my application. If my application needs a database and a storage I just fire up an instance of those services and connect it to my application. No need to setup machines for doing those tasks - they are just “resources” within my application architecture which I configure for my needs. But with great power comes great responsibility. The way systems and applications are being developed is changing. New development patterns are forming and old ones get retired. Now it’s not just a “lift and shift my application into the cloud” as it could be done with IaaS. Mostly a redesign of the service/application architecture is necessary, to be able to use the cloud services to their full potential.

    To be honest PaaS already sounds like “Kthxbye, I have all I need for developing and hosting my services in a very loose way”. Far wrong! Not so long ago a new paradigm formed out of PaaS, which is called FaaS - function as a service. I see you raising an eyebrow and asking me “RLY?”. And my answer is “FRLY!”**. 

    But what do I need functions for if i have my web servers up and running, loosely connected with my services? I can extend it in a quite flexible way with additional features.. Right? So using functions for … what?

    Functions can be seen as small scaled services which are hosted standalone and are running autonomously. In addition they can be triggered by events. So functions are small portions of code triggered by events. Sounds no bit like a fully qualified way for building your application? True! But a bunch of those functions are. The idea is going into the direction of microservices - cut down big monolithic services into small and more maintainable portions. And those portions can be hosted as functions. They can interact with each other, be chained, trigger other services - simply just be integrated into complex architecture structures.

    Apart from being small, functions can be set up in no time. The application is abstracted and the focus in development is on the function itself. The whole infrastructure and application layer is managed and even the performance scaling can be done dynamically other functions. Now it sounds a bit more like “next level to PaaS”, right?

    But - keeping the golden principle of “separation of concerns” in mind while designing an architecture with functions ist most important. As handy as functions can be they bear the same dangers to an architecture as microservices - which is: having none :D


    ** The term “Freili” is a Bavarian short form of the German phrase “Ja, natürlich” which means “Yeah, sure!”

    Fabian Deitelhoff: Die Verlosung zur W-JAX 2016

    Die W-JAX 2016 in München (7. - 11. November 2016)

    Im vorherigen Beitrag zur W-JAX 2016 hatte ich es bereits angekündigt. Ich darf eine Freikarte für die Hauptkonferenz der W-JAX vom 8. – 10. November 2016 verlosen. Die Verlosung läuft bereits und wer gewinnen möchte, sollte sich beeilen. 🙂 Weitere Infos zur Verlosung finden sich in diesem Beitrag.

    Verlosung

    Mir wurde freundlicherweise eine Freikarte für die Hauptkonferenz der W-JAX vom 8. – 10. November 2016 zur Verfügung gestellt. Wenn ihr gewinnen möchtet hinterlasst bitte einen Kommentar, warum ihr an der Konferenz teilnehmen möchtet. Das muss nichts Besonderes sein. Ich möchte nur gerne vermeiden, dass Kommentare auftauchen, die offensichtlich dadurch entstanden sind, das einmal von links nach rechts mit dem Gesicht über die Tastatur gerollt wurde. 🙂

    Aus allen Kommentaren fische ich dann per Zufall einen heraus, so wie ich das bei den letzten Verlosungen auch gemacht habe. Die Verlosung läuft von heute, Montag den 24. Oktober 2016 bis zum Sonntag, den 30. Oktober um 20:00 Uhr. Die Teilnahme ist ab 18 Jahren möglich und der Rechtsweg ist wie üblich ausgeschlossen. Der Gewinn kann nicht ausgezahlt werden.

    Bei Fragen zur Konferenz oder sonstigen Angelegenheiten zur Verlosung freue ich mich immer über Kommentare und Nachrichten.

    Vielen Glück allen!

    Uli Armbruster: Session Unternehmenswerte

    Auf das Thema Unternehmenswerte konnte ich schon aus vielen Blickwinkeln schauen: Ob als Mitarbeiter, als Geschäftsführers, als Selbstständiger oder Dienstleister. Umso mehr hat es mich gefreut, dass Daniel Marbach dazu eine Session vorgeschlagen hat. Teilnehmer gab es reichlich. Ich hätte mir zwar  gewünscht, dass mehr aktive Teilnehmer ihre Meinung bei der nach dem Fishbowl-Konzept geführten Diskussion geäußert hätten, aber insgesamt war es eine wirklich gelungene Session. Die Aufnahme hat ein wenig mit Schwächen bei Bild und Ton zu kämpfen, aber unser Schüler Tim hat sein Bestes gegeben, um in der Nachbearbeitung die nötige Qualität rauszuholen.

    Das Video darf man gerne als Einladung zur Diskussion verstehen. Deshalb halte ich hier die Punkte fest, die mir im Kopf geblieben sind:

    Duzen/Siezen: Ein diskussionswürdiger Punkt, bei dem die Meinungen sicherlich auseinandergehen. In jedem Fall springen immer mehr Unternehmen auf den „Du-Zug“ auf. Klar ist aber auch: Die Anrede muss zur Unternehmenskultur passen. Ein Beispiel aus meinem Alltag sei genannt: Wenn unser Tim, Schüler, kürzlich erst 18 geworden, mit mir arbeitet, dann würde durch das Siezen aus meiner Sicht eine Hürde aufgebaut werden, die ihn bei der Arbeit weniger kreativ und in Bezug auf seine Lösungsansätze weniger „probierfreudig“ machen würde. Die Angst Fehler zu machen und sich an die Vorgaben des Chefs halten zu müssen, wird durch das Duzen einfach gemindert.

    Kommunikationsnähe: Kommunikation findet bekanntlich zum Großteil nonverbal statt. Deshalb ist es umso wichtiger, eine möglichst hohe „Kommunikationsnähe“ zu erreichen. Sei es durch regelmäßige Treffen vor Ort (bei verteilten Mitarbeitern) oder durch Videokonferenzen. Chats und E-Mails sollten mehr durch die vorher genannten Punkte ersetzt werden. Für mich wird dabei einfach mehr Menschlichkeit vermittelt, die auch größere Meinungsunterschiede überwinden lässt.

    Rituale: Halte ich ebenfalls für sehr effektiv. Seien es nun das Kickern oder Schachspielen in der Mittagspause, das Feierabend-Darts, das TGIF-Bierchen oder das Daily (als Videokonferenz!): Alles trägt zur besseren Kultur bei. Daniel hat mir einmal erzählt, dass bei Particular Videogespräche häufig mit einem „Kaffee-Gespräch“ über das allgemeine Befinden beginnen, bevor über Geschäftliches gesprochen wird.

    Loben: Das ist nun mein persönliches Steckenpferd, wobei ich mit meiner Meinung vermutlich eine Minderheit vertrete. Ich halte Lob für Gift. Ein paar Argumente könnt ihr dazu im Video hören. Auf Twitter wurde dazu auch noch etwas gesagt. Dieser Link wurde in dem Kontext empfohlen. Weitere Informationen gibt es hier.

    Persönlichkeitsanalyse: Das finde ganz spannend. Mehrere Firmen haben schon Persönlichkeitsanalysen für ihre Mitarbeiter durchführen und diese dazu schulen lassen, um Konfliktpotential zu erkennen und jedem Werkzeuge an die Hand zu geben, sich auf den Kollegen/die Kollegin einzustellen. Im Nachhinein hat mir noch ein Teilnehmer erzählt, dass bei ihnen die Projektgruppen nach dem Ergebnis zusammengestellt wurden. Alle, bei denen dies umgesetzt wurde, haben sich dazu positiv geäußert.

    Wenn euch der Artikel geholfen hat, dann liked oder teilt ihn und hinterlasst einen Kommentar

    Hinweis: Das Beitragsbild hat mir Andreas Richter zur Verfügung gestellt.


    Einsortiert unter:CIO Topics, Events, German, Personalführung Tagged: Open Space, Video

    Manuela Rink: Azure Functions - get started!

    After providing some hands on examples on how to deal with Azure Functions I wanted to give you a link summary to really kick start with this topic.

    image

    A very nice warm up is the session of Chris Anderson from this years //build conference. Here you get the what and why with nice little insights and first usage scenarios.
    https://www.youtube.com/watch?v=76OmQ2mNYBg

    Right afterwards have a look at the session of Matthew Henderson also from this years //build conference. This is quick one with a good overview followed by a full blown real world scenario.
    https://www.youtube.com/watch?v=uiqc0iWwAzw

    The full developers documentation can be found here
    https://azure.microsoft.com/en-us/documentation/services/functions/

    If you need step by step tutorials on how to implement a webhook triggered function or an event processing one, have a look right here.
    https://azure.microsoft.com/en-us/documentation/articles/functions-create-a-web-hook-or-api-function/
    https://azure.microsoft.com/en-us/documentation/articles/functions-create-an-event-processing-function/

    And last but not least I’ve written some articles about what serverless computing is in general
    http://iamcodeprincess.tumblr.com/post/151936972786/serverless-is-the-new-black
    and how to get your own “Bullshit Business quote of the day” function - deploy Azure Functions via the Azure CLI and ARM templates to Azure and use them within an iOS app
    http://iamcodeprincess.tumblr.com/post/152248954131/your-daily-business-quote

    Now, go crazy with Azure Functions!

    And let me know how you are doing ;)

    MSDN Team Blog AT [MS]: DevOps erleben

    DevOps ist eines der Schlagworte in der Softwareentwicklung. Aber was ist es genau ? Kann ich das einmal live erleben ?

    Unser Partner Anecon bietet unter dem Titel: “One Day in Space” eine praktische, hands-on Erlebnisreise zum Thema DevOps an. Lernen Sie mit Kollegen (aus anderen Bereichen) Ihres Unternehmen das Thema und die Prozesse kennen um eine erfolgreiche DevOps Strategie zu entwickeln. Die Plätze sind limitiert – bitte rasch anmelden und auch die Kollegen aus anderen Fachbereichen mitnehmen!

     

    Jetzt Platz reservieren für “One Day in Space”
    “One Day in Space” ist ein eintägiger, rollenbasierter Workshop, bei dem erlebbar gemacht wird, welche Vorteile die Einführung von DevOps in Unternehmen mit sich bringt. Sie können entweder als Einzelperson oder als Unternehmensteam mit bis zu 3 Personen teilnehmen. Alle Details finden Sie >> hier oder an space@anecon.com.

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