Zobrazují se příspěvky se štítkemjava. Zobrazit všechny příspěvky
Zobrazují se příspěvky se štítkemjava. Zobrazit všechny příspěvky

pátek 30. listopadu 2018

Refactoring, část IV: Odstraňování duplicit

Co je špatně?

Duplicitní kód se sice rychle a snadno generuje (podobně jako diplomky politiků), ale později se ve zlém vrátí tím spíš, čím víc "klonů" existuje. Scénář katastrofy je obvykle rutinní:
  1. Uživatel nahlásí chybu nebo je třeba implementovat novou vlastnost
  2. Chyba se opraví - čili klon se liší od svých pravzorů
  3. Jiný uživatel reklamuje chybu v jiném klonu
  4. Chyba se opraví - obvykle jinak než v prvním klonu.
  5. Ostatní klony jsou neopravené. Trpí stejným problémem? Netrpí jím? Jak to, že fungují správně? Je část klonovaného kódu v jejich případě zbytečná? Nebo nefungují správně, jen ještě nikdo v jejich případě chybu nereklamoval?
  6. Rozdíly narůstají, chyby někde mizí, jinde zůstávají nebo se dokonce mění. Technický dluh roste exponenciálně.

Konfigurace CPD, Copy And Paste Detector


CPD je součástí PMD maven pluginu, čili když už, nejspíš budete používat oba. Kontrolám PMD samotného se ale vyhnu, to si najděte jinde ;)
CPD porovnává soubory a hledá v nich opakující se sekvence "tokenů". Algoritmus lze trochu konfigurovat, viz dokumentace pluginu.

                <plugin>
                    <artifactId>maven-pmd-plugin</artifactId>
                    <version>3.11.0</version>
                    <executions>
                        <execution>
                            <id>cpd</id>
                            <goals>
                                <goal>cpd</goal>
                            </goals>
                            <phase>verify</phase>
                            <configuration>
                                <skip>${cpd.skip}</skip>
                                <minimumTokens>100</minimumTokens>
                                <excludes>
                                    <exclude>**/en/**/*</exclude>
                                    <exclude>**/generated/**/*</exclude>
                                </excludes>
                            </configuration>
                        </execution>
                        <execution>
                            <id>cpd-check</id>
                            <goals>
                                <goal>cpd-check</goal>
                            </goals>
                            <phase>verify</phase>
                            <configuration>
                                <skip>${cpd.skip}</skip>
                                <printFailingErrors>true</printFailingErrors>
                                <verbose>true</verbose>
                            </configuration>
                        </execution>
                    </executions>

Pokud plugin najde dvě stejné sekvence delší jak 100 tokenů, shodí build a vypíše nalezené duplicity. Ty pak budete muset řešit.

Řešení

Fuj: Přehodím řádky

Ano, z pohledu CPD jste z toho venku, ale po pravdě ... vážně myslíte, že jste se problému zbavili? Ve skutečnosti jste se zbavili jen jeho hlášení, problém trvá. Navíc jste si ještě zhoršili orientaci ve třídě.

Fuj: Zvýším minimumTokens

... a zbavím se hlášení. Problém trvá, ale co hůř, ono to často ani nezabere, protože těch duplicit je víc, byť i jen na málo řádcích. Pointa je právě v tom, co vlastně je ten "token". Ta stovka je docela rozumná, proto je taky jako default.

Exkluze

Ta funguje stoprocentně. Není ovšem určená k ignorování skutečných problémů, nýbrž k ignorování falešných hlášení problémů. Může být nalezená duplicita, skutečná duplicita, falešným hlášením? Je třeba si uvědomit, že cílem není zbavit se jakýchkoliv duplicit, ale zbavit se hrozících problémů s duplicitami, zlepšit architekturu, uklidit.

Do exkluze tudíž typicky dávám jednak kód generovaný, se kterým nic nenadělám, jednak třeba JPA entity, které mohou mít velmi podobné vlastnosti, přestože vzájemně nijak nesouvisí. To, že se něco stejně jmenuje, nemusí znamenat, že je to duplicitní - a CPD s oblibou hlásí stejné čtyři settery a gettery, jdoucí za sebou.

Problém může být, pokud nemáte žádnou konvenci, jak třeba JPA entity odlišit od jiných tříd. Hodně štěstí ;-)

Vyvedení do samostatné metody ve stejné třídě

Samozřejmost, pokud je duplicitní kód jediné třídy. Nebo ne? Pokud na 10 řádkách máme 8 lokálních proměnných, tohle nebude smysluplná cesta. Můžeme je zkombinovat do jednoho výpočtu, jenže ... to zásadně zhorší čitelnost, takže taky ne. Takže jiná možnost.

Vyvedení do společného rodiče

Je to možnost, ale je třeba zvážit, zda vyváděná funkcionalita do rodiče opravdu patří. Pokud ostatním potomkům rodiče je tato funkcionalita cizí a nemají s ní nic společného, nedělejte to. Jedině že byste stvořili dalšího "mezirodiče", ale pokud mu nedokážete dát smysluplný název, budu se opakovat - nedělejte to; příliš vysoká hierarchie rodičů a potomků je další problém, čili je tu riziko, že odstraněním jednoho problému vytvoříte jiný.

Vyvedení do "utility" nebo "cizí" třídy

Utilitky, helpery, atp., jsou víceméně neobjektová věc, na druhou stranu netrpí problémy s dědičností, dobře se na ně píšou testy, takže tuhle možnost vůbec nezatracujte.
Podobně je možné, že víte o třídě, kam tento kód vlastně i logicky patří a lze ho odsud sdílet na potřebná místa. Předpokladem je, že vyvedenému kódu dokážete vytvořit nějaké pěkné smysluplné API. Ale to se vlastně týká každého "vyvádění".

Vyvedení do default metody interface

Óóó, jak snadné a efektivní!
Jenže to má háček - nese to riziko. Implementace z abstraktního rodiče, implementující stejnou metodu, má vyšší prioritu než jakýkoliv interface!!!
Vážně si rozmyslete, jestli vyváděný kód může opravdu sloužit jen jako pouhý "default". V případě kolizí pak musíte metodu stejně přetížit a z těla volat Iface.super.metoda(), jinak řečeno musíte říct, kterou z dostupných implementací chcete používat.
Pokud máte ale v rodiči metodu implementovanou, complier vám nic neřekne a neporadí, předpokládá, že to vážně chcete.

Silver bullet: přečtěte si to

Překvápko: někdy není třeba duplicitní blok "vyvádět", stačí oba duplicitní bloky naprosto stejně zjednodušit. Třeba odstranit 10 opakovaných přetypování. Nebo jen něco, co se na obou místech otravně opakuje, vyvést ven a sdílet. Výsledek? Ubyde tokenů, jak prosté, už to nevypadá jako hloupý copy and paste, jen něco, co dělá stejnou věc, a to už není známka copy and paste.

Svět je zase v pořádku :-)

úterý 12. září 2017

Experiments with the Payara Micro, level I

New company, new project, new technologies. Okay, I'm experimenting with Payara Micro. Payara team produces more and more examples in several blogs, but they are very trivial and not always usable in production environment. At this time I'm not sure if I would be able to do the evolution to the final professional system, but it is not a problem, because the application modules are simply Java EE standard modules.
The difference is only in final organisation of the modules, deployment and container configuration, so I can create the standard EAR application in parallel to UBER jar with the Payara Micro. So this style of development is perfectly safe.

Target 

Application with the following modules:
  • DAO and bussines logic service module (JPA, JTA, EJB, CDI?), created but nearly empty in this blog 
  • Web service module (JAX-RS), only one simple service method in this blog 
  • GUI module (JSF), not resolved in this blog 
And project will have also following aggregation alternatives:
  • Uber JAR with Payara Micro - experimental, responsive development 
  • EAR for standard Payara domain 
The reason for this separation of modules is that a JSF GUI application obviously have different requirements than a Web service application. It might not be a problem for some time, but it could be a problem later. This is not any premature optimization - this will force developers to keep in mind the separation line between modules and maybe to create some clean API. That will help right now and it will be simplier to split it later.

There may be even more Maven modules:
  • superpom - common Maven plugin configurations, basic dependency management 
  • project parent - aggregator of all project modules 
  • integration tests for the web service module 
  • selenium tests for the gui module

Dead-end streets and good streets 

Well, I had hard two days with the Payara Micro. Blogs helped, but I always needed more and I was always stucked in some weird state. Yes, it was always my fault, but ... okay, now you can learn from my mistakes.

LOG4J2 

I used LOG4J with SLF4J for many years, it was pretty trivial to make it work and a bit harder to grab logs of embedded Payara in integration tests. I have found a memory leak in old LOG4J's reconfiguration and I know perhaps everything about that.
Now it is worthless with LOG4J2. But finally the configuration was also simple despite I still have not found a way to merge logs of the application and Payara. Example log4j2.properties, seems like a good street:
status = info
dest = err
name = PropertiesConfig
#log4j2.debug = true

property.path = target/logs

filter.threshold.type = ThresholdFilter
filter.threshold.level = debug

appender.console.type = Console
appender.console.name = STDOUT
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = %m%n
appender.console.filter.threshold.type = ThresholdFilter
appender.console.filter.threshold.level = info

appender.rolling.type = RollingFile
appender.rolling.name = RollingFile
appender.rolling.fileName = ${path}/experiment-ws.log
appender.rolling.filePattern = ${path}/experiment-ws-%d{MM-dd-yy-HH-mm-ss}-%i.log.gz
appender.rolling.layout.type = PatternLayout
appender.rolling.layout.pattern = %d %p %C{2.} [%t] %m%n
appender.rolling.policies.type = Policies
appender.rolling.policies.time.type = TimeBasedTriggeringPolicy
appender.rolling.policies.time.interval = 2
appender.rolling.policies.time.modulate = true
appender.rolling.policies.size.type = SizeBasedTriggeringPolicy
appender.rolling.policies.size.size=1024MB
appender.rolling.strategy.type = DefaultRolloverStrategy
appender.rolling.strategy.max = 1

logger.ws.name = org.dmatej
logger.ws.level = debug
logger.ws.additivity = false
logger.ws.appenderRef.file.ref = RollingFile

rootLogger.level = debug
rootLogger.appenderRef.stdout.ref = STDOUT
rootLogger.appenderRef.file.ref = RollingFile  

JAX-RS, lists ... Jackson!

Creating the first JAX-RS web service is pretty trivial ... you need two classes, first to configure the context of services in the module, second to implement the service:

import javax.ws.rs.ApplicationPath;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.glassfish.jersey.server.ResourceConfig;

@ApplicationPath("rs")
public class RestAppConfig extends ResourceConfig {

