Automatic Breadcrumb for Jekyll on GitHub Pages

There are many Breadcrumb Plugins out there but I wanted something that works on GitHub Pages together with jekyll’s safe mode.

Assuming you have the following static page URL structure for all pages (you will need to disable the breadcrumb inside your blog pages)

/page1/index.html
/page1/subpage1/index.html
/page2/index.html
...

You can use the following liquid statement which will render a breadcrumb with url and text from the frontmatter. Make sure all your pages have page.breadcrumb set to the value you want to be shown inside the breadcrumb element.

Example page with frontmatter:

---
layout: default
title: My Java-Page
breadcrumb: Java-Page
---

<div class="container">
  <div class="row">
    <div class="col-md-12">
      peace yo!
    </div>
  </div>
</div>

Now here is the code for the breadcrumb

The output will be a breadcrumb for bootstrap. You will need to style the html with css.

<ol class="breadcrumb">
  <li><a href="/">Home</a></li>
  <li><a href="/page1/index.html">Foo</a></li>
  <li class="active"><a href="/page1/subpage1/index.html">Bar</a></li>
</ol>

Developing a Modern Distributed System – Part II: Provisioning with Docker

As described in an earlier blog post “Bootstrapping the Project”, comSysto’s performance and continuous delivery guild members are currently evaluating several aspects of distributed architectures in their spare time left besides customer project work. In the initial lab, a few colleagues of mine built the starting point for a project called Hash-Collision:

Hash-collision's system structure

They focused on the basic application structure and architecture to get a showcase up and running as quickly as possible and left us the following tools for running it:

  • one simple shell script to set up the environment locally based on many assumptions
  • one complex shell script that builds and runs all services
  • hardcoded dependency on a local RabbitMQ installation

First Attempt: Docker containers as a runtime environment

In search of a more sophisticated runtime environment we went down the most obvious path and chose to get our hands on the hype technology of late 2014: Docker. I assume that most people have a basic understanding of Docker and what it is, so I will not spend too much time on its motivation here. Basically, it is a tool inspired by the idea of ‘write once, run anywhere’, but on a higher level of abstraction than that famous programming language. Docker can not only make an application portable, it allows to ship all dependencies such as web servers, databases and even operating systems as one or multiple well-defined images and use the very same configuration from development all the way to production. Even though we did not even have any production or pre-production environments, we wanted to give it a try. Being totally enthusiastic about containers, we chose the most container-like place we could find and locked ourselves in there for 2 days.

impact-hub-munich

One of the nice things about Docker is that it encourages developers to re-use existing infrastructure components by design. Images are defined incrementally by selecting a base image, and building additional functionality on top of it. For instance, the natural way to create a Tomcat image would be to choose a base image that already brings a JDK and install Tomcat on top of it. Or even simpler, choose an existing Tomcat image from the Docker Hub. As our services are already built as fat JARs with embedded web servers, things were almost trivial.

Each service should run in a standardized container with the executed JAR file being the sole difference. Therefore, we chose to use only one service image and inject the correct JAR using Docker volumes for development. On top of that, we needed additional standard containers for nginx (dockerfile/nginx) and RabbitMQ (dockerfile/rabbitmq). Each service container has a dependency on RabbitMQ to enable communication, and the nginx container needs to know where the Routing service resides to fulfill its role as a reverse proxy. All other dependencies can be resolved at runtime via any service discovery mechanism.

As a first concrete example, this is the Dockerfile for our service image. Based on Oracle’s JDK 8, there is not much left to do except for running the JAR and passing in a few program arguments:

FROM dockerfile/java:oracle-java8
MAINTAINER Christian Kroemer (christian.kroemer@comsysto.com)
CMD /bin/sh -c 'java -Dport=${PORT} -Damq_host=${AMQ_PORT_5672_TCP_ADDR} -Damq_port=${AMQ_PORT_5672_TCP_PORT} -jar /var/app/app.jar'

After building this image, it is ready for usage in the local Docker repository and can be used like this to run a container:

# start a new container based on our docker-service-image
docker run docker-service-image
# link it with a running rabbitmq container to resolve the amq dependency
docker run --link rabbitmq:amq docker-service-image
# do not block and run it in background
docker run --link rabbitmq:amq -d docker-service-image
# map the container http port 7000 to the host port 8000
docker run --link rabbitmq:amq -d -p 8000:7000 docker-service-image
# give an environment parameter to let the embedded server know it has to start on port 7000
docker run --link rabbitmq:amq -d -e "PORT=7000" -p 8000:7000 docker-service-image
# inject the user service fat jar
docker run --link rabbitmq:amq -d -e "PORT=7000" -v HASH_COLLISION_PATH/user/build/libs/user-1.0-all.jar:/var/app/app.jar -p 8000:7000 docker-service-image

Very soon we ended up with a handful of such bash commands we pasted into our shells over and over again. Obviously we were not exactly happy with that approach and started to look for more powerful tools in the Docker ecosystem and stumbled over fig (which was not yet deprecated in favor of docker-compose at that time).

Moving on: Docker Compose for some degree of service orchestration

Docker-compose is a tool that simplifies the orchestration of Docker containers all running on the same host system based on a single docker installation. Any `docker run` command can be described in a structured `docker-compose.yml` file and a simple `docker-compose up` / `docker-compose kill` is enough to start and stop the entire distributed application. Furthermore, commands such as `docker-compose logs` make it easy to aggregate information for all running containers.

