JBoss Seam 2.0 Video Talk
Thursday 8 November 2007
Posted byEugene at 03:39 14 comments
RSF ("Reasonable Server Faces")
Friday 21 September 2007
RSF version 0.7.2 has been released. RSF promotes minimal and clean designs - in contrast to the majority of current Java frameworks which proliferate with increasingly complex schemes for managing stateful components, RSF cuts through the issue by promoting and facilitating zero server state designs. This brings web development more in line with the web - as well as making fewer demands on server resources, it arguably delivers apps which users find more idiomatic and intuitive.
Other features since RSF's previous announcement at 0.6.1 include UVB (the "Universal View Bus") - a slimline DWR-like RESTful web service automatically derived from your webapp structure, and extensions to its rendering model allowing any section of markup to become a candidate for reuse.
Going forwards, RSF is rapidly tracking the developments towards Spring Web Flow's 2.0 release, with its integration up to the mark for compatibility with the latest milestones of SWF 2.0M1 and Spring 2.1M3. RSF's focus on markup purity and type-safety
for view resolution is a perfect complement to SWF's positioning as a universal application controller and state management engine.
RSF is actively working with the Fluid Project to produce a maximally reusable and accessible set of client-side components that work - for everyone.
The forthcoming 0.7.3 release of RSF will focus on automatic client-side validation and improvements in portalization, in advance of the major revision 0.8, where RSF APIs will be brought in line with their 1.0 release versions by alignment with Spring 2.x and Java 1.5-level features.
Release notes and changelist are available on the RSF wiki. A large set of sample applications and guides are available to help programmers get started. Discussion and support are available on the forums and the mailing lists.
Posted byEugene at 01:29 1 comments
MyEclipse 6.0 Offers Help for the Java Weary
Friday 7 September 2007
Genuitec's MyEclipse 6.0 is all about the developer. Now based on Eclipse 3.3, the new version of this integrated Eclipse distribution includes a database and Tomcat 6.0, so that developers can deploy their application for on-desktop testing with just a few clicks. Elsewhere in this update are expanded Swing support, new AJAX debugging tools and access to a repository of sample code.
MyEclipse 6.0 standard edition costs US$29.95 per year, per seat. The professional edition, which costs $49.95 per user per year, includes UML and architectural tooling features as well.
Posted byEugene at 00:53 0 comments
OpenSymphony's ClickStream
Introducing ClickStream
OpenSymphony's ClickStream is a user tracking component for Java web applications. This means you can take a look and analyze the traffic paths and the sequence of pages that users have generated as they browsed your site.
This traffic path is called a clickstream and it is the logical
grouping of a HTTP session identifier and the requests associated
with it, until the end of this session. The good news is you can
easily add this feature to your application by embedding
OpenSymphony's ClickStream to take advantage of this site usage information.
Posted byEugene at 00:47 0 comments
Terracota and Continuations by Bevin Geert
Thursday 6 September 2007
Geert Bevin gives a concise overview of how Terracotta clustering works and describes how easy it is to integrate it with your applications in a transparent way, unlike other clustering technologies that require programmer participation to make them work. "Terracotta's philosophy is to treat clustering the same way as garbage collection," he said. Geert also talks about his work in continuations and clustering, and gives a few examples of how continuations work, and why they're important to web developers.
Posted byEugene at 00:26 64 comments
Greenhopper released for project management in JIRA
GreenHopper is a management tool for Atlassian's JIRA bug tracking, issue tracking and project management.
The main goals of this plugin are to provide JIRA users with the following:
- An interactive and simple interface to manage their projects (AJAX-based)
- Tools to increase the visibility and traceability of ongoing versions
Posted byEugene at 00:22 0 comments
GWT 1.4 released
New widgets and libraries
- RichTextArea, HorizontalSplitPanel and VerticalSplitPanel, SuggestBox, DisclosurePanel, PushButton, ToggleButton, and an enhanced Image widget make advanced applications easier than ever.
- ImageBundle automatically consolidates multiple images into a single HTTP request.
- NumberFormat and DateTimeFormat make easy work of complex internationalization and localization.
- You can finally use java.lang.Serializable with GWT RPC, and the GWT RPC server-side subsystem is no longer intimately tied to servlets. You can easily wire it into any Java back-end infrastructure. Spring fans, rejoice.
- A new JUnit-based benchmarking subsystem makes measuring and comparing the speed of code snippets as easy as writing unit tests.
New deployment options and optimizations
- Adding GWT modules to an HTML page is now simple: just add a <script> tag.
- You can now include GWT modules across domains. Note that including scripts from other sites that you don't fully trust is a big security risk.
- External JavaScript files referenced from your GWT module load synchronously now, so script ready-functions are no longer needed.
- Auto-generated RPC whitelist files are now produced during compilation to help catch accidentally responding with objects that compiled GWT client code wouldn't be able to deserialize.
- The GWT distribution now includes a DTD for the GWT module XML format, making it easier to configure modules in an DTD-aware XML editor.
Posted byEugene at 00:19 0 comments
Google Web Toolkit out of beta as of 1.4 release
Sunday 2 September 2007
There's lots and lots of cool new stuff in GWT 1.4, so it's hard to know where to start.
How about application performance?! This release includes several breakthroughs that make your compiled GWT code significantly smaller and faster. Many users are reporting that after a simple recompile with 1.4, their applications are up to 30% smaller and 20%-50% faster. And startup time in particular is now highly optimized thanks to a new bootstrapping technique and the availability of image bundles.
To see the new hotness in action, try visiting the new-and-improved Mail sample a few times. It's darn fast the very first time you visit it, but subsequent visits are insanely fast. That's because, in addition to a fast initial startup, GWT code uses a clever caching technique to prevent applications from making unnecessary HTTP requests.
As Joel Webber (Tech Lead of GWT Core Libraries) would say, "The fastest HTTP requests are those that do not, in fact, occur."
Posted byEugene at 09:32 0 comments
Seven habits of effective developers
ZDNet Asia's interview with Sun staff engineer Lee Chuk Munn, who likens writing applications to writing books. The habits he cited include: understand the problem, use appropriate tools, strive for simplicity, and so forth.
"Programming is just an expression to a solution. A lot of it is about understanding and recognizing the problem and getting help. This [concept] is generic across all programming languages, it doesn't matter what you use--whether it's C+ or Java. The approach is still the same," he said.
"What irks me is developers today are churning out applications without any regard or love for it. That's my number one pet peeve. So, it's like they're doing it for the money which is good, if you're a project lead, but you need to put in some concern and care into what you're building and not just in shipping [the application]," he noted.
Posted byEugene at 08:50 0 comments
PageBus and the AJAX Challenge: TheServerSide Video Tech Brief
Thursday 23 August 2007
TIBCO's PageBus is an open-source Javascript messaging bus for integrating heterogenous AJAX elements in a web page through broadcasting and listening of events published to specific topic names. Messages can be dispatched from one AJAX component to another, or they can be bridged with messaging systems on the remote server. Rather than hard-wiring the AJAX components on a page to talk to one another, PageBus simplifies development by providing a simple publish-subscribe API. This helps modularize applications and promotes team development, unit testing, and better source repository management.
PageBus is the main integration technology behind the AJAX Challenge, a web development contest with the goal of creating the largest mashup in history. Are you up to the challenge?
Kevin Hakman is the director of developer evangelism for TIBCO General Interface, an award-winning rich Internet application framework. General Interface, the company that he co-founded, was a pioneer in AJAX technologies at Fortune-500 companies and a leading AJAX integration and modularization of web applications, and was acquired by TIBCO. Kevin is a frequent speaker at conferences and seminars worldwide and a contributor to several technology publications.
Posted byEugene at 02:03 0 comments
Interface21 announces Spring Web Services 1.0
What is Spring Web Services?
Spring Web Services is a product of the Spring community
focused on creating document-driven Web services. Spring Web Services aims to facilitate contract-first
SOAP service development, allowing for the creation of flexible web services using one of the many ways
to manipulate XML payloads.
Key Features
- Makes the Best Practice an Easy Practice: Spring Web Services makes enforcing best practices
easier. This includes practices such as the WS-I basic profile, Contract-First development, and having
a loose coupling between contract and implementation. - Powerful mappings: You can distribute incoming XML request to any object, depending on message
payload, SOAP Action header, or an XPath expression. - XML API support: Incoming XML messages can be handled in standard JAXP APIs such as DOM, SAX,
and StAX, but also JDOM, dom4j, XOM, or even marshalling technologies. - Flexible XML Marshalling: The Object/XML Mapping module in the Spring Web Services distribution
supports JAXB 1 and 2, Castor, XMLBeans, JiBX, and XStream. And because it is a separate module,
you can use it in non-Web services code as well. - Reuses your Spring expertise: Spring-WS uses Spring application contexts for all configuration,
which should help Spring developers get up-to-speed nice and quickly. Also, the architecture of
Spring-WS resembles that of Spring-MVC. - Supports WS-Security: WS-Security allows you to sign SOAP messages, encrypt and decrypt them,
or authenticate against them. - Integrates with Acegi Security: The WS-Security implementation of Spring Web Services provides
integration with Acegi Security. This means you can use
your existing Acegi configuration for your SOAP service as well. - Built by Maven: This assists you in effectively reusing the Spring Web Services artifacts
in your own Maven-based projects. - Apache license. You can confidently use Spring-WS in your project.
Spring Web Services 1.0 facilitates the creation of contract-first, document-driven Web services, delivering the flexibility, productivity and ease of use benefits of the Spring Framework to the Web services environment.
Contract-first is where one writes (or generates) the WSDL for the service before writing the implementation, as opposed to the JAX-WS mechanism, where the Java code is written and the API generates the WSDL from that.
Contract-last has fragility problems (where the API might change over time, as the implementation changes), potential issues with cyclic graphs (where class A has a reference to class B, and class B has a reference to class A), conversion issues (the example given in the page referenced is that of a date, which Java represents as a time), performance (where the actual data marshaled might be more than you expect), and versioning (which is part of fragility, and Spring-WS addresses through mechanisms such as XSL to modify the request/response to match a requirement.)
Spring Web Services 1.0 also facilitates best practices such as the WS-I basic profile, and loose coupling between contract and implementation, allowing for the creation of flexible Web services using one of the many ways to manipulate XML payloads. By providing developers with a simpler approach to contract-first development, Spring Web Services 1.0 resolves many of the interoperability issues associated with typical Web services approaches.
Interface21 has a tutorial on using Spring-WS to write contract-first services, of course, that walks through the process.
Posted byEugene at 01:58 0 comments
Tech Brief about Aranea Framework, by Jevgeni Kabanov
Thursday 16 August 2007
Posted byEugene at 09:07 1 comments
jMaki: Tech brief
Monday 13 August 2007
Posted byEugene at 07:49 0 comments
IE memory leaks solution for AJAX enabled components.
Tuesday 31 July 2007
First Part. Short Intro.
First of all , I must say that probably you already know about problem with memory leaks in IE. And also we have a lot of pages on different sites where people were discussed the patterns of memory leaks in IE.Just try to google on memory leaks in IE, or something like that - and you'll see.
Main part. The problem.
But I want to share with you the solution to a problem with memory leaks in IE.
I want to describe you a problem, If you'll made your own AJAX-enabled component with a lot of javascript on the client-side, you may get the situation when memory allocated by IE will grow after each(or may be not each) component refresh with AJAX or whole page refresh probably.
You could see such behavior , if you assign( by javascript ) to your AJAX enabled component any custom(means non-standard :) ) events or some specific functions, in which you'll get reference to that component.This is very popular way to do such things.
And if you'll take your AJAX enabled component and will try to refresh(not one time - let's say 1000 times) whole component or just it's part via AJAX - you will see in Task Manager that memory that was allocated by IE was grew up.
Final Part. The Solution.
The solution is to "clean" all custom javascript object(in javascript functions is also objects) that were "attached" to your component. By "clean" you can read - just assign null values. It will break all circular references, and possible closures.
And memory allocated by IE will not grow. Why? Because before that any DOM element that can be already null, but has any custom javascript objects attached to it, could not be collected by Garbage Collector.
But from now IE will "understand" that such elements can be collected by Garbage Collector, because there would not be any references from that objects to another one.
Below, I give you a short javascript function that I saw on this blog.
/*!
@fn MetaWrap.Page.Element.scrub = function(p_element)
@param p_element A reference to the element we want to scrub
@return void
@brief Nulls element references that commonly cause circular references.
@author James Mc Parlane
@date 23 October 2005
Called for every Element that is garbage collected by
MetaWrap.Page.garbageCollectListeners() or by the teardown code
MetaWrap.Page.deleteListeners()
As a generic leak pattern cleanup, this solution is only
effective for elements have had a listener added via
MetaWrap.Page.Element.addEventListener
Works by nulling event listeners and custom expanded members.
This will only work if you use the following naming standard
for your custom expansions of the element object.
m_XXX eg. m_flipover
$XXX eg. $flipover
*/
MetaWrap.Page.Element.scrub = function(p_element)
{
// For each member of the element
for(var l_member in p_element)
{
// If its an event listener or one of my user assigned
// members m_XXX, $XXX (self imposed naming standard)
if ((l_member.indexOf("on") == 0) ||
(l_member.indexOf("m_") == 0) ||
(l_member.indexOf("$") == 0))
{
// Break the potential circular reference
p_element[l_member] = null;
}
}
}
If you'll call this function for all elements and it's childNodes that were replaced by AJAX request-response, you'll "clean all unnecessary".
Hope it will help.
Posted byEugene at 05:17 2 comments
QuipuKit 1.2 Is Available Now!
Sunday 29 July 2007
QuipuKit is a JSF components library. I wrote about it in my past posts.
I've tried it in two of my projects. Web applications that was made - working under Tomcat server, so I wasn't boring about Quipukit's compatibility with other servers. Now as was written in press release , QuipuKit library works under Jboss server, WebShpere server and support JBoss Seam framework.
Other features are pretty good. Mainly I was using it's TreeTable and DataTable components.In version 1.2 Quipukit library now has SuggestionField component.As I saw in it's demo - it's kind an AutoComplete component.
You can take a look by your own on the demo of QuipuKit library.
$450 for per developer license - it's great price for library like that.
Posted byEugene at 08:35 0 comments
JSF 1.2 - Apache MyFaces 1.2.0 released
Wednesday 18 July 2007
The Apache MyFaces team is pleased to announce the release of Apache MyFaces Core 1.2.0.
MyFaces Core 1.2.x is a JavaServer(tm) Faces 1.2 implementation as specified by JSR-252. MyFaces Core has passed Sun's JSR-252 TCK and is 100% compliant with the JSR-252 specification.
MyFaces Core 1.2.0 is available in both binary and source distributions.
* http://myfaces.apache.org/download.html
MyFaces Core is also available in the central Maven repository under
Group ID "org.apache.myfaces.core".
Release notes are available.
From the editor: It's as yet unclear whether Tomahawk, which extends JSF with new components and converters, is compatible with MyFaces Core 1.2.0, as Tomahawk is specified as a JSF 1.1 library. Likewise with the other MyFaces subprojects, such as Tobago (more user interface components and theming), Trinidad (dialog management and page flow scope), and Orchestra (which combines JSF with a persistence layer). They should be compatible, however: is anyone willing to confirm?
Post from TheServerSide.COM
Posted byEugene at 07:36 0 comments
JCR 2.0 under public review
The next major revision of the Java Content Repository (JSR-283) has entered public review status on the JCP web site. Most of the visible changes revolve around querying a repository for content, with the SQL and XPath query languages being deprecated.
JCR is gaining acceptance in the market, with open source vendors like Alfresco, Apache, Magnolia as well as commercial vendors such as Day, and Percussions available. (Note: this is very far from an exhaustive list, although it'd be nice to have an exhaustive list somewhere...)
The revision to the specification is an excellent step forward.
Posted byEugene at 01:44 0 comments
WebGalileo Faces releases components as open source
JSCAPE and SoftAspects today announced that their popular WebGalileo Faces component suite will be released as open-source under the Apache License. The decision to go open-source was made in an effort to expand the user base while continuing to offer commercial support options. JSCAPE and SoftAspects will continue to offer support to current licensed customers as well as provide community user forums and paid commercial support options for the newly released open-source version.
WebGalileo Faces is a suite of Ajax-enabled Java Server Faces (JSF) components for streamlined development of Rich Internet Applications. Using WebGalileo Faces, developers can create web based applications in a fraction of the time required and with fewer errors. This time savings allows developers to deploy applications much faster and focus more of their efforts on the business logic of the application versus the technical details of writing software.
Components include containers, panels, dual lists, menus, date and time components, and a flow chart component.
WebGalileo Faces has built-in support for several IDE including Sun Java Studio CreatorTM, IBM Rational Application DeveloperTM, Oracle JDeveloperTM and EclipseTM.
For more information or to download WebGalileo Faces go to http://www.javawebcomponents.com
This message on TheServerSide.COM
Posted byEugene at 01:42 3 comments
Aspect Orientation for Mashups using OpenESB by Gopalan Suresh Raj
Saturday 14 July 2007
Modularity and Encapsulation have always been cornerstones of good software engineering. Modularizing concerns is an important way to ensure that there is very little overlap in functionality between software services. Concerns that defy encapsulation are termed Cross-cutting concerns. Cross-cutting concerns make a clear separation of concerns difficult to achieve since they may cut across many modules within a software application. Some examples of such cross-cutting concerns are logging which cross-cuts all logged classes and operations, or caching which cross-cuts all cached objects, or alerting, or message tracking, or auto-reconnect, or queuing, et aliae.
Aspects help to encapsulate cross-cutting expressions in one place. By applying an Advice, at various points in an application called Join-Points, Aspects can alter the behavior of the non-aspect parts of a software application.
The Java Business Integration (JBI) specification, JSR-208, provides a loosely coupled integration model for distributed services within a Service-Oriented Architecture (SOA). The architecture allows dynamic deployment of JBI components and JBI service assemblies that can be used as Aspect and Advice mechanisms to alter the behavior of other services. Once these Aspect and Advice mechanisms are "plugged" in on-the-fly between a Consuming Service and a Provisioning Service through a Service Facade, the architecture provides a mechanism to dynamically define, verify, audit, track, enable, and enforce these cross-cutting concerns.
More information is available on the GlassFish wiki.
By Java.net
Posted byEugene at 05:00 0 comments
Java EE 6, OSGi & Sun on different wavelength's
Friday 13 July 2007
Java EE 6 is on the drawing board, but the opinions are already starting to diverge. Rod Johnson -- of Spring fame -- thinks Java EE 6 is on the right track, see the discussion on Rod Johnson: "Java EE 6 Gets it Right" . However, this is not the same tone adopted by some OSGi proponents.
Peter Kriens over at OSGi writes: "Can someone tell Sun about OSGi", going onto say :
Someone just sent me a mail linking JSR 316. A JSR that will specify Java Enterprise Edition 6, the successor of Java EE 5, which was defined in JSR 244.
Now before we take a look, lets just investigate some recent trends in the Enterprise computing world. Hmm, BEA moved their micro Service Architecture on top of OSGi, IBM Websphere 6.1 seems to have chosen OSGi, Jonas is an EE framework build on OSGi from day one, and the JBoss Microcontainer is modified to support OSGi. On top of that, we have one product that made many people re-think Java EE: Spring. Now this product fell in love with OSGi. The market clearly says one size does not fit all. One would expect that these trends have some influence on Java EE 6? Sigh, think again.
Alex Blewitt, continues with his post "Sun submits JSR 316, still doesn't get OSGi", saying :
What's really interesting is that this approach (of combining lots of individual elements to one big package) mirrors what Sun's trying to do with the Java language. Instead of breaking units down into smaller and smaller levels (or bundles), they're going the opposite way and defining larger and larger chunks.
What are your thoughts on Java EE 6 ? Are the OSGi claims unfounded ? Or are they on the mark ?
Full post from Peter : http://www.osgi.org/blog/2007/07/can-someone-tell-sun-about-osgi.html
Full post from Alex :
http://www.eclipsezone.com/eclipse/forums/t98330.rhtml
This article was posted by TheServerSide.COM
Posted byEugene at 04:42 0 comments
Interoperability between the Java platform and Windows Communication Foundation (WCF)
Project Tango develops and evolves the codebase for Web
Services Interoperability Technologies (WSIT) that enable
interoperability between the Java platform and Windows Communication
Foundation (WCF) (aka Indigo).
Project Tango's WSIT tecnology is bundled inside GlassFish v2. It is also
possible to download a more recent version of WSIT and install into
GlassFish or Tomcat.
Project Tango uses JAX-WS and
JAXB as a foundation upon which
to build plugins to provide web services features such as
bootstrapping communication, optimizing communication, reliable
messaging, atomic transactions, security and trust.
One of the main goals of Project Tango is to provide
interoperability with Windows Communication Foundation,
the Web services stack bundled with the .NET 3.0 platform.
The two main value propositions of Project Tango are the following:
● An implementation of the key WS-* specifications
● Interoperability with .NET 3.0 framework
Tango provides an implementation of the key enterprise Web services technologies, commonly known as WS-*, with a focus to provide interoperability with Windows Communication Foundation, which is a component of .the NET 3.0 framework that provides Microsoft's unified framework to build distributed applications.
For any Web service communication, there is a Client that invokes an Endpoint. The Endpoint advertises its capabilities as metadata which the Client uses to bootstrap communication with the Endpoint. This metadata indicates which of the capabilities―Security, Reliability, and Transactions―are supported at the Endpoint. The figure shows a pair of Client and Endpoint, one using Metro and the other using .NET 3.0. The Metro Client and Endpoint can be deployed on any of the GlassFish V2 supported platforms. The .NET 3.0 Client and Endpoint can be deployed on any of the .NET 3.0 supported platforms.
Posted byEugene at 02:00 0 comments
Seam and Flex by Shashank Tiwari
Wednesday 11 July 2007
JBoss Seam and Adobe Flex are two promising technologies. Seam makes it easy to build stateful web applications. It integrates the Java EE frameworks together. Flex is a great rich application development framework. The question is can they and should they be used together?
Seam till its 1.x versions used JSF as the main UI framework. This implied that it was built around a server side UI model. Flex on the contrary is a client side UI framework. Oops! so we have a big disconnect right away! Not really, there possibly are some viable options to make them work together. In the latest version of Seam 2.0.0 BETA the coupling with JSF has been loosened. Also, in the past its been demonstrated that JavaScript UIs (built on frameworks like DOJO or any other) could directly remote to Seam server side components. Remember though that JavaScript runs within the browser whereas Flex applications runs within the Flash VM. Does that matter?One option is to have Flex as the front end and make Flex components remote to Seam? Technically this is a possibility and may be good in situations where Flex is used as a pure view description technology. In fact has anybody wondered writing a JSF render kit for Flex? That would be one nice looking but ugly under the hood hack. The state and event management would be all mixed up and one would end up writing more wiring to save the two together than use in isolation. I know some of you may oppose this thought and may cite cases where you have used Applets as a face for Servlets or similar server side technologies. Yes it works, is it elegant though? And what were the big wins of making them work together anyway? This the same question I ask when I read articles that claim that Spring MVC can work smoothly with Flex and Java Portlets can work effortlessly with Flex. Is it better to make complicated applications by spending more time and energy as opposed to building clean applications faster? In other words is it better to do the right thing or focus on making everyone happy?
So what does it mean in the context of our main exploration of making Seam and Flex work together? We have looked at the dry option of remoting a Flex face to a Seam server side. We could possibly liven it up by managing state on both sides - client and server - and introduce something that could be called a State Transfer Object (STO) to transfer the state information back and forth. Doesn’t sound good! It reminds me of the pain of using DTOs. Is there any other option? My answer is that I don’t know of one yet. I am trying to write a bridge between the two, following the principle of delegation and inclusion of common contexts wherever possible and ofcourse cheating (oh sorry! drawing inspiration) from the JavaScript remoting integration and the GWT integration in the Seam code base. If and when its ready, it would show up as an open source tool for everybody to play with and I will annouce its arrival. BTW, if anyone else here is interested in hacking that with me, you are most welcome to join in. In the meanwhile I would certainly like to hear your experiences in making these two work together. Both real life experiences and armchair musing are welcome.
Before I end this post, it may be important to discuss the “should they be used together” part of the question. Seam integrates the parts that make up Java EE very well. EJB3 components and POJOs are available as transactional components within stateful contexts. The programming model is simplified with the use of annotations. Integration with persistence architectures is really cool - I wish like with JSF, I could validate my form input on the Flex screen using Hibernate Validators or directly bind Flex component and control properties or instances to EJB3 entity beans.
With Seam there are lesser number of those XML files and template configurations to handle, as opposed to others, say Spring, where they are in abundance. Plus the biggest benefit is that you don’t have to learn a new framework really, most of what Seam uses is standard Java EE - EJB3, expression language, annotations, etc…..
Flex creates really elegant user interfaces. The best part is one can create them really quickly. Last week I hacked a fairly functional prototype for a reporting and charting application in 2 days - I can never do that with any other technology - not even with Ruby on Rails. Even if I can it would never look so nice and be functional. Part of the speed is surely attributed to the FlexBuilder eclipse plugin and it takes a lot more effort before such an application can go to production.
To summarize, both are great technologies. Also, though they overlap in many places they clearly have their strengths in different areas.
Theoretically bringing them together implies a beautiful face and smooth controls to a powerful engine — Tell me who would not want to drive such a machine?
Posted on O'Reilly Blog
Posted byEugene at 02:08 0 comments
Remind about OSGi.
Sunday 8 July 2007
OSGi is a specification of a Java based service platform targeted for use by systems that require long running times, dynamic updates, and minimal disruptions to the running environment.. The Eclipse Equinox project provides one of many available implementations of this specification (EclipseZone recently featured a podcast with Equinox project lead Jeff MacAffer) and serves as the reference implementation of the latest OSGi R4 specification. Initially, OSGi was targeted at home automation and residential gateway devices. More recently, it has found use in everything from mobile phones to cars.
The OSGi specification breaks software up into units of functionality called bundles. As a result this makes OSGi an idea base for applications such as IDE and application servers that often have numerous "modules" that may or may not need to be started at runtime or after the application has been started. The Eclipse IDE has made use of OSGi as its base since version 3.0. More recently other applications have started leveraging OSGi.
One recent use of the Eclipse Equinox technology is to bundle servlets and JSP's in Eclipse style plugins for dynamic WAR deployment. The Apache Tuscany SOA project has recently started exploring OSGi. Websphere 6.1 and JOnAS 5 are also being reworked as OSGi applications. A case study published by Adobe details how they made use of OSGi in their Adobe Creative Suite 2 application:
... [team members] found that reusing Adobe Creative Suite 2 components in an Equinox environment was as simple as writing a thin compatibility layer.Developing plug-ins to deliver new functionality in the past had presented significant challenges. Since it was difficult to validate dependencies, Version Cue had not been able to make the most efficient use of system resources by loading exactly what was needed. Using Equinox and the Eclipse plug-in model, resolving plug-in dependency is simple, and they have been able to achieve true dynamic loading and unloading of plug-ins on demand. The result is a smarter, leaner and faster application that provides a better user experience.
Developers in the trenches are also starting to notice OSGi. Xerto's Imagery application is built on Swing but uses OSGi for its plugins layer. Blogger Werner Schuster recently commented:
if you want to write any kind of nontrivial program where you want a clean seperation of the individual modules. If you do that, you can spend ages writing a runtime system that tediously reimplements all the OSGi features,.. or you can just use OSGi. And it will pay off… OSGi isn‘t a new kid on the block… it‘s now up to version 4, not to mention that Eclipse has used it now for about 3 years and provided lots of feedback. I became really convinced of OSGi usefulness when I had some class loading issues while writing EclipseShell… I already feared having to mess with the classloaders (not much fun if you‘re using JVM based dynamic languages which might or might not pack their own class loading tricks). But no! The solution to my problems was … adding a line to the Manifest.MF ... et voila! (If you‘re curious, google for “Buddy-Classloading”)...So… screw Sun‘s NotInventedHere syndrome, screw Dolphin, screw waiting for JSR-277 to be shoved into existence. The future is here right now and it‘s tried, tested and easy to use in the form of OSGi, Eclipse for development, and Equinox for the runtime.
It will be interesting to see how the Java community makes use of OSGi which is available today versus Sun's "super-packages" (JSR 294) and Java Modules (JSR 277) initiatives scheduled for Java 7. A blog post by Sun's Alexis Moussine-Pouchkine described the two JSR's:
JSR 294 is development-time and language driven while JSR 277 is all about deploy-time ... one of JSR 294's goal is to enable "separate compilation", i.e. compile against an interface without needing the actual implementation. Most of JSR 277 has to do with annotating JSR 294 modules. Pretty much like moving archive manifest information to Java annotations.
Read original article on InfoQ
Posted byEugene at 05:08 0 comments
JSF 2.0. When & What ?
I think most of web developers on java, know that JSR 314is in the review ballot phase.
This JSR is all about JavaServerFaces 2.0
By next year when the specification is ready for release we would see a lot of goodies in JSF, some of them being -
- better view decription technology - somewhat like facelets or maybe better.
- application modification and deployment at runtime
- tighter integration with Ajax. perhaps support for a small JavaScript library contract specification.
- better and maybe centralized error handling
- minimization of “xml hell”, use of annotations instead
- possibility of RESTful urls and use of GETs
- skinning and themeing
- reduction of effort required for creating custom components
You can view the requirements scratchpad for this JSR.
Posted byEugene at 05:08 0 comments
OSGi , Spring OSGi and the server-side. Part 4
Now , I want to tell you about server-side of OSGi technology.
Nowadays, better support of server-side gives Eclipse Equinox OSGi framework.
From a code point of view, Equinox is an implementation of the OSGi
R4 core framework specification, a set of bundles that implement various optional OSGi services and other infrastructure for running OSGi-based systems.
More generally, the goal of the Equinox project is to be a first class OSGi community and foster the vision of Eclipse as a landscape of bundles. As part of this, it is responsible for developing and delivering the OSGi framework implementation used for all of Eclipse. In addition. the project is open to:
- Implementation of all aspects of the OSGi specification (including the MEG and VEG work)
- Investigation and research related to future versions of OSGi specifications and related runtime issues
- Development of non-standard infrastructure deemed to be essential to the running and management of OSGi-based systems
- Implementation of key framework services and extensions needed for running Eclipse (e.g., the Eclipse Adaptor, Extension registry) and deemed generally useful to people using OSGi.
Server-Side Equinox
Equinox can be used on the server to serve up static content and to run servlets or JSPs. In each of these cases you need to setup an HTTP server and then configure it with the appropriate content. There are two basic ways of running an HTTP server in Equinox;
Follow the steps for the configuration best suited to your scenario then return here to write your bundle based web application.
HintEmbed a server in Equinox is the easiest configuration to setup and run. This will allow you to do all your development and debugging. Only when you go to production or in special circumstances will you need to embed Equinox in an existing servlet container.
Posted byEugene at 05:01 1 comments
Rethinking JSF - The Real Problem. By Joseph Ottinger
Saturday 7 July 2007
This article is worth to look at. The main problem that discussed there is that JSF, for a component framework, has so few components.
It is hard to disagree with that.
"So... where are the login box components? Where are the search box components? Where are the data input components? Where's the ability to manage "pretty URLs?" ("Pretty URLs" are also known as bookmarkable URLs, or search-engine-friendly URLs.) Where is the data flow? Where's the conversational state?
There's absolutely nothing in JSF that prevents these things from being made, and some groups (vendors, open source groups) have already made some of them - frameworks and implementations like Seam, IceFaces, RichFaces, Tomahawk, NetAdvantage, and others. For others, code is readily available in books like "JSF: The Complete Reference" (Schalk, Burns), "JSF In Action" (Mann), and "Core JSF" (Geary). Some elements are even available on the web (for example, how to manage pretty URLs). There are also sites with lots of JSF information: IBM developerWorks, Java.sun.com, www.jsfcentral.com, www.jsftutorials.net, and TheServerSide itself. "
"Advice for new component authors: stop reinventing the wheel! Everyone has a tab panel, a menu component, a spinner, a drag-and-drop mechanism. It's been done. While perhaps newer and better ways to do things will always be welcomed, aiming for a "me-too" implementation doesn't help propagate the technology in any real way. What JSF needs is a set of components that use interfaces as models, along with a "standard implementation" of those interfaces that can be replaced at runtime with specific functionality. Along with this set of components, documentation that addresses the learning curve would be welcomed."
Full article
Posted byEugene at 06:55 1 comments
Ajax Experience: What's interesting for Java developers?
"The Ajax Experience, scheduled for July 25-27 2007 in San Francisco, has a lot of great sessions of interest to Java developers - whether you're following JSF, GWT, Struts, or even hand-coding your client-side UIs yourself. The Ajax Experience caters to the technology behind Web 2.0 - you should check it out.
Topical tracks include architecture, performance, design and effects, and specific frameworks. Speakers include framework developers like Brad Neuberg (Dojo), Patrick Lightbody (Struts2), Joe Walker (DWR), and more. Specific sessions of interest to Java developers include "Flash: Strengths vs. Weaknesses and How to Best Utilize it in Projects," by Geoff Stearns, a Youtube engineer; Advanced Prototype usage (Prototype is the underlying toolkit used by many Ajax frameworks); Continuations in Javascript; Advanced Web Security with Joe Walker, and more.
Of course, these are only the tip of the iceberg for Ajax developers.
So what makes this conference useful? Well, consider: for most users and applications, the web interface is the primary (or even only) point of contact. The back end may be elegant, incredibly fast, amazingly efficient, but with a clunky interface, nobody will care. The killer applications today tend to focus on the user experience: useful menus, dynamic behavior that caters to the way users want to use the application.
With a few rare exceptions, the way people make their application interfaces sing today is with Ajax, rich client interfaces that offer interactivity and rapid response to users.
The Ajax Experience is a great way for Java developers to leverage this technology, whether as experts or as people needing introduction to the concepts, whether you need to understand how the basic architecture works or if you need to optimize how your application already leverages the technology.
What stands out to you in the Ajax Experience?"
By TheServerSide.COM
Posted byEugene at 06:53 0 comments
JSR-275 - Units and Measures for Java 7 - draft terminates soon
Friday 6 July 2007
I really interested in what it would be? And how it would be implemented?
This is what they say:
"Java developers who work with physical quantities (such as developers in the scientific, engineering, medical, and manufacturing domains) need to be able to handle measurements of these quantities in their programs. Inadequate models of physical measurements can lead to significant programmatic
errors. In particular, the practice of modeling a measure as a simple number with no regard to the units it represents creates fragile code. Another developer or another part of the code may misinterpret the number as representing a different unit of measurement. For example, it may be unclear whether a person's weight is expressed in pounds, kilograms, or stones.
Developers must either use inadequate models of measurements, or must create their own solutions. A common solution can be safer and can save development time for domain-specific work. This JSR proposes to establish safe and useful methods for modeling physical quantities."
JSR-275 "Measures and Units" Early Draft Public Review terminates soon (July 8). Your comments/feedback are important to us (the latest version 0.8 is available here).
The JSR-275 should be a major enhancement for Java 7 by providing "strong" typing (through class parameterization) and easy internationalization of Java programs (preventing conversion errors). The reference implementation is provided by the JScience project under BSD License.
Let's wait and will take a look when all will be done.
Posted byEugene at 00:57 0 comments
WhoDoes, free web-based project management software
Monday 2 July 2007
GotThingsDone.comhas released WhoDoes, a new intuitive web-based project management software developed with Ruby on Rails.
Whodoesis suitable both for firms and professionals that have to plan and manage various projects of diverse complexity, where a lot of people, united or distributed anywhere, have to be coordinated and have to collaborate with tracking the advancement of the developed activities.
WhoDoes is designed to assist Project Managers and team members in the planning and management of projects with varying complexities.
It makes managing of complex projects easy, and facilitates the convenient planning of short-term small activities.
The major hitch in project management is making all the team members aware of what they have to do daily, so a successful project management tool must first of all answer the following question: What do I have to do today?
WhoDoesis designed to manage activities and share real time information with all the team members, whether they are in the same office or distributed all over the World.
Among its key features:
- Web-based: WhoDoesis usable from every computer connected to the Internet. No installation is required, it's totally cross-platform and cross-browser.
- Easy to use: A simple and easy web application helps to reduce the time spent on project planning.
- Team co-ordination: WhoDoes has a control panel to communicate and collaborate with all team members anywhere, filling the communication gap between who plans and who works.
- Roles division: Roles and permissions are divided for each project user.
- Easy time tracking: Gives detailed real-time informations and time control on tasks, project times and delays, allowing project managers to manage delays at the right moment.
- Repository: A shared archive for project documentation, a common space where all the team members could share materials and find the last official version of the project documents.
WhoDoesis completely free to use. All the features included in this version will remain free even when chargeable versions come out in the future.Follow this link to register for a new WhoDoes account.
Posted byEugene at 01:18 1 comments
OSGi , Spring OSGi and the server-side. Part 3
Saturday 30 June 2007
Here is a part from comparison between Spring OSGi and OSGi services, Equinox extensions.
Comparison Matrix
| Extensions | Services | Declarative Services | Spring-OSGi | |
|---|---|---|---|---|
| What are registered? | XML declarations, optionally containing class names. | Java objects. | Placeholder proxies for Java objects, replaced by real Java objects on first use. | Placeholder proxies for Java objects, replaced by real Java objects on first use. |
| How are they registered? | All <extension> nodes in the plugin.xmlare automatically registered. | Through the BundleContext API | All service component XML files declared through the Service-Component manifest entry are automatically registered. | All Spring XML files contained in the META-INF/springfolder of a bundle, or declared through the Spring-Context |
| How are they consumed? | Queried by extension point ID. Registry returns all entries, consumer must iterate them to find which one(s) it wants. | Queried by interface name, plus a property filter. Usually the filter is specific enough to ensure just one match. | Internally uses same query over interface name plus filter, but the query is performed within SCR. Matching services are supplied to consumer code via JavaBean-style setter methods. | Same as for DS, but can additionally supply matching services via constructor arguments. |
| What is the cardinality? | Conventionally, one to many. One extension point has many extensions, but each extension has exacly one extension point. However another plug-in can query extension points that it doesn’t own. | Many to many. One service can be used by multiple consumers, and one consumer can use many services. | Same as for services | Same as for services |
| When are they loaded? | Extension declarations are loaded during start-up, or when a new plug-in is installed. Classes named in the extension are loaded lazily, i.e.only when needed. | The class that implements a service must be loaded and instantiated before the service can be registered. This happens only when the bundle is explicitly started. | For delayed services, the SCR registers a placeholder proxy service immediately when a DS-enabled bundle is resolved. The real class is loaded and instantiated when the service is first used. | Same as for DS. |
| How is dynamic installation/uninstallation dealt with? | Either query on each use or track with ExtensionTracker. | Either query on each use or track with ServiceTracker. | SCR calls methods on the component to supply it with the latest available matching service. It can also call an unset method when the service becomes unavailable. | Similarly to DS, supplies latest matching service through setter method on the bean. |
| Can caching references to extensions/services cause problems? | Yes, and as a legacy of pre-OSGi usage, some plug-ins still do this. | Yes, but this is strongly discouraged by the specification, and in practice happens rarely. | No, SCR does not do this. | No, Spring-OSGi does not do this. |
Comparison by EclipseZone
Posted byEugene at 09:57 2 comments
OSGi , Spring OSGi and the server-side. Part 2
Spring OSGi is a sub project of Spring Framework.
"The Spring Framework is the leading full-stack Java/JEE application framework. It provides a lightweight container and a non-invasive programming model enabled by the use of dependency injection, aop, and portable service abstractions. OSGi offers a dynamic application execution environment in which components (bundles) can be installed, updated, or removed on the fly. It also has excellent support for modularity and versioning."
Benifits from using Spring OSGi in OSGi runtime environment:
- Better separation of application logic into modules
- The ability to deploy multiple versions of a module concurrently
- The ability to dynamically discover and use services provided by other modules in the system
- The ability to dynamically deploy, update and undeploy modules in a running system
- Use of the Spring Framework to instantiate, configure, assemble, and decorate components within and across modules.
- A simple and familiar programming model for enterprise developers to exploit the features of the OSGi platform.
If you want to know more about Spring OSGi and Spring Framework, you can start from reading introduction on Spring Framework site.
Posted byEugene at 09:57 0 comments
OSGi , Spring OSGi and the server-side. Part 1
Friday 29 June 2007
I want to post here some information that will help you to find out more about OSGi and how Spring Framework work with it.
First I want to say few words about OSGi technology.
From Wikipedia, the free encyclopedia:
"The OSGi Alliance (formerly known as the Open Services Gateway initiative - now an obsolete name) is an open standards organization founded in March 1999. The Alliance and its members have specified a Java-based service platform that can be remotely managed. The core part of the specifications is a framework that defines an application life cycle model and a service registry. Based on this framework, a large number of OSGi Layers, APIs, and Services have been defined: Security, Module, Life Cycle, and Service Layers; Framework API; Package Admin Service; Start Level Service; Conditional Permission Admin; Permission Admin Service; URL Handlers Service; Log Service; HTTP Service (runs servlets); Device Access; Configuration Admin Service; Metatype Service; Preferences Service; User Admin Service; Wire Admin Service; I/O Connector Service; Initial Provisioning; UPnP Device Service; Declarative Services; Event Admin Service; Deployment Admin; Auto Configuration; Application Admin Service; DMT Admin Service; Monitor Admin Service; Foreign Application Service; Service Tracker; XML Parser Service; Position; Measurement and State; and Execution Environments.
"The OSGi specification is developed by the members in an open process and made available to the public free of charge under the OSGi Specification License. The OSGi Alliance has a compliance program that is open to members only. As of January 2007, the list of certified OSGi implementations contains 3 entries."
OSGi in fact:
"OSGi technology is the dynamic module system for Java™. The OSGi Service Platform provides functionality to Java that makes Java the premier environment for software integration and thus for development. Java provides the portability that is required to support products on many different platforms. The OSGi technology provides the standardized primitives that allow applications to be constructed from small, reusable and collaborative components. These components can be composed into an application and deployed.
The OSGi Service Platform provides the functions to change the composition dynamically on the device of a variety of networks, without requiring restarts. To minimize the coupling, as well as make these couplings managed, the OSGi technology provides a service-oriented architecture that enables these components to dynamically discover each other for collaboration. The OSGi Alliance has developed many standard component interfaces for common functions like HTTP servers, configuration, logging, security, user administration, XML and many more. Plug-compatible implementations of these components can be obtained from different vendors with different optimizations and costs. However, service interfaces can also be developed on a proprietary basis.
OSGi technology adopters benefit from improved time-to-market and reduced development costs because OSGi technology provides for the integration of pre-built and pre-tested component subsystems. The technology also reduces maintenance costs and enables unique new aftermarket opportunities because components can be dynamically delivered to devices in the field. "
To be continued...
- Resources:
- OSGI Alliance
- OSGi in Wikipedia
- OSGi Blog
Posted byEugene at 04:42 0 comments
Bundling Ajax into JSF components
"Any Java developer who has already worked with Java Server Faces has undoubtedly come across the need for a custom component. Most components in JSF implementations are rudimentary and don't really address real-world situations--if data-entry solutions for all problem domains were as simple as a login form, then JSF would be just the right tool out of the box. The saving grace of the framework is the ability to create and extend custom components, and if you couple that with the power and versatility of Ajax, you really start to reap the benefits of the modern Model-View-Controller architecture." - by Chris Hardin.
To get more information on how to bundle Ajax into custom JSF components, you can start from reading this article.
I want to say , that nowadays - you almost can't do JSF application without Ajax if you want to create powerful rich application.
Users of your application are hope and waiting that web application will be as close as possible to desktop applications. With all their's intuitive and responsible user interface, with flexible look&feel - with ability change it "on the fly".
Posted byEugene at 04:26 0 comments
QuipuKit JSF Library
The QuipuKit component suite includes advanced UI widgets (TreeTable, Chart, Calendar) and provides enhanced implementations of the standard JSF components (DataTable, TwoListSelection). Each QuipuKit component offers a rich feature listand various customization options, enabling you to create a desired look-and-feel with ease.
I'm currently using this library in one of my project. All my thoughts and impressions I will write later.
Posted byEugene at 02:16 0 comments
Combine JSF Facelets and the Flying Saucer XHTML Renderer
This is a very nice tool for JSF and Facelets.
"Facelets and the Flying Saucer Renderer have a symbiotic relationship: one produces XHTML content while the other "parses" it and lays it out into an object graph in memory. While this object graph is then usually translated into Graphics2D API calls to render the document in Swing/AWT, it can also be transformed into various other formats such as PDF, a selection of image formats, or as a Scalable Vector Graphics (SVG) document." - by by Jacobus Steenkamp
Now it is very easy to create reports in pdf documents using just simple .xhtml pages with all it's supported content.
- Articles:
- Generating PDFs for Fun and Profit with Flying Saucer and iText
- Full description on java.net
Posted byEugene at 01:44 1 comments
Ajax - Real benefits of real components. Part 4
Wednesday 27 June 2007
Continue from part 3.
Short list of useful AJAX components (from 32 to 39) :
32. Grid3 Example
33. AJAX Table Sort Script (revisited)
34. AJAX Sortable Tables: from Scratch with MochiKit
35. AJAX TableKit
36. AJAX LightBox, Sexy Box, Thick Box
37. AJAX Lightbox JS
38. AJAX Unobtrusive Popup - GreyBox
39. SmoothGallery: Mootools Mojo for Images | Full gallery
Full article by
Smashing Magazine
Posted byEugene at 05:38 0 comments
Ajax - Real benefits of real components. Part 3
Continue from part 2.
Short list of useful AJAX components (from 21 to 31) :
23. Disable form submit on enter keypress
24. AJAX Instant Completion: Rico Framework
26. AJAX Emprise Charts: 100% Pure JavaScript Charts
27. amCharts: customizable flash Pie & Donut chart
28. PJ Hyett : The Lightbox Effect without Lightbox
29. AJAX Upload Form
31. Ajax.Form: mootools demo
Full article by
Smashing Magazine
Posted byEugene at 05:37 0 comments
Ajax - Real benefits of real components. Part 2
Continue from part 1.
Short list of useful AJAX components (from 11 to 20) :
11. AJAX Calendars
14. Ajax poller
15. AJAX HistoryManager, Pagination
16. AJAX Tooltips: Nice Titles revised | Blog | 1976design.com
19. GMail Ajax Style Username Signup
Full article by
Smashing Magazine
Posted byEugene at 05:35 0 comments
Ajax - Real benefits of real components
Friday 22 June 2007
Almost every person who work in web-development knows about all benefits that we've got with Ajax. All new web applications have to be more and more interactive, responsive and flexible. Here I wanted to present for you most interesting Ajax components that already done and can make development easy and your applications more powerful.
Short list of useful AJAX components (first 10) :
1. AJAX AutoSuggest: An AJAX auto-complete text field
2. AJAX Autocompleter / script.aculo.us library
4. Ajax autosuggest/autocomplete from database
9. AJAX Dialogs, Menus, Grids, Trees and Views
Full article by
Smashing Magazine
Posted byEugene at 10:38 0 comments
What this blog about?
This blog is about Java, web development, all Java related server-side technologies,
about UI and how to design it, and also about JSF , AJAX, custom JSF components etc.
Posted byEugene at 10:38 0 comments