The V word – why is verbosity considered bad?

The V word – why is verbosity considered bad?

I came across an article the other day that was praising the fact that Java becomes less and less verbose due to the recent changes to the language. And I have a confession to make: I don’t think that this is necessarily a good thing.

I think the craft of programming has in general a lot of problems that come from its roots in mathematics and the genius myth. Programmers have grown up to be these mythical creatures that sit in the basement, don’t like the sunlight and write cryptic codes on white on black screens. And are, all of them, geniuses. That needs to go away.

One of the things that I usually say about programming is that you usually do it when you are well rested and the best of yourself, after a full night of sleep, the necessary coffee (or water in my case) provided and in general able to do deep concentrated work. The problem is that you do emergency maintenance at 4 a.m., when you just caught an hour of sleep after a long night out, slightly drunk, with a cold coming and usually the worst of yourself. So you should aim at this level of mental capacity. That’s a variation of the theme that one should write code for the future self, slightly more radical.

And here comes my problem with the verbose is bad myth. If you get a very verbose explanation of something that is usually a good thing. If the information you get is very verbose that is usually also a good thing. Only in code verbosity becomes a bad thing.

One example of this reduced verbosity is type inference. In general it has its use-cases, but if you have type inference throughout your whole code base you often lack necessary local information. Sure my IDE helps, but that is somehow hindering my flow while reading code. I have a runtime in my head that can understand Java code, but obviously I can’t hold the whole program. So I need local points to start my reading and understanding and if that is interrupted too much by looking up things it becomes just to hard. I know that the compiler is super clever and can infer all those types, but can I? The answer is no in a lot of places.

Another example is mutability. Of course it is annoying to write final in front of everything, but it conveys so much of the original authors intention, what she had in mind when she wrote that piece of code that it is a very helpful piece of information. That programming (be it object-oriented or functional does not matter) is mostly about reducing the amount of possible stats is a whole article in itself, but sometimes those verbose parts of the Java Programming Language are actually good.

In general I would expect anyone to put as much information in the few lines they are writing as possible. Of course that is more to type, but typing speed is in general not the limiting factor of programmer productivity. And yes, code is read a lot more times than it is written, and even if it is slightly more to read it might help the reader to understand all the state and all the implications faster, more efficient and with fewer errors. Verbosity in code has to become a positive aspect again.

JSR 311 and RxJava 2 in “Vert.x Boot”

JSR 311 and RxJava 2 in “Vert.x Boot”

Regarding my earlier posts on something Spring Boot like for Vert.x and after my evaluation of Vert.x Zero Up there is one idea that I still would like to try out, basically combining JSR 311 Resources with RxJava 2 directly on the resource level.

Usually resource code would look like this:

@GET
@Path("example")
@Produces(MediaType.TEXT_PLAIN)
public void getExample(@Suspended final AsyncResponse asyncResponse) {
    Single.just("Hello World").subscribe(asyncResponse::resume, asyncResponse::resume);
}

There are two boilerplaty things in here that I really would like to get rid of, the start of the Rx flow and the actual response subscription.

From my point of view it would make sense to abstract that away and enable rx flows directly:

@GET
@Path("example")
@Produces(MediaType.TEXT_PLAIN)
public Single<String> getExample() {
    return Single.just("Hello World");
}

@POST
@Path("examplePost")
@Produces(MediaType.TEXT_PLAIN)
public Single<String> postExample(Single<ExampleBody> request) {
    return request.map(service::doSomething).map(mapper::mapResponse);
}

Let’s see if there is way to generate the boilerplate around that and use rxified resources.

Vert.x Zero Up?

Vert.x Zero Up?

Regarding my former post, Vert.x Boot, I was told that there is actually a similar project rising:

Vert.x Zero Up is apparently flying mostly under the radar, at least I have not heard anything about it yet. So it is time to check it out, I don’t really have time to play with it right now, but maybe I can see from the docs if it is going into the direction that I want to go.

import io.vertx.up.VertxApplication;
import io.vertx.up.annotations.Up;

@Up
public class Driver {

