Bash: Alle freien Microsoft eBooks auf einmal laden

Eric Lingman, seinerseits Director of the Sale Excellence Blog, hat nun in einem Blogpost eine viel Zahl an nun freien eBooks rund um Microsoft Technologien als Linkliste veröffentlicht.

Download All eBooks

Wer im stressigen Alltag nicht die Muse hat alles durchzusehen was man brauchen könnte sondern dies eher nachgelagert machen möchte hat Pech gehabt – es gibt laut Blogpost aus diversen Gründen keinen „Download all“ Button.

Da nun aber selbst auch auf Windows eine Bash vorhanden ist, entsteht für Konsoleros nur der Zeitaufwand was es benötigt, drei Zeilen Bash-Befehle zu schreiben.

#1. Wir laden die Linkliste

wget http://www.mssmallbiz.com/ericligman/Key_Shorts/MSFTFreeEbooks.txt

#2. Wir laden alle verlinkten eBooks

wget -i MSFTFreeEbooks.txt

#3. *.pdf Suffix anhängen

for f in *; do mv "$f" "$f.pdf"; done

Nicht alle Links müssen funktionieren, so kann es durchaus sein, dass eure Bash, bzw. wget manchmal Fehler wirst. Der Großteil der Links funktionierte jedoch einwandfrei.

Quelle: drwindows.de

Es ist nur ein kleiner Commit für einen Menschen, aber … – Apollo 11 Quelltext auf Github veröffentlicht

Apollo 11
Quelle: Github.com

Das Gefühl als vor vielen vielen Jahrzehnten der erste Mensch seinen Fuß auf den Mond gesetzt hat muss schon sehr beeindruckend gewesen sein. Nun kann man auf Github einen Blick auf manche Bestandteile der Software der Apollo 11 Mission werfen.

Dies dürfte für Liebhaber von Assembler Code sicherlich ein toller Blick in die Vergangenheit seien, für alle anderen wohl eher ein Kauderwelsch an Genialität.

Erklärung

This source code has been transcribed or otherwise adapted from digitized images of a hardcopy from the MIT Museum. The digitization was performed by Paul Fjeld, and arranged for by Deborah Douglas of the Museum. Many thanks to both. The images (with suitable reduction in storage size and consequent reduction in image quality as well) are available online at www.ibiblio.org/apollo. If for some reason you find that the images are illegible, contact me at info@sandroid.org about getting access to the (much) higher-quality images which Paul actually created.

docs.microsoft.com – Neue, zentrale Sammelstelle für technische Dokumentationen

Quelle: docs.microsoft.com
Quelle: docs.microsoft.com

Passende Dokumentationen von und zu Microsoft Diensten, APIs und SDKs zu finden kann mitunter wirklich haareraufend sein. Vor allem wenn es um ein Library geht welche unter Windows 7, Windows 8, Windows 8.1 und Windows (UWP) zwar existiert, jedoch einen immer leicht anderen funktionsumfang beziehungsweiße Gebrauchsanleitung besitzt oder einfach von Dingen die sehr alt oder sehr neu sind.

Zu mindestens in manchen Punkten versucht Microsoft scheinbar Besserung nicht nur zu geloben sondern auch zu bringen. Unter docs.microsoft.com entsteht eine zentrale Anlaufstelle für technische Dokumentationen von den Redmondern. Bisher umfasst diese zwar nur einen Bruchteil von dem was sie auflisten könnte, jedoch ist ja bekanntlich jeder Anfang schwer und ich hoffe einfach so, dass Microsoft hier einmal etwas konsequent durchzieht und es Entwicklern wieder einfacherer macht die richtige Version zur richtigen Dokumentation zu finden – ohne sich durch falsch formatierte oder falsch verlinkte Seiten immer tiefer in das TechNet wühlen zu müssen.

Ob die UWP Dokumentation hier ebenfalls einzieht wollte mir der deutsche Twitter-Account von Microsoft Developer nicht bestätigen – deswegen gehe ich (leider) erst einmal von einem nein aus.

Twitter tscholze - MS Dev

Swift: Enum-basierende UIControl Styles (nicht nur für den Interface Builder)

