Programování

Sbohem a šáteček!

1

Končím s ubytovníčkem, konec, šlus, adie! V lean kanvasu jsem měl zaznačený zisk jediný – zkušenost. A té jsem dosáhl – udělal jsem špatný úkrok stranou, takže pryč s tím, soustředit se na jiné věci. Ještě bych ale tímto posledním postem rád shrnul věci, o kterých jsem chtěl původně psát (resp. když jsem na nich dělal, připadalo mi dobré o nich průběžně psát na blog, protože by mohly přitáhnout pozornost). Jenže jsem o nich nepsal. Teda psal, ale hrozně pomalu. Plán byl – jeden týden, jeden blogpost. A kdy že se objevil první? Pche! Proč dělat tisíc věci na 1/1000? Navíc některé „jakodělat“? To je radši zrušit úplně!

Chyba číslo jedna: myslet ti, že to mám ověřený. Chybělo něco jako „move your fucking ass out of the building.“ Nedávno jsem vytáhl nápad ubytovníčku a lidé na mě koukali jako na blázna: „Jak jako spát s někým v pokoji? My si s drahou polovičkou bereme dvoulůžko!“ Následovalo přemýšlení nad pivotem – udělat rezervační systém pro ubytovací zařízení. Nojo, ale proč? Copak mám nějaké ubytovací zařízení? A i kdyby!

Ubytovníček

Ubytovníček

Chyba číslo dva: myslet si, že mám pěkně rozvrhnutý projekt. Neměl jsem konkrétní cíl, neměl jsem konkrétní čas, kdy bych ho měl dosáhnout, neměl jsem vlastně spoustu věcí, hlavně, že jsem měl doménu :).

Konkrétní čas

Konkrétní čas

Chyba číslo tři: technologie? Ta ne, za její volbou si stojím. Jen bych příště nešel cestou RADu ve formě Roo. Ovšem i zde je namístě otázka – je to tím, že za tu předlouhou dobu, co jsem na tenhle projekt nemákl, jsem se všechno, co Roo nabízelo, naučil sám a zautomatizoval? Že jsem se naučil psát testy, že už si připadám Spring intermediate a výš, že si radši model vytvořím sám a bez aspektů, že i ty query si napíšu radši ručně a lépe… Zase na druhou stranu – podíval jsem se hlouběji na webflow, tiles a dojo. Aspoň na chvíli jsem se cítil být frontenďákem :).

Grafické znázornění webflow

Grafické znázornění webflow

Chyba číslo čtyři: chtěl jsem psát všechno a obsáhle na blog. Chtěl. Jenomže než jsem se k tomu vždycky dokopal, tak se mi to, co jsem chtěl popisovat, vykouřilo z hlavy. A cucat si to z prstu se mi prostě nechce, stejně tak to celé dělat znovu jenom kvůli popisu. Takže základem je – napsat to hned! A napsat to stručně. Pokud někdo má zájem o bližší informace, ozve se a může se případně navázat dalším dílem. Proč sepisovat něco, co vlastně ani nikoho nezajímá a nikdo to nejspíš ani nečte? Zbytečná ztráta času! Samozřejmě je také nutné uvažovat cílové publikum – proč jsem sakra na blog související s ubytováním psal věci ohledně vývoje? Copak to je blog s tématem „jak rozjet (nemám to slovo rád – ) startup?“ Příště striktně oddělit témata a takovéhle posty nepsat vůbec, nebo je psát do tech části.

Jaké je cílové publikum blogu?

Jaké je cílové publikum blogu?

Chyba číslo pět: „i cesta může být cíl“ – rozdělat projekt a učit se na něm. Jenomže když to učení nakonec převažuje nad cílem jako takovým, tak to nebude to pravé ořechové a zůstanu trčet ve vzduchoprázdnu. Vlastně to souvisí s předchozím bodem – příliš jsem se soustředil na to, co napíšu, jak to napíšu a jak to ještě rozvedu, aby to vydalo na víc, než pár řádků. Takže jsem chystal sáhodlouhej článek o propojení Pivotal Trackeru s „mojí pružnou metodikou“ (teď nově vydáno s menší obměnou a imho mnohem praktičtější)…nehledě na to, že mezitím u Good Data přestalo fungovat reportovadlo/analýza pro Pivotal Tracker. Mu!