  private static final Logger LOG = LogManager.getLogger(RestAppConfig.class);

  public RestAppConfig() {
    LOG.debug("RestAppConfig()");
    try {
      packages(RestAppConfig.class.getPackage().getName());
      LOG.info("REST configured!");
    } catch (final Exception e) {
      LOG.error("Cannot configure the REST web services!", e);
    }
  }
}
And the second:

import java.util.Arrays;
import java.util.List;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

@Path("user")
public class UserRestService {

  @GET
  @Path("list")
  @Produces(MediaType.APPLICATION_JSON)
  public Response list() {
    final List<String> list = Arrays.asList("Křemílek", "Vochomůrka"); // UTFG ;-)
    return Response.ok(list).build();
  }
} 
Maven command to run the application, it will be used in all following examples:
 mvn clean install;  mvn fish.payara.maven.plugins:payara-micro-maven-plugin:start -pl :experiment-uberjar
Final part of the log:

[2017-09-12T16:31:25.369+0200] [] [INFO] [AS-WEB-GLUE-00172] [javax.enterprise.web] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505226685369] [levelValue: 800] Loading application [experiment-ws-0.0.1-SNAPSHOT] at [/experiment-ws-0.0.1-SNAPSHOT]

[2017-09-12T16:31:25.681+0200] [] [INFO] [] [javax.enterprise.system.core] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505226685681] [levelValue: 800] experiment-ws-0.0.1-SNAPSHOT was successfully deployed in 12 472 milliseconds.

[2017-09-12T16:31:25.685+0200] [] [INFO] [] [PayaraMicro] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505226685685] [levelValue: 800] Deployed 1 archive(s)

[2017-09-12T16:31:25.686+0200] [] [INFO] [] [PayaraMicro] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505226685686] [levelValue: 800] [[
 
Instance Configuration
Host: dmatej-lenovo
HTTP Port(s): 8080
HTTPS Port(s):
Instance Name: Frail-Barracuda
Instance Group: MicroShoal
Hazelcast Member UUID cbddb9aa-5f21-4ee1-984f-78be942124d4
Deployed: experiment-ws-0.0.1-SNAPSHOT ( experiment-ws-0.0.1-SNAPSHOT war /experiment-ws-0.0.1-SNAPSHOT )

]]

[2017-09-12T16:31:25.702+0200] [] [INFO] [] [PayaraMicro] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505226685702] [levelValue: 800] [[
 
Payara Micro URLs
http://dmatej-lenovo:8080/experiment-ws-0.0.1-SNAPSHOT

'experiment-ws-0.0.1-SNAPSHOT' REST Endpoints
GET     /experiment-ws-0.0.1-SNAPSHOT/rs/user/list

]]
Ok, that was pretty simple. But the service does not work and ends up with HTTP 500 (try it with browser):

[2017-09-12T20:19:02.013+0200] [] [SEVERE] [] [org.glassfish.jersey.message.internal.WriterInterceptorExecutor] [tid: _ThreadID=22 _ThreadName=http-thread-pool::http-listener(3)] [timeMillis: 1505240342013] [levelValue: 1000] MessageBodyWriter not found for media type=application/json, type=class java.util.Arrays$ArrayList, genericType=class java.util.Arrays$ArrayList.

Solution 

Only add the dependency on Jackson to pom.xml and the following line as the first to the RestAppConfig's constructor:
register(JacksonFeature.class);
The final pom.xml of the ws module:

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <artifactId>experiment-ws</artifactId>
  <packaging>war</packaging>
  <name>Experiment - Web Services</name>
  <parent>
    <groupId>org.dmatej.experiment</groupId>
    <artifactId>parent-pom</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <relativePath>..</relativePath>
  </parent>
  <dependencies>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
    </dependency>
    <dependency>
      <groupId>javax.ws.rs</groupId>
      <artifactId>javax.ws.rs-api</artifactId>
    </dependency>
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
    </dependency>
    <!-- to use optimized JAX-RS configuration -->
    <dependency>
      <groupId>org.glassfish.jersey.core</groupId>
      <artifactId>jersey-server</artifactId>
    </dependency>
    <!-- to simply use lists in JSONs -->
    <dependency>
      <groupId>org.glassfish.jersey.media</groupId>
      <artifactId>jersey-media-json-jackson</artifactId>
    </dependency>
  </dependencies>
  <build>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>false</filtering>
        <includes>
          <include>**/*.properties</include>
        </includes>
      </resource>
    </resources>
  </build>
</project>

JDBC Pool 

This was a real pain but solution was so simple ... do you know what I hate? NullpointerException. In fact I appreciate that it exists, because it tells "the programmer was not careful". And if the programmer was not careful, it is a bug - maybe even trivial to fix. But another exception I have seen was ClassNotFoundException ... This is the pom.xml of the UBER jar:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.dmatej.experiment</groupId>
  <artifactId>experiment-uberjar</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>Experiment Uberjar</name>
  <parent>
    <groupId>org.dmatej.experiment</groupId>
    <artifactId>superpom</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <build>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>false</filtering>
        <includes>
          <include>**/*.txt</include>
        </includes>
      </resource>
    </resources>
    <plugins>
      <!-- HOWTO: https://github.com/payara/maven-plugins -->
      <plugin>
        <groupId>fish.payara.maven.plugins</groupId>
        <artifactId>payara-micro-maven-plugin</artifactId>
        <version>1.0.0</version>
        <executions>
          <execution>
            <goals>
              <goal>bundle</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <payaraVersion>4.1.2.173</payaraVersion>
          <useUberJar>true</useUberJar>
          <deployArtifacts>
            <deployArtifact>
              <groupId>org.dmatej.experiment</groupId>
              <artifactId>experiment-ws</artifactId>
              <version>${project.version}</version>
              <type>war</type>
            </deployArtifact>
          </deployArtifacts>
          <customJars>
            <customJar>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-api</artifactId>
            </customJar>
            <customJar>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-core</artifactId>
            </customJar>
            <customJar>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
            </customJar>
          </customJars>
          <commandLineOptions>
            <commandLineOption>
              <key>--autobindhttp</key>
              <value>true</value>
            </commandLineOption>
            <commandLineOption>
              <key>--prebootcommandfile</key>
              <value>${project.build.outputDirectory}/prepare-resources.txt</value>
            </commandLineOption>
          </commandLineOptions>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
The prepare-resources.txt was this (note that empty lines are interpreted as an error):

set configs.config.server-config.admin-service.das-config.dynamic-reload-enabled=false
set configs.config.server-config.admin-service.das-config.autodeploy-enabled=false
create-jdbc-connection-pool --datasourceclassname com.mysql.cj.jdbc.MysqlDataSource --restype javax.sql.DataSource --property user=test:password=test:DatabaseName=experiment_test:ServerName=localhost:port=3306:zeroDateTimeBehavior=convertToNull:useUnicode=true:useJDBCCompliantTimezoneShift=true:useLegacyDatetimeCode=true:serverTimezone=UTC:characterEncoding=UTF-8 experiment-mysql
set resources.jdbc-connection-pool.experiment-mysql.steady-pool-size=5
set resources.jdbc-connection-pool.experiment-mysql.max-pool-size=20
set resources.jdbc-connection-pool.experiment-mysql.connection-validation-method=auto-commit
set resources.jdbc-connection-pool.experiment-mysql.is-connection-validation-required=true
set resources.jdbc-connection-pool.experiment-mysql.fail-all-connections=true
ping-connection-pool experiment-mysql
But it did not work, server startup failed and I had no idea why ... and Payara did not help me ... there were two kind of stacktraces:

java.lang.RuntimeException: Orb initialization erorr
        at org.glassfish.enterprise.iiop.api.GlassFishORBHelper.getORB(GlassFishORBHelper.java:191)
        at com.sun.enterprise.naming.impl.SerialContext.getORB(SerialContext.java:349)
        at com.sun.enterprise.naming.impl.SerialContext.getProviderCacheKey(SerialContext.java:356)
        at com.sun.enterprise.naming.impl.SerialContext.getRemoteProvider(SerialContext.java:386)
        at com.sun.enterprise.naming.impl.SerialContext.getProvider(SerialContext.java:331)
        at com.sun.enterprise.naming.impl.SerialContext.lookup(SerialContext.java:480)
        at com.sun.enterprise.naming.impl.SerialContext.lookup(SerialContext.java:440)
        at javax.naming.InitialContext.lookup(InitialContext.java:417)
        at org.glassfish.resourcebase.resources.naming.ResourceNamingService.lookup(ResourceNamingService.java:236)
        at com.sun.enterprise.connectors.service.ConnectorConnectionPoolAdminServiceImpl.getConnectorConnectionPool(ConnectorConnectionPoolAdminServiceImpl.java:799)
        at com.sun.enterprise.connectors.service.ConnectorConnectionPoolAdminServiceImpl.obtainManagedConnectionFactory(ConnectorConnectionPoolAdminServiceImpl.java:938)
        at com.sun.enterprise.connectors.service.ConnectorConnectionPoolAdminServiceImpl.getUnpooledConnection(ConnectorConnectionPoolAdminServiceImpl.java:549)
        at com.sun.enterprise.connectors.service.ConnectorConnectionPoolAdminServiceImpl.testConnectionPool(ConnectorConnectionPoolAdminServiceImpl.java:430)
        at com.sun.enterprise.connectors.ConnectorRuntime.pingConnectionPool(ConnectorRuntime.java:1162)
        at org.glassfish.connectors.admin.cli.PingConnectionPool.execute(PingConnectionPool.java:143)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$2$1.run(CommandRunnerImpl.java:544)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$2$1.run(CommandRunnerImpl.java:540)
        at java.security.AccessController.doPrivileged(Native Method)
        at javax.security.auth.Subject.doAs(Subject.java:360)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$2.execute(CommandRunnerImpl.java:539)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$3.run(CommandRunnerImpl.java:570)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$3.run(CommandRunnerImpl.java:562)
        at java.security.AccessController.doPrivileged(Native Method)
        at javax.security.auth.Subject.doAs(Subject.java:360)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl.doCommand(CommandRunnerImpl.java:561)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl.doCommand(CommandRunnerImpl.java:1469)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl.access$1300(CommandRunnerImpl.java:111)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$ExecutionContext.execute(CommandRunnerImpl.java:1851)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$ExecutionContext.execute(CommandRunnerImpl.java:1727)
        at com.sun.enterprise.admin.cli.embeddable.CommandExecutorImpl.executeCommand(CommandExecutorImpl.java:169)
        at com.sun.enterprise.admin.cli.embeddable.CommandExecutorImpl.run(CommandExecutorImpl.java:94)
        at fish.payara.micro.boot.runtime.BootCommand.execute(BootCommand.java:65)
        at fish.payara.micro.boot.runtime.BootCommands.executeCommands(BootCommands.java:105)
        at fish.payara.micro.boot.runtime.BootCommands.executeCommands(BootCommands.java:99)
        at fish.payara.micro.impl.PayaraMicroImpl.bootStrap(PayaraMicroImpl.java:987)
        at fish.payara.micro.impl.PayaraMicroImpl.main(PayaraMicroImpl.java:186)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:498)
        at fish.payara.micro.boot.loader.MainMethodRunner.run(MainMethodRunner.java:48)
        at fish.payara.micro.boot.loader.Launcher.launch(Launcher.java:107)
        at fish.payara.micro.boot.loader.Launcher.launch(Launcher.java:70)
        at fish.payara.micro.boot.PayaraMicroLauncher.main(PayaraMicroLauncher.java:79)
        at fish.payara.micro.PayaraMicro.main(PayaraMicro.java:361)