fig-log-output

Here is an excerpt from our `docker-compose.yml` that illustrates how self-explanatory those files can be:

rabbitmq:
 image: dockerfile/rabbitmq
 ports:
 - ":5672"
 - "15672:15672"
user:
 build: ./service-image
 ports:
 - "8000:7000"
 volumes:
 - ../user/build/libs/user-1.0-all.jar:/var/app/app.jar
 environment:
 - PORT=7000
 links:
 - rabbitmq:amq

Semantically, the definition of the user service is equivalent to the last sample command given above except for the handling of the underlying image. The value given for the `build` key is the path to a directory that contains a `Dockerfile` which describes the image to be used. The AMQ service, on the other hand, uses a public image from the Docker Hub and hence uses the key `image`. In both cases, docker-compose will automatically make sure the required image is ready to use in the local repository before starting the container. A single `docker-compose.yml` file consisting of one such entry for each service is now sufficient for starting up the entire distributed application.

An Aside: Debugging the application within a Docker container

For being able to debug an application running in a Docker container from the IDE, we need to take advantage of remote debugging as for any physical remote server. For doing that, we defined a second service debug image with the following `Dockerfile`:

FROM dockerfile/java:oracle-java8
MAINTAINER Christian Kroemer (christian.kroemer@comsysto.com)
CMD /bin/sh -c 'java -Xdebug -Xrunjdwp:transport=dt_socket,address=10000,server=y,suspend=n -Dport=${PORT} -Damq_host=${AMQ_PORT_5672_TCP_ADDR} -Damq_port=${AMQ_PORT_5672_TCP_PORT} -jar /var/app/app.jar'

This will make the JVM listen for a remote debugger on port 10000 which can be mapped to any desired host port as shown above.

What we got so far