V nekonečnu přímka však se Vždycky ve kruh schoulí

V nekonečnu přímka však se Vždycky ve kruh schoulí

Sečteno a podtrženo: příště si definuju nejenom konkrétní cíl (konkrétně specifikovaný MVP), ale i nějaký náznak představy o čase, kdy ho chci dosáhnout. A díky známému „každý úkol zabere přesně přesně tolik času, na kolik ho odhadneme,“ budu odhady zaokrouhlovat dolů – budu mít hotovo dřív! 🙂 Brzkého nákupu domény nelituju, i tu příští koupím velmi brzo – přece jenom to není nijak extra vysoká částka a když ji využiju pro landing page (použil jsem Launchrock) se základními informacemi a možností registrace zájemců (jako tomu bylo teď) a na subdoménu vrznu opět nějaký blog, snad Posterous úplně neumře, jak je teď slibováno. A především – budu se věnovat něčemu, čemu se opravdu chci věnovat a v čem vidím smysl. Nebudu násilně vymýšlet blbovinu, o které se někdo zmínil v hospodě u píva, že by mohla být fajn. Takže nashle příště u dalšího začátku!

PS pokud má někdo zájem o doménu ubytovnicek.cz, twitter účet stejného jména a fb fanstránku, tak se mi ozvěte s nástinem plánu. Tomu, co mě nejvíce zaujme to všechno milerád (zdarma) přenechám!

(Repost z blog.ubytovnicek.cz)

Pozadí ubytovníčku: platforma

0

Konečně se dostáváme do trochu techničtější fáze, o které měl původně tento seriál celý být. Ovšem pro některé souvislosti a nasměrování i na trochu potřebné teorie byla odbočka směrem k Running lean nezbytná. Tato fáze vychází z některých polí v Lean canvasu a sice pole cena a pole zisk. Nejsem si jistý, zda tento způsob zadání je možné považovat za korektní vyplnění těchto polí, ale popravdě – je mi to docela jedno.

V poli cena mám pouze dvě položky – platba za doménu a čas. Od toho se bude odvíjet veškerý návrh technické části. Všimněte si, že nikde není uvedena cena za hosting či virtuál, ceny za licence na ten který použitý software, cena za grafiku a další. Opravdu jedinou investicí by měl být můj čas.

Lean canvas

Lean canvas

Jaké technické řešení teda zvolit, když má být zdarma? Mohl bych si vybrat nějaký free hosting s podporou třeba php, ale vzhledem k mému odporu k tomuto jazyku to nehrozí. Jsem Javista a přestože mám v plánu pustit se do učení se nějakého dalšího nového jazyka, nemyslím si, že tohle je vhodná příležitost, takže zůstanu u té Javy. Možností běhu javy zdarma (alespoň několika instancí) na serverech je dneska už taky poměrně velké množství (Amazon Elastic Computing Cloud, Google App Engine, Heroku, Cloudbees, CloudFoundry a další), zkušenost mám pouze s Google App Enginem a Cloud Foundry, takže budu volit z nich. Volba je poměrně jasná, protože GAE je uzavřený (nejenom, svého času mě pěkně vytočil, když jsem se snažil udělat abstrakty pro persistentní objekty), navíc mi neumožní zdarma běh většího množství instancí a (jako bonus) můj odpor vůči této společnosti v poslední době docela stoupá, začínám na ni koukat jako na „evil one“.

