.
Anmeldung | Registrieren | Hilfe

.NET-Blogs Archiv April 2017

Mobil bis ins hohe Alter: Microsoft HoloLens unterstützt thyssenkrupp bei der Produktion individuell gefertigter Treppenlifts

24.04.2017 13:11:53 | Mathias Gronau

Praxisbeispiele für den Einsatz der HoloLens kommen meist aus dem Produktionsumfeld. Die Montage und Reparatur komplexer Maschinen wird unterstützt. Auf der CeBIT zeigt Microsoft gemeinsam mit thyssenkrupp ein Beispiel für den Einsatz der HoloLens, bei dem die Endverbraucher direkt von dieser Technologie profitieren können. Um maßgeschneiderte Home-Mobility-Lösungen liefern zu können, setzt thyssenkrupp auf Microsoft HoloLens. Die Mixed-Reality-Brille ermöglicht Kunden in Echtzeit die Visualisierung eines Treppenlift-Produkts im eigenen Zuhause. Durch die Beschleunigung verschiedener Prozessschritte sind zudem bis zu vier Mal schnellere Lieferzeiten möglich. Microsoft HoloLens wird damit bei thyssenkrupp zu einem wesentlichen Werkzeug bei der Bereitstellung individueller Mobilitätslösungen in den eigenen vier Wänden. Der Bedarf nach solchen Lösungen wird rasant steigen: Neben der schnell wachsenden städtischen Bevölkerung tragen auch ein besseres Gesundheitswesen und ein höherer Lebensstandard zu einer längeren Lebenserwartung bei. Es wird erwartet, dass die globale Bevölkerung von derzeit 7,4 Milliarden bis 2100 auf über 11 Milliarden anwächst – und altert. Im Jahr 2016 war weltweit bereits jeder achte Mensch über 60 Jahre alt. Für Deutschland berechnet das Statistische Bundesamt, dass im Jahr 2060 69 Prozent der Bevölkerung im Rentenalter sein werden. Diese Zahlen verdeutlichen, dass die Mobilität älterer Menschen in Städten eine wachsende Herausforderung darstellt.1 Mobilitätslösungen wie Treppenlifts tragen bereits heute zu einer höheren Lebensqualität älterer Menschen bei, die damit länger und unabhängiger in ihrem eigenen Zuhause leben können. Allerdings führen einige Aspekte bei der Gestaltung und Bereitstellung von Home-Mobility-Lösungen zu hoher Komplexität: Jede häusliche Situation hat ihre Besonderheiten, daher ist jeder Treppenlift im Prinzip ein Einzelstück, das speziell auf individuelle Anforderungen zugeschnitten ist. Zudem erwerben die meisten Kunden ein solches Produkt erst, wenn ihre Mobilität bereits stark eingeschränkt ist. Dadurch wird der Kauf zu einer emotionalen Erfahrung, bei der sie ihre neuen Einschränkungen anerkennen müssen. Oft wollen die Kunden aus dieser Situation heraus ihre Käufe sofort geliefert bekommen; das heißt, es ist Eile geboten. Microsoft HoloLens wird den Kunden maßgeblich helfen, Mobilitätslösungen individuell zu gestalten. Treppen können nun sofort unter der Berücksichtigung von Ergonomie und Hindernissen wie Heizungen, Licht – und Elektrohalterungen oder der Nähe zur Wand usw. vermessen werden. Kunden können bequem auf einem Tablet sehen, wie der Treppenlift auf ihrer Treppe aussehen wird, und Entscheidungen zu Polsterung, Farbe von Stuhl und Schienen sowie maßgeschneiderten Besonderheiten treffen. So erhalten sie ein Produkt, das in das Erscheinungsbild ihres Zuhauses passt. „Neue Realitäten erfordern neue Lösungen“, kommentiert Andreas Schierenbeck, CEO von thyssenkrupp Elevator. „Wir sehen in der Microsoft HoloLens einen Wegbereiter, der uns dabei unterstützt, das Kundenerlebnis für Home-Lösungen neu zu erfinden. Damit tragen wir dazu bei, kontinuierliche Lebensqualität für die alternde Bevölkerung bereitzustellen – unabhängig von ihren Mobilitätseinschränkungen.“ thyssenkrupp hat Microsoft HoloLens für den häuslichen Bereich bereits bei mehr als 100 Kunden in Holland, Spanien und Deutschland mit exzellenten Ergebnissen und positivem Kundenfeedback eingesetzt. Als nächster Schritt steht die deutschlandweite Einführung an.

Thorsten Herrmann übernimmt bei Microsoft das Großkunden-Geschäft

20.04.2017 10:09:06 | Mathias Gronau