Heutzutage findet ein Kampf um die schönste und die am besten durchgestaltete App in der iOS Welt statt. Die Zeiten sind vorbei als alleinig das moderne Aussehen von iOS 7 Controls ausreichte um Kunden (und deren Kunden) zufrieden zu stellen wenn es um das Aussehen einer neue App ging. Dies ist nichts Neues. Dieses „sattsehen“ an gewohnten Designs konnte man schon zum Ende von iOS 6 sehen als die Standard-Controls im Skeuomorphic Design schon länger als altbacken und „sattgesehen“ galten.

Zum Glück gibt es ja extra Menschen auf dieser Welt was das Handwerk vom Gestalten von UI und UX nicht nur sehr gut beherrschen sondern meist auch noch von der Pike auf gelernt haben. Eventuell deswegen ärgere ich mich in der iOS Welt gefühlt nur noch sehr wenig über hässliche Apps – die in den Charts trenden.

Des einen Freud, des anderen Leid. UI Designer können noch so gute und abgesprochene Vorarbeit im Gestaltungsprozess leisten, am Ende liegt es am ausführenden Entwickler das erdachte App Design auch in baubaren Quelltext umzusetzen.

Hierbei können kleinere Helferlein unnötigen Stress und Aufwand sparen. Vor allem in agilen Prozessen wo es durch aus einmal sein kann, dass eine Überschrift vom Typ A plötzlich eine andere Farbe haben soll oder gar sich ein ganzes Farbkonzept ändert. In solchen Fällen ist es pure Qual eine komplexe App per Hand durchzugehen und im Interface Builder alle Farbwerte, States und Paddings anzupassen.

Aus diesem Grund haben mir meine tollen Kollegen einen Trick beigebracht um sich selbst und damit dem Projekt Zeit zu sparen: Enum-Basierende Styles für (nicht nur) den Interface Builder.

Um dies zu verdeutlichen habe ich eine kleine, simple Demo für einen einfachen Usecase erstellt. Ein UIButton soll je nach Status (Normal, gedrückt, deaktiviert) eine andere Hintergrundfarbe bekommen. Hierzu kommt noch etwas allgemeines Styling.

Enum based Button style

Quelltext

Generell benötigt man für dieses Feature eine eigene, auf beispielsweise UIButton basierende Klasse. Dieser Trick ist auf nahezu alle UIControl-basierenden Klassen anwendbar. Das gesamte Demoprojekt gibt es auf Github.

@IBDesignable
public class Button: UIButton
{
    /// MARK: - Properties -
    
    // 1.
    /// Style identifier
    /// Default value = MyStyle
    @IBInspectable
    public var styleIdentifier: String = "MyStyle"
    {
        didSet
        {
            applyNormalStyle(styleIdentifier)
        }
    }
    
    // 2.
    /// Overrides enabled property
    /// Will apply normal or disabled state
    override public var enabled: Bool
    {
        didSet
        {
            if enabled
            {
                applyNormalStyle(styleIdentifier)
            }
                
                
            else
            {
                applyDisabledStyle(styleIdentifier)
            }
        }
    }
    
    
    // MARK: - Initialization & Setup -
    
    // 3.
    override init(frame: CGRect)
    {
        super.init(frame: frame)
        setup()
    }
    
    
    required public init?(coder aDecoder: NSCoder)
    {
        super.init(coder: aDecoder)
    }
    
    
    override public func awakeFromNib()
    {
        super.awakeFromNib()
        setup()
    }
    
    
    // 4.
    override public func beginTrackingWithTouch(touch: UITouch, withEvent event: UIEvent?) -> Bool
    {
        let touched = super.beginTrackingWithTouch(touch, withEvent: event)
        
        if touched
        {
            applyPressedStyle(styleIdentifier)
        }
        
        return touched
    }
    
    
    // 4.
    override public func endTrackingWithTouch(touch: UITouch?, withEvent event: UIEvent?)
    {
        applyNormalStyle(styleIdentifier)
        return super.endTrackingWithTouch(touch, withEvent: event)
    }
    
    
    // 5.
    override public func prepareForInterfaceBuilder()
    {
        setup()
    }
    
    
    // MARK: - Helper
    