    public static void main(final String[] args) {
        VertxApplication.run(Driver.class);
    }

}

That seems close enough to what Spring Boot is doing. I’m just wondering where the @Up annotation is needed for. Also using the io.vertx package namespace is a bold choice.

In my imagination that would be more like:

public class Application {

    public static void main(final String... args) {
        VertxBoot.application(args)
                 .withResources(UserResource.class, AvatarResource.class)
                 .withModules(SqlDatabaseModule.class, RedisModule.class)
                 .withModules(BusinessLayerModule.class, DaoLayerModule.class)
                 .bind(8080);
    }

}

A clear entry point for the application, that shows you what kind of features are used and what the structure of the application is.

I definitely don’t understand everything that Vert.x Zero Up does, apparently there are multiple modes to run an application, they all look the same code wise but require differnt YAML configuration files. It comes with JSR 311 support, which seems to be a custom implementation, something that would come for free when using Vert.x Jersey. There are some nice additions though, it allows @StreamParam with Vert.x own Buffer class, it requires some custom annotations though, and does classpath scanning, something that I’d really love to avoid due to startup performance reasons, we want to have micro services after all.

There is an interesting concept in there about offloading event loop work to worker threads with annotations (@Address) via the Vert.x event bus. I’m not a huge fan of this implicit coupling, that might get out of hand quite quick. On the other hand we are talking about micro services, so there should only be some of those bridges in any given service. I’m wondering if someone could achieve something similar that is transparent but still uses one given rx2 flow that would be easier to follow.

In general I’m pretty amazed of the amount of documentation there is, that is pretty good. Though a lot of it feels somehow generated or auto-translated but it is pretty excessive.

JSR 303 is supported, but only inside the system and not for request objects as far as I understand the documentation. I think that would be an essential part.

I still need to check if all the JSR 311 and JSR 330 support is custom, because I strongly believe that one should use existing libraries for that, otherwise maintenance will be a hell. From what I see from the docs it looks like that, because there are given limitations e.g. for JSR 330 as everything is a singleton.

I will play with it for an afternoon, but from what I’ve seen so far I want to go in a different direction and thus it may be still worth to spend some time to build a prototype of the framework I imagine.

BTW, I’m still looking for a good name for Vert.x Boot that does not collide with Vert.x and Spring Boot.

Vert.x Boot first step

So, I happen to find myself with a lot of free time at my disposal. Having spent the last three years head-of-teching in a startup I also have finally the time to think about the technologies we used, the shortcomings, the pitfalls and what I would do different on the next project.

Turns out that I really fell in love with Vert.x as a technology, Java 10 and RxJava2. As you still can see on GitHub we build an awfull lot of components around that. Vert.x is just blazingly fast and easy to understand, RxJava makes for nice reactive streams and modern Java is just fun to work with.

We also had a couple of Spring Boot services, mostly for simplicity and the hype four years ago. In general Spring Boot brings a lot of features, most of them you don’t need or don’t know. It is also quite slow when it comes to startup, in a container, on a VM, in the Cloud.

Now, while I am wondering what to do next and what to do in general I started wondering what I would do knowing what I know now.

We mostly used a stack based on Vert.x, RxJava (sadly 1.x) and Vert.x Jersey. We glued it all together with a couple of abstractions over Verticle deployment and got our own nice stack this way.

Things I would (and have done with newer services) is using RxJava2 as well as replace HK2 with Guice. HK2 is nice but also slightly inferior to Guice in my opinion. For some reason HK2 is not that well maintained, as of last week there was still no support for Java 10 in a released version.

And now I am wondering if I should take this whole stack to a new level and build something like Vert.x Boot, a system that easily lets you bootstrap Vert.x microservices for a variaty of use-cases with the following features:

  • Easy to use bootstrapping process like Spring Boot has
  • Guice as CI and general application configuration approach (I strongly believe in using code for as many things as possible)
  • Vertx-Jersey as a general REST/JAX-RS abstraction
  • Metrics and Prometheus integration out of the box using Micrometer
  • Defined readiness and liveness probe patterns (health checks)
  • Very good RxJava2 integration
  • Minimal dependency footprint that is easy to upgrade in order to follow Java’s amazingly fast upgrade cycle
  • Some well defined testing and containerization patterns (we all build images now, no?) that make it easy to build “golden” images, maybe using Testcontainers