Thorsten Herrmann (49) ist am 1. April in die Geschäftsleitung von Microsoft Deutschland eingetreten und wird ab 1. Juli für das Großkunden- und Partnergeschäft in Deutschland verantwortlich zeichnen. Thomas Herrmann berichtet unmittelbar an die Vorsitzende der Geschäftsführung von Microsoft Deutschland, Sabine Bendiek. Thorsten Herrmann übernimmt damit die Aufgaben von Alexander Stüger, der die Position seit dem Ausscheiden von Alastair Bruce im Juli 2016 interimistisch bekleidete. Alexander Stügers neue Aufgabe in der Microsoft Organisation wird zu einem späteren Zeitpunkt bekannt gegeben. Thorsten Herrmann kommt von Hewlett Packard Enterprise (HPE) zu Microsoft. Bei HPE war er in den letzten drei Jahren als Vice-President für die weltweiten Geschäftsbeziehungen zwischen HP (später HPE) und SAP zuständig. Der studierte Wirtschaftsinformatiker startete seine Karriere 1989 bei IBM. 1997 wechselte er zu Compaq Computer GmbH in den Vertrieb für SAP R/3-Infrastrukturlösungen und wurde später Regionalvertriebsleiter. Seit dem Merger mit HP war Thorsten Herrmann in verschiedenen leitenden Vertriebspositionen tätig ehe er im April 2009 in die Geschäftsführung der Hewlett Packard GmbH berufen wurde. In dieser Rolle übernahm er als Vice President die Verantwortung für den Großkundenvertrieb bei HP Deutschland. „Auf der Hannover Messe in der kommenden Woche sehen wir, in welcher Geschwindigkeit die Digitalisierung klassischer Industrien vorangeht. Microsoft leistet nach meiner Beobachtung einen substanziellen Beitrag, die Industrieunternehmen bei ihrer digitalen Transformation wirksam zu unterstützen. Dabei bringe ich meine Erfahrungen und Expertise jetzt sehr gerne ein“, sagte Thorsten Herrmann vor Mitarbeitern. „Mit Thorsten Herrmann konnten wir einen Top-Manager mit einer umfassenden Vertriebs-Expertise und Marktkenntnis für uns gewinnen und ich freue mich sehr auf die persönliche Zusammenarbeit“, kommentierte Sabine Bendiek die Berufung des neuen Geschäftsleitungs-Kollegen.

A first glimpse into CAKE

19.04.2017 19:00:00 | Jürgen Gutsch