With a local installation of Docker (on a Mac using boot2docker http://boot2docker.io/) and docker-compose, starting up the whole application after checking out the sources and building all JARs is now as easy as:

  • boot2docker start (follow instructions)
  • docker-compose up -d (this will also fetch / build all required images)
  • open http://$(boot2docker ip):8080/overview.html

Note that several problems originate from boot2docker on Mac. For example, containers can not be accessed on `localhost`, but using the IP of a VM as boot2docker is built using a VirtualBox image.

In an upcoming blog post, I will outline one approach to migrate this setup to a more realistic environment with multiple hosts using Vagrant and Ansible on top. Until then, do not forget to check if Axel Fontaine’s Continuous Delivery Training at comSysto is just what you need to push your knowledge about modern deployment infrastructure to the next level.

Cross-language benchmarking made easy?

There is this eternal fight between the different programming languages. “The code in ‘XYZlang’ runs much faster than in ‘ABClang'”. Well, this statement bears at least three misunderstandings. First of all, in most cases it is not the source code you wrote, that gets actually executed, second thing, please define “faster” upfront, third thing, and general rule of experiments: Do not draw conclusions based on a benchmark, see them more of a hint that some things seem to make a difference.

In this article series, I will not discuss about numbers and reasons, why code X or language Y supersedes the other. There are many people out there who understand the backgrounds much better than me – here, short hint to a very good article about Java vs. Scala benchmarking by Aleksey Shipilëv. There will be no machine code, no performance tweaks which make your code perform 100 times better.  I want to present you ideas, how you can set such micro benchmarks up in a simple, automated and user friendly way. In detail we will come across these topics:

  • How to setup one build that fits all requirements?
  • Gradle in action building across different languages
  • Benchmarking with JMH (java) and Hayai (C/C++) to proof the concept
  • How to store the results?

Continue reading

Cross-language benchmarking – Gradle loves native binaries!

Last time I gave you an introduction to my ideas about benchmarking. I explained to you that comparing performance between different compilers and implementations is as old as programming ifself, and, above all, it is not that simple to setup as it sounds. If you don’t know what I write about, have a look at the former post on this topic. There, I explained, how to setup a simple Gradle task which runs JMH benchmarks as part of a Gradle task chain. However, the first article is no prerequisite at all for this article!

Today I want to start from the other side. As a C++ developer who wants to participate in a performance challenge, I want

  • a framework that outputs numbers that can be compared with other benchmark results
  • to run all benchmarks at once
  • to compare my results with other implementations or compiler assemblies
  • to execute all in one task chain

Continue reading

Von Mitarbeiter zu Mitarbeiter – was haben wir auf der ersten cS ONE Conference gelernt?

Wie euch meine Kollegin Selma letzte Woche schon berichtet hat, haben wir Anfang Dezember unsere erste, eigene cS ONE Konferenz veranstaltet. Ein Event der ganz und gar im Zeichen der Wissenvermittlung und des Teambuildings stand. Um einen besseren Eindruck von der tollen Stimmung und den Themen des Tages zu bekommen, habe ich mal einige Abstracts zusammengestellt, inklusive der Meinungen des Speaker und Kollegen.

 

Cindy

Da wir als Beratungsfirma hauptsächlich beim Kunden vor Ort arbeiten, ist jede Gelegenheit bei der man alle (nicht-Projekt-)Kollegen trifft schön. Dafür haben wir zwar monatlich ein Teamessen, die cS One jedoch war etwas ganz Besonderes: Da hatte man einen ganzen Tag lang Zeit und Muße sich mit allen Kollegen über verschiedene relevante sowie triviale Themen auszutauschen in einer Atmosphäre, die eine perfekte Mischung war aus “Arbeit” (Konferenzräume, Stuhlkreise) und “Spaß” (Playstation mit Guitar Hero). Je mehr unsere Firma wächst, desto wichtiger sind solche Gelegenheiten und ich freue mich sehr auf eine cS Two, Three und Four.

Vortrag: Data, data everywhere and only Map-Reduce to drink – ein Projektbericht

“Gemeinsam mit unserem Partner MapR haben wir im Vorfeld der cS One einen Vortrag auf der Strata Europe Konferenz in Barcelona gehalten zum topaktuellen Thema Internet-of-Things Architektur in Verbindung mit einem tatsächlichen Big Data Projekt das comSysto im Jahr 2013 realisiert hat. Bei dem Projekt handelte es sich um einen Mobilfunkanbieter der die vorhandenen Netzwerkdaten um sozio-demografische Merkmale anreichern wollte um so interessante örtlich-zeitlich aufgegliederte Marketing Insights zu gewinnen. Diesen Vortrag haben wir natürlich auch intern vorgestellt, erweitert um Diskussionen inwieweit die Internet-of-Things Architektur die damaligen Projektherausforderungen hätte beeinflussen können.”

Workshop: Shortcut Mania

“Es sind die sonderbaren Dinge, die uns in comSysto auf einem ganz besonderem Niveau zusammen schweißen. Z.B., dass wir uns 45 Minuten lang über die besten Tastenkombinationen in IntelliJ, Shell und Co. unterhalten können. Die Shortcut Mania Workshop Teilnehmer haben alle ihre Lieblingskombinationen wie kleine Sammlerstücke vorgezeigt und – wie es unter leidenschaftlichen Sammlern so zu geht – auch hitzig über die Überlegenheit des neuen IntelliJ Key Mappings gegenüber dem alten Key Mapping diskutiert. Am Ende waren alle Teilnehmer um einige Sammlerstücke reicher.”

Workshop_Shortcuts_2 Workshop_Shortcuts_1 Workshop_Shortcuts_3

 

Christian

Die cS ONE war eine ausgezeichnete Idee die hoffentlich in den kommenden Jahren eine Fortsetzung finden wird. Der Austausch mit Kollegen zu fachlichen Themen in einem lockeren Rahmen hilft enorm bei der Wissensverteilung im Unternehmen und kann nicht durch gemeinsame Events nach der Arbeit ersetzt werden – hier steht zu sehr der Freizeit-Aspekt im Vordergrund. Ich denke dieser Tag war der beste Beweis dafür, wie umfangreich das Know-How innerhalb von comSysto mittlerweile ist und wie viel wir voneinander lernen können.

Vortrag: Telefonica Deutschland, ein Projektbericht

“Telefonica Deutschland ist seit langer Zeit einer der größten Kunden von comSysto bei dem zahlreiche Mitarbeiter in verschiedenen Teams und Projekten arbeiten. Nicht zuletzt aufgrund der Fusion mit e-plus ergeben sich für die IT aktuell zahlreiche Herausforderungen auf technischer und organisatorischer Ebene. Neben dem regulären Tagesgeschäft müssen einerseits Teams skaliert, neue Rollen definiert und Entwicklungsprozesse jeden Tag hinterfragt werden. Gleichzeitig stehen wir auch vor zahlreichen Architektur-Entscheidungen mit weitreichenden Folgen, um die Software anschließend im laufenden Betrieb iterativ vom Ist- in den Ziel-Zustand zu überführen. Der Vortrag greift einzelne Ausschnitte aus diesem Themenkomplex auf.”

Projektbericht Telefonica Deutschland

 

 

 

 

 

 

Zusatzinfos: Den Talk hat Christian zusammen mit Jens, Alica und Otto vorbereitet und gehalten.

Vortrag: Sensor Labs

“In einer Serie aus mehreren internen Labs wurde das comSysto Office mit zahlreichen Tinkerforge Sensoren zur Überwachung von Temperatur, Lärmpegel, Bewegungen sowie Berührungen ausgestattet. Über einen Raspberry Pi wurden die Messdaten in einer MongoSoup-Instanz abgelegt. Beim Speichern von großen Datenmengen in MongoDB ist das verwendete Schema essentiell für Speicherverbrauch, die Mächtigkeit von möglichen Queries und die Übertragungszeit von deren Ergebnissen. Wir haben daher kontinuierliche und diskrete Sensordaten in untertschiedlichen Schemas gespeichert. Neben einem einfachen Web-Interface zur Sichtung der Daten wurde R für die Analyse an MongoDB angebunden. Wir haben die kontinuierlichen Daten in R als Zeitreihe eines ARIMA Modells analysiert, um Trends und sich wiederholende Muster zu erkennen. Das Modell eignet sich gut für die Analyse von Temperaturdaten, für die Analyse der Lautstärke erwies es sich als weniger geeignet.”

Sensor Lab

 

 

 

 

 

 

Zusatzinfos: Den Sensor Talk haben Christian, Lars und Julio zusammen vorbereitet. Im Lab dabei war auch Cindy und Mario. Zum Thema Labs kannst du mehr auf unserer Website lesen.

Zusatzinfos: MongoSoup ist der erste deutsche MongoDB-as-a-Service-Anbieter, entwickelt von comSysto und auch auf AWS Servern in Deutschland erhältlich.

 

Daniel

Ich finde, dass die erste cS One sehr gelungen war. Die Vortragsqualität durchwegs sehr gut und in den Workshops konnte man sich gegenseitig austauschen und voneinander lernen. Dank einem eigenen “Spielzimmer” und genügend Zeit für Pausen kam auch der Spaß nebenbei nicht zu kurz.

Vortrag: JVM Deep Dive Talk

“Was sind Safepoints, Tiered Compilation, Constant Table, Tenured oder Shenandoah? Jeder dieser Begriffe hat mit der Java Virtual Machine (JVM) zu tun. Als Java Programmierer nutzen wir täglich die JVM, machen uns aber selten bewusst wie sie funktioniert.

Dieser Vortrag bietet einen Blick hinter die Kulissen und stellt die wesentlichen Komponenten der JVM vor: Runtime, JIT Compiler und Garbage Collector. Neben dem Zusammenspiel der Komponenten, wird auch gezeigt wie man deren Verhalten analysieren kann. Damit hat man das Rüstzeug um das Laufzeitverhalten der eigenen Applikation besser zu verstehen, eigene Experimente durchzuführen und die Performance zu verbessern.”

Zusatzinfos: Daniel wird übrigens im März zwei Talks auf der Javaland halten:

Thema 1: JVM-Microbenchmarks mit dem Java Microbenchmarking Harness

Thema 2: Make or Break: The Big Impact of Small Changes in Performance

Die nächsten Talks mit Daniel in unserer Lightweight Java User Group München stehen ebenfalls fest. Im März und im Juni könnt ihr, wie wir auf der cS ONE Konferenz, gebannt Daniels Worten lauschen. Anmelden, und dabei sein!

Workshop: Modern Dev Tools

Lockere Vorstellung verschiedener moderner Tools, die bei uns im Einsatz sind (oder wir uns gern mal ansehen würden)wie z.B. Gradle für Builds.  Oder wie werden Java 8 Features eingesetzt? Wie wird Software gebaut und deployt? Packaging (Stichwort: Vagrant, Docker), Monitoring von Produktionssystemen, Logging, etc. etc.

Workshop_Modern_Dev_Tools_byDanielM

 

 

 

 

 

 

 

 

 

Franky

Volle Punktzahl! Unbedingt wiederholen und so weitermachen.

Vortrag: AngularJS in 45 Minuten

“Dieser Vortrag gibt einen kurzen Einstieg in AngularJS. Ausgehend von den Unterschieden zu herkömmlichen JavaScript-Frameworks (wie jQuery), werden die wichtigsten Teile eine “Single-Page-Application (SPA)” erläutert. Eine einfache Beispiel SPA wird auf Basis von AngularJS gebaut. Von einem Eingabefeld ohne Logik, wird ein digitales Bücherregal gebaut, welches Bücher über Ajax (REST) von einem Backend-System lädt. Am Ende habe ich einen Ausblick auf kommende Features von AngularJS 2.0 mit einer persönlichen Interpretation gegeben.”

Zusatzinfos: Franky bereitet zur Zeit einen AngularJS Workshop vor. Wer zeitnah informiert sein möchte, kann sich gerne für unseren Newsletter anmelden. In diesem werden wir über die nächsten Aktivitäten in punkto AngularJS berichten. Oder du schickst uns eine kurze E-Mail an marketing@comsysto.com und wir erfassen dich als Interessenten schon mal vorab in der Teilnehmerliste.

 

Florian

Hat Spaß gemacht, war interessant etwas zu lernen. Sinnvoll um auf diese Weise einen Raum zu schaffen, um Menschen zusammen zu bringen, die sich ansonsten nicht täglich sehen.

Vortrag: Agile im Kundenprojekt

“Zunächst habe ich eine Einführung zu unserem Kunden gegeben und über die Art, wie dieser Kunde Produkte baut, erzählt. Im Anschluss haben wir uns angeschaut wie sich basierend auf dem Taylorismus Organisationen im letzten Jahrhundert entwickelt haben, um Menschen und Teams zu führen. Diese Art der Steuerung hat in einem komplizierten Umfeld zu den nötigen Erfolgen geführt, jedoch hat sich gezeigt, dass in einem Umfeld komplexer Rahmenbedingungen diese Art der Steuerung versagt. Mit Beginn der Digitalen Revolution hat man die etablierten Steuerungstechniken versucht ebenso auf die Softwareentwicklung zu übertragen, was jedoch nicht funktioniert hat. Um den Stand eines Softwareentwicklungsprojektes festzustellen wird klassischerweise auf Content/Scope, Zeit, Kosten/Ressourcen und Qualität geschaut, was den etablierten Steuerungskonzepten entspricht. Ein neuer Ansatz, auf Projekte zu schauen, bietet 7 Perspektiven: Value, People, Functionality, Quality, Tools, Time, Process. Basierend auf diesen 7 Perspektiven haben wir uns in dem Talk die Arbeit von Team New York angesehen und diskutiert.”

 

Max

Die cS One Konferenz fand im letzten Jahr zum ersten Mal statt und kann sich wirklich sehen lassen. Es war sehr schön, einen Tag mit fast allen Mitarbeitern zu verbringen. Die Stimmung war toll, der Spirit war zu spüren. Besonders beeindruckt hat mich ich die Vielfältigkeit der Vorträge, die gute Aufbereitung der Themen. Leider hat mir die Zeit für die Topic-Tables ein bißchen gefehlt, was ich hoffentlich bei der cS Two nachholen kann.

Workshop: Gruppendynamik

“Viele von uns arbeiten im Berufsalltag in Teams und/oder haben täglich mit Gruppen von Menschen zu tun. In jeder Gruppe laufen bestimmte Prozesse ab und es bilden sich mit der Zeit bestimmte Strukturen aus. In diesem Workshop besteht die Möglichkeit mal abseits des sachlichen Inhalts, mit dem sich eine Gruppe beschäftigt, auf die darunterliegenen gruppendynamischen Merkmale einer Gruppe zu schauen. Aufbauend auf den formalen Merkmalen eines Gruppe wie der Zweck der Gruppe, die Mitglieder und einer gewissen zeitlichen Perspektive, wollen wir hier Themen betrachten wie Gruppenrollen, Normen in Gruppen und Modelle zur Beschreibung eines Phasenverlaufs. Diese Mechaniken beeinflussen die gute Zusammenarbeit und die Aufgabenbewältigung einer Gruppe erheblich. Das Wissen über diese Mechanismen kann das Analysieren und die Intervention in einem Team erleichtern.”

Vortrag: Stressmanagement

“Stress ist die Würze des Lebens”, so hat Hans Seyle die Bedeutung des Stresses für uns Menschen beschrieben. Wir alle empfinden Stress in gewissen Situationen, der eine mehr der andere weniger. Dieser Vortrag beschäftigt zum einen mit der Beschreibung was Stress für uns Menschen bedeutet, wie wir Stress erleben und welche Implikationen dies hat. Zum anderen sollen Strategien aufgezeigt werden, wie mit Stress umgegangen werden kann. Im ersten Teil wird beschrieben, was Stress auslösen kann (Stressoren), wie wir dann den Stress verarbeiten (persönliche Verstärker) und welche Reaktion daraus entsteht. Die Stressreaktion kann in körperlich, koginitiv, emotionale und behaviourale Aspekte aufgeteilt werden. Ausgehend vom Konzept der Salutogene werden personliche als auch institutionelle Strategien der zur Stressbewältigung und Prävention vorgestellt.”

 

Robert

Insgesamt fand ich die Konferenz sehr gelungen, sowohl von der Organisation, der Mischung der Vorträge und Workshops, sowie den Ideen mit den Monkeys. Ich würde mich sehr auf eine cs Two freuen ;-)

