Understanding the future is critical for web developers. Decisions you make today need to be aware of what's coming if you're going to be successful on web. In this session, we'll examine ASP.NET AJAX and gain a deep understanding of how it can help us solve the problems of an ajaxified Internet. From a rich client-side library that changes the way you write JavaScript to easy integration with ASP.NET, understanding how to leverage the power of ASP.NET AJAX is key for future ASP.NET applications. We'll also examine the future of web browsers and seek to understand how they will affect the applications we build.

There is an emerging technology in the ASP.NET world that is going to radically change the way you think of ASP.NET development, and it's called ASP.NET MVC. In this session, we'll introduce ASP.NET MVC and explore this new way to think about web application development. We'll look at how you build a basic ASP.NET MVC application, how you can use UI "components" in an MVC world, and discuss the pros and cons of switching to MVC. Attend this session and you'll know everything you need know to get started with ASP.NET MVC- or know enough to decide to stay with Web Forms. The choice is yours.

Microsoft's next generation Windows presentation framework and the successor to WinForms, WPF, has been officially out for well over a year. So why is WPF adoption still very low? In this session we'll take a broad look at WPF- where it came from, how it works, why it's better than WinForms- to establish a clear picture of WPFs role in Windows application development. We'll then look at some of the reasons WPF adoption has been relatively slow and determine if those reasons should impact your decision to begin developing with WPF. Finally, we'll look in to the future and shed some light on the new tools and UI components that are going to make WPF development mainstream and paint a picture of what WPF development will look like in the next 6 to 12 months. If you're considering a WPF project, don't miss this session.

Partitioned tables and indexes help improve the scalability and manageability of very large SQL Server databases. In this session, we will take a look at the table and index partitioning capabilities in SQL Server 2005/2008. The discussion will outline the features and benefits of partitioning, explain how it works, and illustrate how to implement and set up this feature. We'll review scenarios for the sliding window, index/table maintanenence, when partitioning helps (and when it hurts), and discuss some potential myths that may exist, then touch on improvements and new enhancments in SQL Server 2008.

A key component to any distributed architecture built with SOA methodologies in mind is the database infrastructure. Service Oriented Database Architecture (SODA) is something that is now much easier to implement and much more robust with features present in Sql Server 2005 and the upcoming 2008 release. Technologies such as Service Broker, Native Web Services, Query Notifications, and the SQL CLR built-in to SQL Server today provide the ability to fully realize the SODA architecture. Service Broker is a new queuing and messaging technology available with Sql Server 2005 and further enhanced in SQL 2008. Service Broker can help database developers build secure, asynchronous, reliable, loosely-coupled, scalable applications without requiring complex and expensive add-on software or additional hardware. Native HTTP endpoints allow message-based communication based on SOAP and other protocols that takes advantage of the Windows Server 2003 HTTP kernel-mode driver. Query Notifications allow data-dependent caches to receive a notification that data requires refreshing because the underlying database has changed. The notification is generated based on the original query that was used to create and populate the cache.

Are solid state/flash drives the next big thing in the industry? Given the rise of Solid State and Flash based storage, what impact does this type of storage component have on SQL Server operations today? We'll dive into the differences you can expect for impact to things such as fragmentation, checkpoints, log writes, etc. vs. a variety of traditional drive systems (DAS, SAN, integrated). The session will cover some slides on solid state drive architecture vs. traditional systems, the pros/cons of SS systems, where SS systems provide benefit and where they don't, and some comparisons of statistics from a variety of tests. Additionally, we'll spend a significant amount of time demo-ing the impact live and side-by-side with traditional storage systems (assuming we can provide a VPN link through an internet connection) in a variety of configurations.

With more people using Continuous Integration there are more and more situations that people are trying to solve. This session will look at ways that you can use CCNet, nAnt and nAntContrib to solve problems like long running builds, assembly versioning, and automated deployment. We’ll also cover some best practices and tools when you’re using both of these products.

Developers in the .NET community are starting to pay more attention to fundamental OO skills in their day to day jobs. Two of the foundational principles for OO development are the Single Responsibility Principle and Separation of Concerns. This session will look at the idea behind each of the principles as well as how implementing each will change your code for better.

We regularly think of layers as physical separations that our code must adhere to when deploying. Layering of your application is more than creating assemblies that reside on different servers. In this session we will discuss the benefits of creating logical layers and seams in your code. We’ll touch on the impact that this has on code reusability and reversibility as well as other coding fundamentals such as Single Responsibility Principle and Separation of Concerns.

This session covers everything you need to know about deploying your development work in SharePoint via Features. This is a must attend session for every developer, for this is the basis you need for customizing SharePoint 2007 with Visual Studio 2008. We will examine a generic project structure for starting with a SharePoint feature – including the all important Feature and Elements XML files. We’ll look at FeatureReceiver code that will fire when installing/activating your feature in SharePoint. We’ll look at how to deploy and register DLLs, and the necessary modifications required to the web.config file. We will look at batch files and the STSADM utility for getting your feature over to the development server. We’ll also look at creating the WSP solution file for production deployment. Once you’ve mastered “The Feature” you will be ready for anything in SharePoint development!

In this session we will start with ASP.NET 2.0 Web Parts and discuss what is required to deploy these and make them operational in SharePoint 2007. We will then move on to creating a SharePoint web part that can host custom developed User Controls – including AJAX enabled web parts. We will look at the best practices for developing, deploying, and debugging the web part. This session is applicable if you are using Windows SharePoint Services 3.0 or SharePoint Portal Server 2007.

In this session we will introduce workflows in SharePoint 2007 by demonstrating the “out of the box” Approval workflow and then creating a custom workflow with SharePoint Designer 2007. We will then create a workflow from scratch using the SharePoint Sequential Workflow template in Visual Studio .NET 2008 and demonstrate key concepts such as working with task lists and history lists. This workflow will then be deployed to SharePoint 2007 and tested. We will discuss and demonstrate the different type of workflow forms available: Association, Instantiation, Modification, and Task Edit. This session is applicable if you are using Windows SharePoint Services 3.0 or SharePoint Portal Server 2007.

