I was at the Herbstcampus 2010 in Nuremberg, that is a four-day IT conference. The main topics consist of Java, JEE, .NET, Agile Development and SOA. Although, prominent speakers are missing, many very good and interesting sessions were available. Here you can find more information: Herbstcampus.
My Talk: Categorization of Web-Frameworks in the Java Environment
I had a talk about the categorization of web framwork in the Java environment. I explained important word regarding web development such as Web 2.0, AJAX, Multi-Page vs. Single-Page and Server-centric vs. Client-centric. Then I gave an overview about the different kinds of web applications (classical web application, rich client, rich internet application, portal, CRUD-client) and categorized the most important web frameworks in the Java environment (e.g. JSF, GWT, Tapestry, Wicket, Grails and Java FX). Finally, I showed some use cases from real life and gave recommendations for choosing a web framework.
You can download my slides here: Kategorisierung_von_Java_Web_Frameworks_Herbstcampus_2010.
In the following, I want to mention some more information about a few of the sessions I visited, and interesting facts that I noted.
Java Server Faces (JSF 2.0): Comparison of Component-Libraries
The following component libraries were compared: RichFaces, ICEFaces and PrimeFaces.
- all are open source and offer enterprise support
- all offer a lot of components (between 50 and 100)
- RichFaces can be combined with PrimeFaces
- unfortunatelly, ICEFaces extends FacesServlet and thus cannot be combined with other component libraries
- PrimeFaces offers an easy possibility to develop web applications for mobile devices such as iPhone, iPad, Android or Blackberry through TouchFaces. Attention: You do develop browser applications, not native applications for the App Store and so on.
How to test Enterprise Java Beans (EJBs)?
There are three possibilities to test EJBs:
1) Many developers use integration tests only (i.e. doing a build and deploying the application on a remote application server for testing).
That is a lot of extra effort and time consuming. Besides, often this solution is not fully automatic.
2) Even worse: Some developers instantiate bean instances with “new()” and thus loose JEE features such as transactions. These features have to be implemented manually if required.
3) The solution: Apache OpenEJB!
That is an EJB Container which is also used in certified JEE application servers such as Geronimo. Thus, if offers a standard which is guaranteed to implement the JEE specification.
- JUnit-Tests create the EJB container
- supports EJB 1.1, 2.0, 2.1 and 3.0
- testing transactions, resources, JPA, and so on is possible without dependecies (no integration test!)
- even Message Driven Beans (MDBs) and Security (e.g. @RolesAllowed) are supported
- alternatively: “embedded Glassfish” may be used instead of OpenEJB for application which base on current JEE 6 standards –> an embedded JEE6 application server
Test-Driven Development (TDD)
The TDD approach uses three phases for each cycle (and NOT two phases!):
1) Write a test (red phase)
2) Implement the test (green phase)
3) Refactor (remove code duplication and so on, both in test- and business-logic!)
After phase three, a new cycle begins…
Disadvantages of TDD:
- the architecture is created step by step
- efforts for refactoring may be very high
BUT: Planning the whole architecture at first is probably a handicap, too!
The solution is anywhere in the middle, i.e. find a good tradeoff. For instance, you should be aware of the module you realize at the moment, but you should not plan the whole project at once.
Another important hint: Use meaningful names for your test-methods, even though the names are longer than usually. no one calls this methods, so it does not confuse or bother anyone.
Google App Engine (GAE)
Three kinds of services exist in the cloud:
- IaaS: Offer infrastructure, quasi a virtual machine for an operating system in the internet (e.g. Amazon EC2)
- SaaS: Offer software, i.e. no local installation is necessary (e.g. Google Docs)
- PaaS: Offer a runtime environment, i.e. offer not only the infrastructure as with IaaS, but also a platform which can be used (e..g Windows Azure, GAE)
So, GAE is a PaaS cloud service and offers a runtime environment for web applications. Besides Python, GAE offers support for Java 5 and 6 since 2009 (but still in BETA status). Particularly, the following technologies are supported (many of them only in an out-dated version): Servlet 2.5, JSF 1.1, JSP, JDO 2.3, JPA 1.1, ANT, Maven.
Requirements: Google User Account, App Engine SDK, IDE (Eclipse or NetBeans).
Advantage to Microsoft, Amazon and other vendors: It is free (if you follow the quota) – but that limits are sufficient for a small or medium enterprise application.
Disadvantage: Many limitations!
- does not use a SQL database, but Google Big Table (although in-memory sql databases such as HSQLDB are allowed)
- many limitations regarding JPA: no @ManyToMany, no JOIN-queries, a lot more…
- bad error messages
- JRE Class White List – only these J2SE classes are allowed. Not using a Black List says a lot about this limitation
- Forbidden: Threads (as within JEE), Files, “arbitrary” network communication using e.g. JAX-RS, JAX-WS, RMI and so on)
–> Only GAE-specific solutions may be used, e.g. a GAE-implementation of the RESTlet-speficiation
–> Reason: CPU-intensive APIs are not allowed to reduce traffic (e.g. SOAP Web Services do a lot of XML parsing and thus are very “expensive”)
Conlusion of GAE:
Positive: The free version of GAE may be used for small or medium enterprise applications.
Negative: The developer has to live with several limitations.
You have to evaluate, if all requirements can be realized (at least, all limitations are documented well by Google).
Mobile Development Choices: Native Apps versus Web Apps
Context of this discussion are enterprise apps, not “99 Cent Apps”.
Soon, mobile devices will be as important as “classical computers” for business. but many different platforms exist: Apple iOS, Android, Blackberyy, webOS, Windows 7 and Symbian. On the other side, browser use a single “platform”. But nevertheless, differences exists and specific development is necessary for IE, Firefox, Safari and so on.
Based on the above facts, the following question was asked: “What is the better solution for mobile devices? Native Apps or Web Apps?”
PRO Native App:
- better performance
- better user experience
- easy access to phone apps such as contacts or calendar
- easy access to phone hardware such as GPS or camera
PRO Web App:
- Porting a web app is much easier: Change some CSS, Skins and maybe some source code. That’s it!
- Delivery: Instantly for Web Apps. Native Apps need to be approved by the App Store, this takes about one to two weeks (considered Apple as example)
- Updates: Same as Delivery! For instance, how do you force an update if a critical bug is fixed?
- Enterprise Integration: Simply use your existing infrastructure (e.g. Web Service interfaces). You may need to adjust your native app or get problems to realize it at all.
Decide if you need a client centric application using either native apps or web apps (realized e.g. with GWT) or a server centric application using web apps (realized e.g. with JSF).
Conclusion about the IT conference “Herbstcampus 2010″:
I also visited the first Herbstcampus 2008 (as student). At that time, a lot of teething troubles existed. But these problems were eliminated (probably, because the organizer has more experiences now), so everything was ok.
Herbstcampus 2010 was a nice IT conference. Many interesting sessions were available (not only for beginners, but also for experienced software developers and architects). Although a few sessions disappointed a lot, most sessions were good to very good. Many experiences, which I gathered, will flow in current and future projects.
So quite possible, that I will be a speaker at Herbstcampus 2011, too