On top of that there should be some modules to integrate with commonly used data layer services and provide the infrastructure that you usally use around that, like connection pooling and schema migrations:

Bonus

  • I really like GraphQL, so something that would abstract around GraphQL Java to build easy to use GraphQL endpoints would also be nice
  • I’m not so sure about my feelings about Jigsaw and the way the Java eco-system is going, but having a good way to work with modules would also be a bonus.

I used to say that Java is not a great fit for Microservices because of memory usage and startup times, but with this stack it might actually make sense. I haven’t yet figured completely out how low you can go, but with a very low old-gen baseline and requests that always run only in your young-generation you can actually run those things with a very small memory footprint.

Maybe that is something to fill my time with once the summer ends.

ApacheCon EU 2012 Day 3

Mit dem dritten bzw. eigentich vierten Tag neigte sich dann auch die Konferenz dem Ende zu, was man unter anderem auch daran merkt das ich nicht mehr so viel mitgeschrieben habe. Reichte dann aber auch.

The CouchDB Implementation (Jan Lehnardt)
Wie der Name schon sagt ein wenig CouchDB internals. War sehr interessant, so richtig lÀsst sich das hier aber auch nicht wiedergeben.

Solr-based search & tagging services at ZEIT Online GmbH – where metadata come from (Christoph Goller)
Ein wenig ĂŒber Analysers und was in der realen Welt wirklich funktioniert.

Apache Camel – Advanced Techniques (Hadrian Zbarcea)
Gut, man sollte eventuell nicht in den “Advanced Techniques” Vortrag gehen wenn man das Produkt nicht kennt, war aber auch ganz, Ă€h, interessant.

Apollo and future of ActiveMQ (Dejan Bosanac)
Die JMS Implementierungen sind erwachsen geworden. Und sprechen jetzt bessere (plaintext) Protokolle: STOMP http://stomp.github.com/.
LevelDB ist ein Key Value Store von Google das ich noch nicht kannte.

World of Logging (Christian Grobmeier)
Logging ist ein gelöstes Problem, ne? Es gibt sehr viele Frameworks und Meta Frameworks, Commons Logging ist etwas tot, daher ist slf4j aktuell die beste Lösung. Aber log4j2 ist unterwegs und bringt viele schöne neue Features.

Danach gab es noch kurze Sessions zu allen möglichen Themen und noch den Shutdown, noch mehr GesprĂ€che und dann war es auch schon Abend und Zeit fĂŒr noch ein gemeinsames Bier und dann schlafen. Heute geht es dann auf den weiten Weg zurĂŒck nach HH mit kleinem Abstecher ĂŒber Bonn.

Mein Fazit ist durchwegs positiv, die Themen waren alle sehr interessant, viel dabei was man sich mal anschauen muss bzw. sollte. Auch die Infos ĂŒber die Apache Software Foundation selbst waren ganz interessant, mit war nicht bewusst wie professionell das da alles ablĂ€uft. Wenn es nicht eh schon tausend andere Konferenzen gĂ€be dich ich auch alle gerne mal besuchen wĂŒrde dann wĂŒrde ich auf jeden Fall jederzeit wieder auf eine ApacheCon fahren.

ApacheCon EU 2012 Day 2

Konferenzen sind ja auch etwas anstrengend. Man muss frĂŒh raus, obwohl man am Abend vorher lange unterwegs war, man hat die ganze Zeit stimulierendes Input um sich herum und man weiß das man Abends schon wieder lange unterwegs sein wird. Und vor allen Dingen lernt man stĂ€ndig neue Menschen kennen. Ich bin also immer noch begeistert von der ApacheCon, hier die Notizen zu heute:

Real-time Big Data in Practice with Cassandra (Michaël FiguiÚre)
Ja, Cassandra halt. Mir ist der Usecase auch immer noch nicht klar, es sei denn du bist Twitter, dann ists schön. Das wesentliche was sich in der letzten Zeit getan hat ist das man jetzt SQL, pardon, CQL mit dem Ding sprechen kann.

What are we working on? (Steve Rowe)
Ja, Lucene halt. :). Auch nichts was ich gestern nicht schon gehört habe, noch etwa sin depth. Ich glaube ich habe gerade einen Lucene Overkill.

Domain-driven apps with Apache Isis (Mohammad Nour)
“Apache Isis is for GUI as Hibernate is for persistence”. RAD Framework mit dem man Apps generieren kann. Sieht lustig aus, kann man bestimmt benutzen wenn man den passenden Use-Case hat.

The Apache Way (Ross Gardler)
Q: “If people off the sub projects dictate what the board is doing, what is the board doing”? A: “Usually we’re drinking whiskey”.
Ross Gardler ist ein großartiger Redner, der Talk hat sehr viel Spass gemacht. Wenn man sich noch nie damit auseinandergesetzt hat wie die ASF funktioniert dann ist er auch voller Infos, jetzt weiß ich wenigstens was ein PMC ist. Auch war mit nicht so bewusst das es Apache Labs gibt. Eine gute Quote zur Arbeitsweise der ASF ist auch: “We never pay for code”.

Ferner hat er folgendes Video empfohlen:
https://www.youtube.com/watch?v=Q52kFL8zVoM

OSGi for mere mortals (Bertrand Delacretaz)
OSGi kann man also auch fĂŒr Webapps verwenden, das war schon sehr lustig. Wenn man den Case hat dann hat man auf diese Art und weise ein sehr entkoppeltes System von dem man Einzelteile austauschen kann. Apache Felix ist hier dann wohl der way to go.

Managing project risk when using open source (Ross Gardler)
Da ich jetzt Fan von Ross geworden bin habe ich mal CouchDB Features liegen gelassen und mir angehört was er sonst noch so zu erzĂ€hlen hat. War aber auch eher ein politscher Talk ĂŒber die möglichen Risiken wenn man FOSS einsetzt, die kennen wir ja nun alle.

Mongo, its all the Rave (Matt Franklin)
Web & Social Mashup Engine. Im großen und ganzen haben sie das auf Mongo umgestellt und danach war es viel schneller (vorher lief es gegen MySQL). Bis auf lustige Requests die plötzlich ewig dauern. Wo das herkommt hat er aber keine Ahnung gehabt. Zumindest weiß ich jetzt was Rave ist.

HBase Status Quo (Lars George)
Kleiner Blick in das Hadoop/HDFS und hauptĂ€chlich HBase Universum. Damit wĂŒrde ich auch mal gerne spielen, ich habe nur die Daten nicht ;).

Danach gab es dann noch Commiter treffen (warum die Apachen immer so mit Commitern beschÀftigt sind versteht man wenn man die Struktur der ASF kennt). Da hab ich mich dann mal angeschlossen, die Struts Leute kennengelernt, die Log4j2 Leute kennengelernt und gutes Essen gehabt, das ich tatsÀchlich diesmal selber bezahlt habe.

Nebenher habe ich heute ein wenig mit ZooKeeper gespielt, das ist wirklich auf einem sehr tiefen Level aber trotzdem sehr schön. So Sachen wie verteilte Locks und Queues kann man zwar damit bauen, sie gehören aber nicht in den API und werden als “Recipes” mitgeliefert. Aber man kann damit bestimmt ein schönes verteiltes System bauen mit dem man Keys in Values transformieren kann und diese dann noch synchronisiert verteilen kann. Mir fĂ€llt da ein usecase mit ungefĂ€hr 10 Nodes ein. Mal sehen ob ich meine Demo dafĂŒr noch an den Start bringe.

ApacheCon EU 2012 Day 1

image