    // 6.
    /// Applies default styles
    private func setup()
    {
        // Apply generic styling
        setTitleColor(UIColor.whiteColor(), forState: .Normal)
        setTitleColor(UIColor.whiteColor(), forState: .Selected)
        contentEdgeInsets = UIEdgeInsetsMake(10, 10, 10, 10)

        enabled = (enabled)
        
        // Apply style
        applyNormalStyle(styleIdentifier)
    }
    
    // 7.
    /// Applies normal style
    ///
    /// - parameter styleIdentifier: Defines the requested style
    private func applyNormalStyle(styleIdentifier: String)
    {
        switch styleIdentifier
        {
        case ButtonStyle.MyStyle.rawValue:
            backgroundColor = UIColor.grayColor()
            
        default:
            return
        }
    }
    
    
    // 7.
    /// Applies pressed style
    ///
    /// - parameter styleIdentifier: Defines the requested style
    private func applyPressedStyle(styleIdentifier: String)
    {
        switch styleIdentifier
        {
        case ButtonStyle.MyStyle.rawValue:
            backgroundColor = UIColor.darkGrayColor()

        default:
            return
        }
    }
    
    // 7.
    /// Applies disabled style
    ///
    /// - parameter styleIdentifier: Defines the requested style
    private func applyDisabledStyle(styleIdentifier: String)
    {
        switch styleIdentifier
        {
        case ButtonStyle.MyStyle.rawValue:
            backgroundColor = UIColor.lightGrayColor()
            
        default:
            return
        }
    }
}


// 0.
/// Defines different button styles
public enum ButtonStyle: String
{
    // Default styling (MyStyle)
    case MyStyle = "MyStyle"
    
    // other styles ...
}

Natürlich kann man diese Styles jetzt nicht nur im Interface Builder setzen. Im Quelltext lässt sich der styleIdentifier ebenfalls wie jede andere (öffentliche) Property setzen. Dank des didSet{ … } werden Änderungen auch zur Laufzeit angewendet.

let button             = UIButton(...)
button.styleIdentifier = ButtonStyle.MyStyle.rawValue

Erklärung

0.)
Definiert das Enum mit dem verfügbaren Styles. Der rawValue ist zum einfachen Matching auf String eingestellt.

1.)
Das styleIdentifier-Property enthält dem in Interface Builder eingestellten Wert. Leider unterstützt der IB noch keine Enums als IBInspectable Datenquelle.

2.)
Die überschriebene enabled-Property benötigt man um den aktivierten beziehungsweise reaktivierten Wert Zustand zu erkennen und somit die entsprechenden gestalterischen Werte zu setzen.

3.)
Benötigte Methoden um bei jedem Initialisieren der Control den Style-Prozess anzustoßen.

4.)
Diese Event Handler werden benötigt um den „gedrückt“ Style zu setzen als auch wieder zu entfernen.

5.)
Wichtig um die angewendeten Styles bereits beim ersten Laden im IB sehen zu können.

6.)
Die generische setup()-Methode setzt allgemein gültige Gestaltungsparameter wie in diesem Beispiel die Textfarbe oder die contentEdgeInsets-Property.

7.)
Methoden welche je nach ausgewählten styleIdentifier die entsprechenden Werte setzen.

Lessons learned
@IBDesignables strapazieren Xcode (Version 7.x) wirklich sehr. Die IDE kommt bei komplexen Oberflächen mit vielen solcher Custom Controls an ihre Grenzen und straft den Entwickler mit anderen Kompilierungsvorgängen oder gar mit regelmäßigen abstürzen. Eine Abhilfe ist, die Designables eines Projektes in ein eigenes Framework zu stopfen – deswegen die public-Indikatoren. Dieser Fix hat natürlich auch an sich selbst wieder negative Seiteneffekte, konnte jedoch bei mir für eine größere Linderung bei meinen Xcode Probleme sorgen.

Swift: Microsoft Cognitive Services Computed Vision ausprobiert

MSFT CV Logo
Quelle:  microsoft.com