Caused by: java.lang.NullPointerException
        at org.glassfish.enterprise.iiop.api.GlassFishORBHelper.getORB(GlassFishORBHelper.java:163)
        ... 44 more
[2017-09-12T21:42:28.782+0200] [] [SEVERE] [] [javax.enterprise.resource.resourceadapter.com.sun.enterprise.connectors] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505245348782] [levelValue: 1000] RAR6001 : Class Not found : com.sun.gjc.spi.ResourceAdapterImpl


com.sun.appserv.connectors.internal.api.ConnectorRuntimeException: Error in creating active RAR
        at com.sun.enterprise.connectors.ActiveRAFactory.createActiveResourceAdapter(ActiveRAFactory.java:111)
        at com.sun.enterprise.connectors.service.ResourceAdapterAdminServiceImpl.createActiveResourceAdapter(ResourceAdapterAdminServiceImpl.java:212)
        at com.sun.enterprise.connectors.service.ResourceAdapterAdminServiceImpl.createActiveResourceAdapter(ResourceAdapterAdminServiceImpl.java:348)
        at com.sun.enterprise.connectors.ConnectorRuntime.createActiveResourceAdapter(ConnectorRuntime.java:405)
        at com.sun.enterprise.connectors.service.ConnectorService.loadDeferredResourceAdapter(ConnectorService.java:184)
        at com.sun.enterprise.connectors.service.ConnectorService.loadResourcesAndItsRar(ConnectorService.java:148)
        at com.sun.enterprise.connectors.service.ConnectorService.checkAndLoadPool(ConnectorService.java:325)
        at com.sun.enterprise.connectors.service.ConnectorConnectionPoolAdminServiceImpl.getUnpooledConnection(ConnectorConnectionPoolAdminServiceImpl.java:553)
        at com.sun.enterprise.connectors.service.ConnectorConnectionPoolAdminServiceImpl.testConnectionPool(ConnectorConnectionPoolAdminServiceImpl.java:430)
        at com.sun.enterprise.connectors.ConnectorRuntime.pingConnectionPool(ConnectorRuntime.java:1162)
        at org.glassfish.connectors.admin.cli.PingConnectionPool.execute(PingConnectionPool.java:143)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$2$1.run(CommandRunnerImpl.java:544)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$2$1.run(CommandRunnerImpl.java:540)
        at java.security.AccessController.doPrivileged(Native Method)
        at javax.security.auth.Subject.doAs(Subject.java:360)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$2.execute(CommandRunnerImpl.java:539)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$3.run(CommandRunnerImpl.java:570)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$3.run(CommandRunnerImpl.java:562)
        at java.security.AccessController.doPrivileged(Native Method)
        at javax.security.auth.Subject.doAs(Subject.java:360)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl.doCommand(CommandRunnerImpl.java:561)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl.doCommand(CommandRunnerImpl.java:1469)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl.access$1300(CommandRunnerImpl.java:111)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$ExecutionContext.execute(CommandRunnerImpl.java:1851)
        at com.sun.enterprise.v3.admin.CommandRunnerImpl$ExecutionContext.execute(CommandRunnerImpl.java:1727)
        at com.sun.enterprise.admin.cli.embeddable.CommandExecutorImpl.executeCommand(CommandExecutorImpl.java:169)
        at com.sun.enterprise.admin.cli.embeddable.CommandExecutorImpl.run(CommandExecutorImpl.java:94)
        at fish.payara.micro.boot.runtime.BootCommand.execute(BootCommand.java:65)
        at fish.payara.micro.boot.runtime.BootCommands.executeCommands(BootCommands.java:105)
        at fish.payara.micro.boot.runtime.BootCommands.executeCommands(BootCommands.java:99)
        at fish.payara.micro.impl.PayaraMicroImpl.bootStrap(PayaraMicroImpl.java:987)
        at fish.payara.micro.impl.PayaraMicroImpl.main(PayaraMicroImpl.java:186)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:498)
        at fish.payara.micro.boot.loader.MainMethodRunner.run(MainMethodRunner.java:48)
        at fish.payara.micro.boot.loader.Launcher.launch(Launcher.java:107)
        at fish.payara.micro.boot.loader.Launcher.launch(Launcher.java:70)
        at fish.payara.micro.boot.PayaraMicroLauncher.main(PayaraMicroLauncher.java:79)
        at fish.payara.micro.PayaraMicro.main(PayaraMicro.java:361)
Caused by: java.lang.ClassNotFoundException: com.sun.gjc.spi.ResourceAdapterImpl
        at com.sun.enterprise.v3.server.APIClassLoaderServiceImpl$APIClassLoader.loadClass(APIClassLoaderServiceImpl.java:245)
        at com.sun.enterprise.v3.server.APIClassLoaderServiceImpl$APIClassLoader.loadClass(APIClassLoaderServiceImpl.java:237)
        at com.sun.enterprise.connectors.ActiveRAFactory.createActiveResourceAdapter(ActiveRAFactory.java:103)
        ... 40 more
]]

Dead-end street: comment out ping 

Okay, stacktraces are gone. But I don't know if the pool has been created and if it works.

Dead-end street: add dependencies 

Idea: add missing dependencies. The Payara versions are not in Maven Central, so I tried to add glassfish versions of org.glassfish.main.jdbc.jdbc-ra.jdbc-core:jdbc-core:4.1.2 and org.glassfish.main.jdbc.jdbc-ra.jdbc40:jdbc40:4.1.2 ... Result? Several warnings like this and finally exception. Dumb idea? Something similar helped us with old versions of the Embedded Payara started by JUnit integration tests but here it was only a cargo antipattern.

[2017-09-12T21:36:37.619+0200] [] [WARNING] [] [javax.enterprise.resource.resourceadapter.com.sun.enterprise.connectors.util] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505244997619] [levelValue: 900] RAR8000 : The method setLogJdbcCalls is not present in the class : com.sun.gjc.spi.DSManagedConnectionFactory

com.sun.appserv.connectors.internal.api.ConnectorRuntimeException: Failed to create MCF for experiment-mysql
        at com.sun.enterprise.connectors.service.ConnectorConnectionPoolAdminServiceImpl.createConnectorConnectionPool(ConnectorConnectionPoolAdminServiceImpl.java:195)
        at com.sun.enterprise.connectors.ConnectorRuntime.createConnectorConnectionPool(ConnectorRuntime.java:331)
        at org.glassfish.jdbc.deployer.JdbcConnectionPoolDeployer.actualDeployResource(JdbcConnectionPoolDeployer.java:201)
        at org.glassfish.jdbc.deployer.JdbcConnectionPoolDeployer.deployResource(JdbcConnectionPoolDeployer.java:170)
        at com.sun.enterprise.connectors.service.ConnectorService.loadDeferredResources(ConnectorService.java:233)
        at com.sun.enterprise.connectors.service.ConnectorService$1.run(ConnectorService.java:153)
        at java.security.AccessController.doPrivileged(Native Method)
Those two dependencies now remove, they are not needed and more, they are not compatible.

Look into the Payara sources and think

 ... and create this issue: https://github.com/payara/Payara/issues/1967 Oh, by the way, why I did not think it before? ORB factory is simply initialized after the prebootcommandfile execution! Ok, let's move the ping to a new file postboot.txt and add another commandLineOption to pom.xml:
<commandLineOption>
  <key>--postbootcommandfile</key>
  <value>${project.build.outputDirectory}/postboot.txt</value>
</commandLineOption>

MySQL and time zones 

Pool ping was still failing with some weird error message about unknown CEST timezone. StackOverflow advices did not work, neither one about configuring the JDBC driver. I have found several bugs reported to MySQL devs: https://bugs.mysql.com/bug.php?id=86425
I tried to change the server's default-time-zone via the MySql Workbench with no success until I noted that it updates incorrect file in my user's home directory. Finally I added these lines into /etc/mysql/my.cnf and restarted the mysql service ... and it worked.
[mysqld]
default-time-zone = +00:00

Success 

Yes, that was all. But ... there is nothing interesting in the log output, no logging about asadmin commands, no logging about their success. I was lazy to create my own logging.properties and to add path as another commandLineOption so I hacked the jar in maven repository (please, don't do this, don't be lazy!) ... the nearest usable loggers and logs was these:

[2017-09-12T22:23:53.622+0200] [] [FINE] [] [javax.enterprise.resource.resourceadapter.org.glassfish.jdbcruntime] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505247833622] [levelValue: 500] [CLASSNAME: org.glassfish.jdbcruntime.JdbcRuntimeExtension] [METHODNAME: isConnectionPoolReferredInServerInstance] JDBC resource jdbc/experiment-jta refers experiment-mysql in this server instance and is enabled
 