Workshop: Building a mobile webapp with famo.us

Famo.us ist ein Open Source JavaScript Frameworks zur Erstellung komplexer UIs für Web  Anwendungen. Die eigens von Famo.us entwickelte Rendering und Physics Engine soll dabei die Umsetzbarkeit von flüssigen Animationen im Browser gwährleisten, wie sie bislang nur native Apps  boten.  Ziel des Workshops war es den Teilnehmern Famo.us und dessen Konzepte vorzustellen. Dabei  wurden in einzelnen Kapiteln die „building blocks“ einer Famo.us Anwendung erläutert. Mit  JavaScript Live-Coding, ausgehend von einem einfachen Github Projekt, wurde erläutert wie eine  Famo.us App aufgebaut ist, wie unabhängige UI Elemente, sog. Views, erzeugt werden, die  untereinander mit Hilfe von Events kommunizieren. Über das Programmiermodell von Famo.us  konnten die Teilnehmer diese UI Elemente positionieren, transformieren und mit Animationen  versehen. Das Ergebnis war eine kleine, einfache Webanwendung, in der alle genannten Konzepte  exemplarisch umgesetzt wurden.

Zusatzinfos: Mit dem Monkey meint Robert unser Firmenmaskottchen, das omnipräsent ist bei comSysto. Ob als Wegweiser auf der cS ONE Konferenz, “besetzt”-Türschild, Namensgeber unseres internen Newsletters oder Plüschäffchen zum Mitnehmen. Auch “g´suffa!”-Sticker haben wir mittlerweile (ein Bild davon findet ihr in Selmas Blogpost).  Die sind mit dem Facebook-Like vergleichbar, sozusagen Sticker-gewordene, bavarisierte Kudos , die wir gerne und reichlich uns gegenseitig vergeben. Du willst auch einen “g´suffa!”-Sticker? Kein Problem. Drop us a line (marketing@comsysto.com) und wir schicken dir einen zu!

