What's New in Seam 2.1 - An interview with Peter Muir
What's New in Seam 2.1 - An interview with Peter Muir
Join the DZone community and get the full member experience.Join For Free
How do you break a Monolith into Microservices at Scale? This ebook shows strategies and techniques for building scalable and resilient microservices.
In this podcast interview, Peter Muir previews some of the upcoming features in Seam 2.1, including support for GWT and Wicket, improved security enhancements for identity management, permissioning, and single sign-on, as well as better support for RESTful application development.
A complete transcript of the interview has been provided below:
DZone: We are sitting today with Peter Muir, core developer on Seam, Web Beans and Rich Faces. Peter is currently focusing on extending Seam beyond JSF, making view layers like Wicket a first-class option, and building the Web Beans reference implementation. [img_assist|nid=4312|title=|desc=|link=none|align=right|width=117|height=168]
Hi, Peter. Can you tell us a little bit about yourself and what you're up to at JBoss?
Peter Muir: I live in Edinburgh, Scotland, on the European side of the Atlantic. I always spend most of my spare time climbing mountains, which is why Edinburgh is a great place to live.
Going on to what I do for JBoss, I've worked for JBoss for about a year and on Seam for about a year and a half. At JBoss I'm also the Web Beans reference implementation project lead. I work on Rich Faces a bit, which is a JSF component library. I also represent JBoss on the JSF 2.0 expert group.
DZone: So, Peter, for those who don't know, what is JBoss Seam, and what fundamental problem does it solve?
Peter: Seam is an application framework, targeted at writing enterprise applications. And the first thing it really provides is a uniform component model, which integrates really well with JSF/EJB3 and JPA. When I say integrates really well, I mean both conceptually, in terms of when you're writing your app, it feels like you're writing in one system. And also, of course, it actually integrates really well.
The second thing we provide is the declarative state management with support for conversations. And this is really something that has become much more popular since Seam started. The flip side of this is we also provide stack, which takes away some of your sort of confusion, perhaps, when you're getting started trying to work out which technology to use. And in this stack, there's deep integration for things like Ajax, JPA, business process management, rule engines, security.
And we also give you some guidelines with stack. We also don't want to force you to design your app in one particular way. We don't want you to design your app around the framework. We want you to design your app and for the framework to help you do that.
DZone: What are some of the main features in the current 2.0 version?
Peter: The current 2.0 version was released in November, so it's been out just over six months, now. One of the big things we did was a lot of streamlining over Seam 1. So this included things like providing a much better dependency management system, allowing parameters to be used in EL, cleaning up the structure and packaging of the Seam components that you use so they're in more logical places with a better design.
And it’s also brought lots of new features, like being able to write components in Groovy rather than Java; integration with Hibernate search; a JSF library for drawing charts onto web pages or PDFs, which Seam also provides; integration with the Quartz library for asynchronicity, and scheduling jobs; integration with RPC-style Web services; and a myriad of fixes to things.
DZone: Many of our members are using heterogeneous environments which employ different containers and development frameworks. How well does Seam work on containers and runtimes other than the JBoss application server?
Peter: Yes. This has really been a big priority for us over the last few months to really bring our offerings on other app servers up to a much higher standard. At the moment, we support WebSphere, WebLogic, OC4J, which is Oracle’s container. GlassFish 2, Tomcat, and of course, we support JBoss application server, both the current GA 4.2 and the upcoming 5, JBoss five release.
For all of these application servers, we have documentation and examples showing you the changes you need to make to your skeleton schema to make it run on this container. And, of course, I should have mentioned that Seam has a skeleton application generator, just like Ruby does, that will get you started really quickly.
And we're slowly ramping up on the quality assurance done on other platforms, particularly with WebLogic and WebSphere. The goal is to make them have the same level of support with Seam as we do on JBoss application server. And JBoss is always going to be the primary platform because it's the platform we all develop on and work with day-to-day. And it's also worth pointing out that if you're buying support for Seam from RedHat, then it's the only platform which you can get support on.
DZone: Great. Now, at the moment Seam 2.0 only supports JSF as a view framework. Are there any plans to change this in the 2.1 release?
Peter: Yes. At the moment, Seam does support GWT, in those terms if you like, but we really don't feel that the support goes to the deep level of integration that I was talking about earlier. This is a big target for Seam 2.1.
Firstly, we want to support Wicket, as a first class view layer. Well, what does this actually mean, with some sort of technical details. Well, what we want to be able to do is allow you, obviously, to be able to access your Seam components for a Wicket club, using annotation controlled injection, to be able to control conversations, with annotations from inside your Wicket class, to be able to control your business process management tasks and your business process management processes themselves. So basically, all the orchestration stuff that you need to do with writing the view side of your app.
And, as I mentioned, we already have support for GWT, and we are working on improving that. If you want to use RIA, the main RIA framework that we've looked at is Flex, and currently there are actually two competing projects regarding Flex integration.
There's Exadel providing a framework called Flamingo. And another open source project called Granite Tide, which provides an alternative implementation for this. And we're currently working on bundling support and examples within Seam, itself.
DZone: Does the addition of first-class support for GWT and Wicket mean that Seam is effectively abandoning JSF, and what do you see in the future of JSF for Seam?
Peter: I think, the big answer here is not at all. We're definitely not abandoning JSF. As I mentioned, I'm on the JSF expert group, representing JBoss and Seam. We're taking all the ideas from Seam back to JSF 2.0, and reviewing them, of course, with all the other members of the expert group, many of whom have solved the same problems, just in a slightly different fashion. So, of course, that's hard work, because we end up having a long discussion about how do we do this, how do we do that? But I do think that we end up with a better piece of software as a result of doing this.
I think that, for me, the strength of JSF has always been that it's a solid base on which you can build other component libraries, other behavior like Seam. I feel this is very much the focus of the expert group in designing JSF 2.0.
They are facing, for example, providing Ajax support, but they're not going to provide a library of rich Ajax components, just the support Java script you need to make your rich components, as it were. But, I am bring in things, of course, like a templating language, some musical Facelets.
In conclusion to this little point about what's the future of JSF, I think JSF is the standard, and as a result, has a bright future. With the improvements we're going to see in JSF 2.0, I think it's going to go from strength to strength.
That does beg the question why are we introducing other support for other view layers in Seam? As I said right at the beginning, Seam is really all about choice. And so, what we're trying to do here is just add choice for our users, whilst maintaining the overall feel of the Seam programming model and Seam, itself.
DZone: Now, support for GWT and Wicket, was this sort of based on, I guess, some level of mass adoption of these two frameworks, and would that mean you would also open it up to other view layers down the road?
Peter: Sure. GWT has shot to popularity, really. I should think it's probably one of the youngest web frameworks around, and has huge popularity and looks very nice visually. That's a big thing, I think, when people look view layers, they want something that's nice visually. So GWT, certainly, because it's popular... It's interesting, it's a different program model to the JSF program model. It's sort of that swing feel program model. We really feel that it's... it's an interesting avenue to explore because of it being a different program model.
Wicket? I don't think Wicket's adoption is as large as GWT or JSF, but it's certainly another very interesting choice, because like JSF, it's a component-orientated framework. However, it does address many of the complaints that people have about JSF, I guess one of which is performance. It performs really nicely.
And secondly, it's very, very easy to implement custom behavior and custom components in Wicket, because, in Wicket, you're always working in Java, as opposed to working in XML, so, if you want to add custom behavior, you just override a method or you write your own subclass of an existing component.
DZone: Great. So, Peter, what other changes can we expect to see in Seam 2.1?
Peter: Sure. So, I've got a list of things here that we've got. So, very briefly, we've got quite a lot of improvements to security, firstly improvements to identity management. Of course, identity management is one of those things that pretty much every application needs: the ability to add users, change users' passwords, store users in the database or in an LDAP server, and display these screens to the user. So, sort of built-in support for that.
And with this comes a much more extensible permissioning model for Seam, where we go from just having a sort of static set of permissions to also being able to define your own permissioning scheme or to be able to use access-control-list style permissions, on top of the current permission scheme we've got, which is either a very simple one or one that's based on the Drools rules engine.
And the third security improvement we have, which is a really big request from our users, is the single sign-on. And this will be primarily, or firstly, through JBoss's single sign-on library. So, that will be a big thing, I think, for many of our bigger enterprise users.
And the next thing is something that I'm really excited about, which is providing much better support for RESTful applications. And we're going to be doing this through integrating JAX-RS, which is the JSR-311, the standard for RESTful web services in Java, and RESTeasy, which is an implementation by another JBoss guy, Bill Burke. And this is still pretty much early days. The first code was committed a couple of weeks ago. But, since reading the O'Reilly book on REST, I've been a real fan of REST, so I think this is pretty exciting, and I'm looking forward to seeing how this works out.
And if people are interested in having a say in this, then come along and talk to us. We're definitely still in the design phases, so we're interested in ideas and other people's experience.
And finally, the other big request that we've had from our users is to make the applications perform better. I mean, who doesn't want their application to perform better and properly, right?
So, we're going to be doing a lot of performance and scalability analysis on Seam. And this is really going to feed back to our users in two ways. First of all, obviously, there's the obvious fact that we're going to be trying to improve any bottlenecks that exist in Seam and looking at where the bottlenecks are.
But I think that possibly what's actually going to have more effect on many people is we're going to write documentation about the patterns you need to use to make your application perform well and scale well. Because, of course, there are certain ways you write your app and it's going to be slow, and there are certain ways you write your app and it's going to be much more performant. So, that's the other big thing that we need to deliver in 2.1.
DZone: So, Pete, you mentioned earlier that you were involved in the WebBeans specification. Can you talk a little bit about what this spec means for Seam users?
Peter: Of course. So, WebBeans, very briefly, is another one of these specifications that's being produced. And like I was saying about JSF, it's not just based on Seam. It's based on Juice and Seam - they're the two main sort of driving forces behind it - but also other, similar frameworks.
And when I was talking about what makes up Seam, I said there's this: declarative state management and the uniform component model. And this is really what WebBeans is. WebBeans is a wholly new contextual component model, so it replaces all the existing conversation control, injection support, definition of components, components life cycle, transaction integration, JPA integration, and also the validation - it specs out the validation support within the framework.
But, what does this mean specifically for Seam? Seam three will be based on the WebBeans specification. And Seam's role in this will be to take the WebBeans implementation and to provide that integration stack that I was talking about earlier, which provides all the extras, as it were: the security, business process management integration, the REST integration, I don't know, other stuff like integration with security, AJAX, that kind of thing.
And what if you want to run existing Seam components on Seam 3, on this new model? Well, they're not going to run in WebBeans, because WebBeans is an entirely new container. But, what we're going to do within the Seam 3.0 series is provide an emulation layer that would allow you to run Seam legacy components inside the Seam three container.
And of course, the big question is: when will Seam three be out? Well, I can't really say, but I reckon we'll have a beta in early 2009.
DZone: I'm sure people will have their hands full with the Seam 2.1, in the short term.
Peter: Absolutely. Hopefully. [laughs]
DZone: So, are there any sort of barriers to WebBeans becoming an official standard? How's that coming along?
Peter: Sure. I mean, I'm not actually directly on the expert group, so I can't comment on how they're getting along. But, my understanding, from talking to Gavin, who's the spec lead, is that he really wants to see more of the reference implementation, more of these ideas implemented before the spec moves too much further.
So, currently, we're pushing ahead strongly on the reference implementation, and we're looking at having a beta of the current spec for the reference implementation, which will basically just implement all of the features that are currently specced out in the current version of the Early Draft Review 2, in the early autumn. So that would be a beta in the early autumn. And I think, once that's done, the second EDR, the second Early Draft Review, is fairly complete. So, hopefully there will be something coming out of the spec group, the official EDR 2, coming out fairly soon.
DZone: In addition to JBoss tooling, Pete, what other tools are currently on the market that support Seam development, and can you give us a sense of how they compare to one another?
Peter: Sure. I mean, the reason that we did JBoss Tools in the first place, or we've added Seam support to JBoss Tools, was obviously because there isn't an existing tooling support out there for Seam. So, when we are discussing the Seam support, I guess, it's quite useful to split what support different IDEs provide into various sort of sets.
So, first of all, obviously, there's support for some of the technologies we integrate, like JPA, JSF. And I think pretty much all the main IDEs - NetBeans, IDEA, and Eclipse - all have support for JPA and for JSF nowadays.
The next thing I think that we can consider is whether they've got Facelets support. So, have they got support for the Facelets view definition language, rather than for the JSP view definition language and JSF? Well, my understanding is, again, that all three of them - Eclipse, NetBeans, and IDEA - all have Facelets support. I mean, obviously, Eclipse has it provided through JBoss Tools here.
And then, I suppose you can talk about the Seam-specific support. So, does it have, for example, EL completion so that it knows about the Seam components and can offer them up for automatic completion of EL? Is there support for refactoring of EL, refactoring of Seam components, so when you change the name of a Seam component, it changes all the EL references to it? And that's really the Seam-specific support, and that's what JBoss Tools offers.
Now, I should say that JBoss Tools currently offers the EL auto-completion; it doesn't offer the refactoring. And that's coming up in an upcoming release. And finally, I understand that IDEA doesn't currently have any Seam-specific tooling, but in the next version, they are developing it.
DZone: Any final thoughts for our audience, Pete?
Peter: Sure. I guess, I would say that, if you haven't tried out Seam yet, you should definitely go out and give it a go. If you're an Eclipse user, then the best way to do this is to grab a copy of JBoss tools and a copy of Seam two and follow the chapter in the reference manual, which talks you through setting up a new project.
And for those users who are currently using Seam, I'd say come and get involved in our community. We have a very strong community at the forums, which are at seamframework.org. And we also have a lot of stellar receptions. We're very open to ideas and to code and to contributions from other people. So, just come along and get involved.
DZone: I want to thank you for your time today, Pete.
Peter: Great. Thank you very much.
Opinions expressed by DZone contributors are their own.