Mein Tag bestand hauptsĂ€chlich aus zwei Tracks, dem Java EE/Webapps Track und dem Lucene/Solr Track, die Gott sei Dank auch am weitesten rĂ€umlich auseinanderlagen, so dass ich immer hin und herlaufen musste. Dabei ist mir aufgefallen das die ApacheCon gegenĂŒber den meisten Konferenzen die ich so kenne doch ein sehr diverses Publikum hat, man hat den Eindruck die Leute kommen aus aller Herren LĂ€nder, nicht nur aus Europa. Das Vortragsprogramm war vollgepackt und es gab in jedem Slot einen Vortrag den ich sehen wollte. So viele Konflikte hatte ich heute nicht, beim letzten Slot hat es mir etwas leid getan das ich Lucene 4 dem Tomcat 8 vorziehen musste.
Auf jeden Fall war der Tag sehr sehr lehrreich, die Talks waren meistens sehr gut und auch voller Wissen das ich noch nicht hatte.
Hier also meine Notizen zu den VortrÀgen:

CDI at Apache – Open WebBeans and DeltaSpike Deep Dive (Mark Struberg)

OpenWebBeans
CDI ist anscheinend ein Buzword das ich noch nicht kannte (DI = Dependency Injection,
C = Context, wobei das sowas wie ein Scope ist im DI Sinne, also so etwas wie ein RequestScope, SessionScope, ApplicationScope etc.). DafĂŒr gibt es einen JSR mit der Nummer 299, der quas das was was Spring macht als Standard beschreibt. Der Vorteil ist dabei sit wohl das CDI bzw. JSR 299 in der Form von OpenWB 3x schneller ist als Spring da es viel zur Boottime macht.

DeltaSpike
All in all Framework fĂŒr alle Layer (Application Stack) in Form von JSR 299 Plugins.
Im Großen und Ganzen schmeißt man Applikationsweite Events durch die Gegend (Benutzer hat sich angemeldet) die man mit Annotationen binden kann. Dazu kommen noch alle möglichen Custom Annotationes die man bauen kann, klingt so als wenn man am Ende direkte Method Calls einfach durch eine Menge an Annotationen ersetzt und dann funktioniert das alles schon. Macht irgendwie Code Browsen anders. WĂŒrde ich trotzdem mal gerne in einem kleinen Projekt testen.

Query Parsing – Tips and Tricks (Erik Hatcher)
HauptsĂ€chlich Überblick ĂŒber die unterschiedlichen Query Parser, da hat sich schon einiges getan seitdem ich den Hund gebaut habe, aber das war ja auch 1.0.
GeoFeatures sind jetzt Build-In und eigentlich ist das was ich aus dem Talk mitgenommen habe das alles schon irgendwie geht. War auch von der Tiefe her sehr gut, wenn man Lucene nicht vom API her kennt war man schon etwas verloren.

Apache TomEE, Java EE 6 Web Profile on Tomcat (David Blevins)
TomEE ist der Java EE 6 Web Profile (ca. 12 anstelle von den vollen ca. 24 Specs fĂŒr Full Profile, da sind noch so tolle Technologien wie CORBA enthalten) Stack aus dem Hause Apache. Im Großen und Ganzen wohl erstmal schneller und besser als die alten bloated Implementierungen (JBoss, Glassfish).
Konkret technologisch bedeutet TomEE: Tomcat + CDI – Apache OpenWebBeans, EJB – Apache OpenEJB, JPA – Apache OpenJPA, JSF – Apache MyFaces, JSP – Apache Tomcat, JSTL – Apache Tomcat, JTA – Apache Geronimo Transaction, Servlet – Apache Tomcat, Javamail – Apache Geronimo JavaMail, Bean Validation – Apache BVal
Wie gesagt, klingt ganz gut, sollte man mal als Stack ausprobieren. NatĂŒrlich mit einer sinnvollen Frontend Technologie wie Wicket. Wobei das taugt bestimmt auch sehr gut wenn man mal eben $Webservice oder $RestService an den Start bringen möchte ohne viele zusĂ€tzliche Libs zu suchen.