cS ONE Konferenz Lageplan

 

 

Firmenmaskottchen Monkey beim Chillen

 

 

 

 

 

 

 

 

 

…und ein Moodboard zu comSysto haben wir auch in einem Speed-Workshop erstellt:

Workshop_cS-Moodboard

 

 

 

 

 

 

 

Neben den Speakern habe ich noch ein paar Meinungen von Kollegen eingefangen:

Christina

Super coole Sache. Sollten wir wieder machen. Vielleicht voten wir für die Themen das nächste Mal, wie auf Barcamps. Die Unterlagen waren professionell und liebevoll gestaltet.

Stefan

Die Vorträge waren toll und das Alternativprogramm (Recreation Area) hat auch gepasst. :-)

Iris

Ich fand es schön, dass man die Gelegenheit hatte, neue Mitarbeiter kennen zu lernen, und man erfahren hat, wer was überhaupt macht bei comSysto. Ich fand es auch schön, dass meine Kollegen aus Kroatien da waren. Sonst spreche ich mit ihnen nur per Video.

Selma

Bei der cS One Konferenz hatten wir nicht nur die Gelegenheit unser Wissen mit anderen Mitarbeitern aus der Firma zu teilen. Wir hatten auch die Chance einander besser kennenzulernen. Da wir viel miteinander arbeiten, finde ich das dies sehr wichtig ist für Teambuilding. Außerdem finde ich es super, dass die Mitarbeiter bei den Talks sich die Themen selber aussuchen durften und Talks über Themen halten konnten die sie selbst sehr interessieren.

