WinFX = .NET Framework 3.0, Henrik Westergaard Hansen, Microsoft A/SWith the upcoming version of .NET Framework 3.0 developers will be given tools and resources to build solutions for Windows never before seen. In this session, Johan will give recommendations and tips on how todays applications will coexist and integrate with the solutions we build tomorrow. A lot of code and demonstrations have been promised, as always when Johan enters the scene.
TDD - That's the way!, Jimmy Nilsson
TDD isn´t about testing...
...it´s about programming!
Writing simpler, clearer and more robust and more maintainable code!
AOP for .NET Developers, Mats Helander, Matssoft AB
Today, Aspect Oriented Programming is a real option for .NET developers who want to address crosscutting concerns of their applications in a structured way. With several open source .NET AOP frameworks to choose from, the time is right to take a look at how AOP can help you in your .NET application development. In this seminar we will discuss the main concepts in AOP and demonstrate examples of how AOP is put to practice in code. We also take a look at some of the innards of an AOP framework to get a good feel for how the "magic" is carried out.
Modifying .NET code reliably with test support, Markus Widerberg, Dotway
Almost all developers have heard something about TDD, Test Driven Development, and how great it is for developing software. But how do you create tests first if all you do is work on already existing code?
This session is about how to change existing code in a reliable and robust way, by making that code testable, and then writing the necessary tests. By increasing the testability of existing code, and adding tests, we get confident about changes and boost the codes´ capacity of change.
In practice, this means that we add to the life span of the code and may halt its depreciation. For instance, we can avoid high risk rewrites and move towards new technologies seamlessly.
You will gain insight into a reliable change process, and see practical solutions to common issues of retrofitting existing .NET code with tests. Armed with this knowledge, you may attempt those necessary changes that no one on the team dares to do, and avoid that painful rewrite that your colleagues often advocate.
If all you ever do is write new code from scratch, feel free to skip this talk entirely...
Dazzling Design-Time features in the .NET runtime, Henrik Strömberg & Richard Houltz, Beijer Electronics AB
One of the many great features of .NET is its rich design-time architecture that allows controls and components to be built and used inside Visual Studio.
We will demonstrate how this design-time experience can be enhanced and how these features also can be used in your deployed applications.
A lot of the features that many developers believe exists only inside Visual Studio can actually be used within your own applications. This includes Windows Forms designer, property editors, code-generation and compilers.
The .NET design-time framework is based on a simple Service Oriented Architecture. Using this lightweight service oriented approach has proved to be a good way to implement loosely coupled applications.
We will show you many of these features and elaborate on the benefits of mastering the design-time architecture.
Three Examples of Applied Patterns, Jimmy Nilsson, JNSK AB
When it comes to patterns and presentations, the common theme is to discuss long catalogs of patterns, from top till bottom. In this presentation we will pick three different problem areas and show how patterns can be used for dealing with those problems. The first area is validation and how the State pattern and the Specification pattern can be used. The second example is about factoring out the responsibility of persistence from the Domain Model and how the Repository pattern can help. Finally, the third example is concept-focused querying and again the Specification pattern will be used, but this time in a different way.
Type-safe, scalable, efficient scripting on .NET, Don Syme, Microsoft Research
Can we reconcile type safety with interactive scripting, performance with succinctness, functional programming with object-oriented? The aim of the F# project is to show this is possible. This talk will present the design of F#, a type-safe multi-paradigm language from Microsoft Research used in a range of areas including simulation and data-intensive analysis applications. With a core based on ML, F# combines the effectiveness of scriptable functional programming with the strengths of the .NET platform, and is remarkable among functional languages for the range of object-oriented and dynamic techniques it supports. We will demonstrate this by example, and conclude with a look at current developments in dynamic and static techniques and the ongoing challenges in combining the best of these worlds.
What makes LINQ tick?, Patrik Löwendahl, Cornerstone AB
C# and VB 3.0 comes with some extensive syntax enhancements to support Language Integrated Queries. But what are those syntax enhancements really and how do they work? In this talk, Patrik show you the functionality surrounding LINQ and present examples where to leverage them in other scenarios then the provided LINQ implementation from Microsoft.
Secure and authenticated .NET development in a distributed world, Magnus Mårtensson, Dotway AB
In the .NET framework 3.0 Microsoft introduces new and improved technologies to bring together, or mashup - the current popular term, services and information. Data parts, picked from a global field, remixed into new locally meaningful contexts - an endeavor named glocalization. How can we build secure programs when all our services are parts which only exist online at many different locations? This session will address what Windows CardSpace - WCS - will bring to the end users. It will also point at what needs to be done in order to publish services in a secure and authenticated manner using - WCF - Windows Communication Foundation. How do we as developers get started using the full power of the distributed world?
Generic framework development - a practical view, Henrik Lykke Nielsen, Captator A/S
The .NET platform is a large development platform comprising technologies, development tools, server products etc. From the point of view of a developer the .NET framework with its large class library is by far the most important part of the .NET platform. The class library contains for most part only basic technical functionality which does not directly address user and system functionality. It is an extensive starting point, but as a developer you quickly realize that when developing even quite standard applications there is still a lot of pretty generic functionality you must handle yourself.
If the goal is to create well structured applications you should place the generic functionality of your applications in separate, reusable components - preferably components developed as part of a coherent framework. Implementation of frameworks is driven partly by the wish to reuse functionality across applications, and partly by the wish to create clear architectural cuts between generic functionality and concrete application implementation.
This session deals with techniques and best practices for developing generic frameworks. The session will be illustrated by examples from Captator´s generic Eifos-framework.