[2017-09-12T22:23:54.398+0200] [] [FINE] [] [org.glassfish.naming] [tid: _ThreadID=1 _ThreadName=main] [timeMillis: 1505247834398] [levelValue: 500] [CLASSNAME: com.sun.enterprise.naming.util.NamingUtilsImpl] [METHODNAME: makeCopyOfObject] [[
  ** makeCopyOfObject:: ConnectorConnectionPool :: experiment-mysql
steady size: 5
max pool size: 20
max wait time: 60000
pool resize qty: 2
Idle timeout: 300
failAllConnections: true
Transaction Support Level: 1
isConnectionValidationRequired_ true
preferValidateOverRecreate_ false
matchConnections_ false
associateWithThread_ false
lazyConnectionAssoc_ false
lazyConnectionEnlist_ false
maxConnectionUsage_ 0
pingPoolDuringCreation_ false
poolingOn_ true
validateAtmostOncePeriod_ 0
connectionLeakTracingTimeout_0
connectionReclaim_false
connectionCreationRetryAttempts_0
connectionCreationRetryIntervalInMilliSeconds_10
nonTransactional_ false
nonComponent_ false
ConnectorDescriptorInfo ->
rarName: __ds_jdbc_ra
resource adapter class: com.sun.gjc.spi.ResourceAdapterImpl
connection def name: javax.sql.DataSource
MCF Config properties-> ClassName:com.mysql.cj.jdbc.MysqlDataSource
ConnectionValidationRequired:true
ValidationMethod:auto-commit
ValidationTableName:
ValidationClassName:
TransactionIsolation:
GuaranteeIsolationLevel:true
StatementWrapping:true
LogJdbcCalls:false
SlowQueryThresholdInSeconds:-1
StatementTimeout:-1
PoolMonitoringSubTreeRoot:resources/experiment-mysql
PoolName:experiment-mysql
StatementCacheSize:0
StatementCacheType:
InitSql:null
SqlTraceListeners:fish.payara.jdbc.SilentSqlTraceListener
StatementLeakTimeoutInSeconds:0
StatementLeakReclaim:false
DatabaseName:iqhouse_experiment
User:test
Password:****
ServerName:localhost
DriverProperties:setcharacterEncoding#UTF-8##setport#3306##setuseJDBCCompliantTimezoneShift#true##setuseLegacyDatetimeCode#true##setuseUnicode#true##setserverTimezone#UTC##setzeroDateTimeBehavior#convertToNull##
Delimiter:#
EscapeCharacter:\
]]  
Now I can continue to level 2: Good REST services ... to be continued ;)

neděle 3. července 2016

Javisté a databáze - základní chyby

Na školení jsem všem implicitně vynadal, že nikdo pořádně neumí používat ani JDBC, ale chtějí (dobře) používat JPA nebo JTA. A co teprve, aby rozuměli trochu tomu, co jejich zacházení způsobí na databázovém serveru ...
Pak se diví, že jim to celé padá na hubu - typicky začnou optimalizovat SQL, ale marně. Jen málokoho napadne, že databázi dávají kapky - pro každý váš požadavek databáze alokuje nějaké zdroje v operační paměti, přidělí vlákno, příkaz zabere nějaké místo na file systému, a databáze čeká až na signál od vás, že už jste hotoví.
Tož si překontrolujte, jestli si databázi nepřetěžujete ...
  • zavíráním statementů
    • kolikrát za sebou generujete stejný prepared statement?
    • nezavíráním statementů
    • jak dlouho má db držet statement?
    • kolik stejných prepared statementů držíte najednou?
    • poslední pomoc: omezit počet použití konexe z poolu, pak jí AS nuceně zavře a otevře novou (Payara)
  • nezavíráním result setů
    • jak dlouho má db držet nalezená data, kurzor?
    • kolik dat to je?
    • fetch size
  • zbytečně dlouhými transakcemi se spoustou změn
    • víte, co se děje v databázi?
    • víte, že i zdroje databáze jsou omezené?
  • nemazáním dočasných tabulek, vytvořených v poolovaných konexích
    • je to v podstatě leak, zapomenutá data pak můžou být náhodně nalezena jiným dotazem, čili hypoteticky to může být i bezpečnostní díra.
  • nadměrným využíváním indexů nebo naopak jejich absencí
    • každé vložení dat způsobí změnu v indexech
    • databáze jsou různě chytré/hloupé při optimalizacích
    • indexy pomáhají při čtení
    • indexy škodí při zápisu
    • někdy se hodí replikace db tak, aby db pro vyhledávání byla důsledněji indexovaná než ta pro zápis
  • chybným nastavením JDBC poolu
    • default lock timeout
    • velikosti bufferů
    • různé optimalizace
    • rozdělení datových zdrojů podle použití (exporty vs. CRUD)
  • chybným nastavením:
    • stmt.setQueryTimeout
    • stmt.setMaxRows
    • stmt.setFetchSize
    • conn.setTransactionIsolation
    • conn.setResultSetConcurrency
    • conn.setHoldability
JPA samozřejmě k relační db přistupují přes jdbc, ale pozor!
  • JDBC transakce není nutně pod JPA transakcí a už vůbec nejsou svázané 1:1
  • JPA transakce není JTA transakce
  • můžou. Je to záležitost nastavení "persistence unit" a také nastavení hintů (viz Query.setHint)
  • EntityManager.unwrap(Connection.class) znamená spuštění JDBC transakce a svázání 1:1 JDBC konexe a JPA manažera se vším, co to obnáší.
JTA se pak řídí hlavně anotacemi, ale pozor pozor!!!
  • pokud si nedáte pozor, můžete si připravit neskutečné magické transakční peklo
  • „requires“ je dobrý default
  • „requires new“ se někdy hodí, ale … uvědomte si, co to znamená!
  • některé posloupnosti těchto hodnot dokážou naprosto šílené věci – s kolika JPA kontexty a JDBC konexemi nakonec opravdu pracujete?
Jste programátoři, vědci, ne pistolníci z televizního divokého západu. Na riskování není čas, musíte přesně vědět, co děláte ;-)

čtvrtek 10. prosince 2015

Loadbalancing with Payara cluster and Apache2

I have tested the configuration on two operating systems - CentOS 7 and Kubuntu 15.10. These instructions are for CentOS, because there it is a bit more complicated.

All application server instances run on Payara 4.1.1.154 - two on CentOS 7 and one on Solaris5.10. Note that for correct cluster replication you need to have configured the multicast routing - or to have all instances on the same network ;)

1) You need to do this as root:
# aka apache2 and modules in debian linuxes
yum install httpd
2) You need time synchronization - one minute error is fatal. You can select another server for time sychronization - check also if it is accessible from the server.
yum install ntp ntpdate
chkconfig ntpd on
ntpdate pool.ntp.org
3) Edit the httpd.conf file and add two lines (use correct hostname, valid from the outside world):
vim /etc/httpd/conf/httpd.conf
ServerName myhost.mydomain.org
LoadModule rewrite_module modules/mod_rewrite.so

4) Edit httpd configuration file and put the loadbalancer settings in it. 
vim /etc/httpd/conf.d/00-default.conf
  • VirtualHost will run on port 80
  • you need some time to hold the session on one instance, where the user logs in - in this time the new session will be replicated to other payara instances in cluster. If the next request would be faster, the session would be invalidated. This is the reason why you need also the ROUTEID cookie - the stickysession changes it's value because a new session is created.
  • third internal host has status +H - that means "hot standby" - it will be routed only if other hosts would be inaccessible.
<VirtualHost *:80>
    ProxyRequests Off
    RewriteEngine Off
    Header add Set-Cookie "ROUTEID=.%{BALANCER_WORKER_ROUTE}e; path=/; Max-Age=60;" env=BALANCER_ROUTE_CHANGED
    ServerName myhost.mydomain.org
    LogLevel debug
    ProxyPass /balancer-manager !
    ProxyPass / balancer://myhost.mydomain.org/ stickysession=ROUTEID
    ProxyPassReverse /  http://myinternal1.mydomain:8300/
    ProxyPassReverse /  http://myinternal2.mydomain:8300/
    ProxyPassReverse /  http://myinternal3.mydomain:8300/
    ProxyPassReverseCookieDomain myinternal1.mydomain myhost.mydomain.org
    ProxyPassReverseCookieDomain myinternal2.mydomain myhost.mydomain.org
    ProxyPassReverseCookieDomain myinternal3.mydomain myhost.mydomain.org
    ProxyPassReverseCookiePath / /
    <Proxy balancer://cisas1.lab.i.cz>
        BalancerMember http://myinternal1.mydomain:8300 loadfactor=1 route=int1
        BalancerMember http://myinternal2.mydomain:8300 loadfactor=1 route=int2
        BalancerMember http://myinternal3.mydomain:8300 status=+H route=int3
        Order Deny,Allow
        Deny from none
        Allow from all
        ProxySet stickysession=ROUTEID
        ProxySet lbmethod=bytraffic
    </Proxy>
</VirtualHost>
5) Allow the httpd service to access the outside world via TCP - without that you will get only HTTP 503 and some message in error_log that the action was declined.
/usr/sbin/setsebool httpd_can_network_connect 1
6) Run the httpd service (and loadbalancing) and watch logs
systemctl restart httpd.service
journalctl -xn
tail -1000f /var/log/httpd/error_log

Payara, aneb zmrtvýchvstání aplikačního serveru Glassfish

SunOne7

Glassfish má za sebou dlouhatánskou cestu ... první, s čím jsem přišel do styku, byl SunOne7. Ten vznikl jako výsledek spolupráce s Netscape a Oracle stále ještě udržuje jakousi stařičkou dokumentaci.

Jeho výhodou byla jedna z prvních podpor EJB (což se ukázalo i nevýhodou, jelikož tato technologie, tj. EJB2 byla prakticky nepoužitelná) a administrační GUI, které naopak použitelné bylo. Z něj se daly konfigurovat a spouštět i vypínat instance aplikačního serveru, čili na tu dobu šlo o vskutku "enterprise" řešení, které v té době nemělo obdoby.
Výhod bylo víc, například integrace JMS a dalších J2EE technologií, aktuálních v roce 2003.
Největší výhodou byla ovšem výborná stabilita. Tenhle aplikáč nám snad nikdy nespadnul, pokud nebudu počítat memory leaky v našich vlastních aplikacích.

Mezi nevýhody patřilo využívání nativních knihoven a tudíž možnost spuštění pouze na OS Solaris, Windows a RedHat 7.2. Rozchodit monstrum jinde vyžadovalo náhodné vyměňování nativních knihoven, než se administrátor "trefil" do konstelace, která fungovala.
A jedna nevýhoda fatální - zapomeňte na zdrojáky nebo artefakty ve veřejných úložištích.
No, pryč od toho ... užili jsme si dost srandy :-)

Sun Java Application Server 8

V roce 2005 přišly specifikace JEE5, JDK5, EJB3, JPA a další, díky kterým se stal starý aplikáč v podstatě mrtvou technologií. Sun se do toho vrhnul po hlavě, část implementací integroval od jiných autorů, část napsal sám - práce odvedl mnoho a velmi rychle, byť s diskutabilní kvalitou.

Tou dobou se už začínala probouzet konkurence - z největších aktuálních jmenujme WebSphere, WebLogic, TomEE, WildFly/JBoss, Jetty, a další. Mírně zastarávající seznamy s malým srovnáním viz wiki nebo wiki.

Přiznávám, že s touto verzí jsem neměl moc zkušeností, jen si pamatuji, že to byl takový mezičlánek, ve kterém byla spousta nedodělků a chyb. V principu to fungovalo, ale ...

Sun Java Application Server 9 aneb Sun Glassfish Enterprise Server 2