User Experience (also known as UX or UE) is a very hot topic these days in software, much more than it has been in the past. Many developers only have a general, cloudy idea of what it is, what it means, and fewer still know what's involved in it or how to do it.In this presentation, we introduce the key concepts, design principles, and competencies involved in UX. Once we establish what it is, we discuss why it is important and provide some guidelines for how much, based on kinds of applications, businesses should think about investing in UX.To provide a more concrete idea of how to do UX, we then look at User-Centered Design (UCD, a.k.a. human-centered design), how the various competencies in UX factor in, what kinds of deliverables they typically have, and show how it could be integrated into an agile process.Finally, we examine the various tools in .NET that make creating good UX easier such as Visual Studio, Expression, WPF, ASP.NET AJAX, and Silverlight. At the end, developers should have enough familiarity with UX, UCD, and .NET tools to have a great starting point to begin incorporating building good UX in their own projects.

NET Framework 3.5 has tons of language enhancements like extension methods, anonymous types, implicit types etc., and also the Language Integrated Query which helps working with Data much more flexible and also allows enhancements such as LINQ to SQL, LINQ to XML etc., that brings in a lot of productivity gains. This session would cover the language enhancements and LINQ features in .NET 3.5.

Internet Explorer 8 has a lot of promising tools for Ajax developers. It ships with developer tools out of the box to enhance the productivity of the web developers. Come learn about the new and updated tools in Internet Explorer 8 that help to build and debug HTML, CSS, and JavaScript as well as the new AJAX features that help enable powerful and dynamic Web applications. This session will show how to build rich, engaging web applications based on the latest tools & techniques available in Internet Explorer 8. You will also learn about the enhanced support for building dynamic AJAX applications.

Today 70% of projects are classified as failed projects – wonder why? Working in silo’s doesn’t help projects succeed. Learn how Visual Studio Team System 2008 helps break the walls across team members and build bridges to help team members collaborate effectively. In this session, you’ll be exposed to the features of Team System 2008 via demonstration and how it can help you and your team collaborate to deliver the best software possible while providing complete visibility into the software development lifecycle.

Want a peek into the crystal ball? In this session, you will learn the amazing new features of Visual Studio Team System Codenamed "Rosario", including new Test Case Management tools, architectural support for Service Oriented Applications (SOA) and Windows Communication Foundation (WCF), enhanced Work Item Tracking and project management support, build management using the Windows Workflow Foundation (WF), and much more. You will see many of the tools applied end-to-end on a multi-platform application.

Do you find it challenging to deliver software projects on time? Do you spend a lot of time fixing bugs and defects in your code? In this session, you will learn how to effectively assess the maturity of your software development process. You will also learn about Agile and Formal development methodologies and how processes are implemented in Team System. You will also get an overview of applied concepts such as risk mitigation, process improvement, quality gates and on target estimation.

Visual Studio Team System does a number of great things out of the box including version control, build management and work item tracking. But what if your environment isn't entirely .NET? What if you want to implement Agile practices such as Continuous Integration? Team System has a rich set of APIs to extend the tools and customize them to your needs. In this session, you will get an overview of the programming interface for Team Foundation Server and how you can extend it under different real world scenarios.

In this overview of what is new in IIS 7.0 we will discuss the features that make IIS 7.0 one of the strongest web platforms to build on today. We'll highlight the new features, opportunities for extensibility and how it affects your application. Whether you build ASP.NET, ASP, PHP, or other CGI-based applications this is one release you won’t want to miss!

When you are ready to migrate to IIS 7 there will be a number of choices to make and understand to allow your application to work. In addition there is new opportunity to enable new IIS 7 features and functionality that previously existed. In this session we will walk through the migration process and explore the choices and challenges ahead for your ASP.NET application migration.

Research has shown that if bug or defects are found late in the development cycle, the more expensive they are to fix and support. Yet, one of the biggest challenges in software development is consistently maintaining a high level of code quality. Visual Studio Team System provides a solid suite of testing tools to seamlessly integrate in your development and deployment processes. In this lab, you will learn about the different facilities available for software testers in Team System, and how to implement Test Case Management within Team System. We look at integrating scenarios and tests, show how to check for code completeness with code coverage tools. You will also get an overview of all the major test tools in Team System to help you more effectively debug your applications.IMPORTANT: Attendees are required to install the VSTS VPC (about 5.2 GB in size uncompressed):http://www.microsoft.com/downloads/, on their notebooks as a pre-requisite for this session.

One of the biggest challenges for Project Managers is gaining visibility to the status and issues of architects, developers, testers and builders. Team System provides a number of tools including Team Foundation Server, Work Item Tracking, Microsoft Excel and Microsoft Project to facilitate the integration of data across teams. In this lab, you will learn how to analyze your current process, set up a new process template, set up requirements and scheduling, and manage work using common project management tools. You will also find out how to use the reporting features of Team System to analyze trends and historical reports, in essence to figure out the health of your project.IMPORTANT: Attendees are required to install the VSTS VPC (about 5.2 GB in size uncompressed):http://www.microsoft.com/downloads/, on their notebooks as a pre-requisite for this session.

Have you ever felt like you were missing something that could make your life easier as a developer and as a power user? In an iterative development environment, developers are challenged with writing and maintaining large code base and quickly delivering features. Using Team System, you can use a combination of Agile methodologies, profiling and analysis to make your applications rock solid. In this lab, you will learn how to profile both ASP.NET and Windows applications, perform static analysis on both Managed and Unmanaged C++ Code, generating and running unit tests and knowing the effectiveness of your development tests using code coverage.IMPORTANT: Attendees are required to install the VSTS VPC (about 5.2 GB in size uncompressed):http://www.microsoft.com/downloads/, on their notebooks as a pre-requisite for this session.

In this session, Nakul will introduce SharePoint 2007 search by demonstrating the customizing and extending out of the box search UI. The approach presented in this session begins with the out of the box UI and drives to determine what the user needs and wants in their search experience. Nakul will discuss:* " Search Center design and configuration* " Search Results XSLT to improve results rendering* " Customizations to enhance the SharePoint search experience* " BDC Integration to search structure data