O Cloud Foundry jsem mluvil už už minulý rok v Ostravě na Dev Skillz. A protože už o tomto řešení bylo napsáno více než dost kdekoliv jinde, tak se čtenář bude muset spokojit se základní informací, že se jedná o  PaaS řešení zaštítěné VmWare, které běží na jejich infrastruktuře, infrastrukturách jiných (AppFog, Uhuru), případně je možné sáhnout po komunity forku tohoto projektu a rozjet si jej na vlastních serverech. Spíše než o jazycích je vhodnější mluvit spíše o podporovaných frameworcích, kterýchž škála je poměrně pestrá: Spring, Grails, Lift, Play, Node.JS, Rails a Sinatra, persistence je zajištěna databázemi relačními (MySQL, vFabric Postgres) i NoSQL (Redis, MongoDB) a pro komunikační mezivrstvu je možné použít RabbitMQ.

Zásadní výhoda je tedy následující: s CloudFoundry mám možnost běhu aplikace zdarma, pokud bych vyžadoval více instancí, větší dostupnost nebo nějaké perličky, můžu si připlatit, nebo přímo přesunout aplikaci na EC2, či na vlastní infrastrukturu!

Jak jsem zmínil, Cloud Foundry přímo umožňuje využití některého z množství oblíbených frameworků, což rozhodně využiju, protože jsem člověk líný, abych začínal od píky. A jsem líný tak, že využiju nějaký RAD, v mém případě Spring ROO, protože nově podporovaný Play v době návrhu ubytovníčku ještě CF nebyl nabízen.

Roo nabízí využití některého ze dvou frameworků pro tvorbu view – Google Web Toolkit a Apache Tiles, takže sahám po Tiles v kombinaci s  jQuery a čistými JSP. Opět nepůjdu do detailů, zájemce odkážu na některý z mnoha tutoriálů na ovládání roo.

V poli zisk mám nejzásadnější položku – zkušenost. V praxi rád testuju různé nápady na lidech, jak se co ujme, jestli to vyhovuje…na malých částech, dalo by se to nazvat uživatelský prototyping. Nejinak tomu je i u tohoto projektu. Chci zkusit, jaký bude poměr registrovaným uživatelům ku uživatelům pouze využívajícím službu (jsem zastáncem možnosti anonymního využívání aplikací na webu, jako tomu bývalo odjakživa – před všemožnými facebooky a unifikovanými loginy v podobě openId a dalších) a prozkoumat zájem potencionálních zákazníků (provozovatelů ubytování), jak se budou stavět k nabídce využívání tohoto systému – vyzkoušet svoje „social skills“, totiž jak s „nepočítačovníky“ správně a slušně komunikovat.

Dalším pokusem (ziskem v podobě informace) bude sestavit vůbec funkční aplikaci nad Cloud Foundry – předchozí byly jenom pokusy v podobě helloworld a drobností pro zábavu – a získat pro ni nějaké reálné uživatele, na kterých se budu moci učit – ať už komunikovat jakožto „já projekt“, nebo ladit přivětivost systému, „zážitek“ z použití služby a další.

V neposlední řadě taky aplikaci zařadím do kategorie svých „pet projektů“, ke kterým se můžu uchýlit k odreagování se, když mě všechno ostatní točí a rád bych se jednorázově alespoň na chvíli věnoval něčemu jinému.

PS Jako side-project vznikl Air Cargo Forwarder, což je aplikace pro Android pro monitorování a ovládání aplikací běžících na platformě Cloud Foundry.

(Repost z ubytovnicek.cz)

Pozadí ubytovníčku: validace

0

Co mám: mnoho nápadů
Výstup: nejjednodušší možné řešení, kterým jsem schopen vyřešit zákazníkův problém
Co budu dělat: mluvit s potenciálními zákazníky, pivotovat, hledat nejjednodušší možnou funkcionalitu
Co pro to použiju: lean canvas (případně jiný canvas či způsob validace, pokud je vhodnější)