SJAS8 byl v podstatě prototyp. SJAS9, později přejmenován na SGES2, znamenal dotažení technologií do konce. Velké problémy byly s JMS (OpenMQ), což byl server provozovaný v serveru, při chybné konfiguraci se prostě zasekl. Důvody jste museli hledat mimo Glassfish, přičemž trvalo dlouho, než jste přišli na to, v čem je přesně problém.
Komunikace mezi GF a MQ probíhala přes porty, a variant konfigurací bylo mnoho, snad ani autorům původně nedošlo, jakou variabilitu jim to dává. To je ale námět spíše na jiný blog - stručně - triviální varianta je "embedded", resp. "zapouzdřený" server, složitá a škálovatelná varianta je "remote" server ...

SJAS9 přišel v roce 2007, zkraje se ještě stávalo, že "zůstal viset" právě díky JMS, později ale byly i tyto chyby vyřešeny a poslední verze SGES2.1.1 byla velmi stabilní a bezproblémová (pokud jí nedestabilizovaly vaše chyby ve vašich aplikacích ;-) ).

Hlavní výhody proti dřívějším verzím:
  • podpora clusteringu - bylo možné provozovat n instancí na m strojích, mezi nimiž se replikovaly sessions uživatelů a bylo možné např. postupné nasazení nové verze, aniž by došlo k výpadku (to samozřejmě mělo svá pravidla, o tom zase jindy).
  • žádné nativní knihovny - kde běží JDK5/6, běží Glassfish (jen občas narazíte na problémy např. s Windows).
  • propracovaná dokumentace
  • kompletní podpora JEE5

Glassfish3

V roce 2010 Oracle koupil Sun a všechno se změnilo. Již předtím jaksi "v ilegalitě" vznikl tzv. Embedded Glassfish, na který jsem narazil prakticky náhodou - kupodivu ve veřejných úložištích, a začal ho používat k integračním testům. Ano, stačil mi JUnit, abych mohl testovat EJB3 s JMS, JPA a se vším všudy!
Embedded Glassfish je totiž přebalené vydání Glassfishe3 do jediného jar souboru. Chybí mu pár XML, která se dají snadno dotáhnout z jiných závislostí a jedete - tak málo stačilo k odstranění největší výtky vůči "enterprise aplikačním serverům"!

Glassfish3 náš tým nakonec přeskočil, ale pomohl nám díky zpětné kompatibilitě se SGES2 právě s testováním.
Embedded Glassfish byl nakonec opět pohlcen Glassfishem a stal se součástí jeho buildu a repository.

V roce 2011 Oracle oficiálně vydal Glassfish3 jako referenční implementaci JEE6. Vzápětí se ale probral JBoss a prakticky Glassfish3 převálcoval.

Byrokracie Oracle navíc silně rozladila některé vývojáře a byla poslední kapkou k jejich přestupu - kam jinam - často k JBoss.
Po vyjádření Oracle o ukončení komerční podpory Glassfishe a o vyčlenění "clusteringu" pouze do komerční verze to vypadalo, že Glassfish prostě skončí, zemře, je konec. Jenže se ukázalo, že tak snadné to mít Oracle nebude ...

Glassfish4 - smrt ... NEBUDE!

Oracle totiž narazil na pár háčků. Nápad s clusteringem vyprovokoval poměrně hlučnou odezvu vývojářů i mimo Oracle, takže od něj bylo ustoupeno. Nápad s ukončením komerční podpory sice Oracle dotáhl do konce, ale nikoho to zase tak moc netrápilo, protože i má osobní zkušenost s komeční podporou Sun/Oracle byla velmi špatná (a je doposud).
Licence Glassfishe ale umožňovala alespoň pasivní přístup ke zdrojákům, a bylo otázkou času, kdy dojde k tomu, kdy je někdo vyžene na GitHub (ano, byl jsem to já, ale ukázalo se, že nejsem první, viz níže :D).

Druhý háček spočíval v tom, že komunita JEE stále potřebuje referenční implementaci a nikdo si jí nemohl jen tak přivlastnit a zamezit přístupu k ní ostatním.

No a poslední háček - všechny implementace JEE7 používají komponenty svých konkurentů. Weld vyvíjí JBoss. EclipseLink vyvíjí Eclipse+Oracle. Catalinu vyvíjí Apache. Pokud by Oracle "zařízl" Glassfish, patrně by nevydal už víc jak jednu jedinou verzi WebLogic, vývoj by se zbrzdil.

A tak v roce 2013 Oracle vydal Glassfish4 jako referenční implementaci JEE7. Změn nebylo mnoho oproti GF3, spoustu práce odvedli externí programátoři, Oracle se zjevně snažil investovat minimum. Čím více chyb v GF, tím lépe pro WebLogic.

Přišel rok 2014 a náš zákazník nakonec souhlasil s "upgrade". Udělali jsme skok z JEE5+JDK6+GF2.1.1 rovnou na GF4+JDK8. Ukázalo se, že to není až tak snadné díky chybám, které ve zdrojácích zevlovaly už od Glassfishe3, čili často 5 i více let.

Payara

Začal jsem zkoumat licence a možnosti, jak se dostat do SVN. Po dnech a nocích, kdy se exporty po různu zasekávaly a padaly díky vadné integritě dat v SVN Oracle, se mi to nakonec podařilo. Nakonec jsem posílal patche přímo do JIRA ... a odezva ... na přijetí jsem čekal nějaké 3 měsíce.

To mě moc nebavilo a proběhla komunikace s šéfem Glassfishe Rezou Rahmannem - pravda, překvapilo mě už, že se se mnou baví, ale ještě víc mě překvapilo, že mě nasměroval na Steva Millige z C2B2 a Payaru.
Po další komunikaci byla moje oprava přijata během 3 dnů do Payary.

Po zastavení komerční podpory Glassfishe se totiž Steve rozhodl, že jí tudíž začne poskytovat sám. Udělal stejný krok jako já, převedl SVN na GitHub, domluvil se s Rezou, a postupně se k němu přidali další a další lidé z komunity, včetně mě.

Tým Payara a jeho přispěvatelé od té doby opravili spoustu chyb a jen tak mezi řečí pomalu posouvají Payaru dál ke specifikaci JEE8. Objevily se požadavky pro podporu Javy IBM, podporována je i Oracle JDK8 (původně 7), opravy se promítají zpětně do Glassfishe od Oracle a samozřejmě - existuje placená podpora, které bych vytkl jen to, že její ceny jsou typicky "enterprise", leč konkurenti nejsou levnější.

Krom toho žije dál i Embedded Payara a vznikly i další distribuce, většinou osekané o nepotřebnou funkcionalitu.

Nakonec vzniklo i toto zábavné reklamní video:

Placená podpora

Na druhou stranu, za Tomcat podporu taky neplatíte, že? Ale to, co umí Payara rozhodně neumí ;-)

Ve výsledku placená podpora slouží hlavně k čestné podpoře profesionálních týmů, které se o tyto projekty starají. Proto pokud pracujete na projektech pro velké firmy či stát, měli byste podporu platit.
Ve skutečnosti sice nezískáte větší podporu, než máte, leč přispíváte tím k tomu, aby aplikační server, který používáte, mohl být dál vyvíjen a udržován, tj. abyste po dvou letech nezjistili, že projekt prostě skončil a vy jedete na mrtvém koni. Což není tak málo, když si to tak vezmete, ne?

V tuto chvíli to vypadá tak, že C2B2 míří mezi velké firmy. Její vývojáři konzultují chyby ve Weld i EclipseLinku, komunita si vypomáhá, zatímco Oracle si stále něco plácá na svém písečku a o ostatní se moc nestará, ale možná je to jen můj pocit ...

Budoucnost

Kdyby někdo měl pocit, že na to má, tým Payary shání vývojáře. Já tam zatím nejdu, mám svůj boj jinde, který navíc slouží jako výborný obří reálný testovací příklad pro Payaru. A zatím můžu říct, že se všichni lepšíme.

Momentálně Websphere, WebLogic ani WildFly neumí všechno, co umí Payara. Možná umí něco navíc, možná něco umí lépe, ale ne dost na to, aby mělo cenu přecházet. Zvlášť když je Payara možná ještě převálcuje :-)

Řekl bych, že i Oracle na to nakonec nutně přijde a bude muset se k tomu postavit čelem. Těžko může komplikovat práci ostatním skrz licence, spíše bych hádal, že se C2B2 pokusí koupit a zklikvidovat, pokud tato konkurence začne být až moc silná.
Dokud ale bude Glassfish na GitHub, bude velmi těžké jeho "lepší klony" kontrolovat, uzmout zpět, takže tahle cesta Oracle asi nepomůže, ne na dlouho. Glassfish není jediný takový projekt, open source se dá sice všelijak poškodit, ale jen stěží kontrolovat, pokud má pod nohama tak silnou infrastrukturu, která má navíc pozitivní efekt i pro komerční obříky.

Časy se mění ... jedno riziko bych tu ale viděl - a tím je paradoxně TTIP (v odkazu TPP, což je podobná dohoda) a různé formy kontroly internetu. Představte si, že vám vláda zablokuje, omezí nebo zpoplatní přístup na GitHub ... že je to paranoidní nápad? Možná - ale třeba tlak například na omezování síly šifer už tu dávno je.
Mimochodem, na některé weby a videa se nedostanete už teď. BBC blokuje přístup na (některá?) videa mimo UK, Youtube "tají" videa před Němci, atd. - co nevidíme, o tom nevím, tohle jsou jen zkušenosti, na které jsme narazili náhodou s kamarády v zahraničí.
To je ale už úplně jiné téma ...

neděle 22. února 2015

Refaktoring, část III.: HashMapové peklo

Proč?

Protože HashMap je objekt, do kterého lze vložit leccos. A to doslova leccos, a vždycky pak musíte předpokládat, že tam různá leccos jsou. Vy ale máte objektový jazyk (nebudeme slovíčkařit), a tak pro objekty obvykle nacházíte jména, definujete jejich chování a vlastnosti. A to je to místo, kde to skřípe - mapa je něco, co objekty dostává s nějakým klíčem a pod tím klíčem je zase vrací. A je v tom fakt dobrá - jenže vám neumožní nic víc.
Je je to jako kdybyste v kuchyni měli obrovský pytel a do nej házeli nákup - pytel brambor, konzervy, kořenky, láhev piva a láhev mléka ... a když něco chcete, otevřete pytel a hledáte. Možná těch pytlů máte více a všechny vypadají stejně.
Mapy jsou zkrátka vhodné na vkládání neomezeného počtu věcí ideálně stejného typu pod klíčem stejného typu a pak k jejich vyhledávání podle tohoto klíče.

