Sunday, May 20, 2012

JEEConf - Kiev, 2012 - Report

This year we had the second JEEConf. The amount of stages was increased from three to four stages.
I was really impressed about conference program "notebooks" :-) it was well done. The amount of people was really huge more then 600. I think it's impressive number for the second conference.

As usual I've selected the most interest topics to watch/visit to:

1. Play with Play! by Anton Naumov
The presenter briefly has shown the Play Framework v.1.2.x features and discussed the pros&cons. The most notably was that he stated the "fails" caused by this framework and how we can avoid similar stuff. The most loud message was "use Spring/MVC, Hibernate and Maven" if you are experienced with them :-). And try to use Play for prototype projects.

2. Hibernate performance tuning by Sander Mak
It's very interesting and pragmatic topic. Even more I can say this presentation was a bunch of receipts for Hibernate performance improvement. There were depicted very interesting nuances which will be definitely valuable in real life codding.I'm looking forward for slides.

3.  Methodology of performance optimization by Alexey Shipilyov and Sergey Kuksenko
It was the most low-level topic on this conference. Guys shown the different ways to perform the subject. They review and in pair-speech way very complicated issues in performance optimization from conceptual point of view. I can't say that I will be able to reuse everything from this speech, but it's great start point for me. They are very proficient presenters.

4. Becoming a Professional Java Developer by Yakov Fain
I must say "Thank you" for this speech. It was cool. Yakov has highlighted the non-technical aspect of Professional (Java) Developer. Of course his advices and observation are based on own experience and might be biased for somebody. But it's honest and reasonable speech might open "some" boring minds. Also, Yakov recommended to read his free e-book "Enterprise Software without the BS". I've already downloaded it and I'm planning to read it in nearest weeks. 

5. Inject Injection by Yuriy Litvinenko
It was like a case study report about involving DI Framework (in this case Google Guice) in legacy project. It was very interesting, because I believe it's challenging task. The presenter has highlighted the issues which his team faced with. I can say this experience might be valuable when somebody needs to decide the benefits and evaluate the risks of involving DI Framework in something "really old". Well done.

6. Cloud Java platforms: what's inside and what's the difference by Ruslan Synytskyy
It was a pleasure to see ukrainian who is one of the founders of Jelastic. Ruslan has reviewed  different types of  "* as a Service": SaaS, PaaS and IaaS. The comparison criteria of PaaS's are very useful for further evaluation.

7. Why do I hate the Hibernate? by Mikalai Alimenkou
It was pragmatic, based on real experience presentation with tons of Hibernate issues. It's very useful for anyone who's developing application with Hibernate. We must know the weaknesses of our tools. Mikalai has used very interesting approach to blame something/someone: "nasty granny". You should review the slides to this presentation to understand what does it mean.

I'd like to say "Thank you" JEEConf organizers team. You are doing very important work for Ukrainian Java Community.

See: JEEConf - Kiev, 2011 - Report

Wednesday, May 02, 2012

Review: Java Brains Spring Framework - Core Spring, by Koushik Kothagal

I've recently watched the subject Java Brains - Spring Framework video tutorials and I must admit that these screencasts were well done. One of the best Java related video tutorials I've ever seen. Whether you are experienced or beginner developer it worth to watch them all. It's very good sample how to produce qualitative and pleasure to watch screencasts.

Let's review each tutorial one-by-one just to have some snapshot what was described there:

01 - Understanding Dependency Injection Dependency Injection (DI) introduction. Here was explained why do we need DI and some conceptual sample.

02 - Setting Up Project Setup. The author avoided using any build tools (Ant, Maven) and set up Eclipse-based project via using Eclipse User Library.

03 - Understanding Spring Bean Factory Explained the differences between Factory pattern and Spring Bean Factory without any technical details, plain conceptual overview.

04 - Writing Code Using the Bean Factory Actually it's the first video with some code inside. Author use classical approach to introduce Spring DI in practice - wrote simple code without Spring and re-wrote it with Spring. And it has nice effect - it became very descriptive.
The next Spring-related things were introduced:
  • spring.xml
  • BeanFactory
  • XmlBeanFactory and FileSystemResources
  • bean instantiation via factory
05 - ApplicationContext and Property Initialization Replaced BeanFactory with ApplicationContext. How to initialize bean property via spring.xml has been shown.

06 - Using Constructor Injection Depicted different ways of constructor injection:
  • plain
  • index based
  • type based
07 - Injecting Objects Created simple object and shown how to inject object dependency (i.e. was used  "property" tag and "ref" attribute, <property name="propname" ref="beanref" />

08 - Inner Beans, Aliases and idref The topic has pretty descriptive content, nothing more was here.

09 - Initializing Collections Here List was used as sample to initialize bean with collection. Stated that the same approach should be applied to Set and Map.

10 - Bean Autowiring Configured autowiring via spring.xml. Described pros&cons:
  • byName
  • byType
  • constructor
11 - Understanding Bean Scopes Explained bean scopes:
  • Singleton
  • Prototype
  • Request
  • Session
  • Global Session
12 - Using ApplicationContextAware Nicely shown how to use ApplicationAwareContext and BeanNameAware interfaces.

13 - Bean Definition Inheritance Nice Spring feature is bean definition inheritance and how it is different from OOP inheritance. Explained when to use it and what is the benefits. Introduced bean abstract and  parent attributes and when to use it.

14 - Lifecycle Callbacks Introduced init and destroy methods in different incarnations:
  • InitializingBean and DisposableBean interfaces
  • bean tag attributes: init-method and destroy-method
  • beans tag attributes: default-init-method and default-destroy-method
  • Added AbstractApplicationCantext to switch on redisterShutdownHook()
15 - Writing a BeanPostProcessor Shown how to implement custom BeanPostProcessor

16 - Writing a BeanFactoryPostProcessor Shown how to implement:
  • custom BeanFactoryPostProcessor
  • introduces properties for spring.xml via adding PropertyPlaceholderConfigurer (implementation of BeanFactoryPostProcessor)
Explained when and why to use BeanFactoryPostProcessors. Explained the differences between BeanFactoryPostProcessors and BeanPostProcessor.

17 - Coding To Interfaces Rewritten the initial demo project to support interface based design, the right way for developing Spring applications :-)

18 - Introduction to Annotations and the Required Annotation Added @Required annotation in demo project and activated it via adding bean post processor RequiredAnnotationBeanPostProcessor.

19 - The Autowired Annotation Shown how to use:
  • @Autowire and @Qualifier annotations
  • <context:annotation-config /> in spring.xml
20 - Some JSR-250 Annotations Shown how to use:
  • @Resource annotation
  • @Resource annotation with parameters
  • @PostConstruct annotation
  • @PreDestroy annotation
21 - Component and Stereotype Annotations Added the <context:component-scan base-packaeg="package" /> to spring.xml. Shown how to use @Component annotation and what rules applied to this annotation. Also, were mentioned other Spring stereotypes.

22 - Using MessageSource To Get Text From Property Files Shown how to use ResourceBundleMessageSource to get properties.

23 - Event Handling in Spring Very nice introduction tutorial into the subject: even definition, event listeners and even publishing on application level.

Ofcource, these tutorial are only intro and you should read Spring Documentation to gain the Spring "black" magic. But, it's good start point.