Summa summarum: Sehr interessante Themen und Workshops, informative Topic Tables und eine gut besuchte Spielwiese haben uns einen tollen Tag bereitet mit viel Input und noch mehr Spaß. Wir von comSysto können eine cS ONE Konferenz nur empfehlen.
Die cS ONE war zwar eine interne Veranstaltung, wir organisieren aber auch öffentliche Trainings, an denen auch du teilnehmen kannst. Einen Überblick über alle Trainings, die wir anbieten, findest du hier.

Brandaktuell und besonders möchte ich das nächste 2-Tages-Training zum Thema Continuous Delivery im April hervorheben. Interesse? Early Bird gilt noch bis Ende Februar.

DSC_0192

Introduction to comSysto´s cS ONE Conference

We were planning this amazing event for a couple month. On December 4th, 2014 it was finally time to start with the cS One Conference. This event was the first ever internal conference for comSysto, therefore everyone was enthusiastic and very excited about the outcome.

The Idea Behind It / Motivation

The introduction to the conference was made during breakfast by Daniel Bartl, one of the owners of comSysto.

Featured image      Featured image

As a proponent of the idea “New Work, New Culture”, we always try to find a way how to give our colleagues a chance to do something they deeply care about and love, to transfer knowledge to each other, to socialize with each other and be able to work in teams together.

The cS ONE Conference was all about knowledge transfer and team strengthening. comSysto employees had the chance to organize their own workshop or bring certain topic up for discussion in a group setting, which was conducted during working hours. The employees were very passionate about their workshops and group discussions and were looking forward to the conference. Everyone had the chance to sign up for the workshops and talks which, took place that day.

The Agenda

In order to start our day with lots of energy, we kicked it off with great breakfast which was very delicious and kept us going until lunch break thanks to lunchbox catering.

Featured image      Featured image

The talks as well as the workshops started both at 10 am. See below the timesheet for each talk and workshop.

Featured image      Featured imageThe topics of the talks were as follows:

  • JVM Deep Dive
  • Angular JS
  • Footfalls reloaded (Talk from Strata Barcelona)
  • Stress management & Burnout prevention
  • Agile at Emnos
  • DIY IOT Sensor Labs

The topics of the workshops were as follows:

  • How groups of people work
  • Shortcut Mania
  • comSysto moodboard
  • Modern Dev Tools
  • Building a mobile web app with famo.us
  • MOOC Mania

The topics of the tables were as follows:

  • comSysto Continuous Improvement Board
  • BIG PICTURE Guild
  • Wissenskombinat Guild
  • Marketing: Outlook for the 1st half year of 2015
  • Trainee @ comSysto + small workshop
  • Managing directors table
  • Introducing the new office team and their roles
  • GULP 2.0

The topic tables at comSysto were similar to a booth at an exhibition, and each topic table covered a different subject matter. Each colleague had the chance to drop by and inform themselves about the certain focus area. Many of the topics were work related. As most of the talks have lots of internal information about clients and projects, we can only show you two of the sessions (GULP 2.0 and JVM Deep Dive).

The guild tables were groups of employees that share knowledge, tools, codes about certain topics. In the BIG PICTURE Guild, employees explore data in small projects like Kaggle competitions, sensor data analysis, IOT, location tracking and anomaly detection. They basically try to get knowledge out of the data mainly by using machine learning methods. Wissenkombinat is the guild that has its focus on knowledge transfer and employee development. The aim of the Wissenkombinat is to improve the good “knowledge” (e.g. increasing efficiency, increasing communication between each other and transferring knowledge, etc.) and to find ways how to better learn from each other. If you want to read more about our guilds (there are several more) then please follow this link to our website.

Featured image        Featured imageFeatured image         Featured image

Each attendee had the chance to rate the talks, workshops and topic tables with our mascot sticker (see below).

IMG_2943

Work Hard, Play Hard

Featured image      Featured image

The chillout corner was very popular. comSysto employees had the chance to play playstation, which by the way belongs to teambuilding :).

What do you think about comSysto’s One Conference?

Does it encourage you to start your own internal conference?

You are so convinced by it and want to join our team? :)

Share your thoughts with me.

Teamgeist on Android Wear