Now that your application is up and running with IIS 7 there is a lot of new opportunity waiting for you. In this session we will dig into the opportunities to embrace and extend IIS 7 through custom handlers, modules, configuration and administrative interfaces using managed code.

In the past production debugging meant writing a lot of tracing code and adding extra logging. With the advances in the latest release of Internet Information Services you can connect into a powerful set of debugging and tracing tools to diagnose complex real world scenarios. In this session we will take a look at the new diagnostics and debugging tools and how you would use them in your web application.

We'll take a tour through what is new and important for ASP.NET developers in the Visual Studio 2008. If you are building modern web applications you will want to hear about the improved design experience, new functionality for JavaScript and AJAX developers, and brand new ASP.NET controls. We’ll also touch on what is coming up in the forth coming Service Pack 1 and Out-of-Band releases for ASP.NET Developers.

We all have seen our share of bad code. We certainly have come across some good code as well.What are the characteristics of good code? How can we identify those? What practices can promote us to write and maintain more of those good quality code. This presentation will focus on this topic that has a major impact on our ability to be agile and succeed.* " Characteristics of quality code* " Metrics to measure quality* " Ways to identify and build quality

Modern development platforms provide annotations that can be added to various language elements. (We use the Java term annotation as we feel it describes the concept more precisely than the term attribute which is used on the .NET platform.) The developer community is still exploring the use of annotations but we can identify several distinct usage patterns. We have also learned some lessons and have principles that guide our use of annotations.This session explains different patterns of annotation usage. The key contribution of the session is a detailed discussion of a pattern that we have found during the development of an enterprise application and have used successfully since. We call this pattern Domain Annotations, and the idea is to enhance the domain model with domain specific annotations that can be used for a variety of purposes. This pattern has not played a major role in public debate yet but we have found that it is one of the most powerful usages of annotations.

Many traditional assumptions about software development have been challenged in recent years. Agile processes and service oriented architectures are two examples of this. An area that has seen little real scrutiny is developer productivity. Almost by convention, every new tool, framework or approach promises huge gains in productivity but a coherent view of all factors involved is usually missing. In this talk I examine several common myths about developer productivity and show that productivity improvements often require a trade-off with other desirable goals. I also discuss the relative impact of some tools and approaches.

The popularity of desktop applications have increased multi fold with the advent of Smart Client architectures. Smart clients work in online /offline modes, connecting to local network servers or Internet servers for synchronizing data, working with local storage and caching, etc. With WPF, this is taken a step further where occasionally-connected applications can also be visually richer and provide unique capabilities such as visual data binding, vector graphics, multimedia integration and much smaller footprint. Learn about these techniques and the technologies that enable you to develop these new breed of Rich Connected Applications.

This session will cover those TOP and exciting SQL Server 2008 T-SQL features such as new data types (i.e. date/time, filestream, large UDT, sparse columns), dependency management for database objects, procedure programming (i.e. table value parameter, table value constructor, delighters), data warehousing enhancements (i.e. MERGE DML statement, Grouping set, filtered indexing), supportability (i.e. DDL trigger), SQL/CLR, collation enhancement and etc. We will try to cover as many features as possible with-in the given timeframe.

Latest development tools and SDKs from Microsoft i.e. Visual Studio 2008, .NET Compact Framework 3.5 and Windows Mobile SDK 6.0, helps developers to write fully customized applications for Windows Mobile platform – very easily. In this session we’ll see the latest enhancements which are available in Visual Studio 2008 for Windows Mobile application development like Device Configuration Manager, Device Certificate Manager, Unit Testing for Windows Mobile, etc.

Ajax has proven a successful means to revamp the Web and facilitate the migration of many applications from “thick” clients to browser-based and zero-install clients. But several applications require real-time data to be effective (for example: financial market data visualization; online auctions; online gaming; messaging systems and social networks). The Comet paradigm, as an extension to the “traditional” Ajax techniques, allows any web page to receive real-time data pushed by a specialized server. This talk will introduce Comet from both a technical and historical perspectives. Several examples will be shown and a simple application, based on the Lightstreamer Comet framework, will be developed from scratch.

We are entering an era of Rich Internet Applications (RIA), and many enterprise development managers are facing the dilemma - which way to go - remain with tried and true Java or .NET or experiment with such newcomers as AJAX, Flex, Silverlight, or JavaFX. While the Internet brings a lot of noise where "it's cool" is the most popular definition, this presentation is an overview of what's out there on the enterprise RIA market. We'll talk about the pros and cons of using various techniques and technologies for the development of the front end for complex distributed systems.

Ajax becomes one of the leading technology to develop Rich Internet Applications. Its increasing popularity promoted by the wide range of toolkits or frameworks offers innumerable functionalities to add visual effects and dynamic behaviors to the expense of a poor or missing security. This session addresses critical elements related to security level that application architects and developers must consider when developing Ajax based applications that use sensitive data.

The Web is continuously democratizing how information is consumed. Today, personal Web use has led to a rapid increase in user sophistication which is naturally reaching the Enterprise. A new mode of information visualization known as a Mashup combined with the collaborative aspects of Web 2.0 is finding success where Composite Applications struggled: cost, speed of development and interactivity. By moving the integration point from the service layer to the presentation layer, driven by the user themselves and controlled by secured processes, Mashups are gaining an Enterprise facet promoting them to be the new generation of Composite Applications.

Creating and debugging Ajax based services does not require a rocket scientist. Good tools can enable everyone from new developers to the advanced developer to do what just a few years ago was impossible. This talk will discuss the Ajax support offered in Netbeans and show how it can enable you to create applications that use Ajax in just a few seconds.

jMaki provides a great way to express widgets from many different libraries and get them to communicate. GWT provides a great model for creating web applications using the Java programing language. This discussion will show how to marry the best attributes of jMaki with GWT extend the number of components available in GWT by including components from JavaScript libraries like Plotkit, Yahoo UI, Dojo, and many others. This discussion will continue with a discussion on how to integrate JavaScript libraries into the GWT environment and cover the costs and benefits of the approach.

