Tips

Tips

• With Java EE 7, your Design Patterns are dead. And your EAR is ugly too.

  Adam Bien isn't without opinions when it comes to modern day enterprise programming techniques. From the use of design patterns, to the manner in which projects and modules are divided, Bien isn't without opinions when it comes to developing Java ...  Continue Reading

• Annotation versus XML configuration: Which JPA option to choose?

  A common debate in the JPA community is whether to configure applications using an XML or annotations based approach. Here are some reasons why you might want to choose XML instead.  Continue Reading

• Simplified ORM configuration with Spring, JPA and Hibernate path scanning

  Configuring Spring, JPA, Hibernate or other ORM technologies can be a challenge. One way to simplify ORM configuration is to configure package scanning for entity classes.  Continue Reading

• How to get the Hibernate Session from the JPA 2.0 EntityManager

  This tip shows you how to get the Hibernate Session from the JPA EntityManager so you can perform functions only available from the JBoss Hibernate project.  Continue Reading

• Understanding the implicit dangers of software component re-use

  Every software developers has the goal of component re-use, but there are implicit dangers in the practice that all developers must be aware of.  Continue Reading

• Mobile ALM Tip: Four ways to effectively move apps out of production

  Moving applications out of production can be a mobile ALM challenge, but with these four tips, organizations will be minimizing the challenge of application decommissioning.  Continue Reading

• Two most commonly misconfigured Tomcat performance settings

  Tomcat on the server is different from Tomcat on the desktop, but too many system admins fail to optimize their production servers for performance.  Continue Reading

• Tomcat performance optimization through consolidated log file handlers

  By default Tomcat uses several log file handlers, but performance can easily be optimized by configuring the server to use only one.  Continue Reading

• Software requirements and expectation management key to project success

  Many shun the task of properly documenting a system, but successful projects know that effective requirements docs lead to better expectation management and a greater degree of success.  Continue Reading

• BEST: Simple web service alternatives to SOAP, XML and REST

  Sometimes architects over-complicate web services, but indeed, effective solutions can be created without SOA, REST and SOAP.  Continue Reading

• Tradeoff management key to successful software development techniques

  To successfully develop software, tradeoffs must be made in cost, quality and time. Proper tradeoff management results in quality software.  Continue Reading

• Performance and troubleshooting tips for JSF 2.0 Facelet developers

  JSF 2.0 has provided a variety of new configuration settings to help improve performance and aid the troubleshooting task, making the lives of software developers and quality engineers much easier.  Continue Reading

• Effective Naming Strategies for RESTful Web Services

  New descriptive languages like WADL and WSDL 2.0 are making it possible to describe the RESTful contract to client applications. However, if your RESTful web services are not named effectively, the mechanism for describing the interface may run out ...  Continue Reading

• ALM expert says Agile methods are the way to conquer mobile ALM

  Enterprise application developers are finding mobile application lifecycle management has challenges. ALM pro Howard Deiner advises an Agile approach.  Continue Reading

• Try an Agile deployment strategy

  Agile development methods hold value for more than planning, design, development and testing. A deployment strategy also benefits from Agile tactics.  Continue Reading

• Finding the cause helps solve future application deployment issues

  Application deployment issues put a black mark on successful enterprise applications. Learn to guard your applications from the most common pitfalls.  Continue Reading

• Cloud deployment shows pros and cons for legacy applications

  Legacy applications may benefit from cloud deployment, but there are a host of concerns to look at, too, when considering redeploying older applications.  Continue Reading

• Consistent application performance: It's not always about speed

  When developing applications, the response time is always an important metric. But inconsistent response times can often be more aggravating than slow sites. Make sure you take response time consistency into your application performance reviews.  Continue Reading

• How to articulate and define performance requirements

  Don't fall into the trap of failing to define performance requirements for your applications early on in the application lifecycle. If you follow this quick tip, you'll find that articulating your performance requirements isn't that hard.  Continue Reading

• Automate Web server load balancing for high scalability

  Automating Web server load balancing tasks provides high scalability for enterprise applications.  Continue Reading

• Why application integration matters

  Application integration may hold much more benefit than most Java development shops realize.  Continue Reading

• Five Neat Things You Can Do Out of the Box with Liferay Portal

  If you've ever run a competitive portal, you know that so many of them have little more than the "weather portlet" or "bookmarks" portlet after installation. Liferay is amazing because it has such full featured functionality 'out of the box.' Here's...  Continue Reading

• Compare new Java Web application tools to the basics

  When evaluating new Java Web application tools look back to the most basic Java development tools and see where the new tool takes you from there.  Continue Reading

• Rich user interface design affects application success

  Use rich user interface design to encourage end users to engage with the application and maximize its useful potential.  Continue Reading

• Java 7 and the intricacies of safe and unsafe casting

  One of the problems with casting is that it does have the potential to cause a loss of precision, especially if the number that gets cast does indeed fall outside of the range of the target type. Here we will explain why this happens.  Continue Reading

• Include vs. Forward of the Servlet RequestDispatcher

  The key difference between the two is the fact that the forward method will close the output stream after it has been invoked, whereas the include method leaves the output stream open.  Continue Reading

• Spring Ehcache integration (Second-level caching in Hibernate)

  Integrating Ehcache with Spring-based applications is actually fairly easy. Let's look at this integration with a sample BuddyManagement application.  Continue Reading

• How to design a Web page that will display properly across browsers

  Learn tricks for keeping a consistent look and feel to your Web applications across major browsers like Firefox and Internet Explorer.  Continue Reading

