Microbenchmarking auf der Java Virtual Machine

Unser Kollege Daniel Mitterdorfer (@dmitterd) hat für Heise Developer einen Artikel geschrieben, in dem er sich mit Microbenchmarking für die JVM beschäftigt. Mit Microbenchmarks kann man die Performance verschiedener Implementierungen einer Software-Komponente vergleichen, beispielsweise Serialisierungsalgorithmen oder JSON-Parser.

Microbenchmarks für die Java Virtual Machine selbst zu implementieren, ist aus mehreren Gründen eine schwierige Aufgabe. Beispielsweise beeinflussen ungenaue Zeitmessungen, eine hohe Grundsystemlast und das Zusammenspiel von Laufzeitumgebung und JIT-Compiler die Ergebnisse. In seinem Artikel diskutiert Daniel diese Probleme und stellt den Java Microbenchmarking Harness vor, der das Erstellen von Microbenchmarks auf der JVM wesentlich vereinfacht.

Den ausführlichen Artikel gibt es bei Heise Developer zu lesen.

dtcamp #14 in Munich – A Review

When we found out that dtcamp #14 was planned to take place in Munich,  comSysto’s design enthusiasts could not resist to support the camp. Dtcamp is a bar camp, targeting design thinking, UX Design, and other related topics. A bar camp is an open conference, organized by and for its participants. So each morning planned or spontaneous sessions were presented, voted on, and scheduled for the day. Since attending a bar camp is free for all attendants, a camp needs sponsors. So we took the opportunity to sponsor the camp because design thinking is an awesome method to shape the world of tomorrow.

On the first day, Dr. Stephan Raimer held the introduction session and opened up with explaining the basics of bar camps. The sponsors had the possibility to present themselves. We decided to present one of our upcoming products: Teamgeist.io.  With Teamgeist.io we want to change the way teams interact with each other. We strongly believe that working in teams will be very different in the future. We already experience a trend towards agile and highly distributed teams which work in a self-organized way. Traditional team management software often does not fit into this context. That’s why we build Teamgeist.io, to support teams to take on the challenge of collaboration, planning, and communication.

IMG_20140321_131533

Afterwards the sessions for the day were presented. Over both days the participants offered great sessions with very different contexts. The sessions that caught our interest most were:

‘Scrum + Rapid Prototyping = Erlebtes Scrum – Wie Du Scrum mit Hilfe einer echten Produktidee erlernst’
Knowing a method like scrum is good, being able to work with it is even better. Martin Geck explained how he uses the FabLab environment to teach Scrum with a hands on hardware project. Experiencing Scrum with a sample project definitively eases the learning process -and could it be any better if you are allowed to use cool 3D printing technology?

‘New Management – Führen mit Design Thinking’
Based on Angela Haas‘s experience of Design Thinking in management with her company ‘partake’, we discussed important points of good leadership and possible methods to achieve them. Especially, her initial ice breaker was great fun (more can be found with the Warm-up Shuffle App).

‘Improvisationstheater, Innovation und Design Thinking’
One of the most active sessions we visited was Dr. Christian Lang‘s impro session. The participants experienced basic improvisation games and learned how those exercises can foster brainstorming sessions, innovation and Design Thinking.

‘Visual Prototyping Toolkit: Wieso? Weshalb? Warum?’
In this session Harriet Kasper and Anne Elisabeth Krüger from Frauenhofer kreativ presented their visual prototyping toolkit. We developed new ways of talent search hands on via social media and visualized them using the toolkit. The enormous outcome was presented afterwards and together we discussed further improvements of the kit.

Apart from participating in sessions we also offered three sessions ourselves. All sessions derived directly from our day to day work experiences and focussed on sharing our discoveries and best practices with the participants.

Session 1 – How to do UX research with a limited budget
UX research is a topic that is often discussed. Most people see value in it and yet in many cases the advantages of UX research are not used because there are underlying fears of costs and time investments.

dtcamp14_freitag_018

With this session we wanted to give advice to those who are interested in applying UX research methods in upcoming projects by answering basic questions on how to prepare a usability test, how to recruit participants, and on how to evaluate the test session to gain insights. This topic has been near and dear to our hearts for a while and we provided a talk about this topic in fall 2013 at w-jax13. If you’re interested in that topic, we have a video recording of a similar talk held at Java Lightweight User Group Munich on our YouTube channel.