Minule jsem psal o něčem, co by se dalo nazvat blitím nápadů. Podstatnější než to je však validace těchto nápadů, v tom pomůže svatá trojice. Tou se rozumí trojice uživatel, uživatelův problém a moje řešení tohoto problému. Nejlepší situace je ta, když sám vidím v něčem problém a chci jej řešit (neboli sám sobě jsem zákazníkem). Potom můžu přistoupit k onomu blití nápadů z minula a mám nápadů na řešení přehršel, protže vím, o čem mluvím. Ovšem i přesto můžu být sám sobě zákazníkem jediným a to je špatně, proto přichází na řadu výše zmíněná validace.

Validace problému/řešení

Validace problému/řešení (zdroj: http://market-by-numbers.com)

Proč jsem zvýraznil spojení uživatelův problém? Protože musím vycházet z problému, který uživatele opravdu trápí, ne z problému, o kterém si myslím já, že uživatele pálí. Proto je třeba se ptát, ne někde v ústraní dumat nad možnými problémy. Je potřeba sehnat potencionální zákazníky, lidi, kteří do dané problematiky vidí a věčné skeptiky (mě :-)) a předložit jim různé scénáře s problémovými situacemi a způsoby jejich řešení a postupně se s nimi dopracovávat k jedinému konkrétnímu výsledku, nebo klidně i několika různým důležitým cílům, z nichž vykrystalizuje výsledný produkt (lépe řečeno Minimal Viable Product).

Postupná krystalizace nápadu (kombinace problém/řešení)

Postupná krystalizace nápadu (kombinace problém/řešení) (zdroj: http://theagni.com/)

Tohle dopracovávání se k výslednému nápadu, který bude mít cenu realizovat, by mělo probíhat iterativně – tedy postupně by se měl nápad doplňovat připomínkami, validovat, doplňovat, validovat…třeba i v několika paralelních větvích, které budou validovány dále ještě jinými způsoby, aby byla vybraná ta nejlepší. Nejlepším výběrem je myšlen kompromis mezi užitnou hodnotou pro uživatele a mojí schopností tuto věc co nejrychleji realizovat. Tím myslím především finanční stránku věci, protože když je čas a peníze, realizovat se dá cokoliv :-).

Lean canvas

Lean canvas (zdroj: http://www.ashmaurya.com/)

V hledání tohoto kompromisu pomůže nástroj zvaný lean canvas. Lépe řečeno – mnoho canvasů, protože co canvas, to kombinace uživatel/problém. Není možné napasovat stejné uživatele na různé problémy, protože je prostě nemusí vůbec pálit. Canvas má několik polí, která se vyplňují postupně a samozřejmě canvas samotný se dále vyvíjí na základě komunikace s potenciálními klienty/zákazníky, díky čemuž mohou nevyhovující canvasy zanikat i vznikat nové. Prvotní vytvoření canvasu zabere okolo 20 minut, delší koumání je ztráta času, jak píše autor této techniky, Ash Maurya, v knize Running lean. Když nevím, nevyplňuju, nebo ani vyplnit nemůžu, protože to zatím není jasné – též budeme iterovat a dopracovávat se k nejvhodnějšímu řešení. Lean canvas vychází z Business model canvasu a vhodně jej rozšiřuje pro začínající projekty, dle slov autora: Business canvas na příkladech ukazoval zajeté instituce, jako apple, nebo skype… Lean canvas se soustředí na začínající projekty a na mnoha příkladech ilustruje tuto techniku na vlastním rozjížděném projektu. Nebudu to dále rozmazávat, stojí to za přečtení – druhé vydání je k sehnání na Amazonu za nějakých $16, první vydání bylo možné předplatit v rámci psaní knihy a dostávat je na etapy (nebo zkuste napsat přímo autorovi, je to člověk otevřený ;-)).

Pivotování