Naopak nejsou vhodné na vkládání omezeného množství dat, které navíc dokážeme snadno pojmenovat, odlišovat, známe chování, možnosti, můžeme (a chceme!) ho dokonce zdokumentovat, ať už méně nebo více.

Jak takové peklo vzniká?

Jak jinak, vzniká z lenosti programátora - kterému přijde hloupé a pracné zakládat spousty nových tříd, které mají jen atributy a k nim příslušející gettery a settery. Ten pak udělá v nejhorším případě toto:
Map data = new HashMap();

Samozřejmě pak nevíte, co v datech máte, a musíte pořád dokolečka hledat klíče a všechny možné varianty typů hodnot, které se mohou vyskytnout.

Nicméně i když onen programátor mapu otypuje, čili vytvoří
Map<String, String> data = new HashMap<>();
nemáte vůbec vyhráno. Pořád totiž nevíte, pod jakým klíčem je třeba příjmení osoby ... a jestli tam vůbec je. Ani konvence vás nezachrání, pořád to může být surname, lastname, lastName ...
Napsat pak takový kód lze samozřejmě celkem rychle, pokud nevyvíjíte něco složitého, ten den to udržíte v hlavě. Dokonce na to lze napsat testy, nicméně nic z toho vás nevysvobodí, až se v kódu po půl roce provozu objeví chyba a vy nebo někdo jiný jí bude muset opravit. Nebo ještě druhá varianta, dostane za úkol ho rozšířit o další funkcionalitu ... najednou se projekt prodraží a nikdo nedokáže říct ani řádově přesný odhad, kdy to bude hotové.

Pokud pak používáte JSP, výsledek programátor nejspíš strčil do pageContext, což je vlastně taky hash mapa, resp. celá hierarchie map, které kontejner průběžně zahazuje nebo maže dle kontextu.

Pokud takový kód psal externista, je nejspíš už bezpečně daleko ... a je to vaše starost.

Jak z toho ven?

Tohle určitě nechcete slyšet, ale máte smůlu - čeká vás dřina!
Pokud používáte JSP, jakkoliv tuto technologii spousta lidí nemá ráda, vám tentokrát pomůže. Ona se totiž dívá na typ objektu, se kterým zrovna pracuje - pokud je to Map, zavolá get("xxx"), jinak zavolá getXxx(), takže jí můžete pod rukama prohodit instance v kontextu, a ona se přizpůsobí.
I tak to ale bude dřina, nicméně tady je její druhá hranice - pokud tedy programátor nevymýšlel jiné šílenosti, ty by jinak bylo vhodnější vyřešit předem ...

Pak už nezbývá než otrocky si na papír vypsat všechny klíče, které se v mapě vyskytují, mapu nahradit vhodně pojmenovaným objektem, a připravit pro klíče stejnojmenné settery a gettery; pozor, přejmenovávání doporučuji nechat na později!
Pokud si nejste jisti typem atributu, pro začátek doporučuji třeba String - kompilátor vám už v editoru vyznačí, kde to nesedí. Naopak Object nedoporučuji, protože se o případné chybě nedozvíte.

No a to je vše. Je? Není. Ještě musíte vychytat některé důsledky. Co když někdo volal isEmpty(), size(), používal výstup z put()?

Mně mapy ale nevadí

Někteří lidé pořád nechápou, co je na tomhle použití map špatně. Tak ještě ... nemůžete plně využít dědičnost, overloading, generiky, přidávat objektům metody, atd. Zkrátka to, co vám jazyk umožňuje, využíváte jen z malé části, neefektivně. Dokonce to hloupoučké maličké leč poctivé POJO zabírá i méně místa v paměti ...
Ale hlavně - čitelnost kódu, to, že vždycky víte, s čím pracujete, kolik to má metod a jakých, co to dělá, k čemu to je, to je to, kde mapa vždycky prohraje, říkajíc
"No, vy mi něco dáte, řeknete mi, jak to poznám, a až to budete chtít, tak já vám to zase vrátím. Jo a taky vím, kolik už toho držím. Co? To není moje starost ... že mám reprezentovat osobu a vracím vám SPZ? Tomu já nerozumím, co mi je do toho?! Když mi dáte konexi do databáze, budu jí držet taky, no a?! Umím to, všechno udržím!"

Řekl bych, že v ten moment tomu nerozumí i někdo jiný ... a ten bude autora kódu proklínat - že na to nevěříte? Jóó, kdo ví ... ;)

sobota 17. května 2014

Refaktoring, část II.: Technický dluh

Aneb kapitola (nejen) pro manažery, ekonomy, zkrátka byrokracii, která rozhoduje o investicích, financování, směrování projektů - a taky o tom, kdy se projekt uzavře jako "hotový".
Původně jsem chtěl jít rovnou na zdrojáky, ale událo se něco, co mě přimělo vložit ještě jednu kapitolu. Zjistil jsem totiž, že u nás se o technickém dluhu až zase tak moc nemluví. Nicméně programátorší "guru" o této metafoře mluví už docela dlouho:

Co je to?

Manažeři i zákazníci milují vodopádový model: objednávka, zadání, analýza, zhotovení, akceptace, zaplacení. Nic složitého to přece není, vypadá to triviálně a jednoznačně. Ti zkušenější už ví, že každá ta fáze skýtá mnohá nebezpečí a pasti. Obecně nejednoznačnost a nedotažení každé té fáze - příčinou je obvykle neznalost přesných požadavků a neznalost způsobu výroby na druhé straně.

Zjednodušeně řečeno, technický dluh vzniká vždy, když kdokoliv na projektu odloží něco, o čem dobře ví, že je třeba udělat, ale odloží to - ať už se to týká analýzy, testů, dokumentace, vyčištění kódu.

Jak moc to vadí?

To je různé - asi jako inflace, státní dluh, vaše dluhy; proto se tomu říká technický dluh. Jsou to nedodělky, ale ne jen ty, které vidíte při předvádění aplikace. Ty skryté jsou daleko nebezpečnější. Proč? Nedodělky, které vidí uživatel, viděli všichni během vývoje projektu, a došlo k nějakému konsenzu, že jde o kompromis, se kterým uživatel dokáže žít.
Nedodělky, které ale vidí jen programátoři (pokud je vůbec někdo vidí), mají vlastnost právě té inflace - je to exponenciální funkce. S každou další iterací se umocňuje vliv dluhu, veškerá jeho negativa. Dlouho to nemusí vadit, ale když nad technickým dluhem ztratí vývojový tým kontrolu, už není cesty zpět a vývoj projektu skončí s potupnou ztrátou a obviňováním všech, kteří se na něm podíleli, navzájem.


Exponenciální funkce

Je jasné, že udržet projekt bez dluhů je prakticky nemožné. Vždycky se dá všechno udělat lépe. Na druhou stranu, když dluhy nesplácíte, špatně skončíte. Z vlastní praxe bych to rozdělil na takové tři kategorie (v horším případě fáze) ...

Dluh pod kontrolou

Dobrý stav, který znamená, že projekt má budoucnost a přestože obsahuje pár chyb (někdy i hodně), má smysl v něm pokračovat. Příznaky jsou následující:
  • vývojáři dávají celkem rozumné odhady pracnosti
  • nikdo není nervózní, panují dobré vztahy
  • vývojáři se těší na další úkol
  • většinou se stíhají termíny

Zadlužení

To už je horší stav, ale není nezvladatelný. Nesmí se podcenit - i za cenu oddálení termínu předání další verze je nutné dluh udržet nebo ideálně snížit. S každým dalším nárůstem se situace zhoršuje. Příznaky tohoto stavu jsou takové:
  • vývojáři pracují přesčas, často neplaceně a dobrovolně
  • zpravidla se nestíhají termíny, předání verze se oddaluje i opakovaně
  • často se mění analýza během vývoje
  • množí se požadavky na "až"
  • horší se přesnost odhadů pracnosti - obvykle se podstřelují v toužebné snaze všech stihnout termín
  • tendence přidávat lidi do zpožděného projektu
Management nechápe, proč se dříve termíny stíhaly a teď ne, má tendenci přitlačit, motivovat, ale prakticky dosahuje jen jediného - zvýšení tlaku a stresu, což často končí odchodem zaměstnanců, zpravidla těch nejlepších v první řadě, těch nejhorších potom v řadě druhé. Zůstávají jen bojovníci - pokud se dokážou vzepřít veškeré nepřízni, má projekt ještě naději.

Exekuce se blíží

V tuto chvíli se podívejte opět na ten graf exponenciální funkce. V určitém bodě se dostanete přes hranici, kdy vývoj dalších verzí projektu stojí ohromné zdroje a úsilí a jste ve stavu, kdy je extrémně těžké s tím něco začít dělat.
  • vývojáři často mění své odhady, klidně o dva řády - z hodiny je týden, z týdne 20 minut.
  • jakýkoli termín vyvolává šílený smích vývojářů
  • panuje nervozita a dochází k hádkám a práskání dveřmi
  • manažeři zakazují jakoukoliv údržbu, dovolené, a snaží se do projektu dostat nové lidi - a to jakékoliv
  • neprovádí se analýza, nebo jen povrchně
  • nehledí se na žádná kvalitativní měřítka
Je téměř vyloučeno, abyste se dostali z této fáze zpět. Pokud chcete v budoucích projektech uspět, uvědomte si, co jste zanedbali dříve, podcenili. Není to o tom, že jste měli požadovat vyšší cenu nebo sehnat více lidí.  Vždy potřebujete čas a vždy potřebujete nějakou stabilní kvalitu. Na tom, co děláte dnes, budete stavět zítra.

Udržování dluhu pod kontrolou

Všechno je vlastně docela snadné a pro řadu souvisejících problémů dokonce existují nástroje.

Odhadování pracnosti

To je problematika, na které často stojí váš úspěch - odhadnout, kolik času budete potřebovat na zhotovení něčeho, o čem ještě nemáte "ani páru", je trochu neřešitelný úkol. Existuje na něj řada strategií a doporučení, ale vždy ke kvalifikovanému odhadu potřebujete přehled. Odhad navíc nemůže být definitivní - je to jen odhad, že ...

P: "Devět žen neporodí ani jedno dítě za jeden měsíc. Chápeš?"
M: "Jojo, tohle ví každej, to znám ... Ale Ty jsi chlap!"
P: "Máš pocit, že devět chlapů nějaké dítě porodí?" 