The semantic web is a decade old vision promoted by web visionaries like Sir Tim Berners Li in which the web will become a set of semantically interconnected "databases" for programs to interact with, mash together and in general make sense of it all. As a bottom up technological adoption approach, it has failed miserably, and outside some research labs none of its icon technologies (e.g. RDF/OWL) have gained much traction. In fact, the web has continued to evolve as a messy technological babel tower.We will advocate a new, top-down approach that transforms the existing web into a semantic web, where every site becomes a semantically aware API, using a combination of structure analysis algorithms and user generated effort. We will showcase the Dapper service that allows the creation of semantic APIs from any site and will present the promise such approach holds for the advancement of fields such as semantic search. We will discuss some of the algorithmic challenges faced with when attempting to transform each and every web site into a nicely behaved programmatic lego block.

A major chunk of the software industry for long has been fueled by the technology needs of enterprises. This has always had direct impact on the tech community more specifically software developers. Every new wave has given rise to a new set of skills and at the same time obsoleted other tech skills. The days of ERP implementation and Y2K are good examples of such waves. Enterprise software unlike consumer software is valued more per license and this value is also transferred to the people with the right matching skills. This makes it necessary for the enterprise IT community to always be ready and prepared to meet the new wave of enterprise technology innovation.Though there have been continued changes in the enterprise IT world, there has also been a constant and stable pattern and that is the pattern of 'abstraction'. With every change the old layer of software have been slowly abstracted by new layers of software. This pattern of abstraction has continued till date and today the last layer of abstraction is the Business Process Management (BPM) and Composite Applications. This new technology has successfully abstracted the previous technology layer of ERP and has found wide adoption for the last three years and has gained maturity now.This new abstraction layer also brings with it new skill sets of model driven development, pushing the enterprise IT workforce more towards business than towards technology depth. This change has also been noted and voiced by industry analysts from Gartner and others. Lesser emphasis on coding/programming and more emphasis on understanding business logic is the key here. Going forward, developers would have to make a choice between enterprise IT and hard core software development in product companies which are focused on creating newer abstraction.

Widgets have proliferated widely on desktops. Users love these cool little applications that give them their own personalized displays of weather, traffic, or the latest sports score. In this session we'll introduce widgets that run on users' mobile phones, how they enhance user experience, and why as developers you should care about mobile widgets. Learn how mobile widgets overcome some of the typical challenges of cell phone users. See successful examples of mobile widgets, interesting widget use cases and pointers to start building your first widget. Learn how as a web developers with knowledge of standards such as XHTML/CSS/Javascript you can easily build interesting widgets to target mobile devices.

While there are a number of AJAX-based RIA frameworks available in the market, very few can scale when it comes to developing enterprise class business applications. The focus of most of the available frameworks is to make existing web sites more interactive. However, enterprise applications require presentation and manipulation of complex data structures, integration with business services, and desktop like functionality. In addition performance is also critical factor.In this Rich Web story, Udayan will walk you through an AJAX framework that was designed for building enterprise applications. The framework in this case study was used as an integral component in the development of a SOA-based insurance application that required a rich user interface. Key characteristics of this framework include:* (1) the ability to provide desktop like look and feel on the browser and* (2) act as a user interface for any SOA application.With a very low footprint, this framework utilizes client resources to a maximum, thereby ensuring optimal performance of the application even on a slow connection. As the story unfolds, you will also notice how client side caching effectively reduced the network traffic and server hit. In addition, limited offline working is also supported. Udayan will also demonstrate how this framework, albeit simple, is able to provide rich functionality and multiply developer productivity. Udayan's rich web story could well inspire you to build fully functional prototypes of application interfaces.

Movement has Meaning. And the web has validated that with the explosion of immersive experiences, thanks to RIAs! Pioneering this revolution is Adobe Flex and AIR, which redefine the way you interact with data -on the web, and the desktop. Marrying "richness" and "reach" in web and desktop applications is no longer a myth. With the new Adobe AIR runtime, desktop applications just got richer - so rich that they compare with the experience that were erstwhile available only on the web. What's more, the gap between developing desktop and web apps just shrunk - Write your apps in HTML, JavaScript, AJAX, Flash or Flex and publish them as AIR applications.In this session you get to explore the new and exciting features of Flex 3.0 framework and AIR 1.0 runtime and watch some spellbinding Flex / AIR showcase applications. We will also build a simple, yet immersive web application using Adobe Flex and then seamlessly take it to the desktop using Adobe AIR.

This session covers a wide-array of topics and a plethora of lessons we have learnt (some the hard way) over the last 9 years in building web apps that are used by millions of users serving billions of page views every month. Topics and Techniques include Vertical scaling vs Horizontal Scaling, Loose Coupling, Caching, Clustering, Db Partitioning, Tuning, Reverse Proxying and more.

This session will provide a technical overview of the Dapper platform and feed creation service as well as a detailed look at Dapper's new server-side mashup framework. The Dapper platform allows for the creation of XML feeds for any website without the need for programming. These feeds can then be used in any application, website, mashup, etc. via a RESTful interface. The first part of the session will address the technical implementation of the Dapper platform, as well as an inspection of difficulties encountered and the ways in which they were resolved. The second portion of the session will focus on Dapper's new mashup framework. A detailed examination of the framework will reveal various design patterns for building mashups.

Information Workers demand an easy-to-use, task-oriented, rich client user interface through which they can access information and enterprise applications, quickly execute transactions in context, perform analytics, share information and collaborate with others over a variety of channels. Their expectations within an organization are increasingly shaped by their experience on public web sites that offer highly participatory and personalized interfaces. This necessitates a unified environment, which is collaborative, multi-channel and task-oriented. This environment should ideally offer access to structured and unstructured content, business applications, enterprise search, and business intelligence coupled with communication and collaboration services. Taking an example of Oracle WebCenter Suite, Rajesh will show you how enterprises can use capabilities to embed and synchronize task-oriented and information-oriented Portlets and Web 2.0 services to create Rich composite applications or Enterprise Mashups.