Auf der diesjährigen BUILD stellte Microsoft eine Vielzahl an neuen und recht interessanten APIs auf Grundlage von künstlicher Intelligenz vor. Die Insider mögen Gnade walten lassen bei dieser Formulierung. Generell ist ja das 2016ner „Ich bau eine Twitter-App“ eine App die Bilder erkennen kann.

Aus diesem Grund habe ich eine kleine und rein für Testzwecke gebaute swiftige Demo gebaut, die ein aufgenommenes Bild Richtung Redmond schickt und mir im besten Falle die erkannten Tags aka Objekte zurück liefert.

Generell ist dies hier nicht wirklich eine spezielle iOS Sache. Es handelt sich bei der Kommunikation mit den Microsoft Cognitive Services um bequeme und plattformübergreifend auf http-Anfragen und JSON-basierenden Antworten.

Den Quelltext zur Demo findet ihr hier auf Github. Für das „Original“ als auch weitere, spaßige Ideen was man mit CV bauen kann findet ihr die Demos im Repository von Alex Repty.

Pädagogisch wertvolle Erklärungen was die Cogntive Services eigentlich sind und wie man diese nutzt findet man im entsprechenden, deutschsprachigen Kurs in der MVA. Auch udemy hat einen entsprechenden Kurs für 35 Euro im Angebot.

Demo benutzen
Damit die Demo läuft, braucht man einen API Key von Microsoft. Diesen gibt es mit fairen Quotas als Probevariante gratis auf der Produktseite von Microsoft. Den Schlüssel muss noch als Wert der entsprechenden Konstanten in der

// CognitiveServiceConfiguration.swift
static let ApiKey = ""

-Datei gesetzt werden.

Im selbigen File findet man noch den Konfigurationswert:

static let RequiredConfidence

Dieser gibt in einer Spanne von 0…1 an, wie sicher sich die KI sein muss bevor sie ein Objekt als erkannt ansieht. Zwischen 0.75 und 0.9 fuhr ich am besten.

CV Demo Screenshot

Lessons learned
Die Erkennung von einfachen Dingen ist meist nicht so ausführlich wie ich gehofft habe. Im angehängten Screenshot hätte ich beispielsweise noch Tags wie „panda“, „green“ oder „leave“ erwartet. Ob dies an einer fehlenden Konfiguration meinerseits des Requests liegt oder am Service an sich kann ich jedoch noch nicht sagen. Ansonsten funktionieren Bilder von Gesichtern besser. Hierbei werden neben Geschlecht auch ob die Person eine Brille trägt und vereinzelt wohl auch, welche ethnische Zugehörigkeit diese Person hat.

Ansonsten gab es noch ein offensichtliches Learning für mich. Es ist eine sehr ungute Idee ein 1:1 Bild der iPhone Kamera im mobilen Internet Richtung Redmond zu schicken. Hierdurch dauerte ein Request bis zu 20 Sekunden. Mit Auflösungen von 250 bis 500 Pixeln ging alles nahezu instantan. Selbst mit so kleinen Auflösungen konnte ich keine Einbusen in der Objekterkennung bemerken.

Follow Tipps
Wer nun Interesse an dieser Thematik gewonnen hat, dem kann ich auf Twitter neben dem sehr netten iOS- und Mac-Entwickler Alex Repty (@arepty) auch die, im deutschsprachigen Twitter-Universum bekannten, @codeprincess, ihrerseits Technical Evangelist bei Microsoft, empfehlen. Folgen lohnt so oder so. :)

Natürlich laden auch andere APIs der Cogntive Services zum experimentieren ein. Eine Übersicht welche Funktionen existierenden findet man auf der relativ übersichtlichen Produktseite von Microsoft.


Artikelbild: https://www.microsoft.com/cognitive-services/en-us/apis

Kuriose Auswüchse der EM 2016: Mach das Island „Huh!“

Für die Zeitkapsel: Bei der EM 2016 gibt es bereits den ersten Meister der Herzen. Island bezwang England im Achtelfinale. Also kleine Anmerkung, inn der selben Woche wählten die Briten ein „Ja“ zum Brexit.