Und Arquillian habe ich heute mehrfach gehört, das ist ein Integration Test Framework fĂŒr JavaEE, aber das kann man bestimmt auch fĂŒr Custom Stacks benutzen. Wobei Integration hier heißt das es tatsĂ€chlich die App in einem TomEE deployt und man alle Konfiguration in dem Arquillian Code macht. Fancy, sieht in der der Demo sehr cool aus, mĂŒsste man mal mit Real World Apps ausprobieren.

Am Rande aufgeschnappt:
YourKit – Profiler

Solr 4, the NoSQL database (Yonik Seeley)
Guter Talk von dem Typ der Solr gebaut hat. Die grundsĂ€tzliche Idee ist das man alles was man ĂŒber Solr weiß vergessen soll und ihn eher als ein NoSQL-Store sehen soll mit dem man auch ganz gut suchen kann.
Allgemein viele neue Features in Solr 4 mit denen man bestimmt ganz tolle Suchen bauen kann. Z.B. Functions beim Suchen und beim ausliefern der Felder mit denen man die Werte in den Feldern noch modifizieren kann. Außerdem sieht die Admin Console nicht mehr so aus als wenn ich sie designt hĂ€tte und hat auch mehr Infos.
Stark empfohlen hat er auch folgenden Blog Artikel:
http://blog.cloudera.com/blog/2010/04/cap-confusion-problems-with-partition-tolerance/

Am Rande aufgeschnappt: ZooKeeper scheint auch mal eine gute Lösung zu sein wo jGroups nicht (mehr) ausreicht. Solr 4 benutzt das auch zum Clustering.

ElasticSearch in Production: lessons learned (Anne Veling)
ElasticSearch ist sowas wie Solr, also Lucene basierter Search Server mit REST API, JSON in, JSON out. Plus Distributed, sind wir das nicht alle.
Leute da draußen bauen krassen Kram: http://udini.proquest.com/ (Scala, Unfilitered, MongoDB, Solr und ElasticSearch auf Amazon EC2). Scheint aber gut zu laufen.

Als neues Buzzword fand ich auch “nodb” ganz schön, das ist dann quasi die Steigerung von NoSQL.

ElasticSearch ist also ein wenig der coole kleine Bruder von Solr.
http://de.slideshare.net/AnneVeling/elasticsearch-in-production-lessons-learned

Wicket – where do we go from here? (Sven Meier)
Nicht so viel neues wenn man Wicket schon mal benutzt hat, MetaDataKey kannte ich noch nicht, ist m. E. aber auch gefÀhrlich, in die Session zu schreiben ist ja irgendwie heute nicht mehr so cool (https://github.com/svenmeier/apachecon-wicket/blob/master/src/main/java/eu/apachecon/customer/ui/model/CustomerSessionModel.java)
Ansonsten war das ein etwas komischer Titel fĂŒr einen Talk der eigentlich eine Intro zu Wicket sein wollte.
Mitgenommen habe ich das ich mir mal Tepstry 5 ansehen möchte und
Vaadin auch (https://vaadin.com/home),

Content extraction with Apache Tika (Jukka Zitting)
Tika ist “erwachsen”, Version 1.2, kann man gut benutzen wenn man einen Use Case dafĂŒr hat. Kann eigentlich alle Dateiformate die es gibt ;).

Lucene 4 Performance Tuning (Simon Willnauer)
Hat schweren Herzens gegen das “Tomcat 8 preview” von Mark Thomas gewonnen, aber bevor ich einen Tomcat 8 ĂŒberhaupt benutzen kann wird noch einiges Wasser die Elbe herunterfließen.
Blazingly Fast Indexing, tausend neue Features und vor allem haben sie ausnahmsweise mal den API geĂ€ndert, komplett. Aber wie immer, alle neuen Features und perfomance Optimierungen klingen großartig will ich auch.

Am Abend gab es dann Bier und Brezen gesponsert von Adobe und noch viele gute GesprĂ€che. Von den EE Leuten habe ich gelernt das wenn man die Spec doof findet muss man halt die Spec Ă€ndern. Nachdem wir dann die Arena dicht gemacht haben gabs noch ein Abendessen von CodeBusters(.es) gesponsert. War im großen und ganzen ein sehr lustiger Tag.