While Web 2.0 technology and services have been common in the public sphere for a number of years, their uptake into the Enterprise has been relatively slow. Rich Internet Applications and Social Networks introduce new ways to allow users to interact with their applications, data and indeed, other users. They do however, bring with them significant opportunity to expose sensitive information.Whether breaches in security are due to unforeseen use of components of the application itself, or simply, by inappropriate information dissemination; through the use of Social Networking tools, Enterprise Web 2.0 introduces security trapdoors that should be addressed as part of the development Framework and application design.This session will look at the various points of exposure in building Web 2.0 based applications for the enterprise, and some of the ways that developers and administrators can secure their applications before data exposure becomes an issue.

The Web 2.0 generation of applications has brought a new user experience to Web-based applications. One possible implementation of Rich Internet Applications (RIA) is through Ajax, a technology cocktail that includes JavaScript, DHTML, CSS and the browser XMLHttpRequest object. To bring the Ajax development experience closer to Java EE developer, Oracle has developed a set of more than 100 Ajax enabled JavaServer Faces components. the ADF Faces Rich Client components. Truly, ADF Faces RC is Ajax for everyone and, in combination with the Oracle ADF data binding layer, provides developers with an unprecedented declarative development experience that makes RIA development productive. This session introduces Ajax application development with ADF Faces RC in JDeveloper 11 by example.

If you think of message bus as a server side component or that AJAX is the in thing, you ought to think again! Manas Ranade, a consultant with TIBCO software, will give you an in-depth technical view of a set of technologies and products that are taking Web 2.0 to a new high.

Designers speak UX, JPEG, Drawing board whereas developers speak C++, C#, Java. How do you connect their worlds? XAML and Microsoft Expression help designers built rich user experiences that can be leveraged by Developers in building rich interactive applications using WPF/Silverlight. Tune in to hear on how a rich design / dev collaboration is possible with Microsoft Expression, WPF, Silverlight and XAML.

The right tooling is essential part of any Java performance tuning effort. Tuning relies on accurate diagnoses of bottlenecks; tools allow problem areas to be identified quickly. In some cases tools will even suggest solutions. For example, IBM Monitoring and Diagnostic Tools - GC and Memory Visualizer may be used to determine whether garbage collection is the underlying cause of any performance issues, size the heap, detect memory leaks (even in native memory), and optimize garbage collection. If leaks or excessive memory usage are identified, the Memory Dump Diagnostic for Java (MDD4J) can find the objects which are monopolising the heap. The Lock Analyzer for Java can highlight poorly written concurrency. Intelligent dump triggering and JVM-provided method tracing can give deep insight into application logic flows. Used together these tools and technique are an effective and accessible strategy for performance tuning. Almost all of the tools discussed are new releases within the past year and incorporate significant new technology. Most of the tools are IBM tools specifically targeted for IBM JVMs. However, the principles are generally applicable.

Java performance advice is easy to find; sometimes good performance advice is harder to find! Java performance is a complex subject, and even a tuning tip which speeded things up in one context may actually slow things down in another context or a few years later. Being able to distinguish performance myths from performance facts is critical to avoid performance mistakes. The first Java performance myth, of course, is that Java is slow. In many cases Java outperforms "fast" languages like C. The second myth is that it is garbage collection which makes Java slow – in fact, garbage collection is one of the things which can help Java outperform other languages. Because it’s both a slow-down and a speed-up, optimising garbage collection can be counter-intuitive. For example, it is common to try and improve application responsiveness by tuning the garbage collector to shorten garbage collection pauses. However, short pauses alone do not guarantee good application response times. Similarly, many conventional code optimisations" defeat Java's dynamic compilers and actually worsen performance. This talk will explore popular performance myths and explain when they’re true and when they’re definitely not true.

The very first item on Agile Manifesto says we must prefer "Individuals and interactions over process and tools." If given a choice between better tools and better people, I would certainly prefer better people. However, there are a number of tools that can help your better developers focus and succeed on agile projects. These tools range from unit testing, mock objects, all the way to measuring the quality of your design. In this presentation you will learn about various tools that can help your agile project run smoothly. The key is not be episodic, but be continuous. These tools can help you constantly keep an eye on the health of your project. We won't simply go through a laundry list of tools in this presentation. We'll take the time to explore each one of them in detail, look at examples of how to use them, and what problems they can solve for you.

Java used to be a single language on multiple platforms. Not any more–when I extol "the power of Java" I mean the Java platform and not the language. You can use several different languages on the JVM, with different capabilities and strengths. In this presentation you'll be introduced to the why's and how's of using dynamic languages on the JVM. You'll see first hand how to integrate your Java code with code written in dynamic languages–how to invoke methods and functions, how to pass parameters and objects, and how to enjoy the idiomatic differences of these languages to program on the JVM.

You're most likely familiar with the Gang-of-four design patterns and how to implement them in Java. However, you wouldn't want to implement those patterns in a similar way in Groovy. Furthermore, there are a number of other useful patterns that you can apply in Java and Groovy. In this presentation we'll look at two things: How to use patterns in Groovy and beyond Gang-of-four patterns in Groovy and Java. This talk is structured to provide you an overview of patterns, show you how to implement common patterns in Groovy, take you beyond the Gang-of-four patterns in Java and Groovy, and hand-hold you with lots of examples.

Web Services is the most popular implementation technology choice for Service Oriented Architecture SOA). SOA is a widely used architectural style in enterprise application development. Reliability, security, performance, and fault-tolerance are some of the key non-functional requirements in enterprise application development. Typically these non-functional requirements should be served by the container or the application server infrastructure which host the services.The traditional approach taken by the JEE application servers is to have a wrapper around their existing infrastructure to support web services. Is this the right approach? Why can't we have services as primary citizens in our SOA design? Why can't we have a pure web services container and the relevant application server infrastructure?These questions and more will be answered in this presentation covering the development of Web services in Java without JEE.

