We’re inviting all of the Java developers out there to an event organized by our sister site, TheServerSide.com, the Web’s largest enterprise Java community. As a member of Ajaxian, you save an extra $100 off the registration fee with the code AJAXIAN. (Register before January 16 to save a total of $400 and get a free book!)
TheServerSide Java Symposium explores current and emerging trends in enterprise Java and how they apply to your daily work. Choose from over 45 technical sessions on new technologies, best practices and practical tips from some of the brightest minds in the industry, including Rod Johnson, Neal Ford, Scott Davis and 35 Java experts.
The latest features of Spring, JSF, Wicket, Tapestry, Google Web Toolkit and more frameworks.
New Java language features, such as EJB 3.1, Glassfish and JavaFX
Popular open source tools, including Eclipse, Maven, Lucene, soapUI, HtmlUnit for testing SOA, Ajax and RIAs.
Expert recommendations on the use of Groovy, Scala and JRuby
Building and maintaining a large-scale SOA
How to create and consume RESTful Web Services.
How and when to use an ESB.
Best practices and tools for optimizing performance and scalability.
And much more!
View TheServerSide Java Symposium agenda to see all of the sessions being presented. Register now with the code AJAXIAN to save an extra $100 and to get a free book while supplies last.
I recently gave a State of the Open Web talk as part of the Google Developer Days overseas, in Italy, Russia, the Czech Republic, and Israel (I’m getting over a 10-hour jet lag right now - whew). The talk description:
“Come learn about the state of the Open Web, what it is, and why it is so important. In this presentation you will learn about the latest Open Web technologies, including the Canvas tag, Web Fonts, SVG, HTML 5, and see demos, code snippets, and the state of their implementations across browsers. Discover what you can use today (more than you’d expect!) and what remains to be done.”
[Disclosure: I work for Google on the Open Web Advocacy team]
We recently raffled off a free pass to The Ajax Experience on Ajaxian.com. Congratulations to Brandon Aaskov, our official raffle winner! If you’re planning on attending The Ajax Experience in Boston, September 29 - October 1, there’s still time to register.
The raffle drew over 500 entries from all over the world. Considering the worldwide appeal of The Ajax Experience, which major city would you like us to consider for 2009? We look forward to hearing from you!
Looking at standard development phases, as a background.
Lo-fi using stickies (post-it notes) to capture design features. Then lo-fi UI sketches. For some sites, this is where we would stop, no need to go any further because it’s obvious - can just go straight to detailed visual design.
Richard’s showing some detailed wireframes. These are actual web pages. ratemyarea.com - the final site ended up very different from the wireframe, but that’s fine. The wireframe contained all the basic content. Yes, CSS isn’t magic and they did have to re-code HTML and CSS, but still, can retain some things like usage of microformats.
Looking at sites like Kayak and Google Analytics with a ton of Ajaxy complexity. Can’t get a feel for this until you play around with it.
Patterns - design that can be reused: e.g. headers and footers.
Behaviours - e.g. progressive disclosure. e.g. including a lightbox in the wireframe because it’s trivial for us to put it in there (using a standard library, without bothering to customise it at this stage), and it is significant to the interaction, so we can see if it feels right. e.g. on e-commerce site, adding to basket updates the basket field - doing this in the wireframe lets us see if users notice the update.
Views - Exploring/experimenting with views of particular interest. e.g. how a significant table or list might be ordered.
Notes - Embedding design notes inside the page, using CSS to toggle them on and off. e.g. simulate login/logout by stylesheet toggle (not real login). (a specific css class for “logged in” or “logged out”). See polypage library.
That’s right, a free pass! We are raffling off one free pass to The Ajax Experience show in Boston, September 29 – October 1. That means that you can attend the $1495 event for free, courtesy of Ajaxian.com.
There’s no catch. We are giving away one free pass to The Ajax Experience. The free pass only includes entrance to the event, so if you don’t call Boston home, you still have to cover your own travel and hotel.
How to enter: Click here and enter your information in the form by Friday, September 5th. Please make sure to enter a working email address. Then we will pick one name out of a hat and one of you will receive a free pass.
We look forward to seeing you at The Ajax Experience next month!
The $100 early bird discount for The Ajax Experience expires today, August 22! Don’t wait! Register now to reserve your spot at the lowest price.
The Ajax Experience conference takes place September 29 – October 1 in Boston. Register today to save $100 with the early bird rate.
The Ajax Experience is the original and most in-depth rich internet application conference featuring over 40 sessions with top industry experts on such topics as cross-browser compatibility, choosing the right framework, best practices on balancing Web 2.0 features with speed, and many more. See our full conference agenda for what we’ve lined up for 2008.
The best part of The Ajax Experience is being able to hear what others are working on and get a feel for where the community is headed.
We look forward to seeing you in Boston next month!
The Ajax Experience conference takes place September 29 – October 1 in Boston. Register today to save $100 with the early bird rate.
On May 28-29 2008, we are having the largest Google event of the year: Google I/O.
Ben and I are talking in the Ajax and JavaScript track, which has other great Ajax content with speakers like Bruce Johnson and the GWT team, Mark Lucovsky and the AJAX APIs team, and Alex Russell of Dojo. There are also other tracks at the event covering APIs & Tools, Social, Maps & Geo, and Mobile.
I wanted to get the Ajaxian community involved, and then I saw some free invites on Mashable so I asked the I/O team if we could get some. They kindly obliged and we have 10 free passes!
To get one, please email or twitter with a reason why you should get a free ticket. The show is in San Francisco, so please make 100% sure that you can be there for those dates. Submissions can come in before midnight tonight, pacific time, and then selection will begin.
Yahoo’s Tom Coates today finally released FireEagle at ETech 2008. Seeing Tom in the office for quite a while getting everything ready makes me very happy to announce that it is out and invite you to come along and sign up for the beta to start testing and - even more importantly - developing applications for it. This is FireEagle:
Fire Eagle is an open location services platform offering web, mobile, and desktop developers a simple way to build new location-based applications while also ensuring that consumers have complete control over their data, including how, when and where their location is made available. Want to easily make your site responsive to a user’s location? Or, maybe you’ve found a way to capture someone’s location and you want to find cool apps to plug it into? By doing the heavy lifting and connecting you to a community of geo-developers, Fire Eagle makes it easier to build location-aware services.
Once you got in you’ll be able to download development kits in several languages including PHP, Python, Ruby and of course JavaScript. All the API calls are REST and the API authentication is handled via OAuth. The output format is either XML or JSON. The code is licensed with BSD and you can even contribute to the FireEagle source at a code repository.
The available API calls are:
user
Returns the location of a specific user in a location hierarchy format.
recent
Returns a list of users of the application who have updated their location within the given amount of time.
within
Takes a Place ID or a WoE ID and returns a list of users using your application who are within the bounding box of that location.
update
Sets a user’s current location using using a Place ID hash or a set of location parameters. If the user provides a location unconfirmed with lookup method then Fire Eagle makes a best guess as to the user’s location and updates.
lookup
Disambiguates potential values for update. Results from lookup can be passed to update to ensure that Fire Eagle will understand how to parse the location parameter.
The uses for a service like this are endless. From sensible search applications that show you places of interest nearby your current location up to real-life games of high-tech hide and seek everything is possible.
Mike and the Air team have announced that the Adobe Bus tour is moving to europe, just without the bus. Instead, they will be doing it like the europeans do, and jumping on the train. Far better for the environment :)
As you may have noticed, we have just updated the on AIR tour website, with new cities, dates and information for the European leg of the tour.
Each event is a free full day event where you can learn everything you need to know to start building applications for Adobe AIR using Flash, Flex, JavaScript and HTML.
I will be joining the other great speakers by showing them my home town in London, and also visiting Brussels and Dublin. If there are Ajaxians at those locations, I hope to see you out there!
Really, there were three highlights of the conference for me, two of them reminders, and one of them a surprise.
GWT is a compiler. Let me amplify: it is a compiler, not just a Java to JavaScript converter. It inlines methods, removes dead code, optimizes loops, all those things that a compiler can and should do. And if you play by the GWT rules, you will not leak memory. Want a faster, smaller app? Wait 3 months and recompile with the newest version. Eventually, the compiler will produce better, more efficient JavaScript than you can produce by hand.
The security concerns for GWT are the same as for all sophisticated Ajax applications: the more state and control logic you put in the client, the more you open yourself up to really nasty attacks. In a sense, the fact that GWT makes writing sophisticated client side code so easy and obscures which Java code is in the client and which in the server, it can increase the potential for making these mistakes.
The surprise? The conference was not attended by that many GWT newbies or web developers looking to bring their Struts apps into the Ajax light. A show of hands brought home the fact that the audience consisted of mostly folks with Swing/AWT/SWT experience (though they also worked with webapps).
This last item made this the most unusual conference I have attended. Usually, when a technology is barely a year old, you expect the first conference to consist of newbies listening to the vendor and a few select clients talk about the technology and their early adopter experiences. If any of the attendees have written apps of their own, they suffer from all of the "version 1 on a new technology" problems, i.e. in version one you don’t have your model quite right, your UI is a bit off and fighting with your model, and you’ve brought other, inappropriate platform idioms to the new technology. With version 2 you fix all of the version 1 problems and introduce a bunch of new ones. With version 3 your model is pretty good and in harmony with your UI and you’ve started to introduce some framework code that makes you more productive.
Well, the folks at the conference were already past version 3 on some pretty slick desktop apps, and the resulting ports to GWT had even the GWT team scratching their heads and saying "wow, I didn’t know you could do that with a browser."
All in all, a very promising start to a conference. If year 2 improves on year 1 and adds a few more tool vendors, as I expect it will, I will definitely attend.
Addison-Wesley and Prentice Hall are putting on a conference dedicated to GWT on December 3-6 in San Francisco.
Meet and learn from the folks, both Google engineers and community members, who have developed GWT. Speakers will share their experiences in building real-world applications with GWT. Speakers include many of the GWT team members, including Bruce Johnson and Joel Webber. They will be joined by Billy Hoffman, Jeet Kaul, Josh Bloch, David Geary, and other members of the GWT community.
Introductory Topics
Getting started with GWT
Solving traditional web usability problems with AJAX and GWT
Building user interfaces
Client/server communication, including RPC, JSON, and XML
Integration and interoperation with existing applications and libraries
Unit testing and benchmarking
Deploying GWT applications effectively
Advanced Topics
Advanced UI programming: Widgets, Panels, DOM, and JSNI
Using deferred binding for dependency injection and code generation
Designing for no-compromise usability, including tips for maximizing responsiveness, supporting history, and internationalizing well
Maximizing code reuse
Understanding compilation, the JavaScript Native Interface (JSNI), and optimizations
Security considerations for AJAX and GWT
Architecting big applications with GWT
Network with colleagues and GWT team members to discuss the underlying promise of GWT as well as its current challenges:
How can I integrate GWT into my existing application?
How have others added functionality to GWT?
How can one best take advantage of Java
design patterns in GWT?
For large projects, how can we handle multiple entry points?
What are the best practices for debugging
GWT applications?
Which IDEs work best with GWT?
How have others integrated Spring and Hibernate?
How can you contribute to the Google Web Toolkit project?
To whet your appetite they put together a couple of interviews with the founders of GWT that are worth a lesson:
Today is the official start of the Ajax Experience East, but we did something a bit different this time around. Some people asked us to level set a little, so we put out some tutorial sessions a day before.
Marc Grabanski was at the tutorial sessions and he wrote up a nice synopsis of the talks given by Ben Galbraith, John Resig, and David Verba.
Marc finishes up posting the sessions that he think will be going too:
We have kicked into gear on day one, and I am having a great time mingling with the community as usual!
Kevin Hoyt of Adobe gave us a personal tour of how you can take your web development skills to the desktop using the Adobe Integrated Runtime (AIR). The talk was designed for the Ajax developer, and special emphasis was given to the latest features in the AIR Beta to include:
File Pickers
Native Clipboard
Native Drag and Drop
Service Monitoring
Native Windows with Custom Chrome
Local Database
Kevin walks through these examples as he builds out sample AIR applications.
Time is flying by. This Friday (9/14) is the Early Bird deadline for The Ajax Experience East coast conference, taking place on October 24-26th in Boston.
There are a few changes taking place at this conference that I want to fill you in on:
Tutorials: We had people asking for a set of tutorials, so we created a day of them which are included with your conference fee. These are perfect for beginners, or those in need of a quick brush-up. These 90 minute sessions are offered pre-conference, to eliminate any concerns you might have about pre-requisites, and get you ready for the full 3 days of technical sessions where you can jump into more advanced content. You can see the list of tutorials which includes Ben and I getting you up to speed on Ajax, David Verba of Adaptive Path discussing the design challenges of Ajax applications, and John Resig giving a rich overview of JavaScript libraries.
There are a bunch of new speakers, including Paul Baukaus, Becky Gibson, Ted Husted, Carla Mott, Adam Peller, Stuart Halloway, Alex Russell, Chris Schalk, Tenni Theurer, David Verba.
There are some exciting new sessions, including The Future of JavaScript (John Resig), Accessibility & Internationalization w/ Dojo, Refactotum: JavaScript (Stuart Halloway), Ensuring a Quality Web Experience (Patrick Lightbody - no abstract yet), Ajax on Struts, Retrofitting Struts with Ajax Taglibs (both with Ted Husted), Advanced JSON (Kris Zyp).
We had our best panels every in San Francisco, so we hope that continues with an Ask The Experts, and Ajax Futures panel at this event. Got questions? Come along.
As always, the highlight of the show for me is getting you all together. In San Francisco we saw a crew discussing what became the end of browser possesion. The hallways are always buzzing, and I learn a lot about what the community is thinking, and where it is going.
Come join us again, and if you register by Sept 28th you will be eligible for an iPhone giveaway. Also, books and a few iPod Touch devices will also be featured giveaways for all attendees on-site.
Chris Wilson (Platform Architect of Internet Explorer) led off Day 2 of The Ajax Experience with his keynote: “Moving The Web Forward”. The talk centered on challenges faced by browser vendors and web developers to achieve more secure, stable, interoperable, and performant solutions. Here’s a bit of a summary…
Security and privacy are incredibly important to developers, browser vendors, and the average user. Ajax introduces some challenges in providing these protections due to code sharing, proxying, script inclusion, etc. It’s as important as ever to have a security model and spend some time “hacking yourself” to find loopholes.
Privacy is a growing concern for not only IT departments but governments. While cookies are perhaps the best known vulnerability (Chris recommends checking this out), many new “danger points” have been introduced by mashups and syndication. Having a privacy model and letting your users know just what you’re doing with their information is key.
Stability and interoperability are a tough pair. The volume of applications relying on non-standard implementations is staggering. Producing a strictly standards compliant version of IE is not an option as many users (and companies) would simply not be able to move to the new version. While many sites (attempt to) implement entirely standards compliant solutions already, many sites (even medium/large sites) do not. Often these violations are implemented without developers even realizing what’s happening. To maintain stability (and not “break the web”) interoperability is something that must be approached methodically (by way of things like “standards-comliant” mode).
Performance is another major concern voiced by users, unfortunately it’s hard to determine exactly what this means to them. Performance can be measured in a variety of different ways against a variety of implementations and approaches. While it’s always a goal to make the browser itself more efficient, many of the largest performance gains are via better designs and implementations of applications themselves.
Chris closed with what is pushing the web and what we can all do to move it forward right. To paraphrase Ben Galbraith (from last years TAE): “Caring about the quality of web UI” is what’s pushing us today. Enabling online social experiences, providing friendlier layouts, graphics, and imaging drives people to sites and gets them participating.
Making browsers (and other devices) interoperable is a huge step in improving what we can provide on the web. While vendors move towards that goal, it’s vital the developers be as careful as possible to implement standards based solutions, even in environments that facilitate non-standard solutions.
The QA:
Would IE be more secure if under a more permissive license? and will we ever see it?
Not really. It’s already frighteningly easy to get a copy of the windows source code (which includes IE). The challenge is making sure that lots of very smart people look at the code very closely for vulnerabilities. This is something the IE team has been quite proactive about, especially since 2002.
Chris doesn’t know of or anticipate any plans to change the license like this but won’t say never
Outlook 2007 doesn’t use the IE renderer and seems to be much less standards compliant, “Why did Microsoft do this to me?!?”
While Chris isn’t part of that team, he sees what they were trying to do: increase consistency between what is used for rendering received email and what is used for creating outgoing mail. He believes that team does realize that it’s a problem and will be working on it.
You had mentioned an issue of when developers don’t know they are relying on something that isn’t standard or writing something that isn’t standard. How can that be resolved or limited?
Workarounds are sometimes going to be necessary - Things need to work and you often can’t wait for the browser vendor to fix it. Developers need to (1) educate themselves on what is standard and what’s not and (2) document anything non-standard that they are doing or relying on to check back with when the next version is released.
Many problems are regarding the inclusion of frameworks included to get some widget or behavior. These frameworks may do something non-standardized under the covers that the developer is not aware of. To framework creators: Stay compliant wherever possible. Releasing a patched framework to accommodate new browser versions is good but there’s still trouble as people often won’t know to update (they’ve forgotten all about that).
What are your top 5 tips to making IE a good debugging env?
(Microsoft Download Center)
1. Install Visual Web Developer Express.
2-4. Get IE Debug Toolbar.
5. Keep updating the debug toolbar.
6. Get the full version of Expression Web Designer. (it’s pay-for so he’s making it #6).
oh, and #3. Fiddler
I’ve heard developing on Vista is broken.
It’s not broken, the challenge is IE runs in “protected mode” by default which sandboxes IE process to prevent others from connecting to it - and it from connecting to others. Disable protection mode and it will work.
Should i start with FF and then fix bugs with IE? What does Microsoft recommend?
Remember the tips before for debugging.
Reference the IE Developer Center for what the platform contains.
As for the general process: start with the standard and test with multiple browsers as you go. What you’re testing in any browser is that browser’s implementation of the standard - so, even if two browsers implement the same standard - you can run into trouble. By testing in several as you go, at least you know when you’re hitting incompatibilities.
What are the big things users are asking for?
Users don’t give very consistent answers to this question but research told us the important things for IE7 were tabs and printing. When starting IE7 they had no plans for enhanced printing but people were really mad about the right hand side being cutoff. They ended up getting a big win with their printing improvements.
Now (post IE7) people want performance but it’s hard to know what that really means to them. Normally the “feel” of browsing is pretty similar, to the normal user, when just casually browsing.
Another request is enabling customization and hiding portions of the UI that the “normal user” isn’t utilizing. Part of this task is to enable more customization while another large part is making existing customizability more friendly and accessible.
RailsConf is underway in Portland, Oregon, and day one (Friday) is in the bag. The keynote by DHH covered what to expect from Rails 2.0. Front and center was an emphasis on RESTful development, which should come as no surprise to anyone who has followed Rails lately. The big takeaway for ajax developers is that Rails will let you return javascript seamlessly for any request, right along side the same code you use for a standard HTTP requests, or XML requests, or whatever. This ultimately means more cohesive, cleaner code in your controllers, and that adding ajax is as easy as adding a format.js to serve XHR requests:
class PeopleController <ApplicationController
...
def create
@person = Person.create(...)
respond_to do |format|
format.html { redirect_to person_url(@person) }
format.xml { render :status => :created, :location => person_url(@person), ... }
format.js {
render :update do |js|
... # RJS code here to update the page with js with your created person
end
}
end
end
end
Rails 2.0 also has some great optimizations coming for HTTP performance. If you've ever looked at the size of prototype+scriptaculous (or dojo, or yui, or...), plus your own custom scripts, PLUS the overhead of the HTTP connections for each seperate javascript file, you know that page load time can get horrendous really quick. The upcoming version will allow easy batching of your js and css, and automatic gzipp'ing when in production, using the standard javascript/stylesheet include tags:
One other quick win Rails 2.0 will give you is multiple hosts for assets. Browsers will only have two concurrent connections open for any single host, but an easy way around that is to use multiple subdomains that resolve to the same domain. So if you set:
Your rails app will randomly choose static01, static02, etc...to get more parallel connections for static assets. This assumes you use the built in img, js, and css helpers, of course.
For more full coverage of the keynote in core-Rails areas, see Nick's notes.
The other ajax-centered session for the day was on full web stack testing with Selenium Remote Control, by Alex Chaffee and Brian Takita (PDF here). The ajax testing story is still a mixed bag, with a lot of different tools and approaches and not one clear best path. Selenium RC lets you test at the function level of your JS, all the way to a functional level of forms and events, all in the language your app is written in (hence the "remote control" part). For more details see the Selenium link above or the detailed pdf for all the code.
, Java