Session 2 – Hands on UX research. How to write a usability test script?
On day two we held a very practical session on how to write a usability test script. The main focus was on how convert assumptions into tasks and how to write the corresponding text for the test script. We used Teamgeist.io as an example and the session participants came up with good task examples. At the session’s end we showed a short clip from previous usability tests to demonstrate what kind of insights can be gained from usability testing.

Session 3 – Instant Paper Prototyping Game
Normally, paper prototypes are first designed and then tested with users. In this session, we tried to design paper prototypes instantly driven by the user’s expectations. Therefore, the participants grouped in pairs with one person acting as ‘User’ and one as ‘Instant UI Designer’. After each interaction, the user was asked what they were expecting to happen and the next frame was drawn based on the answer.

BjVZTLQIMAAu2i0.jpg:large

At the end, all pairs presented their evolved prototypes and all participants voted for the best solutions. Finally, the best three teams received prizes and we discussed pros and cons of the method as well as possible fields of use.

13360367214_97bbe8212d_b

To sum it up the dtcamp #14 was great fun, an awesome place to meet interesting people, and to broaden one’s view on design thinking and User Experience. We like to thank Dr. Stephan Raimer from oose Innovative Informatik for organizing the camp and Joscha Lautner, Johann Schorr, and Caspar Siebel from Impact Hub Munich for providing a very inspiring location.

If you want to learn more about our experiences and what comSysto can offer to you and your company in terms of UX, please contact Elisabeth.Engel@comsysto.com or Christina.Eckleder@comsysto.com!

Does Datameer support a full Big Data analysis process?

Over the last days I had the chance to test Datameer Analytics Solution (DAS). DAS is a platform for Hadoop which includes data source integration, an analytics engine and visualisation functionality. datameer_lifecycleThis promise of a fully integrated Big Data analysis process motivated me to test the product.

It really includes all required functionality for data management or ETL, it provides standard tools to analyse data and there are nice ways to build visualisation dashboards. For example, there are connectors for Twitter, IMAP, HDFS, or FTP available. All menus and processes are self-explaining and the complete interface is strongly Excel or spreadsheet oriented. If you are familiar with Excel you can do the analyses on your Big Data out of the box. For a fast on the fly analyses performance you only work with a subset of your data and the analyses you store will then be automatically transformed into a kind of procedure. In the end – or according to a schedule you set – you “run” the analyses on your Big Data: DAS collects the latest data for you, DAS creates MapReduce jobs in the background and updates all your spreadsheets and visualisations. To close the analyses circle you can use the connectors to write your results back to HDFS or a database as HBase or many more technologies.

DAS is really designed for Big Data. If you test it with small data you will be frustrated by the performance – the overhead of creating MapReduce jobs dominates in this situation. But as soon as you start with real Big Data analyses this overhead gets negligible and DAS is taking over a lot of your programming work.