Wer sich ein bisschen selbst wie ein Isländer freuen mag, der klicke auf das Bild und „Huh“-e mit.

Island Huh

Einsteig in das Microsoft Bot Framework – die Enkel der IRC-Bots erwachen

Microsofts Entwickler Konfernz BUILD war dieses Jahr viel von Visionen angetrieben wie Sache X in Y Jahren vielleicht funktionieren könnte. Wenn man den schnelllebigen Technikmarkt ansieht sind (für meiner einer) solche Aussagen oft schneller vergessen als ein Chamäleon die Farbe wechselt. Ich mag eher Dinge die sofort greifbar sind und zum ausprobieren einladen. So war es mit dem Bot Framework von Microsoft (Github Repository). Vorgestellt und am gleichen Tag konnten es sich interessierte Entwickler schon genauer ansehen und damit experimentieren.

Bots sind nicht neues. Mindestens wer zu IRC-Zeiten aufgewachsen ist kann sich an Channel-Bots wie Eggdrop und Co. noch sehr gut erinnern. Die Entwicklung hierfür war allzu nicht so schwer wenn man einmal den Dreh raus hatte. Später folgten Bots für andere Chatplattformen wie Hipchat oder Slack. Nun kommt also auch Microsoft hinzu. Der Ansatz aus Redmond wirkt (natürlich) mehr in Richtung Kommerz und unternehmensgetrieben Kommunikation ausgelegt als auch das der Dienst für eine breitere Masse interessant sein soll. Im Abstrakten gesehen sollen diese Bots in etwa gleich reagieren wie die altbekannten Kompanen aus IRC-Zeiten. Man sagt etwas und der Bot reagiert darauf. Selbstverständlich heute etwas schlauer und kontextsensitiver als die !say Kommandos der damaligen Zeit – im Grunde jedoch das gleiche, irgendwie.

Da ich die offizielle Dokumentation noch etwas verwirrend finde habe ich mir eine einfache Checkliste zusammen gestellt um mit der Entwicklung von Bots beginnen zu können.

  1. Auf docs.botframework.com verstehen was überhaupt Sache ist
  2. Entscheiden ob man in C# oder Node.js entwickeln möchte
  3. Aktuelles Visual Studio (Version egal) installieren
  4. Trotzdem noch mal Visual Studio aktualisieren (Tools – >Extensions and Updates -> Updates)
  5. Manuell (!) dieses Bot Project Template herunterladen
    Template nach „%USERPROFILE%\Documents\Visual Studio 2015\Templates\ProjectTemplates\Visual C#“ (für C#) verschieben
  6. Visual Studio neustarten
  7. Neues Projekt / Solution aus dem Template erstellen, bauen und ausführen lassen
  8. Falls alles korrekt ist, startet Edge mit einer Dummy Seite, falls nicht hat etwas nicht geklappt

Bot VS TemplateIn der offiziellen Dokumentation wird oft vom „Bot Framework Emulator“ gesprochen jedoch nur einmal darauf verlinkt. Ihr könnt den Emulator HIER herunterladen.

Startet ihr nun den Emulator könnt ihr eigentlich sofort mit dem „interaktiven Chatten“ loslegen. Der im Template integrierte Demo-Bot gibt euch die Anzahl der Characters eurer Nachricht zurück.

Bot Emulator

Weiter kann man im Emulator auch gleich die JSON Kommunikation zwischen euch und dem Webservice des Bots sehen.

Alles im allen viel der erste Blick auf das Framework richtig gut aus. Natürlich war es nur ein anschnuppern – welches zu mindestens für mich Lust auf mehr gemacht hat.

Leider gibt es noch keine themenspezfischen Bot Foren im MSDN. Dieser Umstand ist jedoch den verantwortlichen klar und haben zu mindestens versprochen dieses Anliegen weiter zu geben – hoffen wir einfach einmal das Beste.

Auf eine Frage bezüglich der „Selbsthostbarkeit“ von Bots warte ich noch in diesem Thread auf eine Antwort.

Falls es meine Zeit zulässt würde ich mich gern weiter mit dem Framework beschäftigen. Mal sehen was man daraus in der Freizeit so knuffiges Bauen kann.