• Cross-browser friendly HTML code

  Here are some basic guiding principles to help Java developers build Web applications that start out with high cross-browser compatibility, without reworking the final product.  Continue Reading

• The importance of cross-browser compatibility in website development

  Ensuring cross-browser compatibility of your Web applications is becoming more and more important as workers are presented with more and more choices of Web browser.  Continue Reading

• Building out a service-oriented architecture with Java EE

  A service-oriented architecture can help software developers deal with complicated applications that often eat up time with excessive maintenance needs.  Continue Reading

• Choosing the best Agile methodology for your development needs

  To be Agile is to be active and involved. But how do we achieve these goals? Let’s look at some of the popular tools of the Agile trade.  Continue Reading

• How to properly estimate a Java project

  Focusing on accurate use cases can simplify software development project estimations and improve your algorithms chances of producing an accurate time to completion.  Continue Reading

• Performance monitoring tools optimize Java applications

  By taking advantage of Java monitoring and performance tuning tools, developers can expect to see consistent application performance across all hardware and operating systems.  Continue Reading

• Integrating Eclipse and WebSphere Portal 7

  Using Eclipse to develop applications for WebSphere Portal 7 can save you a considerable amount of licensing expense, but the integration can be a bit tricky in the early stages.  Continue Reading

• Waterfall versus Agile methods: A pros and cons analysis

  In project management, Agile has been touted as a replacement for antiquated Waterfall methods. Yet Waterfall methods do hold value for certain projects and some development teams.  Continue Reading

• HTML5, Java and the future of Web development

  The new mobile Web may feature a clear separation between the front-end HTML5 UI and the back-end Java applications.  Continue Reading

• RESTful Web services made easy

  Learn the basics about RESTful web services in this quick tip. You can create a RESTful Web service using nothing more than the JDK, a simple text editor and Tomcat 7.  Continue Reading

• How to successfully deploy BPM

  BPM offers tremendous potential to organizations seeking to improve efficiency and ROI, but it takes a thoughtful approach. This article outlines some BPM best practices.  Continue Reading

• Building Java Web services with NetBeans 7

  In this tutorial, I'll walk through building a simple Web service with NetBeans 7. Let's see just how far the Java specification and the tools that support the spec have come.  Continue Reading

• Dependency Injection in Java EE 6 (Part 6)

  In this last article of the series, we will cover portable extensions, available implementations as well as CDI alignment with Seam, Spring and Guice.  Continue Reading

• Working with JSPs in JSF 2.0

  Working with JSPs in JSF 2.0  Continue Reading

• Mixing Annotations with faces-config.xml Settings in JSF 2.0

  What happens when you annotate a bean, and edit the configuration in the faces-config.xml file at the same time?  Continue Reading

• Combining Annotation and XML Configurations in your Spring 3 Applications

  Who says you need to choose between XML and annotation based configurations. Why not use both! It's as easy as a little import annotation at the top of your config file.  Continue Reading

• High Scalable & Distributed Architecture with EJB & Spring Framework

  In an Enterprise world, Spring Framework with some standard ORM tool like Hibernate gained considerable acceptance as a light-weight architecture for mid size applications. Also in Java EE 5 specification, major changes has been done on component ...  Continue Reading

• Database Access with Spring 3.0 and the JdbcTemplate

  Learning Spring can be intimidating, because there are so many different aspects to the framework. At its core, Spring is an Inversion of Control (IoC) and Dependency Injection (DI) container. It's also a powerful platform for doing some aspect ...  Continue Reading

• 12 Best Practices for Optimizing the JBoss EAP Platform

  Looking to improve the performance of your JBoss EAP Platform? Here are a few tips that'll help you optimize your distibuted JBoss infrastructure.  Continue Reading

• Evil Design Patterns - When Design Patterns Become the Problem

  Have you ever been on a project in which all of your team members have just gone through an intense week of Design Pattern training? It's painful.  Continue Reading

• Learn Hibernate Quickly: Simplified Java Persistence with Hibernate & JPA

  Learn Hibernate Quickly: Simplified Java Persistence with Hibernate & JPA, covering both Hibernate 3.2.x and the JPA 2.0 compliant Hibernate 3.5.  Continue Reading

• WebSphere Portal 7 Performance Tips: Changing the Heap Size & Verbose Garbage Collection

  Why is WebSphere Portal Server 7 so slow? It's not! It's just not configured properly. Sal Pece will show you a few quick little changes you can perform on your WebSphere Portal Server (WPS) to help speed things up.  Continue Reading

• ZK Performance Monitors

  Given Ajax applications' event driven nature, it would be beneficial if developers could identify the time consuming event handlers and make the necessary performance tuning accordingly. With ZK, a server-driven Ajax framework, developers could ...  Continue Reading

• Dependency Injection in Java EE 6: Conversations (Part 4)

  This series of articles introduces Contexts and Dependency Injection for Java EE (CDI), a key part of the Java EE 6 platform. Standardized via JSR 299, CDI is the de-facto API for comprehensive next-generation type-safe dependency injection as well ...  Continue Reading

• Special characters in XAML

  XAML files are a form of XML. As such, they have to follow the rules of XML. There is one XML rule that can cause trouble when working with strings within attributes in XAML, known as special character.  Continue Reading

• Spring Converters and Formatters

  Spring 3.0 introduces a simple Converter interface that you can implement and reuse anywhere in Spring. You can use them in Spring MVC to convert request String values to Controller method parameter values of any Object type that you can write a ...  Continue Reading