My test infrastructure
The following figure provides a nice overview of the Datameer infrastructure. DAS supports many data sources, it runs on all Hadoop distributions, it provides a REST API and you can add plugins as connectors for other modelling languages such as R (#rstats).

I tested DAS Version 3.1.2 running on our MapR Hadoop cluster version 3.0.2. After getting the latest package version from the Datameer support the installation was straightforward and it worked out of the box. Thanks to Datameer for providing a full test license. There are several online tutorials and videos available and there are some tutorial apps. Apps are another great feature of Datameer. You can download Datameer Apps which include connectors, workbooks and visualisations for different analysis examples. And you can create your own app from your analyses and share them with your colleagues or the community.

My test data and analyses
I tested DAS with the famous “Airline on-time performance” data set consisting of flight arrival and departure details for all commercial flights within the USA, from October 1987 to April 2008. I downloaded all the data (including supplements) to maprfs, created connectors for the data and imported the data into a workbook.

datameer_browser

In the workbook I tested many classical statistical counting analyses:

  • grouping functionality for the airports and counting the number of flights
  • grouping for the airlines and calculating different statistics as mean values for the air time
  • using joins to add additional information like the airline name to the airline identifier
  • doing sorts to extract the most interesting airports depending on different measures

I am not an Excel expert. So it took me some time to get used to this low level process of doing analyses on spreadsheets. But in the end it is a very intuitive process of creating analyses.

Every new analysis will be available in a new tab in your workbook. There are several nice functionalities to support your work. For example there is a “sheet dependencies” overview which provides information about the dependencies between sheets.
datammer_workbook

Apart from the classical analyses, DAS provides some data mining functionality. It is called “Smart Analystics”. So far, it covers k-means clustering, decision trees, column dependencies and recommendations. It works out of the box but is not yet on the level to be satisfying for real analyses. E.g. for k-means clustering there is no support for choosing the right number of clusters (k) and you can not switch between different distance functions (default is euclidean distance).

Finally, I visualised all my results in a nice “Infographic”. There are many different visualisation tools and parameters available. After playing around with the settings you can create a nice dashboard and share it with your colleagues.

datameer_infographic

Please be aware that the complete data set is about 5 GB. Importing the data set takes about 30 minutes and running the workbook took more than 3h in my case. In the end I split my analyses into several workbooks to improve the feasibility.

Summary
It was easy to get started with Datameer Analytics Solution (DAS). It is definitely a great tool to do Big Data Analyses without any detailed Hadoop or Big Data knowledge. Furthermore, it covers many use cases and provides all required functionality for your daily analysis process. However, as soon as your analyses get more complex, the limitations of Datameer become apparent and you will probably  look for a more powerful tool set or start implementing your Big Data analyses directly on Hadoop.

Finally, Datameer supports many steps in the Big Data Analysis Process, it works efficiently and the usability is straight forward. But Big Data is more than ETL, data analysis and visualising the results. You should never forget to think about your use case and the business value that you want to extract from your data. In the end, this is what should guide you in choosing the tools and/or implementations to use.

If you would like to know more about how Big Data analysis can help your business, feel free to contact us!

Skillmazing – Visualize your Skill Profile

This week our new platform Skillmazing starts into public beta. During the last four months we developed a new way of managing skills and visualizing skill profiles.

Until last year, we only managed them in a table format. This was a good start, but implied a lot of problems. Especially, as the table rapidly grew in size, it was hard to retrieve information instantly. Therefore, we developed a new application called Skillmazing. The tool especially focuses on personal development and supports users in improving their skills. Since we think that the application can not only benfit our company, but everybody who is interested in developing their skills, we would like to share it with you.

What Skillmazing offers:

  • See what skills you have and what you would like to improve
  • Search for material and stuff you can do to improve your skills
  • Get your skills, goals and progress visualized
  • Save your visualizations as .svg or .png file
  • Search for like-minded people to improve your skills together
  • Share your profile on social plattforms or via email

As default, all your data is invisible for other users. So create your profile and make it visible for others to present your skills and attract like-minded people!

Start Now

Choose from nine different visualizations and create personal profile visualizations like this:

Skill Visualization Sunburst

Skill Visualization Village Chart

Skill Visualization Bar Chart Horizontal

Skill Visualization Badges

Skill Visualization House Chart

Skill Visualization Bar Chart Vertical

Skill Visualization Timeline

Skill Visualization Puzzle

To see more, visit my skill profile here.

As Skillmazing started into public beta this week, we are looking forward to your feedback! Enjoy!

Erste Adresse für Big Data in der Cloud

Wir freuen uns mitzuteilen, dass comSysto seit Kurzem Advanced Consulting Partner im Amazon Web Services Partner Network (APN) ist.

comSysto wurde bereits Mitte 2013 als Beratungspartner in das  APN aufgenommen. Seitdem arbeiten wir erfolgreich mit AWS zusammen, etwa für MongoSoup, unserer Cloud-basierten MongoDB-as-a-Service Lösung.

Mit der Qualifikation als Advanced Consulting Partner festigt comSysto seine Stellung als Anlaufstelle für Kunden,  die Unterstützung beim Entwerfen, Gestalten, Migrieren und Implementieren neuer Cloud-Anwendungen mit  AWS suchen.

AWS hat comSysto mit Big Data Competency ausgezeichnet.  Dieses Prädikat bekommen AWS – Partner, deren Berater, Analysten und Entwickler die Werkzeuge und Technologien beherrschen, um ihren Kunden bei der Verarbeitung und Analyse großer Datenmengen zu helfen. comSysto hat Erfolge beim Kunden und technische Expertise im Kompetenzbereich Big Data bewiesen.

Weltweit können nur zehn AWS Advanced Consulting Partner Big Data Competency für sich beanspruchen – in Deutschland ist comSysto der einzige AWS-Partner.

Als Advanced Consulting Partner hat comSysto Zugriff auf AWS-Ressourcen und Trainings. Außerdem verfügen wir über AWS-geschulte Certified Solutions Architects und bieten unseren Kunden vollen AWS Business Level – Support. Damit wird comSysto zu einem führenden Anbieter für Cloud-basierte Big Data – Anwendungen in Deutschland.

Wenn Sie mehr über unsere Philosophie, Expertise und über die Lösungen erfahren möchten, die comSysto für ihre Big Data Herausforderungen bieten kann, besuchen Sie unsere Homepage oder kontaktieren Sie uns per Mail!

New Wicket Release: comSysto’s User Guide added

The recent release 6.13.0 of the Java web application framework Wicket brings along good news for comSysto:

An updated version of the  Wicket User Guide that comSysto’s Andrea del Bene and a team of our colleagues wrote has been added to the Wicket project’s accompanying Wicket’s new release 6.13.0.

As the Apache projects’ announcement puts it, „After many years of people asking for a reference guide for Apache Wicket we finally were able to add one to our site thanks to Andrea del Bene and comSysto for writing the guide and providing the hours of converting it to our site.“

The User Guide provides comprehensive documentation covering all the way from the framework’s basic structure and concepts to advanced topics such as complex forms, security, AJAX, or Spring integration. Its aimed at beginners as well as more experienced Wicket users.

Being users of the framework, ourselves, we’ve frequently blogged about Wicket before (see this, this, and this post)

Please give us feedback on whether you enjoy  the guide and if it’s helpful to you!

Ein Hands-On Rundgang durch Neo4j 2.0

Letzte Woche hat unser Partner Neo Technologies offiziell den neuen Release 2.0 der Graphdatenbank Neo4j herausgebracht. Auch bei comSysto setzen wir Neo4j ein und veranstalten regelmäßig Trainings. Das nächste Neo4j Training wird am 25. März stattfinden. Hier geht’s zur Anmeldung.

Wir nehmen den Release von Neo4j 2.0 zum Anlass, uns die neuen Features einmal genauer anzusehen.

Labels

Die wichtigste Neuerung bei Neo4j 2.0, von der man schon im Vorfeld viel hören konnte, sind Labels. Doch was bringen sie eigentlich? Im Prinzip ist ein Label nur eine spezielle Form von Property. Allerdings bringt Neo4j 2.0 darauf aufbauend eine Reihe weiterer Features mit, auf die ich im Folgenden genauer eingehen werde.

Die Cineasts Datenbank

Viele Leser werden die Cineasts-Datenbank von Neo4j kennen. Für alle anderen hier eine Skizze des für uns relevanten Schemas:

Beispieldaten Cineasts-DB

Beispieldaten Cineasts-DB

Im “Schema” gibt es Filme, die eingehende Relationen vom Typ DIRECTED und ACTS_IN haben. Alle Knoten, die mindestens eine ausgehende ACTS_IN Relation besitzen, sind Schauspieler. Die Knoten, die eine ausgehende DIRECTED Relation haben, sind Regisseure. Natürlich gibt es auch Schauspieler, die auch Regie geführt haben. Es gibt noch weitere Relationen und Knotentypen, auf die wir hier aber nicht weiter eingehen wollen.

Ihr findet das Schema zum Download bei Neo4j. Nach dem Download entpackt ihr das Zip-File, benennt den Ordner in cineasts.db um und verschiebt ihn in das Verzeichnis data der Neo4j-Installation:

$ mv cineasts_12k_movies_50k_actors <your_location_of_neo4j-2.0>/data/cineasts.db

Anschließend muss der Pfad zur Cineasts-Datenbank unter conf/neo4j-server.properties konfiguriert werden:

...
# location of the database directory
org.neo4j.server.database.location=data/cineasts.db
...

Da es sich um eine mit Neo4j 1.9 erzeugete Datenbank handelt, muss die Option allow_store_upgrade in conf/neo4j.properties aktiviert werden:

...
# Enable this to be able to upgrade a store from an older version
allow_store_upgrade=true
...

Damit sind wir bereit, den Server zu starten:

$ ./bin/neo4j start

Unter http://localhost:7474 findet sich bereits die erste Neuerung – das neue WebInterface:

Das Neo4j 2.0 WebInterface

Das Neo4j 2.0 WebInterface

Da wir uns später den Execution-Plan der Queries anschauen wollen, steigen wir gleich auf die Neo4j-Shell um. Diese könnt ihr mit ./bin/neo4j-shell starten.

Legen wir also richtig los und schauen uns zuerst einmal an, wie viele Schauspieler wir im Datenbestand haben:

$ START a=node(*)
MATCH (a)-[:ACTS_IN]->()
RETURN count(distinct(a));

+----------+
| count(a) |
+----------+
| 44943 |
+----------+
1 row
569 ms

Mit Version 2.0 gibt es auch einige Änderungen bei der Syntax der Abfragesprache Cypher. Eine davon ist, dass die START-Clause jetzt optional ist. Lassen wir sie also einfach weg:

$ MATCH (a)-[:ACTS_IN]->()
RETURN count(distinct(a));

+----------+
| count(a) |
+----------+
| 44943 |
+----------+
1 row
547 ms

Labels erzeugen und Verwenden

Wie eingangs erwähnt, erkennen wir alle Schauspieler daran, dass sie in einem Film mitgespielt haben und somit über eine ausgehende ACTS_IN Relation verfügen. Die neue Möglichkeit, einen „Knotentypen“ explizit festzulegen, sind Labels. Also versehen wir einfach alle Schauspieler-Knoten mit einem Label „Actor“:

$ MATCH (a)-[:ACTS_IN]->()
SET a:Actor;

+-------------------+
| No data returned. |
+-------------------+
Labels added: 44943
2328 ms

Um nun die Anzahl aller Schauspieler herauszufinden, können wir das Label benutzen:

$ MATCH (a:Actor)
RETURN count(a);

+----------+
| count(a) |
+----------+
| 44943    |
+----------+
1 row
71 ms

Dabei fällt auf, dass die Query dieses mal fast um den Faktor 10 schneller ist als zuvor. Um herauszufinden, woran das liegt, führen wir beide Queries mit dem Keyword PROFILE aus:

$ PROFILE START a=node(*)
MATCH (a)-[:ACTS_IN]->()
RETURN count(distinct(a));

ColumnFilter(symKeys=[" INTERNAL_AGGREGATE6732c803-0b1c-4a8d-b287-3b29e9b9a8bb"], returnItemNames=["count(a)"], _rows=1, _db_hits=0)
EagerAggregation(keys=[], aggregates=["( INTERNAL_AGGREGATE6732c803-0b1c-4a8d-b287-3b29e9b9a8bb,Count(a))"], _rows=1, _db_hits=0)
TraversalMatcher(trail="(a)-[ UNNAMED25:ACTS_IN WHERE true AND true]->( UNNAMED39)", _rows=94700, _db_hits=157745)
$ PROFILE MATCH (a:Actor)
RETURN count(a);

ColumnFilter(symKeys=[" INTERNAL_AGGREGATEba355d13-8e00-4da5-9ff9-2740146abe62"], returnItemNames=["count(a)"], _rows=1, _db_hits=0)
EagerAggregation(keys=[], aggregates=["( INTERNAL_AGGREGATEba355d13-8e00-4da5-9ff9-2740146abe62,Count(a))"], _rows=1, _db_hits=0)
NodeByLabel(label="Actor", identifier="a", _rows=44943, _db_hits=0)

Wie man an der Anzahl an Datenbankzugriffen (den _db_hits) ablesen kann, wurde für das Ergebnis der zweiten Query kein Datenbankzugriff gebraucht. Die Anzahl der Knoten wurde mit Hilfe eines Index’ bestimmt, der alle Knoten mit einem Label indiziert. Natürlich war das auch vor Version 2.0 möglich, jedoch musste ein solcher Index programmatisch erzeugt werden. Jetzt genügt eine einfache Cypher-Query.

Legen wir nun zwei weitere Labels für Filme (“Movie”) und Regisseure (“Director”) an, dann sehen unsere Daten jetzt so aus:

Beispieldaten Cineasts-DB mit Labels

Beispieldaten Cineasts-DB mit Labels

Labels und Indexe

Eine weitere interessante Neuerung hatten wir eben schon kurz angerissen: Indexe, oder genauer gesagt: das Erzeugen von Indexen. Vor Version 2.0 konnte man Indexe programmatisch oder per REST-API anlegen oder den Auto-Index verwenden. Nun können Indexe einfach mit Cypher-Statements für bestimmte Labels erzeugt werden, also ohne den eigentlichen Programmcode anzufassen.

Das wollen wir auch gleich an einem einfachen Beispiel probieren. Wir suchen den Schauspieler mit dem Namen “Mel Gibson” und schauen uns mit PROFILE den Execution-Plan der Anfrage an. Die Cypher-Query sieht wie folgt aus:

$ PROFILE MATCH (a:Actor{name:"Mel Gibson"}) RETURN a.name;

+--------------+
| a.name       |
+--------------+
| "Mel Gibson" |
+--------------+
1 row
93 ms

ColumnFilter(symKeys=["a", "a.name"], returnItemNames=["a.name"], _rows=1, _db_hits=0)
Extract(symKeys=["a"], exprKeys=["a.name"], _rows=1, _db_hits=1)
Filter(pred="Property(a,name(5)) == Literal(Mel Gibson)", _rows=1, _db_hits=44943)
NodeByLabel(label="Actor", identifier="a", _rows=44943, _db_hits=0)

Man kann am Execution-Plan ablesen, dass alle Nodes mit dem Label “Actor” aus dem Index gelesen werden. Neo4j iteriert über alle 44943 Knoten und liefert diejenigen zurück, welche eine Property “name” mit dem Wert “Mel Gibson” besitzen.
Wir erstellen nun einen Index auf der Property “name” für Knoten mit dem Label “Actor”:

$ CREATE INDEX ON :Actor(name)

+-------------------+
| No data returned. |
+-------------------+
Indexes added: 1
7 ms

Anschließend führen wir dieselbe Query noch einmal aus und schauen uns den Execution-Plan an:

$ PROFILE MATCH (a:Actor{name:"Mel Gibson"}) RETURN a.name;

+--------------+
| a.name       |
+--------------+
| "Mel Gibson" |
+--------------+
1 row
15 ms

ColumnFilter(symKeys=["a", "a.name"], returnItemNames=["a.name"], _rows=1, _db_hits=0)
Extract(symKeys=["a"], exprKeys=["a.name"], _rows=1, _db_hits=1)
SchemaIndex(identifier="a", _db_hits=0, _rows=1, label="Actor", query="Literal(Mel Gibson)", property="name")

Man kann sehen, dass sich der Execution-Plan geändert hat: Bei “Actor”-Knoten wurde automatisch der neue Index für die “name”-Property verwendet, ohne dass sich die Query geändert hat. Es wurde in der gesamten Ausführung genau ein Knoten angefasst, da der Index einen Verweis auf den richtigen Knoten zurückgibt und von dort lediglich “name” ausgelesen werden muss. Die Ausführungszeit der Query hat sich von 93ms auf 15ms reduziert.

Hier sieht man die interessanten Features, die nun durch Labels möglich sind. Neo4j und Cypher machen damit relationalen Datenbanken und SQL echte Konkurrenz.

Es ist außerdem möglich, Constraints auf Basis von Labels zu definieren. Aktuell gibt es jedoch ausschließlich Unique-Constraints. Man muss bei allen Labels, Indexen und Constraints natürlich bedenken, dass man dadurch ein Schema definiert, wobei diese Art Schema sicher nicht so starr ist wie das Schema einer relationalen Datenbank.

Transactions als REST-Ressource

Das letzte neue Feature ,das wir uns noch betrachten wollen, sind REST-Transaktionen. Mit Neo4j 2.0 sind Transaktionen Ressourcen, die wenn nötig über HTTP an den Aufrufenden geschickt werden. Zum Testen der REST-Schnittstelle eignet sich das WebInterface hervorragend. Dazu startet man den Befehl mit einem Doppelpunkt und dem Namen der gewünschten HTTP-Methode, gefolgt von einer relativen URL und einem Request-Body. Wir werden uns das jetzt am Beispiel anschauen, indem wir in einer Transaktion den weltberühmten Schauspieler ‘Max Mustermann’ in per REST-API in unsere Datenbank aufnehmen:

:POST /db/data/transaction { "statements":[{ "statement": "CREATE (a:Actor{name:\"Max Mustermann\"})" }] }

:201 CREATED {
  "commit": "http://localhost:7474/db/data/transaction/18/commit",
  "results": [
    {
      "columns": [],
      "data": []
    }
  ],
  "transaction": {
    "expires": "Tue, 21 Jan 2014 14:39:19 +0000"
  },
  "errors": []
}

Da eine Transaktion erzeugt wurde, können wir davon ausgehen, dass auch der Schauspieler-Knoten von “Max Mustermann” angelegt wurde. Wir werden jetzt in einer neuen Transaktion nach “Max Mustermann” suchen, ohne die vorherige Transaktion zu committen:

:POST /db/data/transaction { "statements":[{ "statement": "MATCH (a:Actor{name:\"Max Mustermann\"}) RETURN a" }] }

:201 CREATED {
  "commit": "http://localhost:7474/db/data/transaction/19/commit",
  "results": [
    {
      "columns": [
        "a"
      ],
      "data": []
    }
  ],
  "transaction": {
    "expires": "Tue, 21 Jan 2014 14:39:24 +0000"
  },
  "errors": []
}

Das Array “data” ist leer, entsprechend wurde der Schauspieler “Max Mustermann” nicht gefunden. Committen wir jetzt die erste Transaktion und führen erneut die Suche nach “Max Mustermann” aus:

:POST /db/data/transaction/18/commit { "statements":[] }

:200 OK {
  "results": [],
  "errors": []
}

 

:POST /db/data/transaction/commit { "statements":[{ "statement": "MATCH (a:Actor{name:\"Max Mustermann\"}) RETURN a" }] }

:200 OK {
  "results": [
    {
      "columns": [
        "a"
      ],
      "data": [
        {
          "row": [
            {
              "name": "Max Mustermann"
            }
          ]
        }
      ]
    }
  ],
  "errors": []
}

Und siehe da, der gesuchte Knoten wird zurückgeliefert. Wir sehen hier eine weitere Eigenschaft der transaktionalen REST-API: man kann eine Transaktion mit einem HTTP-Request erzeugen und committen. Das hat natürlich den Vorteil, dass weniger Netzwerk-Overhead entsteht.

Die Möglichkeit, mehrere Statements in eine Transaktion zu kapseln, hatte man vor Version 2.0 nur im Embedded-Mode oder im Server-Mode unter Verwendung von Plugins bzw. Unmanaged Extensions.

Fazit

Es gibt noch eine Reihe weiterer Neuerungen, wie zum Beispiel die Syntax-Verbesserungen für Cypher oder die `MERGE`-Operation, jedoch sind meiner Meinung nach Labels (und die damit verbundenen Features) und die transaktionale REST-API die Highlights von Neo4j 2.0 . Dadurch ist die Entwicklung von Anwendungen mit Neo4j wesentlich flexibler geworden. Es gibt kaum noch Use Cases, die nicht durch Cypher abgedeckt werden können, wodurch es – im Zusammenspiel mit der transaktionalen REST-API – wesentlich einfacher wird, zu skalieren und aus dem Embedded-Mode in den Server-Mode zu wechseln (vice versa). Man muss sich nicht schon zu Beginn der Entwicklung festlegen, sondern kann – ganz agil – auf eine veränderte Umgebung reagieren.

Neo4j Training

Neugierig geworden? Dann sichert Euch einen Platz beim nächsten Neo4j Training am 25.3.2014 in München. Wir freuen uns auf Euch!