This session will walk you through the architecture, code and the development environment of a real-life Java EE application using the very latest frameworks such as Wicket, Spring and Hibernate. The presenter will share his experiences developing a web-application that integrates these different frameworks. Open Source is not just about frameworks and zero-cost options for deploying your applications, but Java developers gaining the freedom to choose from a wide array of very effective development tools such as Ant, Maven 2 and of course IDE-s such as Eclipse or NetBeans.This session will cover how Open Source development tools can be used to arrive at a development environment that incorporates best practices such as Test Driven Development (TDD) and Continuous Integration. Code coverage tools and automated coding standards validation tools will be discussed. Using free and open source tools such as JMeter and the NetBeans profiler, watch how you can do load-testing and profiling to ensure that your web-application is free of performance bottlenecks and can scale to the levels you need. You even have options for writing functional test cases that will exercise the functionality of your application within a web-browser.

While SOA as principle is established throughout the industry these days, topics that are non technology related are still way out of sight. This session will introduce the organizational aspects around successful SOA implementations, from analyzing the maturity of an organization, towards establishing the strategy, and methodologies to arrive there safely. All small steps on the journey to BPM.

The Java Management Extensions (JMX) architecture provides interfaces for defining runtime monitoring, management and configuration support for Java applications. The JMX standard is part of both Java SE and Java EE specifications. This standard is suitable for adapting existing systems, implementing new solution for management, and monitoring and plugging into future applications.

The BPEL standard has emerged as the core standard for business process orchestration. IT organizations need a very reliable and highly available BPEL infrastructure if its business depends on composite applications using BPEL. In this session we will discuss how can administrators manage and monitor the complete BPEL infrastructure. It will discuss managing your BPEL Server and the dehydration store so that the business processes are available 24 x 7. We will provide best practices to simplify your deployment procedure and outline some methodology to implement proactive monitoring of partner links and dependent services before it is actually encountered by customers. The session will conclude with best practices for ensuring organizations to meet the service level agreement required by your customers.

In Java EE 5, the EJB 3 specification has gone through a transformation unlike any other. It has evolved from the previous EJB 2.1 incarnation that many considered an overly heavy and difficult component model into a powerful and flexible standard that is the buzz of the industry. Its ease of use and popular lightweight persistence model--Java Persistence API --are setting it up to be the standard of choice for server components and persistence applications. This session introduces and explains the EJB 3 Java Persistence API and presents examples of how to use these APIs effectively. It will introduce JPA Entities, Entity Manager API and Java Persistence Query Language.

Mashups or applications that seamlessly aggregate data from many sources have become a mainstay for the web applications and services we all use today. Mashups have now entered the Enterprise and as a result have created some challenges for developers such as security, service integration, and users interface design that need to be addressed. This discussion will discuss the costs and benefits of creating enterprise mashups with Java. In this session we will create many live examples of enterprise mashups.

jMaki is a framework that enables you to quickly add Ajax to your web applications. jMaki provides consistent models for describing data and the interactions between components and services as well as a proxy that enables you to consistent and safely incorporate data from external sources. This session will discuss the component parts of the jMaki framework including the tooling support in Netbeans and Eclipse. During this session we will build many Ajax applications and mashups live.

In this session, Subramanyan will talk about the Yahoo! User Interface (YUI) Library, a set of utilities and controls, written in JavaScript, for building richly interactive web applications using techniques such as DOM scripting, DHTML and AJAX.

In this session, Chintan will share Yahoo! perspectives on product and design outlook to Rich Web Innovations.

Software development is expensive, when business rules are hard-coded in your application's source code, changes and additions to those rules translate to wasted time and money. Good object-oriented, component-based approaches can alleviate the burden of keeping up with changes in the business world but they still require that expert knowledge of the changes be passed from the decision makers to the business analysts and finally to programmers that need to implement these changes. Business Rule Engines and Business Rule Languages are based on the basic premise of separation of concerns by empowering business domain experts to express the rules of business in a way that it is directly usable by applications.Drools is an open source pure-Java implementation of a forward chaining rules engine. Drools can be used in a J2SE or J2EE application and allows you to express rules programatically or by building domain specific rule languages. Learn how Business Rules with Drools can make your Java applications more flexible and robust.

This session explores some of the programming techniques that a powerful dynamic language enables, in particular meta-programming or the art of writing code that writes code. Meta-programming techniques are being used extensively in many successful frameworks based on dynamic languages such as Rails, Grails and countless others. Learn how you can use meta-programming in Groovy to improve and streamline your Java applications.

Learn how JRuby can bring simplicity to the complex and rich APIs available in the Java platform. In this session you'll learn how to use JRuby to tackle common tasks in Java SE and Java EE as well as how to abstract and simplify complex APIs. Learn the many different ways that you can architect your applications, including how to create powerful hybrid applications with Spring or EJB3 in the middle tier and JRuby on Rails in the front end, using JRuby for truly "skinny" controllers and more.

Learn how to build featured rich applications using the Eclipse Rich Client Platform. The Eclipse platform is an open tools platform, on top of this platform you can build your own applications (which do not need to be IDE like or IDE related). Yet you can enjoy the benefits of working with a mature and featured rich platform that can greatly reduce the amount of time required to create a professional-looking and robust Java UI application.In this session learn the foundations of building Eclipse RCP applications, including SWT and JFace and we will use the concepts learned to create a professional looking Java application that can rival any .Net application.

Being a good coder is not the same as being a good enterprise developer. In this session we'll talk about various aspects of your professional career covering the following topics: Does your resume work? How to pass the technical job interview with flying colors; Keeping your skills current; Employment in the USA: full time vs. consulting; Looking for another job and resigning; What's wrong with these offshore teams?; American corporate culture, and much more.

One new way to architect your applications is to build it in-the-cloud on an on-demand infrastructure. By keeping your components loosely coupled and independent to each other, your application can scale well.Combining the power of this basic infrastructure setup with open source distributed processing frameworks like Hadoop gives ordinary developers the power to do extraordinary things. Hadoop is a framework that allows computation of large datasets by splitting the dataset into manageable chunks, spreading it across a fleet of machines and managing the overall process by launching jobs, processing the job no matter where the data is physically located and, at the end, aggregating the job output into a final result.Amazon Web Services’ Alexa Web Search Service uses a similar architecture and Hadoop framework in production. Developers are now able to run a small regular expression over millions of documents crawled by Alexa and filter the search results, in a cost-effective manner and get back the results in minutes.In this talk, Seattle-based Jinesh Varia, Evangelist for Amazon Web Services, will talk about this new shift from client-server architectures to client-cloud architectures and share some of the architectural insights, business benefits and best practices of this self-scaling java-based architectures in-the-cloud.