Jak se projevuje technický dluh na odhadu? Představte si, že máte nějakou knihovnu, kterou lehce zanedbáváte - používáte jí ale v aplikaci bez problémů. Přijde ale nový úkol pro aplikaci, při kterém ale zjistíte, že v knihovně je chyba. Také zjistíte, že chybu jste v jiných aplikacích, které na ní už narazily, obešli. Jenže tuto obezličku v nové aplikaci uplatnit nemůžete, protože je v rozporu se zadáním - a navíc jste tehdy nepsali ani testy, takže ani nevíte, co všechno se opravou naopak rozbije.
A tak vám nezbude, než chybu opravit, čímž ale možná rozbijete již hotové aplikace s obezličkou. Tudíž pak budete muset i dopsat testy a opravit i tyto aplikace.

A teď se krátce zamyslete - jaký asi byl původní odhad? Kolikrát ho během opravy změníte? A jaká byla výsledná pracnost? Tím to ale nekončí - opravené aplikace bude možná třeba také distribuovat, takže nám vzniká další pracnost.
Ufff, tohle bolelo. A ještě bude, protože všem musíte vysvětlovat, co se vlastně stalo a proč - a čas běží dál a náklady rostou.

Psaní automatických testů

Automatický test je vlastně další kód, který programátor napíše nejlépe předtím, než začne programovat nějakou funkcionalitu aplikace. Test není součástí aplikace, ale verzuje se spolu se zdrojáky, a moderní programovací jazyky velmi pečlivě zohledňují testovatelnost.
Není žádná výmluva pro nepsaní testů, nikdy. Už dobrých 20 let se považuje za prokázané, že automatické testy vedou k
  • rychlému nalezení chyb nového kódu
  • ujasnění designu a zpětné vazbě analýze dříve, než je aplikace hotová
  • rychlému nalezení chyb, které způsobily opravy na jiném místě
  • konzistentnímu refactoringu (nic se nerozbije)
  • dokumentaci funkcionality (test minimalisticky ukazuje, jak se funkcionalita používá)
Naopak prosby nebo dokonce zákazy manažerů, aby se psaní testů odložilo, protože není čas, končí tak, že
  • dostanou funkcionalitu ještě později
  • druhý den se opravuje oprava dne předchozího, den za dnem
  • nikdo neví, co to vlastně dělá a k čemu to je (brzy ani autor)
  • jakákoliv změna v kódu znamená nutnost manuálního přetestování skoro celé aplikace, protože nikdo neví, co všechno změna ovlivnila

Refactoring

Refactoring se přímo zaměřuje na snižování technického dluhu. Obvykle je dobré začít psaním testů, dopisováním //FIXME a //TODO, případně komentářů, kam si zapíšete své objevy proč a co se v tom daném místě děje, co je na tom špatně, jak by to mělo být správně. Tyto komentáře neslouží k tomu, aby v kódu zůstaly, ale abyste se při své analýze neztratili.
Musíte postupovat opatrně, protože se pohybujete na "minovém poli" (proto kód chcete přece refaktorovat), a krok vedle může znamenat, že své úpravy zahodíte (dokud je ještě čas).

Refactoring předně slouží k tomu, aby byl kód čitelný, měl jasné odpovědnosti a funkcionalitu, choval se předvídatelně a funkcionalita byla vždy k nalezení tam, kde jí člověk hledá. Potom se na kódu teprve dá stavět něco dalšího, kde nebudete muset vymýšlet žádné obezličky.

Refactoring nikdy nekončí - ke každému kódu se po čase musíte iterativně vracet, protože jak se rozvíjí aplikace, je občas třeba změnit trochu i uspořádání kódu, sloučit věci, které se původně zdály rozdílné, ale nejsou, rozdělit věci, které původně dělaly téměř totéž, ale už dávno to není pravda, atd.
Ač se to některým lidem zdá pořád neuvěřitelné, nečitelnost kódu, velké množství duplicit a slabé pokrytí testy mají extrémní vliv na jakýkoliv budoucí rozvoj, daleko větší než sebekomplikovanější zadání.

... a odkládání

Pokud se údržba zanedbává, problémy na sebe nenechají dlouho čekat:
  • náklady na rozvoj aplikace jsou čím dál vyšší, neúměrně požadavkům zákazníka
  • opravené chyby uživatel opět hlásí jako neopravené (našel je i jinde)
  • aplikace se chová nekonzistentně (a uživatel jí nenávidí)
  • aplikace potřebuje více paměti a je pomalá
  • vývojáři trvá velmi dlouho, než zjistí, co má vlastně dělat, těžko se orientuje
  • n testů téže věci a podobná věc není otestovaná vůbec
  • nepřehledná dokumentace, nepřehledné testy, nepřehledná aplikace
  • vývojáři nenávidí aplikaci a po čase odchází jinam (nepodceňovat!)
Často se ale zapomíná také na to, že jsme jen lidé a zapomínáme. O týden odložená údržba už znamená, že se v ošklivém kódu přestává orientovat i jeho autor, a nejen rozvoj aplikace, ale i její údržba stojí více, je namáhavější a také při ní pravděpodobně vznikne více chyb.Je to podobné jako s úvěry - u některých můžete odložit několik splátek, ale pak je bude mnohem těžší dohnat. Možná to už nezvládnete ...

Nástroje

Co se týče sledování odhadu technického dluhu u nás používáme SonarQube; V této aplikaci je i řada dalších metrik kvality software a dá se říct, že je to jediná aplikace, kterou znám, která umí zobrazovat i historii různých hodnocení projektů a dá se i zhruba použít k porovnávání kvality. Podotýkám, zhruba, protože žádný software nemůže posoudit to, jak vaše aplikace plní požadavky uživatele a zákazníka.

No a pokud jde o nástroje pro vývojáře a tvorbu automatických testů, refactoring a vývoj obecně, ti už "ty svoje" nástroje určitě dobře znají ;-)

neděle 13. dubna 2014

Refaktoring, část I.: Proč já?!

Úvod

Četl jsem už spoustu článků i blogů o tom, co programátor má nebo nemá dělat, a jak užitečný a dokonce nutný je refaktoring. Nikde se ale moc nepíše o strategiích refaktoringu a dost lidí se ho pořád i tak trochu bojí. Tož jsem se rozhodl, že o tom něco napíšu sám, neb s tím mám dlouholeté zkušenosti.

V roce 2007 jsem přišel do firmy ICZ, jako "junior", který o Javě "už někde slyšel". Ne jako nějaký odborník, zkraje jsem byl zkrátka tolerován. Ne na dlouho ... po dvou měsících na jednom projektu ze mě udělali vedoucího projektu jiného, o dost většího, který dodnes (2014) přežil leccos, neustále narůstá a komplikuje se, ale paradoxně se i zlepšuje jeho stabilita i udržovatelnost - přitom na něm dělá pořád míň a míň lidí. Jak to?
Postupně začnu popisovat své zkušenosti - řekněme takovou formou "občasníku". Nebudu vám vtloukat do hlavy agilní metodiky, scrum, extrémní metodiky, zkrátka, nebudu vám říkat, co máte dělat. On totiž každý projekt potřebuje "svoje". To samozřejmě není nic proti těm metodikám, je dobré je znát, a vybírat si vhodné "zbraně k boji".
Jen pro zajímavost: "můj" projekt má po 11 letech vývoje zhruba 500 000 řádek kódu (kódu v Javě! čili ne javadoc, ne prázdné řádky a dokonce ani webové stránky - JSP).

Jsem nový v týmu

Tak to začalo. Návyky z minulé práce se tu nevedly. Nové návyky byly pro mě zvláštní, nové, chvílemi jsme se vzájemně odsuzovali, ale ve výsledku jsme stále táhli za jeden provaz.

Fáze 1: První zákaz

Když jsem uviděl víc jak 1000 řádkovou třídu, servlet, dokonce s jedinou metodou, chvíli jsem na to zoufale zíral, a pak začal refaktorovat. Když jsem se zmínil šéfovi, bylo mi řečeno, že nemám "spravovat co není rozbité" a "zákazník tohle neplatí".
Obvyklá rada zní - z takové firmy rychle utíkejte!
Mám takový "zlozvyk", vlastně dva:
1) Neutíkám z boje, nerad se vzdávám, radši zkusím, co se s tím dá udělat.
2) Nenechám si zakázat něco, o čem vím, že to dokážu dotáhnout do konce.

Fáze 2: Tolerance

Ukázalo se, že porušení zákazu nemá negativní důsledky. Pořád mi to nikdo nevěřil, někteří programátoři mě považovali za magora, kamikaze, a někteří to vzali jako výzvu. Výsledkem bylo mlčení na obou stranách, termíny se stíhaly, všechno víceméně fungovalo jako předtím, ok.
V tuhle chvíli se musím zastat možná i vašich projekťáků: postavte se do jejich role, pochopte, o co jim jde:
1) Více změn, větší pravděpodobnost chyb.
2) Změny v předaném hotovém kódu mohou způsobit změnu chování a ta se těžko vysvětluje zákazníkovi - ten NECHTĚL, abyste cokoliv z toho měnili.
3) Pokud se nestihne termín, vaší firmě hrozí penále a pokud navíc měníte něco, co nikdo nechtěl měnit, bude to bez slitování. Zákazníka refaktoring nezajímá, berte to na vědomí.

Musíte získat důvěru šéfa, ne hysterčit. Musíte být dost pečliví a dobří na to, aby se za vás mohl s čistým svědomím postavit.

Situace, kdy v týmu panuje nevraživost, když se se svými šéfy nechcete bavit o tom, co děláte, a vzájemně si lžete, je opravdu chvíle vhodná ke zvážení odchodu jinam. Ale pokud se to ani nepokusíte změnit, pravděpodobně jinde dopadnete stejně.
Většina programátorů jsou vysokoškoláci, odborníci, experti, dokonce se dá říct vědci. Pokud něco víte, musíte umět taky najít argumenty, důkazy, a mít trpělivost je ukázat a vysvětlit každému, komu bude třeba. Já vím, nejspíš jste ve vsyvětlování stejně špatní jako já - učte se to, jinou radu nemám ;)

Změna týmu (vítej v pekle!)

Fáze 3: Nedůvěřivá polopodpora

Po pár měsících mě přesunuli do jiného týmu na jiný projekt, kterému nikdo z programátorů nechtěl velet.
"Unit testy? Co to je? To si nikdo neobjednal!" - první reakce na otázku automatických testů. Refaktoring mi byl opět zakázán a opakovaně jsme si s projekťákem vysvětlovali, proč ano a proč ne - nicméně nikdy jsem s tím nepřestal. Testy jsme ale nepsali ještě dlouho.
Můj první úkol byla "opravička" (podle zadání droboučká) v aplikaci, která měla asi 5000 řádek ve 4 třídách (jedna měla přes 3000 řádek). To snad ani nebyla Java, to bylo peklo. Dostal jsem na to 12 člověkodní. Po dopoledni, stráveném "pícháním klackem" do zdrojáků, jsem pochopil, že netuším, co to dělá a jak.
Za nějakých 5 člověkodní jsem z těch 4 tříd udělal 42, aniž by se aplikace chovala jinak. Jen víc psala do logů. Později popíšu detailně, jak na to ;)
Za další den jsem našel hledanou chybu. A cestou našel asi 4 další, které stoprocentně uživatel musel vidět také!
Při ručním testování se zjistilo, že analytici našli další chyby, a že jsou i v provozní staré verzi. Po konzultaci se zákazníkem došlo i na opravy těchto chyb, načež po 7 člověkodnech jsem byl hotov (později vysvětlím, jak se to pozná ;)).

