Agile Prague 2014

September 16th, 2014

Dnes skončila konference Agile Prague 2014. Loni jsem z ní byl nadšený, letos jsem spíše rozpačitý. U spousty z přednášek jsem marně čekal na to, až mi řeknou něco co nevím. Takže tu vypíchnu jen pár nejzajímavějších.

Zlepšete svoje komunikační schopnosti aniž byste řekli jediné slovo

Paul Klipp

Když se budete bavit se Stevenem Hawkingem, budete mu skákat do řeči, abyste mu řekli svůj názor o černých dírách?

Nejvíc mě asi zaujalo povídání Paula Klippa o komunikaci. Neřekl mi nic co bych nevěděl, ale dokázal to pěkně vysvětlit. V zásadě říkal, že abychom mohli lépe komunikovat, tak se musíme naučit poslouchat. A to je jednoduché, stačí jenom

  1. Přestat mluvit
  2. Přestat přemýšlet o tom, co řeknu, až ten druhý domluví

Už jsem o tom psal loni. Nové bylo ale propojení s, nelekněte se, meditací. To že racionálně vím, že bych měl naslouchat, neznamená, že to budu dělat. K tomu prý pomáhá učit se meditovat. Ani ne tak samotná meditace, ale spíš to, jak mi to nejde. To jak medituju, medituju a najednou programuju nebo přemýšlím co nakoupit. Prý ten proces přikázání si, že se mám vrátit k meditování je stejný jako proces přikázání si, že mám naslouchat. Zajímavé. Stejně zajímavý byl i přístup řečníka. Nejen že to dal bez slidů, ale nechal lidi tři minuty zkoušet meditovat. To chce koule.

Doporučoval knížku Time to Think.

Nedělejte Agile

Bob Schatz

Povídání o tom, že Agile se nedá dělat. Že agilními se můžete stávat. Zajímavá myšlenka byla, že by se člověk měl vědomě zlepšovat. Ne jen chodit do práce, ale každý den vědět, v čem se chci zlepšit. To musím zkusit.

Líbil se mi i workshop o couchování, ale to je nezapsatelné. Připomněl jsem si a vyzkoušel GROW model.

A pak už mám jen pár postřehů a citátů.

Vascco Duarte povídal o NoEstimates. V zásadě to bylo o tom, že je lepší neodhadovat, jen nalámat story na menší a nepočítat jejich koplexitu, ale počet.

Testování nachází defekty, QA jim zabraňuje. Ray Scott

Nemůžete škálovat mizerný kód. Dean Leffingwell

Pomalý proces přímo vede k nízké kvalitě a vyšším nákladům. Vasco Duarte

No a pak se mi z nějakého důvodu líbily tyto slidy Claudia Perroneho

Terraforming organisations from Claudio Perrone

Terraforming organisations from Claudio Perrone

Důvěra a vlastnictví

July 1st, 2014

Nemůžete donutit lidi, aby si navzájem věřili, ale můžete vytvořit kulturu, kde se dá důvěra budovat.

Dneska jsem náhodou narazil na obrázek, který mě zaujal. Bylo to v knize Agile Culture, kterou jsem buď nedočetl nebo jsem si ji vůbec nezapamatoval. Nicméně ten obrázek stojí za to. Tady je

Model důvěry a vlastnictví

Proč se mi tak líbí? Protože krásně vystihuje, proč se zavádění Agile ve spoustě firem nepovede. Na vodorovné ose máme pocit vlastnictví týmu nebo jednotlivce. O tom jsem psal nedávno. Vlevo je malý pocit vlastnictví, vpravo velký. Svislá osa znázorňuje míru důvěry vedení v zaměstnance. Nahoře je úplná důvěra, dole je velká potřeba kontroly.

Podívejme se nejdřív na čtverce mimo diagonálu. Černý znázorňuje selhání. V tomto případě je selhání důsledkem velké důvěry v lidi, kteří na to dlabou. Nemají pocit vlastnictví a zároveň na ně nikdo nedohlíží, takže není důvod, proč by to mělo fungovat. Nic překvapivého.

Zajímavější je červený čtverec. Tam se dostaneme, pokud mají lidé velký pocit vlastnictví, ale vedení jim nevěří, hlídá je procesy, kontrolními mechanizmy a jinými korporátními radovánkami. Tento stav je také nestabilní. Pocit vlastnictví je křehká věc, takže to dříve nebo později sklouzne do žlutého čtverce.