We have seen applications that “talk” directly to other applications (via web services), we have seen applications that can asynchronously call the server and maintain its “rich and glamorous” look without requiring page-reloading (via AJAX).Imagine if your applications could “think” and could scale-out automatically with demand/load. Imagine if your application can “sniff” the load pattern and automatically decide and make an “educated guess” of how many more servers are needed and actually automatically spawn that many virtualised server instances, without any human intervention to address the increased demand.In this session, Seattle-based Jinesh Varia will demo and walk you through these new concepts and ideas that utilize Amazon ‘Infrastructure as a Service’. Jinesh will provide an overview and dive into Amazon Elastic Compute Cloud (Amazon EC2), Amazon Simple Storage Service (Amazon S3), Amazon Simple Queue Service (Amazon SQS) and the newly released Amazon SimpleDB.Jinesh will share some of the coolest applications that have been built using Amazon Web Services and will share stories that have changed the way we have done business in the past.

This talk will cover:

• Market sentiments for Java ME applications (MIDlets)
• What can I do with Jave ME?
• The genetic made up of Java ME
• How Java ME is supported on Nokia devices
• Starter’s kit
• Top tips for development
• Web Run Time on Nokia Platforms

JSF has matured a lot from its early days. Numerous plug-ins and extensions has given the back-end support that makes JSF the perfect choice for today's Enterprise applications. During this session, attendees will get a feel of what it is like building applications using JSF with its powerful UI Component Model with AJAX, in conjunction with different technologies like Seam and Facelets. This session will end with best practices on how to migrate Struts-based applications to JSF.

As more and more companies are starting to adopt SOA for their IT needs, a few patterns are emerging on their usage of SOA technologies like ESB, BPEL, Business Rules and BAM. This talk will use a set of real life customer use cases to take a look at the typical problems customers are trying to solve and discuss the various stages of SOA adoption in the real world. It will describe the technologies, processes, and best-practices available to help companies succeed in their SOA initiatives. The presentation will also cover the obvious and not so obvious SOA pitfalls that can be avoided with proper planning.

Troubleshooting production Java applications is a challenging task. Most of the monitoring and diagnostics tools are inadequate in a production environment because of one or more of the following reasons:* " Requires code changes due to byte code instrumentation or AOP techniques* " Requires server restarts due to application changes* " Very high overhead to get enough granularity required for triaging performance problems* " Unable to identify and resolve memory leak issues in a production environment* " Provide no visibility from Java EE containers through DatabaseIn this presentation, Neelima presents a new approach to diagnose production applications by peeking into memory structures of the Java Virtual Machine. She will showcase this new technique by demonstrating Oracle’s AD4J product and how it provides the ability to view the state and execution context of application in the JVM with little to no overhead. You will see that this approach does not need any complex configuration or application instrumentation. You will learn to use this methodology to diagnose problems in real time on a production environment, without requiring server restart or application rewrite.

JSF has seen increased momentum among enterprise Java developers ever since JSF made it into Java EE 5.0 and became the standard framework for Java-based Web development. While some are just now taking their first steps with JSF, early adaptors of JSF have already discovered both the upsides and downsides of this framework. And while some are just waiting for the next major JSF release to be completed, others have implemented many enhancements on top of JSF in commercial and open-source frameworks.This session explains areas in which JavaServer Faces needs to advance to meet the requirement of Rich Internet Application (RIA) development with Ajax. Live demos use the ADF Faces Rich Client component set that is built on top of the Apache MyFaces Trinidad project. ADF Faces Rich Client is a blueprint of what's missing in JSF: Strategies for reuse, declarative components, enhanced page templating and extended page flow concepts and scopes.

Version 5.0 is the latest standard in Java EE development with a lot of new technologies and features included. Certainly, the most prominent building blocks in this version of Java EE are EJB 3.0, JPA and JavaServer Faces. Developers are quickly adopting these technologies to build standard, compliant and portable web applications; with no strings attached.In addition, the latest changes to Web Services further open up the Java EE platform for SOA, another reason to have a closer look at Java EE 5.0. But no matter how excellent your Java EE development skills are, productivity is determined by the tools you use. And this is where Java EE enterprise developers usually hit a roadblock.Fortunately, the Oracle JDeveloper 11g development environment is perfect for Java EE developers and provides sophisticated support for EJB, JPA, Web Services and JavaServer Faces. Additionally, JDeveloper provides you with easy databinding and Ajax development functionality that takes little manual coding. Join this session to learn about Java EE 5.0 and how easy it can be to build state-of-the-art web applications with superb productivity.

As the amount of content continues to grow within organizations, challenges with its creation, management, and distribution continue to grow as well. Enterprise content management (ECM) provides organizations with a platform to house unstructured content and deliver it in the proper format to multiple enterprise applications. This presentation will address the challenges of managing content and the benefits of Enterprise Content Management.

There are several JSF Portlet Bridges. These implementations vary as to neither provide consistent interoperability with another nor across portlet containers. I.e. the same JSF artifact can run differently in different bridges and/or the same code can run differently in the same bridge on different portals.The purpose of JSR-301 is to standardize the behavior of these bridges implementations to ensure true interoperability for JSF artifacts. Primarily related to three areas:1. Coexistence: rules ensuring a bridge's implementation doesn't subvert concurrently executing non-portlet based code within the same web application, i.e. Servlet/Http. In addition, the specification defines rules ensuring a portlet bridge's implementation doesn't subvert JSF (controller) extensions.2. Correctness: there are differences between the Portlet and the JSF model. This specification will define correct transformations between them.3. Extensions: there are Portlet features with no corresponding JSF concepts. Even more for the next Java Portlet Specification (JSR-286). E.g., how do portlet events map to JSF lifecycles? This specification will define how these extensions behave in the JSF environment.