Fáze 4: Poplácání po zádech ... a ... a jéje

Ano, to byla malá výhra. A protože jste "fakt dobří":
1) Příště máte času polovičku, ne-li mnohem méně
2) Dostanete na starost ostatní programátory
3) Nekonečné konflikty se všemi, jen vedoucí sousedního týmu se vám směje
4) Přibývá stresu, ubývá chuť k práci
5) Není čas na změny

Tohle je začátek konce, kdy nakonec buď odejdete, nebo dospějete a postavíte se definitivně na vlastní nohy. Opět jsme u argumentace - té se nikdy nezbavíte!

Odhad pracnosti

S oblibou přirovnávám práci programátora k luštění křížovek - hodí se to jak pro vysvětlování věcí projekťákům, tak laikům.
Baví vás to? Tak si představte, že 8 hodin denně, 5 dní v týdnu, luštíte křížovky. Máte pocit, že vás to bude bavit? Ne, programátor vážně není "dělník, co jen pracuje hlavou"!
Takže, zkuste to takhle - šéfovi přineste libovolnou těžší křížovku, a za 5 minut se ho zeptejte, kdy jí už bude mít hotovou. A pak jemně konstatujte, že když on po vás chce odhad, je to podobné.
Pokud je navíc kód ve stavu, kdy se v něm nelze vyznat, je odhad prakticky nemožný. Nenaděláte nic, neexistuje řešení, jak dát byť řádově přesný odhad. Ano, měsíc je vhodná jednotka na jakoukoliv změnu v takovém kódu!

Programátoři

To znáte z amerických filmů, typicky vojenských, sportovních. Ne, nejsou to blbci, naopak! Někteří jsou chytří až moc - což je nejhorší varianta, pokud si je nezískáte na svou stranu. Oni se ve svém kódu přece vyznají a funguje! Nic je nedonutí změnit přístup, formátování, přestat psát Javu ve Vimu, používat na všechno statické metody s názvem a() a 20 parametry nebo hashmapou (vede se věčný boj, co z toho je horší).
Krom věčného vysvětlování a kontrolování cizí práce musíte stíhat i své vlastní programování. Ne, nemůžete přestat programovat - jednak by tým přišel o (aspoň jakýstakýs) vzor, jednak je to váš způsob získat si nějakou autoritu, ale hlavně se pořád ještě učíte nové věci - nemůžete radit a dohlížet na jiné, když sami nevíte, jak na to.
Ano, je to přesně jako v těch amerických filmech: hledejte silné stránky, buďte tolerantní, ale zároveň někdy musíte prostě někoho seřvat, nedá se nic dělat. Pravda je, že až tady mě naučili se "nasrat", do té doby jsem byl flegmatikem.

Konflikty

Z předchozího odstavce už je jasné, že buď najdete alespoň nějaké spojence, nebo odejdete. Nebo zatnete zuby a budete makat, dokud všechno nepřijde samo.
Jako vedoucí jsem byl tehdy řekl bych dost špatný. Jako programátor jsem dělal velké pokroky, ale nově nabyté zkušenosti a informace jsem neměl dost zažité na to, abych je někomu dokázal předávat.
Zpětně vím, že mám vážně moc dobré šéfy. I když se někdy hádáme, odsekávám, jednou jsem projekťáka dokonce nazval diletantem, načež on se neurazil, počkal, až "vyšumím", já se omluvil, a argumentoval a argumentoval, než jsme se nějak dobrali k tomu, že "doufá, že vím, co dělám".
Zkrátka, pokud víte, že jste něco přehnali, nebo dokonce byli na někoho nespravedliví, řešte to co nejdřív a velkoryse.

Stres

S tím mám problém dodnes. Je toho moc. Rady už znám taky, ale neumím se jimi důsledně řídit: vstávejte rituálně, pravidelně a stejně pravidelně choďte z práce. V práci nezapínejte Facebook ani jiné podobné blbiny, žerou neuvěřitelné množství času a oberou vás buď o výsledky, nebo o zbytek dne, kdy ty výsledky budete dohánět. Dodržujte pitný režim a jezte střídmě. Po práci se fyzicky hýbejte.
Tož jsem si to teď hezky sepsal, třeba se konečně polepším :-)
Chuť k práci mám, tu mi dává pohled zpátky na to, co všechno se už změnilo k lepšímu.

Změny

Z pohledu projekťáka, natož zákazníka, není na výslovně zákazníkem neobjednané změny čas nikdy.
Takže pracujete tak trochu v ilegalitě. Opět, jste experti, musíte vědět, co můžete změnit a co nemůžete změnit v dané iteraci. Prakticky jde o to, aby to neoddálilo termín - a pokud, aby to bylo obhajitelné. Což se lehko říká, ale těžko dělá.
Řekněme, že do toho budete dávat zhruba 30% času týmu. Pro projekťáka je to strašně moc a bude to chtít snížit. Nebo aspoň pro tuhle iteraci. Ne, neexistuje. Proč? Protože pokud to neuděláte TEĎ, termín bude možná (!) splněn, ale:
1) Větší riziko (řekněme rovnou, jistota) chyb, které tým bude řešit zdarma v rámci záruky
2) Oddálení údržby neznamená, že příště jí strávíte 60% další iterace, ale zůstane tam těch 30% a mezitím vám přibude produkce z minulé iterace.
3) Nezapomínejme na lidskou paměť - o dvě iterace dál už se učíte chápat svůj vlastní kód, čili stojí to další čas navíc.

Pokud změny uděláte, má to "nenápadné" bonusy:
1) Odhad pracnosti je řádově přesnější (z měsíců jdeme na dny)
2) Opravy jsou záležitostí hodin, dokonce minut
3) Od nějaké úrovně stavu kódu lze levně psát unit testy
4) Rozvoj aplikace má tah na branku, víte, co děláte a co ještě budete dělat, neobjevují se záhadné chyby.

Dnes

Fáze 5: Mám nejlepší tým v historii projektu

Ne, pořád jsme nevyhráli. Ale vedeme si dobře. Ta věta z podnadpisu mě napadla chvíli poté, co jsem se na jednoho "mého" programátora ukrutně naštval, seřval ho a za chvíli mi došlo, že neprávem. A že jsem poslední dobou dost nepříjemný. A že to není poprvé. Obratem jsem se mu omluvil a na další poradu přinesl láhev vína a nešetřil jsem.
Stresu je hodně, ale to není žádná omluva, takhle by se ten tým rychle rozložil. Vyhrazuji si právo být člověkem a občas se zachovat jako idiot, načež to ale neznamená, že bych tím nenáviděným idiotem hodlal zůstat.

Zpětně jsme udělali ohromný kus práce s tou půlmilionřádkovou saní. Ano, pořád půlmilionřádkovou, počet řádek narůstá velmi pomalu, protože pořád je tu těch 30% investice (někdy méně, někdy více). Mezitím se aplikace naučila komunikovat s asi 6 dalšími systémy, přešla z Javy 1.4 na JDK6 a má našlápnuto na JDK8, bylo napsáno asi 3000 testů od knihoven až po aplikace a testy GUI, přešlo se z Antu na Maven2 a později Maven3, kvalitu nám už několik let "známkuje" Sonar, máme automatický build systém a zasílání změn, atd.

V jednu dobu bylo na projektu neuvěřitelných 13 lidí. Dnes je nás 5 a děláme toho snad ještě více.
Náš projekťák má občas pořád tendenci někde "ušetřit", ale nechá si to vysvětlit a nepochybně svou práci dělá dobře.

Dostávám nabídky na dvojnásobek současné mzdy, ale není to jen tak - neodcházím z několika rovnocenných důvodů:
1) Mám rád evoluce, ne revoluce. Chci si užít pocit, kdy už budu vědět, že všechno klape. Myslím, že nejsem tak daleko od tohoto stavu.
2) Jiná práce, jiný tým, jiné podmínky, dost možná bych musel znovu někoho přesvědčovat, že používá technologie, ke kterým už se dnes nikdo nezná, že psát testy není ztráta času, že požadovat nějakou úroveň zdrojáků není perfekcionalismus, ale pud sebezáchovy.
3) Mám rád živé projekty, ne režim "přijít - napsat - spustit - odejít".
4) Mám tým, ve kterém se dokážeme domluvit, vyhovět si, a případně i zabojovat, aby projekt dopadl dobře (zákazník spokojený, projekťák spokojený, firma dostane zaplaceno a my možná odměny :-) ).

Samozřejmě to neznamená, že tu ta možnost odejít není. Ale momentálně jí nevyhledávám a nabídky odmítám.

Závěr úvodu (no hurá)

O refaktoringu se tu vlastně dneska mluvilo málo, zato dlouho. Asi jsem nenapsal ani nic, co by člověk nevěděl, ale šlo mi o to nabídnout pohled na tu "evoluci" od začátku do konce (budiž prozatímním neustále utíkajícím koncem označen dnešní den).
Pokud přijdete na projekt o této velikosti, nečekejte, že s ním pohnete jen tak. Je to práce na dlouho a vy se pořád musíte vejít do rozpočtů a těžce si vydobývat důvěru jiných. Ta vzniká tak, že uspějete krůček po krůčku v zakázkách, že vaše dílo funguje, když jiná mají problémy.
Je to hodně o hledání rovnováhy a schopnosti dotahovat věci do konce tak, abyste se k nim nemuseli vracet nečekaně a často a ... neradi.

Ano, zákazník srovnává hrušky s jablky, a vy to děláte taky, jen si to neuvědomujete. Dnešní naší společnosti chybí respekt, empatie, schopnost podívat se na něco očima někoho jiného - ale o tom jindy a jinde. Učte se to. Většina firem nabírá programátory a analytiky v jednom, takže - analyzujte ;)

Další díly asi budou kratší a jelikož to píšu bez přípravy a konceptu, uvidíme, co ze mě "vypadne".  Každopádně bych se chtěl zaměřit na nějaké strategie refaktoringu a zhodnocení toho, která kdy může být úspěšná.

Poslední dnešní věta:
Neexistuje nerefaktorovatelný kód!