Pivotování (zdroj: http://steveblank.com/)

Ale zpátky k validacím: v této fázi se bude určitě hodně pivotovat, protože mám představu, kdo jsou mými zákazníky, oni jimi však většinou nebudou, musí sami sebe identifikovat s mým produktem. Proto se budou cíle velmi často měnit a v této fázi je to výhodné a také velice vhodné, protože nic reálného zatím neexistuje a měním pouze myšlenky a nahlížení na ně. Jen se k tomu musím přinutit, je to jako u zubaře – včasný zásah bolí mnohem méně. Časem se to nějak ustálí a najednou bude vše „nad slunce jasné“.

Teď už by mohl být pomalu čas na nákup domény, dočkali jsme se! Taky je možné začít vytvářet profil pro aplikaci na sociálních sítích, (nejenom) abychom se dostali uživatelům pod kůži a vytvořili si nějaké publikum. Ale o tom zase až příště, konečně se to stočí k techničtějším věcem, o kterých měla tato série původně celá být!

(Repost z blogu Ubytovníčku.)

Import scripts architecture, pt. II

1

First post of this series ended with code snippet, which invokates importAction itself. It’s not still the importing itself, but we are almost there. This post will be about what happenes, what hapened before and what is going to happen :-). But first things first, let’s have a look on Factory and Proxy pattern, which are used while calling imports.

Factory pattern is based on idea instead of creating a new object with new operator, factory is asked, which returns a new instance. This is way standard Spring’s bean factory works. It may looks like following diagram (image is from oodesign.com):

Factory Pattern

Factory Pattern (click for source - oodesign.com)

To hide newly created instance behind an interface facade Proxy pattern is used. This functionality is imho basic of AOP programming, because instead of calling original object, something else may be called. Have a look on following diagram (again from oodesign.com):

Proxy Pattern

Proxy Pattern (click for source - oodesign.com)

Now it’s possible to put those patterns together and get real importAction functionality: importAction is just an interface, which hides importActionImpl newly created for every request. This can be seen on following snippet of application context configuration.

<bean id="ImportAction" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="targetName" value="importAction"/>
    <property name="singleton" value="false"/>
    <property name="proxyInterfaces">
        <list>
            <value>cz.shmoula.imports.ImportAction</value>
        </list>
    </property>
</bean>

<bean id="importAction" class="cz.shmoula.imports.ImportActionImpl" scope="prototype" />

As I wrote a while before – all of this is done due to posibility of calling something else. But back to implementation, for details refer to some AOP documentation. Method importAction.invocateImportScript() is a pointcut, on which two advisors are bound. Have a look at following diagram.

ImportActionAdvice

ImportActionAdvice

This configuration can be achieved by NameMatchMethodPointcutAdvisor, see following snippet for ImportContentAdvisor bean definition and updated ImportAction itself:

<bean id="importContentAdvice" class="cz.shmoula.imports.ImportContentAdvice" />

<bean id="ImportContentAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
    <property name="advice" ref="importContentAdvice"/>
    <property name="mappedNames">
        <list>
            <value>invocateImportScript</value>
        </list>
    </property>
</bean>

<bean id="ImportAction" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="targetName" value="importAction"/>
    <property name="singleton" value="false"/>
    <property name="proxyInterfaces">
        <list>
            <value>cz.shmoula.imports.ImportAction</value>
        </list>
    </property>
    <property name="interceptorNames">
        <list>
            <value>ImportContentAdvisor</value>
            <value>DeployContentAdvisor</value>
        </list>
    </property>
</bean>

<bean id="importActionTask" class="cz.shmoula.imports.ImportActionTask" scope="prototype">
    <property name="importAction" ref="ImportAction"/>
</bean>

Last few lines is definition of importActionTask I wrote in previous post. In this class importAction.invocateImportScript() method is called. This method has one parameter – map of properties of config file (in format <QName, Serializable>) to read them once and have them all the time and not need to call nodeService.getProperties() again and again – in advisors or importAction class. When this method is called, proxy of importAction catches this calling and calls invoke() method on ImportContentAdvice and DeployContentAdvice. Let’s have a look on invoke() method in ImportContentAdvice:

public Object invoke(MethodInvocation invocation) throws Throwable {
    Object[] objects = invocation.getArguments();
    Object result = null;
    Map<QName, Serializable> propertiesMap = __resolve_arguments_to_map_(objects);

    String lockToken = (String) propertiesMap.get(ContentModel.PROP_NODE_UUID);
    setTokenOnTarget(invocation, lockToken);

    try {
        AuthenticationUtil.setRunAsUser(AuthenticationUtil.getSystemUserName());
        misLockingService.createLock(lockToken);

        object = invocation.proceed();

        misLockingService.releaseLock(lockToken);
    } finally {
        AuthenticationUtil.clearCurrentSecurityContext();
    }

    return result;
}

All what ImportActionAdvice does can be seen on previous snippet. It locks used config file to prevent access from another thread, using node uuid as a locking token. Then it authenticates a system user (mainImportThread runs outside any security context) and invocates next chain (DeployContentAdvisor and after then invocateImportScript(), if everything goes ok). After return from invocation lock is released and security context is cleared. If anything happens inside, lock release is skipped, so some rescue mechanisms are automaticaly initiated after some time. Simple, yet effective, i hope.

Import scripts architecture

1

It has been some time since last post about import scripts from external sources to alfresco repository, I was busy with debugging and threading, but now I have some little time to write some notes on that topic again. I’d like to introduce „architecture“ of my solution, at least a first part of it, so lets start with an image.

Calling ImportAction

Calling ImportAction

MainImportingThread is Runnable implementation, which is initiated on init. Main thread sleeps some time and searches for config files in repository, while not sleep. If found some, ImportActionTask instance is created for each config in separate thread. ImportActionTask checks, if is it possible to run script described by config. If so, run script method on ImportAction is executed. That’s in few words functionality of the first part. Now in more details.

First version used quartz jobs triggered by org.alfresco.util.CronTriggerBean every 10 seconds, but that was temporarily solution, too heavy in my eyes. In second version I tried to use BatchProcessor, but spent few days without got it worked as I want :-(. Finally I used ThreadPoolTaskExecutor with combination of java.lang.Runnable in main thread and it worked like a charm! As I wrote a while ago, MainImportingThread has its own separate thread, which cyclically looks for configuration files in repository. It looks like following snippet:

public void init() {
    taskExecutor.execute(new Runnable() {
        @Override
        public void run() {
            while(keepAlive) {
                Thread.sleep(threadSleepMs);

                for(ResultSetRow row : resultSet) {
                    Object oTarget = pool.makeObject();

                    if(oTarget instanceof ImportActionTask) {
                        ImportActionTask importActionTask =  (ImportActionTask) oTarget;
                        importActionTask.setScriptRef(row.getNodeRef());
                        taskExecutor.execute(importActionTask);
                    }
                    pool.destroyObject(oTarget);
                }
            }
            taskExecutor.shutdown();
            pool.destroy();
        }
    });
}

For every row in result set PoolableObjectFactory creates a new instance of ImportActionTask and pass it to ThreadPoolTaskExecutor to execute. After all that – object is destroyed (destroyObject method is there just for sure – in time this method is called action still runs).

ImportActionTask is Runnable implementation, so every action runs its own thread. After execution isTimeToRun() method is called and action runs only when it’s its time and action is enabled, as it defined in data model illustrated on following diagram.

Config model

Config model

isTimeToRun() method uses fields importCron, importLastAction and isImportActive for its work. Its body looks similar to following simplified code snippet:

private boolean isTimeToRun() {
    if(!model.isImportActive())
        return false;

    String cronString = model.getImportCron();
    Date lastAction = model.getLastAction();

    CronExpression cronExpression = new CronExpression(cronString);
    if(cronExpression.getNextValidTimeAfter(lastAction).getTime() > System.currentTimeMillis())
        return false;

    return true;
}

Previous snippet checks cron expression against time of last successfully executed action using org.quartz.CronExpression and in case of success (ie lastAction+cron < current time) importAction itself may be triggered. But more on this next time, right now just another snippet from ImportActionTask, which calls importAction (received from ProxyFactoryBean):

public void run() {
    if(isTimeToRun) {
        try {
            importAction.invocateImportScript();
        } finally {
            importAction.clean();
        }
    }
}
Go to Top