Both Spring and Web Beans intend to address similar issues of current Java EE standards. Both provide a web-tier presentation framework that provides, among other facilities, a component model for GUI components, a "managed bean" model for application logic, and an event-driven interaction model that binds the component models.JSF as such provides no access to transactional resources. The context model provided by the Servlet specification is insufficient for complex enterprise applications. The current component model is not consistent with Java EE registry (JNDI) or dependency injection. The goal of both frameworks is to enable “POJO” (EJB3) as managed beans, unifying the two component models and simplifying the programming model for web-based Java applications. The session will also highlight aspects such as Integration of JPA extended persistence contexts with the enhanced context model, Collaboration with JSF and other Common Annotations for Java, and best practices to ensure that components written to conform to this specification may be executed as Web Services.

This focused session will address Enterprise Single Sign-On, Identity Management and Enhanced scenarios for its usage in large scale Java Applications, based on SAML and other Security Standards and Frameworks. We look at providing interoperability between Open Source and Commercial Solutions, as well as between platforms like Java, Social Networking Portals or .NET. We also look at the principals of Identity Management for Java as well as more concrete ways of implementation. Based on Leading Industry strength technologies such as BEA WebLogic Portal, Acegi (Spring) Security Framework or OpenID. Beside technical challenges, end user aspects both positive and potential issues for data protection and privacy will also be highlighted.

This session demonstrates how to use Mylar and Maven within the Eclipse Environment to manage, organise, and control all relevant aspects of an (Agile) Project Lifecycle. Including Continuous Integration based on Apache Continuum or Cruise Control and how to use special Agile Tools like XPlanner. As well as alternatives such as Eclipse Jazz and how to integrate them with Mylar or a Maven-based Build System.

The applications on the web and within the enterprise are focusing user experience more than ever before thank to RIA technologies like Flex and AJAX. Adobe's Adobe(r) ColdFusion(r) solves the day-to-day challenges of Internet application development, allowing one to be extremely productive in the creation and deployment of engaging online applications. Livecycle Data Services, a part of the Adobe Livecycle Enteprise Suite is a Java framework that allows RIA developers to connect to Java based backend applications seamlessly.This session will focus on how one can rapidly develop Flex based Rich Internet Applications that talk to Cold Fusion and LCDS backends.

Functional Programming Languages (FPLs) have been around for a long time. A lot of features that we get excited about in dynamic languages are common place in FPLs. FPLs are gaining importance due to various changes in our industry. What's exciting is that you can use them on the JVM. In this presentation we will dig into the details of what makes FPLs so interesting and look at ways to use them on the JVM?in your Java projects.* " What's Functional Programming?* " Why is Functional Programming suddenly important?* " Features of Functional Programming* " Functional Programming Languages* " JVM and FPLs* " Examples of Functional Programming features* " Examples of mixing Java and FPLs

Turnaround is the time it takes for the changes in code to propagate to the running application. It includes build time, deploy time and initialization time. Recently some developments in the Java ecosystem and IDEs made it possible to develop software with zero turnaround. This talk is an overview of these developments, which include dynamic languages like Groovy, JavaScript and JRuby, framework support for reloading like Tapestry 5 and RIFE, module approach in OSGi and generic class reloading approaches like HotSwap, JavaRebel and FastSwap. With each approach we discuss benefits and limitations. We also review how to set up your build environment to get least possible turnaround whether you program legacy code or start from scratch.Familiarity with the Java development cycle is assumed. As an overview talk its goal is to show the possible options rather than discuss each of them in depth.

SaaS, Software as a Service, has been gathering momentum through 2007, fueled by off-the-web server-virtualization platforms such as Amazon's EC2. In SaaS, typically, a specific application or solution is offered in a hosted/managed model with the client just signing up for the solution and accessing it over the web- all operational aspects taken care by the SaaS provider. In 2007, some of the SaaS momentum shifted gears and extended their offerings to include more generic platforms as a service on the web, that allow "building" your own applications on such platforms. Ranging from SalesForce.com's Apex platform to the due-soon Titan from Microsoft. The former is a generic business process platform, while the latter is a platform to build CRM apps (will possibly include a basic CRM functionality shell which can be used to build your own CRM solution).More recently, SaaS extended the product model a bit further. By additionally taking care of even hosting and managing the operations. Software is now available as a service. Either completely hosted or parts of the functionality hosted (Software as a Service). The enterprise will just need to sign up and the solution is available- in a traditional utility model, ‘off the tap’. This lets the small enterprise focus on its core business and not have to deal with any aspect of the IT solution operations.As solution architects consider a services model for delivering their software to their clients, different set of challenges come into the solution design and architecture. Ranging from mult-tenancy considerations, to easy configurability, on-demand customization, leveraging platforms for SaaS and more. This session presents an overview of the SaaS model, benefits, approaches, architectures and technology options available.

The Eclipse Language Toolkit is a set of plugins extracted from the widely popular Java Development Toolkit (JDT), which focusses on language independent pieces for refactoring. Refactoring is the process of changing an application internally for better readability, best practises, maintenance but without changing its external behaviour. Refactoring toolsets provide an enormous benefit to developers because they directly impact how easily developers can introduce changes to the system. Simple tasks such as renaming files or moving files can introduce enormous change on to a system and a collection of tools based on reference searches, impact analysis, dependency graphs and refactoring utilities can make this process easier.In this session, Sachin shares his experiences in building refactoring for SOA Tools using the Eclipse LTK. He shows how re-factoring and the Eclipse LTK support can be extended by any Eclipse plug-in to provide the ability to manage changes to configurations and other meta-data.

This session is focused on integrating and interoperating between solutions developed on the Java 2 Enterprise Edition and the Microsoft .NET platform. We will discuss challenging real world scenarios and the approach to address them. This session compares and contrasts the technologies between J2EE and .NET. We then discuss interoperability strategies across the presentation tier, business tier and the data tier. It also provides a road map to the next generation interoperability techniques at various levels.