To je oblast, kde se pohybuje většina korporací a z které se zatraceně těžko vylézá. Obě osy spolu totiž souvisí a snadno tam vzniká začarovaný kruh. Lidé mají pocit, že jim vedení nevěří, tak na to kašlou, kvůli tomu jim vedení nevěří ještě víc, začne je ještě víc hlídat, kvůli čemuž na to lidi ještě víc kašlou, na což je potřeba zareagovat ještě přísnějšími procesy...

Lídři, soustřeďte se na „co“ a „proč“, nikdy na „jak“.

Agile je bohužel v zeleném čtverci. Abychom se tam dostali, tak musíme ten začarovaný kruh zlomit a to nejspíš změnou kultury. Pokud máme ve firemní kultuře nedůvěru, pokud na každou neznámou reagujeme procesem, tak nám Agile nemůže fungovat. Aby fungovat začalo, tak musíme kulturu změnit. Krůček po krůčku je potřeba uvolňovat omezení. Zároveň je potřeba zvyšovat pocit vlastnictví a doufat, že při tom nesejdeme z cesty. Naštěstí je ve skutečnosti ten pás na diagonále tlustší než na obrázku, takže se snad dá docela dobře manévrovat.

Converting ListenableFutures to CompletableFutures and back

June 11th, 2014

Java 8 introduced CompletableFutures. They build on standard Futures and add completion callbacks, future chaining and other useful stuff. But the world did not wait for Java 8 and lot of libraries added different variants of ListenableFutures which serve the same purpose. Even today are some library authors reluctant to add support for CompletableFutures. It makes sense, Java 8 is quite new and it's not easy to add support for CompletableFutures and be compatible with Java 7 at the same time.

Luckily it's easy to convert to CompletableFutures and back. Let's take Spring 4 ListenableFutures as an example. How to convert it to CompletableFuture?

static <T> CompletableFuture<T> buildCompletableFutureFromListenableFuture(
		final ListenableFuture<T> listenableFuture
	) {
        //create an instance of CompletableFuture
        CompletableFuture<T> completable = new CompletableFuture<T>() {
            @Override
            public boolean cancel(boolean mayInterruptIfRunning) {
                // propagate cancel to the listenable future
                boolean result = listenableFuture.cancel(mayInterruptIfRunning);
                super.cancel(mayInterruptIfRunning);
                return result;
            }
        };

        // add callback
        listenableFuture.addCallback(new ListenableFutureCallback<T>() {
            @Override
            public void onSuccess(T result) {
                completable.complete(result);
            }

            @Override
            public void onFailure(Throwable t) {
                completable.completeExceptionally(t);
            }
        });
        return completable;
    }

We just create a CompletableFuture instance and add a callback to the ListenableFuture. In the callback method we just notify the CompletableFuture that the underlying task has finished. We can even propagate call to cancel method if we want to. That's all you need to convert to CompletableFuture.

What about the opposite direction? It's more or less straightforward as well

class ListenableCompletableFutureWrapper<T> implements ListenableFuture<T> {
    private final ListenableFutureCallbackRegistry<T> callbackRegistry 
					= new ListenableFutureCallbackRegistry<>();

    private final Future<T> wrappedFuture;

    ListenableCompletableFutureWrapper(CompletableFuture<T> wrappedFuture) {
        this.wrappedFuture = wrappedFuture;
        wrappedFuture.whenComplete((result, ex) -> {
            if (ex != null) {
                if (ex instanceof CompletionException && ex.getCause() != null) {
                    callbackRegistry.failure(ex.getCause());
                } else {
                    callbackRegistry.failure(ex);
                }
            } else {
                callbackRegistry.success(result);
            }
        });
    }

    @Override
    public void addCallback(ListenableFutureCallback<? super T> callback) {
        callbackRegistry.addCallback(callback);
    }


    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        return wrappedFuture.cancel(mayInterruptIfRunning);
    }

    @Override
    public boolean isCancelled() {
        return wrappedFuture.isCancelled();
    }

    @Override
    public boolean isDone() {
        return wrappedFuture.isDone();
    }

    @Override
    public T get() throws InterruptedException, ExecutionException {
        return wrappedFuture.get();
    }

    @Override
    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        return wrappedFuture.get(timeout, unit);
    }
}

We just wrap the CompletableFuture and again register a callback. The only non-obvious part is the use of ListenableFutureCallbackRegistry which keeps track of registered ListenableFutureCallbacks. We also have to do some exception processing, but that's all.

If you need to do something like this, I have good news. I have wrapped the code to a reusable library, so you do not have to copy and paste the code, you can just use it as described in the library documentation.