Focused Sessions at GIDS 2012

Functional Programming has been around for a while, but it is gaining popularity, especially due to direct support in languages on the JVM and the CLR. Writing code in functional style is not about syntax. It is a paradigm shift. In this presentation, using examples from F# and C#, you will learn how to write code in functional style. We will start out discussing the elements of functional programming and then look at examples of some common operations and how you can implement those in functional style.

Object-oriented scripting languages, or agile dynamic languages, as some like to call these, are gaining the attention of programmers. Ruby has come to prominence due to it expressive power. The language is light and simple. The dynamic nature allows you to express some constructs that are generally harder in so called statically typed languages (C++, Java, C#) must easily in Ruby. In fact, Microsoft has actively brought some of the Ruby-like features into versions of C#. Learning Ruby is critical even if you don't intend to use it directly. We will take an example driven approach to look at interesting features and strengths of Ruby, and also discuss some of the weaknesses as well. Finally we will discuss how .NET programmers can leverage Ruby.

Unit testing is easy when your code has no dependencies. Sure a good design reduces dependency, however it is not practical to entirely remove dependencies. We mock out these dependencies often to carry out unit testing. Some dependencies tend to be more intricate than others. For example, static method and sealed methods often pose more challenges than other methods when it comes to mocking. In this presentation we will start with a general discussion about mocking and quickly dive into approaches we can take to deal with intricate dependencies.

C#, the prominent language on the CLR, started out as a marginally better language than its counterpart on the JVM. After a few years of simply mimicking Java, C# has taken a sharp turn for the better. It is one of the languages that has evolved quite significantly and has departed from its roots, in a nice way. In this presentation we will take a look at where this language started and how it has evolved over the years.

Access Control Service (ACS) is perhaps the most powerful but least understood aspect of Windows Azure. While developers / architects understand it’s value proposition they are often left confused with surrounding acronyms and buzzwords like Active / Passive federation, SWT, SAML, ADFS, WIF, WS-Trust, WS-Federation, OAuth, OAuth WRAP, etc. This session distills the facts along with the underlying business motivation helping you with your ‘AHA’ moment on ACS. Having built the initial base session advances to focus on typical usage patterns of Access Control Service within enterprises. These common recurring implementation themes would further simply the mapping of ACS to your LOB applications. Attend this session to walk out with real implementation knowledge on ACS.

Should I let you in? How do I know you are who you say you are? Identity in the cloud is an Authentication conversation that needs to happen, and the tools and services available today make it easy to implement. Access Control Services provides a great way to leverage existing identity pools for your application. In this session we dive into how it works and what you need to know to be able to implement it in your solutions. From creating and configuring the services to putting them to work in your application we will explore the tools, the code and the tips for making it work the way it was meant to.

Working with Data is core to what we do as developers. Relational databases have made it possible to build line of business applications that enable businesses to be successful in today’s fiercely competitive market by providing the information needed to make smart business decisions. Increasingly the need to access and work with this data has gone mobile and the challenge is how to connect these platforms. In this session we explore cloud storage options and how to create services that can be leveraged across devices and platforms.

The Windows Azure platform is an internet-scale cloud services platform hosted through Microsoft data centers. The platform includes the Windows Azure operating system and a set of rich developer services. Come to this eye opening session that will reveal some of the spanking new features in Windows Azure that we bet you did not know existed.

This end-to-end scenario talk demonstrates how Windows Azure enables and extends the reach of mobile applications with the example of the classic Rock-Paper-Scissors game played on the phone against a service hosted in the cloud. Starting from a blank slate this talk showcases the use of Access Control Services to use identity from Google, Yahoo and Live ID to authenticate the user, then implements a SQL Azure database to store game history. Finally it implements the game interface using Silverlight on Windows Phone 7.1 pulling information from a WCF Data Service that exposes an OData endpoint.

Windows Communication Foundation (WCF) is one of the leading technologies for building distributed applications.WCF 4 introduces many enhancements and new features such as simplified configuration, discovery, routing services, better integration with IIS, and improved support for building RESTful services. In this session we will examine these improvements of WCF 4 and how they affect the way we create and consume WCF services.

Windows Communication Foundation (WCF) is one of the leading technologies for building distributed applications. WCF 4.5 which ships with the new .NET 4.5 and Visual Studio 11 introduces many new features that both simplifies the way we create services and enables us improve the way our services work.

Since .NET 4 came out, we've seen many new technologies - new versions for ASP.NET MVC, improved jQuery plug-ins, and the new Razor view engine. In this session we'll learn how to incorporate all these technologies to build the new generation of ASP.NET web applications

Compute-intensive applications and Windows Azure go hand in hand with the cloud's ability to scale-on-demand. The Windows Azure HPC Scheduler is the next generation of Microsoft's high-performance computing technologies which enables you to develop parallelapplications and deploy them to the cloud. In this session we will see how to write various parallel applications using various programming models, such as MPI and WCF.

When it comes to Microsoft .NET-connected development, more and more frameworks are entering the market, both from Microsoft and from open source. Think of ASP.NET MVC, Castle, Windows Workflow Foundation (WF), Entity Framework, Unity, Linq2SQL, ADO.NET Data Services, Windows Communication Foundation (WCF), nHibernate, Spring.NET, CSLA, NUnit, Enterprise Library, MEF or ADF.

Once you apply one or more frameworks to a project, the trouble begins. What if you require features that aren’t implemented in the framework? What if you decide that another framework would have been better and want to switch halfway through your project? What if the author of your favorite open source framework suddenly stops developing? What if the framework contains bugs or omissions? And what if a new version of the framework is released that is implemented differently? These and many more everyday problems can bring your project a halt, or at least require serious refactoring.

During this highly interactive talk, Sander Hoogendoorn, chief architect of Capgemini’s agile Accelerated Delivery Platform and member of Microsoft’s Partner Advisory Council .NET, demonstrates pragmatic architectures and patterns that will help your projects avoid framework issues and to keep code independent of framework choices. Sander presents models of layered architectures, and looks at applying bridge patterns, managers-providers, dependency injection, descriptors and layer super-types, accompanied by lots of demos and (bad) code examples using blocks from Microsoft’s Enterprise Library, NHibernate, Log4Net, and the Entity Framework.

Join this interactive discussion to share your experience of improving the structure and quality of your software architecture and code, and to discuss how to avoid common pitfalls of applying frameworks to .NET software development.

Use cases have been around for many years describing the requirements of software development projects. From a developer’s point of view, use cases are often seen as too abstract and too complex to develop code from. Until now, that is.

During this interactive talk, speaker Sander Hoogendoorn will demonstrate how to model, generate (using model driven development) and build smart use cases. This great technique allows you to model use cases at a much more pragmatic, low-granular level, enabling to be implemented simply and directly into applications built in ASP.NET or Silverlight for example. Thus smart use cases fit well in your layered software architecture, implementing the task pattern and delivering great traceability between requirements, design, coding and testing.

Using many real-life code examples and demos, the speaker will introduce both the positive impact that smart use cases have on your layered software architecture, as well as the design patterns required to implement them. Furthermore, the speaker will demonstrate how smart use cases can be unit tested as well, thus achieving great code coverage and allow to do regression testing automatically.

JavaScript is one of those very powerful languages that is often misunderstood and underutilized. It is quite popular, yet there is so much more we can do with it. In this presentation we will deep dive into the capabilities and strengths of this prominent language of the web.

Programmers often complain that it is hard to automate unit and acceptance tests for JavaScript. Testability is a design issue and with some discipline and careful design we can realize good automated tests. In this presentation we will learn how to automate the testing of JavaScript using both TDD and BDD tools.

Saying JavaScript is powerful is an understatement. The problem is it is way too powerful and dangerously flexible. Programmers often have trouble reaping its benefits due to its uncontrolled flexibility and, to a certain extent, lack of structure. One approach is to learn to tame the beast, like the authors of complex JavaScript libraries have done. Fortunately there is an alternative. CoffeeScript is JavaScript created in a humane way. In this session we will learn how, using CoffeeScript, we can reap all the benefits of JavaScript, but without losing our sanity in the process.

Secure DHTML / Frontend is foundation of a secure web app. In this session we will demo attacks inflicted by using unsafe DHTML APIs and code (JavaScript, CSS, DOM, HTML4 & 5) and how a developer could avoid those leveraging safe and defensive coding techniques. This talk would also introduce new security features in HTML5 like Sandbox, PostMessage, new security features in EcmaScript 5, and new HTTP security headers.

Abstract Awaited

Abstract Awaited

Abstract Awaited

Use cases have been around for many years describing the requirements of software development projects. From a developer’s point of view, use cases are often seen as too abstract and too complex to develop code from. Until now, that is.

During this interactive talk, speaker Sander Hoogendoorn will demonstrate how to model, generate (using model driven development) and build smart use cases. This great technique allows you to model use cases at a much more pragmatic, low-granular level, enabling to be implemented simply and directly into applications built in ASP.NET or Silverlight for example. Thus smart use cases fit well in your layered software architecture, implementing the task pattern and delivering great traceability between requirements, design, coding and testing.

Using many real-life code examples and demos, the speaker will introduce both the positive impact that smart use cases have on your layered software architecture, as well as the design patterns required to implement them. Furthermore, the speaker will demonstrate how smart use cases can be unit tested as well, thus achieving great code coverage and allow to do regression testing automatically.

Java has come a long way, and yet there is so much that is happening in this space. In this presentation we will take a look at the exciting additions and changes in the most recent version of Java. We will look at performance improvement measures, new language features, dynamic invoke capability, and new APIs.

Programming concurrency has turned into a herculean task. I call the traditional approach as the synchronized and suffer model. Fortunately, there are other approaches to concurrency and you can reach out to those directly from your Java code. In this presentation we will discuss the actor based concurrency and also the software transaction memory. We will then develop examples using AKKA and compare the power of these approaches in contrast to the traditional approach.

Scala is a statically typed, fully OO, hybrid functional language that provides highly expressive syntax on the JVM. It is great for pattern matching, concurrency, and simply writing concise code for everyday tasks. If you are a Java programmer intrigued by this language and are interested in exploring further, this section is for you. We will go through a rapid overview of the language, look at its key strengths and capabilities, and see how you can use this language for your day-to-day programming. This session will be coding intensive, so be ready for some serious Scala syntax and idioms.

The features in Java have varied from release to release, with some releases having more language features and others tilting more on the platform and API improvements. Under the stewardship of Oracle, Java is poised for another release. In this presentation we'll discuss the features we can anticipate in it.

In this talk we will discuss how Java EE 7 will enable a new class of PaaS providers, and we’ll introduce the development, deployment and management models for standard Java cloud applications. We will delve into the PaaS capabilities being introduced in the next release of the platform, and explore the kinds of systems being targeted. After describing the multi-tenant resourcing configuration issues we’ll relate them to the resource sharing architectures that developers need to be aware of and point out the advantages and disadvantages of each. We will finish off with a summary of some of the other new features Java EE 7 will be offering developers

When Java SE 5 came out with support for generics and annotations it created a major stir in the development world, opening up new and improved ways of programming. Java SE 8 is the next big release of Java and will likely be similarly consequencial. We will discuss the primary features that are being proposed by Java SE 8 and how they will revolutionize the development process. We will focus on the coming Java Module System (currently called project Jigsaw) and present an overview of how it works and how it will shape the Java programs of tomorrow. Attendees will get a jump on learning the features of Java SE 8 and will be better prepared, having a mature grasp of the concepts before the big release hits them between the eyes.

The Kinect has delivered a low cost sensor aimed at games playing without a physical controller. From the beginning people have been hacking the Kinect and using it for all sorts of weird and wonderful applications. This session will look at how the Kinect sensor can be used from Java applications using an open source API. We’ll also look at how the Kinect can be combined with other sensors like accelerometers, bend sensors and a compass to create a truly immersive application. The session will include plenty of exciting demos using JavaFX and JMonkeyEngine to drive the user interface.

JavaFX 2.0 is a significant milestone in fulfilling the vision of Rich Internet Applications for the Java platform. Starting with this version, developers can create JavaFX applications completely in the Java programming language, using standard Java development tools. It also introduces several new features to the JavaFX platform: integration with Swing applications, hardware-accelerated graphics, the ability to embed Web content, stable media playback, and an improved UI controls library. With the help of code examples and demos, this session explores key new features and discusses use cases and benefits for Java developers of using JavaFX.

The Kinect has delivered a low cost sensor aimed at games playing without a physical controller. From the beginning people have been hacking the Kinect and using it for all sorts of weird and wonderful applications. This session will look at how the Kinect sensor can be used from Java applications using an open source API. We’ll also look at how the Kinect can be combined with other sensors like accelerometers, bend sensors and a compass to create a truly immersive application. The session will include plenty of exciting demos using JavaFX and JMonkeyEngine to drive the user interface.

Application developers face many challenges in order to go about managing complete application lifecycle. Importance of continuous development to deployment is ever increasing but is more complex in terms of operations and management and brings in more friction points. This presentation will introduce Cloud concepts and what does a PaaS means to developers. Then it will go over challenges of achieving continuous software development, deployment and management and what role PaaS plays in alleviating pain, reducing cost and increasing productivity. This presentation will also go over building a Java EE web profile application and then continously build, deploy and manage using CloudBees' PaaS.

One of the major themes of Java EE 7 and JPA 2.1 is multi-tenancy and EclipseLink, the JPA 2.1 reference implementation, has blazed the trail by shipping support for both multi-tenancy and tenant specific extensions in the Eclipse Indigo release. EclipseLink multi-tenancy enables the use of a single persistence unit by multiple tenants while keeping their data isolated and secure. But to provide a SaaS platform EclipseLink also provides tenant specific extensions so that each tenant can augment JPA entities with the additional data they need to capture and maintain.

In this session we will:

• Look at the challenges presented by multi-tenancy in Java EE and JPA
• Explore the EclipseLink JPA multi-tenancy and extensibility features
• Introduce the EclipseLink MOXy extensibility features that enable exposing multi-tenant and extended data over REST
• Explore a complete multi-tenant Java EE application that supports dynamic tenant provisioning and customization

This session will include live demos.

A PaaS offering typically facilitates application deployment without the cost and complexity of managing infrastructure, by providing all of the facilities required to build and deliver services.

Current Java EE deployment requires the deployer to provision the various dependent services of an application in that container. To support PaaS deployment scenarios, GlassFish is working to provide a simplified application provisioning and deployment interface to users, with the runtime handling the discovery of service dependencies, provisioning services, and associating service references with these services. Some of the metrics (such as CPU, memory, and response times) can be used to monitor system health. These metrics can then be used to determine if the cluster of virtual machines hosting the Java EE container needs to be dynamically expanded or shrunk to accommodate fluctuations in demand.

This session details how Java EE containers such as GlassFish can provide such service orchestration and elasticity capabilities. This session will take an existing Java EE 6 application and walk through the complete life cycle of taking this application from desktop to a PaaS environment. The session will explain the development, testing, and debugging of such an application in the PaaS envinronment.

JMS is a key part of Java EE, despite its not having been updated since 2002. There is therefore no shortage of ideas for updating it, which is why in 2011 the JMS community has come together in JSR 343 to define JMS 2.0. JMS 2.0 will define new facilities to support Java EE 7 and the needs of the cloud. It will also include features to improve ease of use, updates to clarify the relationship with other Java EE specifications, a mandatory API for integration with application servers, and many other changes that that have been proposed following nearly a decade of use. Come and hear what is in the early draft of JMS 2.0, and join the subsequent discussion.

JAX-RS 1.X has been a hugely successful Java API for RESTful services development and a lot of real-world experience has resulted in a number of new features being proposed. JSR 339 was created in early 2011 with the objective of exploring and scoping all these proposals. The purpose of this talk is to elaborate on all the new planned features. The most commonly requested feature for JAX-RS 2.0 is a client API. Client APIs can range from low-level, just above HttpURLConnection, to high-level, often including support for IoC and hyperlinking. Other features that will be covered in this presentation include: asynchronous processing, hypermedia, validation, interceptors, improved content negotiation, as well as better integration with other specifications such as JSR 330

NA

NA

The popularity of agile software development processes and methodologies is imminent and fast growing. Many organizations and projects turn towards agile to help solve the problems of traditional software development. Scrum, extreme programming, test driven development, and lean are no longer the new kids on the block. However, with the rising popularity of agile, mainly due to lack of experience, or management over-expecting results, the coming years many agile projects will fail miserably. Agile is not the silver bullet.

In his enthusiastic style speaker Sander Hoogendoorn, global agile thought leader at Capgemini and involved in agile projects since the mid-nineties, will demonstrate the differences in traditional and agile projects, and show why agile projects will fail – independent of the process used. Sander will elaborate on a series of agile anti-patterns that people will recognize immediately. Think of the Scrumdamentalist, Agile-In-Name-Only, the Pseudo-Iteration, Guesstimation, the Bob-the-Builder Syndrome, Parkinson’s Law, the Agile Project Manager, and Student Syndrome. Of course with many embarrassing examples and anecdotes from real-life projects.

Use cases have been around for many years describing the requirements of software development projects. From a developer’s point of view, use cases are often seen as too abstract and too complex to develop code from. Until now, that is.

During this interactive talk, speaker Sander Hoogendoorn will demonstrate how to model, generate (using model driven development) and build smart use cases. This great technique allows you to model use cases at a much more pragmatic, low-granular level, enabling to be implemented simply and directly into applications built in ASP.NET or Silverlight for example. Thus smart use cases fit well in your layered software architecture, implementing the task pattern and delivering great traceability between requirements, design, coding and testing.

Using many real-life code examples and demos, the speaker will introduce both the positive impact that smart use cases have on your layered software architecture, as well as the design patterns required to implement them. Furthermore, the speaker will demonstrate how smart use cases can be unit tested as well, thus achieving great code coverage and allow to do regression testing automatically.