Die ganze IT Welt spricht derzeit von Wearables. Also wollte ich mir in einem Lab die Android Wear API genauer anschauen. Schnell war auch schon der erste Anwendungsfall gefunden. In unserer Teamgeist App gibt es seit kurzem die Möglichkeit Kudos zu verteilen.

Kudos

Auf einer Android Wear Uhr würden sich die Kudos prima darstellen lassen. Dazu gäbe es zwei Aktionen. Einmal für einen Kudo “voten”. Die andere wäre die Teamgeist App öffnen.

Für eine Integration mit der Teamgeist App bräuchten wir eine neue Schnittstelle. Zum kennen lernen der Android Wear Api begnügen wir uns deswegen im folgenden mit einer Android App die Kudos erstellt und verschickt.

Nach kurzer Recherche wurde klar, dass für den Anwendungsfall gar keine eigene Android Wear App notwendig ist. Es reicht eine normale Android App die mittels der Notifications API Nachrichten direkt an die Uhr versendet. Anwendungen eigens für Android Wear geschrieben, werden in einem späteren Tutorial näher beleuchtet.

Vorbereitung

Ein paar Dinge die wir benötigen bevor wir loslegen können:

  • Intellij (14) als IDE
  • Android SDK mit installierten API Packages für Level 19 (4.4.2), 20 (4.4W) und Android Support Library V4 (20)

Android SDK

  • Aus Mangel einer echten Android Wear starten wir eine aus dem AVD Manager heraus

AVD Wear

Für das Koppeln mit einem Handy benötigen wir auf dem Handy die Android Wear App aus dem Play Store. Das koppeln von der emulierten Wear und einem per USB angeschlossen Handy funktioniert erst dann wenn folgender Befehl auf Kommandozeile eingegebenen wurde (im Tools Verzeichnis vom android-sdk):

~/development/android-sdk-mac_86/platform-tools$ adb -d forward tcp:5601 tcp:5601

Erst wenn der Befehl ohne Fehler ausgeführt wurde, lässt sich aus der Android Wear App im Handy die emulierte Uhr mit dem Handy verbinden. Wird das Handy vom Rechner getrennt und neu angeschlossen, muss der Befehl erneut ausgeführt werden. Eine genau Beschreibung gibt es von Google oder hier.

Neue Android App erstellen

Nachdem wir den Emulator mit dem Handy erfolgreich gekoppelt haben, erscheinen auch schon die ersten Notifications auf der Uhr wie z.B. der Eingang neuer Mails.

Damit wir nun selbst Notifications versenden können erstellen wir InteliJ ein neues Projekt. Im ersten Bildschirm wählen wir links Android und rechts das Gradle: Android Module aus. Auf der darauffolgenden Seite müssen wir ein paar Einstellungen wie z.b. die Version des Target SDK vornehmen.

Target SDK

Anmerkung: Wir hätten hier auch 4.3 wählen können da die Android Wear App ab Android 4.3 unterstützt wird.

Auf den nächsten Seiten belassen wir die Einstellung wie sie sind und wählen auf dem letzten Bildschirm nur noch den Ordner für unser Projekt aus.

Cleanup des generierten Projektes

In unserer Teamgeist App benötigen wir natürlich als erstes unseren Teamgeist und fügen diesen zu den drawables hinzu :)

teamgeist_logo

 

In der activity_main.xml löschen wir die TextView und erstellen statt dessen einen Button.

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Sende Kudos"
    android:id="@+id/kudo_button" android:layout_centerVertical="true" android:layout_centerHorizontal="true"/>

Um mit den Button in Java zu arbeiten holen wir uns eine Referenz darauf in der MainActivity#onCreate() Methode und setzen auch gleich einen OnClickListener.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    Button kudoButton = (Button)findViewById(R.id.kudo_button);
    kudoButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
          //hierher kommt unser Notification Code
        }
    });
}

Wenn wir jetzt unsere App starten, sollte sich auf dem Handy die App öffnen mit einem Button “Sende Kudos” auf weißem Hintergrund.

Senden einer ersten Notification

Um eine erste Notification zu senden müssen wir noch die V4 Support Library zu unserem Projekt hinzufügen. Hierzu fügen wir der dependency Section unserer build.gradle Datei eine Zeile hinzu.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile "com.android.support:support-v4:20.0.+"
}

Beim ersten mal hinzufügen der V4 Support Library zu einem Projekt erkennt IntelliJ dies und erstellt durch nachfragen ein eigenes Repository hierfür.

Nun können wir auf die Notification API in der onClick Methode des vorher erstellten OnClickListeners zugreifen und fügen folgenden Code hinzu.

@Override
public void onClick(View view) {
  //1. Erstellen eines NotificationCompat.Builder mit Hilfe des Builder Patterns
  Notification notification =
    new NotificationCompat.Builder(MainActivity.this)
      .setSmallIcon(R.drawable.teamgeist_logo)
      .setContentTitle("Notifications?")
      .setContentText("Congratulations, you have sent your first notification")
      .build();

  //2. Wir benötigen einen NotificationManager
  NotificationManagerCompat notificationManager =
    NotificationManagerCompat.from(MainActivity.this);

  //3. Versenden der Notification mittels NotificationManager und NotificationBuilder
  int notificationId = 1;
  notificationManager.notify(notificationId, notification);

}
  1. Als erstes wird mit Hilfe des NotificationCompat.Builder und dem Builder Pattern eine Notification erstellt. Hier setzen wir zu Beginn einen Titel, einen Text und ein Bild.
  2. Dann benötigen wir zum versenden einen NotificationManager. Den erhalten wir mit dem Aufruf der from() Methode von der Klasse NotificationManagerCompat.
  3. Danach sind wir bereit die Notification über die notify Methode des NotificationManagers zu verschicken. Die notificationId dient hierbei zur Unterscheidung von verschiedenen Notifications einer App.