Since a couple of years I use FAKE (C# Make) to configure my builds. Also at the YooApps we use FAKE in some projects. One of the projects uses it since more than two years. FAKE is really great and I love to use it, but there is one problem with it: The most C# developers don't really like to use new things. The worst case for the most C# developers - it seems - is a new tool, that uses an exotic language like F#.

This is why I have to maintain the FAKE build scripts, since I introduced FAKE to the team.

It is that new tool and the F# language that must be scary for them, even if they don't really need to learn F# for the most common scenarios. That's why I asked the fellow developers to use CAKE (C# Make).

  • It is C# make instead of F# make
  • It looks pretty similar
  • It works the same way
  • It is a scripting language
  • It works almost everywhere

They really liked the idea to use CAKE. Why? just because of C#? It seems so...

It doesn't really makes sense to me, but anyway, it makes absolutely sense that the developers need to use and to maintain there own build configurations.

How does CAKE work?

CAKE is built using a C# scripting language. It uses the Roslyn compiler to compile the scripts. Instead of using batch files, as FAKE does, it uses a PowerShell script (build.ps1) to bootstrap itself and to run the build script. The bootstrapping step loads CAKE and some dependencies using NuGet. The last step the PowerShell script does, is to call the cake.exe and to execute the build script.

The bootstrapping needs network access, to load all the stuff. It also loads the nuget.exe, if it's not available. If you don't like this, you can also commit the loaded dependencies to the source code repository.

The documentation is great. Just follow the getting-started guide to get a working example. There's also a nice documentation about setting up a new project available.

Configuring the build

If you know FAKE or even MSBuild it will look pretty familiar to you. Let's have a quick look into the first simple example of the getting started guide:

var target = Argument("target", "Default");

Task("Default")
  .Does(() =>
        {
          Information("Hello World!");
        });

RunTarget(target);

The first line retrieves the build target to execute from the command line arguments. Starting from line 3 we see a definition of a build target. This target just prints a "Hello World!" as a information message.

The last line starts the initial target by its name.

A more concrete code sample is the build script from the CAKE example (I removed some lines in this listing to get a shorter example):

#tool nuget:?package=NUnit.ConsoleRunner&version=3.4.0

var target = Argument("target", "Default");
var configuration = Argument("configuration", "Release");

// Define the build directory.
var buildDir = Directory("./src/Example/bin") + Directory(configuration);

Task("Clean")
  .Does(() =>
        {
          CleanDirectory(buildDir);
        });

Task("Restore-NuGet-Packages")
  .IsDependentOn("Clean")
  .Does(() =>
        {
          NuGetRestore("./src/Example.sln");
        });

Task("Build")
  .IsDependentOn("Restore-NuGet-Packages")
  .Does(() =>
        {
          MSBuild("./src/Example.sln", settings =>
                  settings.SetConfiguration(configuration));
        });

Task("Run-Unit-Tests")
  .IsDependentOn("Build")
  .Does(() =>
        {
          NUnit3("./src/**/bin/" + configuration + "/*.Tests.dll", new NUnit3Settings {
            NoResults = true
          });
        });

Task("Default")
  .IsDependentOn("Run-Unit-Tests");

RunTarget(target);

This script uses another NuGet package to run the NUnit3 tests and references it. A nice feature is to configure the NuGet dependency at the beginning of the script.

This build script contains five targets. The method IsDependentOn("") wires the targets together in the right execution order. This way is a bit different to FAKE and maybe a little bit confusing. It needs to write the targets in the right execution order. If you don't write the script like this, you need to find the initial target and to follow the way back to the very first target. You will read the execution order from the last to the first target.

FAKE does this a little easier and wires the targets up in a single statement at the end of the file:

// Dependencies
"Clean"
  ==> "Restore-NuGet-Packages"
  ==> "Build"
  ==> "Run-Unit-Tests"
  ==> "Default"
 
RunTargetOrDefault "Default"

This could possibly look like this dummy code in CAKE:

// Dependencies
WireUp("Clean")
  .Calls("Restore-NuGet-Packages")
  .Calls("Build")
  .Calls("Run-Unit-Tests")
  .Calls("Default");

RunTarget(target);

Running the build

To run the build, just call .\build.ps1 in a PowerShell console:

If you know FAKE, the results look pretty familiar:

Conclusion

Anyway. I think CAKE gets pretty much faster accepted by the fellow developers at the YooApps than FAKE did. Some things will work a little easier in CAKE than in FAKE and some a little different, but the most stuff will work the same way. So it seems it makes sense to switch to use CAKE at the YooApps. So let's use it. :)

I'm sure, I will write down a comparison of FAKE and CAKE later, if I have used it for a few months.

Please use a password manager

17.04.2017 19:00:00 | Jürgen Gutsch

Since years, I'm using a password manager to store and manage all my credentials for all the accounts I use. The usage of such a tool is pretty common for me and it is a normal flow for me to create a new entry in the password manager first before I create the actual account.

I'm always amazed, if I meet people, who don't use any tool to store and manage their credentials. They use the same password or the same bunch of passwords everywhere. This is dangerous and most of them already know about that. Maybe they are to lazy to spend one or two ours to think about the benefits and to search for the right tool or they simply don't know about such tools

For me the key benefits are pretty clear:

  • I don't need to remember all the passwords.
  • I don't need to think about secure passwords while creating new one
  • I just need to remember one single passphrase

Longer passwords are more secure than short ones, even if the short ones include special characters, numbers and upper case characters. But longer passwords are pretty hard to remember. This is why Edward Snowden proposed to use passphrases instead of passwords. Using passphrases like this, are easy to remember. But would it really makes sense to create a different pass-phrase for every credentials you use? I don't think so.

I just created a single pass-phrase which is used with the password manager and I use the password manager to generate the long passwords for me. Most of the generated password are like this:

I4:rs/pQO8Ir/tSk*`1_KSG"~to-xMI/Gf;bNP7Qi3s8RuqIzl0r=-JL727!cgwq

The tool I use is KeePass 2, which is available on almost all devices and OS I use. As small desktop app on Windows, Mac and Linux as an app on Windows phones and Android. (Probably on iOS too, but I don't use such a device). KeePass stores the passwords on a encrypted file. This file could be stored on a USB drive or on a shared folder in the cloud. I use the cloud way to share the file to every device. The cloud store itself is secured with a password I don't know and which is stored in that KeePass file.

What the F***, you really put the key to lock your house into a safe which is inside your house? Yes!

The KeyPass file is synced offline and offline accessible on all devices. If the file changes it will be synched to all devices. I'm still able to access all credentials.

With the most password mangers, you are able to copy the username and the password, using shortcuts to the login forms. Some of them are able to automatically fill in the credentials. KeePass uses the clipboard, but deletes the values from the clipboard after a couple of seconds. Like this, no one else can access or reuse the credentials within the clipboard.

There are many more password manager out there. But KeePass - with the encrypted file - works best for me. I'm responsible to store the file on a save location and I can do that wherever I want.

Summary

Use a password manager! Spend the time to try the tools and choose the tools that fits you best. It is important! Once you use a password manager, you never want to work without one. It will make you live easier and hopefully more secure.

Blogging with Git Flow

02.04.2017 19:00:00 | Jürgen Gutsch

Since a while we use Git Flow in our projects at the YooApps. Git Flow is a add-in for Git, that helps us to follow the feature branch process in a standard way. We usually use our Jira ticket number as names for features, bugs or hotfix and we use the Jira Version as a Release name. This makes absolutely sense to us and makes the flow pretty transparent. We also use BitBucket to host our Git repositories, which is directly linked to Jira. That means on every Pull Request we have the direct link to the Jira ticket.

Using Git Flow to release new posts

My idea is to also use Git Flow to release new blog posts.

My blog is generated by Pretzel, which is a Jekyll clone written in C#. I host it on an Azure Web Site. I write my posts in GitHub style Markdown files and push them to GitHub. Every time I push a new post, the Azure Web Site starts a new build and runs Pretzel to generate the static blog.

I already wrote some blog posts about using Pretzel

Dear hackers and bots: Because it is a static web site, it doesn't make sense to search for WordPress login pages or WordPress APIs on my blog ;)

Since almost one and a halve year now, I use Git on GitHub to publish my posts, but I only use the master branch yet and I don't commit the drafts. I sometimes write two or three post in parallel and I anyway have around ten drafts in the Pretzels _drafts folder. This feels a bit messy and I will probably loose my drafted posts, if the machine crashes.

Using Git Flow, I don't need to use the _drafts folder anymore. Every unfinished feature branch is a draft. If I finish a post, I would just need to finish the feature branch. If I want to publish the posts, I can start a new release.

Maybe the release step is a bit too much. But currently I need to push explicitly to publish a new post and it shouldn't be a big deal to also create a new release to merge all finished posts from develop to master. If it doesn't fit, it would be easy to switch to the more simple feature branches.

Let's see how it works :-)

This blog post feature branch is created by using the following commands in the console:

git flow feature start blogging-with-git-flow

Now I'm in the draft mode and will create the blog post file, writing, adding images, linking between existing posts and so on. If this is done I do a first commit and publish the feature branch to GitHub:

git add _posts/*
git add img/*
git commit -m "new post about blogging with pretzel"
git flow feature publish

At this state I can change and commit as much as I want to. If I finish the blog post, I'm going to finish the post and push the current develop branch to GitHub:

git flow feature finish
git push

The last step is publishing the posts. I currently not sure, but I could probably use the number of posts as the minor version number, which will also be used as tag for the release:

git flow release start 1.48.0
git flow release finish
git push --all
git push --tags

(I possibly should create a batch command to execute the four lines to release new posts)

After that push, Pretzel will start "baking" the blog including the new blog post.

If I want to see the current drafts, I just need to display the existing branches:

I'm sure this will be a clean way to publish and to handle the drafts and finished posts.

Versioning

While publishing the latest post like this, I realized that GitHub actually will display a release in the GitHub repository, this is quite nice. This is not really needed but a funny fact and a reason why I wanna think a little more about the version numbers, if I release a new article.

My idea is to change the Major version, if I do a huge change on the layout of the blog or if I add a new feature. Because the layout is still the first version and I only did some really small changes, I'll keep it as version 1. For the minor version I will use the number of published articles.

This doesn't really makes sense from the semver perspective, but blogging should also be fun and this really means is fun to me.

This means, with the latest post I published release 1.47.0 and this post will be in release 1.48.0 ;-)

Authoring

In the last post about writing blog posts using Pretzel, I wrote that I use MarkdownPad 2 to write my pots. Unfortunately it seems that this editor is not longer maintained, no new version was published for a while. I paid for it, to have some more extended feature to use. Anyway, a few months ago it crashes every time I opened it and there was no way to get an updated or fixed version. (I'm pretty sure it was related to the installation of CefSharp.) This is why I now use Typora, which is pretty minimalistic and lightweight. It works completely different, but in a pretty cool way. It doesn't use a splitted screen to edit and preview the content. With typora you write markdown code directly and it immediately translated it to the preview in the same editor view. It also supports custom CSS and different Markdown styles. It is real WYSIWYG.

Any thoughts about it? Feel free to drop a comment and let me know :-)

Regeln | Impressum