- Program analysis. Good at creating original FindBugs plugin and PMD plugin, to keep codebase consistent and high quality.
- Testable & maintainable code. Good at coding with DI, TDD and SLF4J. Keep caring about SOLID principles and well documentation comment.
- Continuous Integration. Experienced to use Jenkins and Travis CI.
- Bytecode manipulation. Good at ASM to generate/modify
- Open source project. Used to send pull request (or patch) to OSS product.
- High performance app development. Good at keeping less I/O, less redraw and less reflow. Also good at performance tuning.
- Learning about new things: Docker, DevOps, LLVM, Arduino, Scrum, Promise, Grunt, Java8, etc.
To keep program consisteent and high quality, we need code review. But it is not scalable approach, and it cost much time to keep running.
The better replacement is the automated program analysis. This technology will help developer to find potential problem in short time (even in pre-merge build), so we can keep codebase clean. It also helps developer to make code review efficient; Program analysis will find easy problem automatically, so human can focus on design and complex problem.
I am good at not only code review, but also automate it by program analysis. Especially, by making original FindBugs plugin, I can keep code base consistent even though there are hundreds developers in project.
For changing product, it is important to keep code testable & maintainable.
Testability is necessary to keep changing codebase. To keep testability, I follow SOLID principles and use DI with care. I use Google Guice or Spring as a DI container, to test a part of module with test double. It helps me to reduce code for initialization, so my test code is easy to maintain and has less footprint.
Maintainability is necessary for growing team, which realize good product. To change really a part of product, I divide product into modules and layers, and make their responsibility clear. I also write documentation comment on each interfaces, to tell intent/design to other developers. Type is also my tool to keep them easy to understand. No
String to reproduce entity.
And to help new developer to join project, it is also important to prepare development/test environment for them. For instance, I can introduce not document but automated script (e.g. Vagrant or Dockerfile) to set up environment.
I have managed/maintained Jenkins cluster for several projects, with many slaves and build matrix. My CI works with program analysis and unit/integrated tests, so it ensures that product is really ready to release. I also developed a Jenins plugin, which is released as one of official Jenkins plugin.
I like Travis CI too, it has simple API and well integrated interface with GitHub. I introduced Travis to my projects and other OSS projects, to keep them well built and tested.
Bytecode manipulation is not black magic. It enables coding/debugging by computer, not developer. So it is really valuable for large scale product. AOP is popular for all Java developer, and Pluggable Annotation Processing API now supports comfortable coding.
Bytecode manipulation is also interesting field for programmer. By this technology, we can implement compiler and interpreter. It helps us to understand how JVM works.
- JVM Simulator
- Bytecode injector for precondition check
- Brainf*ck compiler and interpreter on JVM
- a Java implementation of the KEMURI programming language
Computer's good point is: cheap, scalable, 24/7, and, yes, high-speed. So if system is not high performance, it kills one of good points of computer. It is also important for UX to provide value to end-user. So, in short, Slow system lacks its idnetity.
This is why system should be high performance. But to realise it, we need a lot of understanding and technology.
I have experience about tuning web application, tuning batch application, maintaining relational and NoSQL database. I made many breakthoughs to improve performance, based on understanding internal implementation of JVM, database and browsers. I also applied hacks like RequireJS, Google Closure Compiler and SPDY, to reduce runtime I/O. Now network latency is really important for performance, so I learned much about how to reduce network access.
I am also used to analyze system by jcmd, Java Mission Control, Flight Recorder and IBM analytics tools (IBM Thread and Monitor Dump Analyze for Java and IBM HeapAnalyzer). These tools are necessary to understand bottleneck, lock and other problem in system. By these tools, I have improved performance of many enterprise applications.
To contact, please use SNS or send a mail to my mail address.