Wenn wir die App jetzt deployen, starten und auf “Kudo senden” drücken kriegen wir unsere erste eigene Notification auf der Uhr.

simple_notification

Hintergrundbild

Anhand des App Icons ermittelt Android eine ähnliche Hintergrundfarbe. Ein eigenes Bild sieht jedoch viel besser aus. Wir erreichen dies in dem wir beim Builder zusätzlich setLargeIcon aufrufen.

new NotificationCompat.Builder(MainActivity.this)
 .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.teamgeist_logo))
 .setSmallIcon(R.drawable.teamgeist_logo)
 .setContentTitle("Notifications?")
 .setContentText("Congratulations, you have sent your first notification")
 .build();

Damit kriegt die Notification auf der Uhr den Geist auch als Hintergrund.

simple_notification_with_background

Benutzerinteraktion

Wir können der Notification verschiedene Benutzerinteraktionen hinzufügen. Mit einem PendingIndent wird beispielsweise eine bestimmte Activity in unserer App aufgerufen und ihr mittels “Extras” Daten übergeben. Den PendingIndent erstellen wir in einer eigenen Methode.

private PendingIntent createContentIntent() {
    Intent viewIntent = new Intent(MainActivity.this, MainActivity.class);
    viewIntent.putExtra("EventNotified", "1");
    PendingIntent viewPendingIntent =
          PendingIntent.getActivity(MainActivity.this, 0, viewIntent, 0);
    return viewPendingIntent;
}

Diesen Indent übergeben wir dem Builder durch Aufruf von setContentIntent.

new NotificationCompat.Builder(MainActivity.this)
 .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.teamgeist_logo))
 .setSmallIcon(R.drawable.teamgeist_logo)
 .setContentTitle("Notifications?")
 .setContentText("Congratulations, you have sent your first notification")
 .setContentIntent(createContentIntent())
 .build();

Durch nach links Wischen der Notification erscheint unsere neue Aktion.

PendingIntent

Klicken wir nun auf “Open on phone” öffnet sich die hinterlegte Activity im Handy, also in unserem Fall die MainActivity. Leider bleibt bisher die Notification auf der Uhr bestehen. Um sie dort zu entfernen, müssen wir abfragen ob die App durch die User Interaktion gestartet wurde und deaktivieren in diesem Falle die Notification. Dazu erstellen wir uns die Methode cancelNotificationOnUserInteraction Methode und rufen sie in der MainActivity#onCreate Methode auf.

private void cancelNotificationOnUserInteraction() {
    Intent intent = getIntent();
    Bundle extras = intent.getExtras();
    if (extras != null && "1".equals(extras.getString("EventNotified"))) {
        NotificationManagerCompat.from(this).cancel(1);
    }
}

Neben dieser Standard Aktion können wir weitere “Actions” hinzufügen. Dazu erstellen wir uns ein Action Objekt mit folgender Methode,

private NotificationCompat.Action showInBrowser() {
    Intent browserIntent = new Intent(Intent.ACTION_VIEW);
    Uri geoUri = Uri.parse("http://app.teamgeist.io");
    browserIntent.setData(geoUri);
    PendingIntent browserPendingIntent =
            PendingIntent.getActivity(this, 0, browserIntent, 0);

    return new NotificationCompat.Action(
            android.R.drawable.ic_dialog_map, "Open in Browser", browserPendingIntent);
}

und übergeben das Objekt an den Builder mittels der addAction Methode.

new NotificationCompat.Builder(MainActivity.this)
 .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.teamgeist_logo))
 .setSmallIcon(R.drawable.teamgeist_logo)
 .setContentTitle("Notifications?")
 .setContentText("Congratulations, you have sent your first notification")
 .setContentIntent(createContentIntent())
 .addAction(showInBrowser())
 .build();

Wir können die Notification jetzt zweimal nach links schieben und kriegen dann eine weitere Aktion zur Auswahl. Beim klicken auf “Open in Browser” öffnet sich nun unsere Teamgeist Webseite auf dem Handy.

OpenInBrowserAction

Mit Hilfe so einer Action würden wir die Voting Funktion realisieren. Die App auf dem Handy müsste dann dem Teamgeist Server den vote übermitteln.

Was gibt es noch?

Damit sind wir am Ende unseres ersten Android Wear Labs angekommen. Neben diesen Aktionen gibt es noch besondere Wear Notification Features. Da wäre zum einen die Möglichkeit die Notification um mehr als eine “Page” zu erweitern. Oder Notifications zu gruppieren. Jedoch das wahrscheinlich bekannteste Feature ist die Möglichkeit auf eine Notification mittels Sprache zu antworten.

All dies sind potentielle Themen für unser nächstes Android Lab. Und natürlich möchten wir die App mit unserem Teamgeist Server verbinden um echte Kudos zu erhalten und für sie “voten” ;-).