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