ABOUT COMMUNITY DAY
By inviting internationally recognized speakers from the industry, the idea is to create a meeting place for the exchange of knowledge and experiences where new relevant topics are addressed.
The first time Edument organized Community Day was in 2010. During the years we have organized several occasions where we meet and talk about the latest in development and architecture. Between 2010 and 2015, the event grew continuously and had a total of more than 1000 participants.
PAST EVENTS
2015 - Game of Development
2013 - Become an expert at NoSQL
2012 - .NET Best Practices
2011 - Tackling Complexity in Software
​
2015
Game of Development
STOCKHOLM & HELSINGBORG
Listen to real developers, sharing the lessons and techniques they've learned against the constant struggle of ineffective development.
We all know them. The developers who seem to nearly always get stuff done, both quickly and to a high standard. The developers who seem to be able to debug just about anything. What's their secret? Is it just experience, or is there more to it than that? And how can effective developers help grow an effective team around them?
Join us for a day of talks about working effectively as a developer. A day with sessions from real developers, sharing the lessons they've learned and techniques they've honed over the years.
PROGRAM
Keynote: Agile Success
- The 8 Agile Maxims I Live By
​
Woody Zuill
Many organizations have adopted an Agile approach but have not seen the results they were hoping for. I keep handy a number of concepts that I have recognized over time to help me to have great success applying Agile thinking. I've condensed these into short, pithy statements I call my "Agile Maxims".
In this talk I share my Agile Maxims, and how I use them to help me make reasonable and responsible decisions quickly. My Agile Maxims are not meant to distract from, or replace The Agile Manifesto, but rather provide a boost to help me think in an Agile way, and more easily evaluate any action I am contemplating.
"Oh, Oops" - how we've misunderstood object orientation and lost the benefits
Jonathan Worthington
The term "Object Orientated Programming" was coined in 1967 by Alan Kay. Since then, he's noted how the choice of name has led to a numerous misunderstandings. "I'm sorry that I long ago coined the term 'objects' for this topic because it gets many people to focus on the lesser idea", he remarked. So what is the big idea? "The big idea is 'messaging'".
What we describe as a method call in many languages was originally known as a "message send". In some languages, it still is named this way - and it gives us a much better idea of how we should understand OO. Often, "what classes shall we have" and "what fields will they have" have been key questions when looking for an object oriented design. However, these questions make a poor starting point. In this session, we'll discover what happens if we start out with messages, focus on invariants (business rules), and allow these to guide us to the classes we need.
Err and err and err, but less and less and less
​
Carl Mäsak
We are our own worst enemies when we write code. Our brains are slow, forgetful, and keep distorting truths. Very unlike a computer. There's a term for what's going on here: cognitive biases. Our brains are full of them. Like mental parasites, they cloud our vision and guide our behaviors.
In this talk we look at such biases, and tie them back to the everyday developer activity. This goes for both individual development activities and being part of a team. We can't get rid of all biases, but knowing about them allows us to compensate for them and mitigate them.
Mob Programming, A Whole Team Approach
​
Woody Zuill
Mob Programming is a development approach where the whole team works on the same thing, at the same time, in the same space, and at the same computer. This is a Whole Team approach to doing all the work the team does - including coding, designing, testing, and working with the customer (partner, product owner, user, etc). This is an evolutionary step beyond Extreme Programming and Agile concepts such as pair programming, face-to-face communication, team alignment, collaboration, and the self-organizing team.
I'll share how we've been using this practice to super-charge our development efforts and deliver high value software for almost 4 years. We'll see what it looks like, the benefits, and how to do it yourself.
We did it our way - Pairing Shock and Awe in an Enterprise
​
Jonathan Worthington & Carl Mäsak
It was autumn 2014. Two of Edument's teachers/consultants, Carl and Jonathan, showed up at the client's place to begin one of their most challenging assignments yet. The requirements communicated up front had been vague - even though the procurement process had "waterfall" written all over it. And it quickly became apparent that getting to the bottom of what was needed would be hindered by a very real language barrier. They knew if they were going to deliver something useful, they needed to learn a lot - very quickly.
Dropped into a cube jungle, where developers sat quietly at their own computers doing stuff, they counter-culturally shared a computer between them, discussing things constantly and rapidly switching between the driver/navigator role. The first 2 days were spent gathering as much information and getting access to as much relevant code they'd need to interact with as possible. On day 3, they TDD-d their way to a small prototype of the thing they'd guessed might just be the interesting small problem hiding in the large one. On day 4, they presented it to the (somewhat surprised) team they were placed with - and listened to the responses.
Soon, patterns emerged. Feedback-seeking demos to the immediate team took place roughly every two days. Higher-level demonstrations of what was done to management took place every couple of weeks. Everything was paired over. The current driver focused on the immediate task at hand, while the navigator kept an eye on the architectural consequences
Better Unit Testing with Approval Tests
Woody Zuill
Whether you are a developer, tester or manager, you'll gain insight and actionable information on how to more effectively test both new and legacy code using the open source ApprovalTest library. Through both demos and explanation of theory, Woody will show you how using ApprovalTests can make testing many types of objects (from simple types to complex objects such as GUIs, arrays, database query results and more) more manageable. The library is available in many programming languages, including C#, Java, Ruby, PHP and more. Most demos will be presented in C#.
2013
Become an expert at NoSQL
STOCKHOLM
For many years, relational databases have been considered the only sensible way to organize data. But in recent years, architects and developers have begun to use more options: document databases, graph databases, event stores and much more.
Relational databases as such are not old-fashioned or bad in themselves, but it is simply the case that there are so many interesting problems that we can not hope to find a complete database solution that suits everyone.
Community Day presents a wide range of options and explains what they are and what problems they are best suited for.
PROGRAM
Keynote: Polyglot Data
​
Greg Young
NoSQL has been a big hit. Unfortunately most have associated it with either document dbs or kv stores. There are many other forms of "Polyglot Data". This talk will look at a few of them and also talk about better ways to utilize many with a focus on the right tool for the job.
Cypher vs. SQL
Jacob Hansson
Cypher is a graph query language used in Neo4j. Much like SQL, it's a declarative language used for querying databases. In this talk, we will compare and contrast the two. What does a join look like in Cypher? What about a left outer join? There are a lot of similarities between the two - Cypher is heavily influenced by SQL.
We'll talk about what these common concepts are, and of course, we'll talk about the differences, what Cypher gives you that SQL leaves you wanting. Come along and see how Neo4j and Cypher can make your daily grind much easier and more fun :)
Neo4j and Graph Databases -
from Zero to Hero
​
Jacob Hansson
One of the developers in the Neo4j.org graph database project, is briefly outlining the main characteristics of graph databases in the NOSQL and broader landscape of persistence solutions. Jacob will go through a number of not-so-niche use cases for graph databases and dive into a fast introduction to Neo4j and its query language cipher, with a number of examples on live data and contrast it to SQL.
Document Databases
​
Rob Ashton
Document databases are useful in a number of situations, and have been implemented in a number of different manners across the various platforms. The big three (CouchDB, MongoDB and RavenDB) may have widely different implementations but the core essence of what a document is doesn't change too much.
So what is a document? How do we model one? How will it relate to the code we write in our application and what are some considerations we'd want to make when working on a code-base that uses a document store? In this talk, Rob will mix a basic introduction to document stores with the real world experience gained over the past few years when using them himself.
Raven DB
​
Rob Ashton
Getting away from the abstract, this talk will be both an introduction to RavenDB and a walkthrough of constructing a model over the top of it, demonstrating real-world map/reduce and the usage of RavenDB in an application.
​
Also covered will be the various ways in which RavenDB can scale up with an application, and what to do when RavenDB isn't enough by itself
Event Sourcing for the Representation
Agility Win!
​
Carl Mäsak & Jonathan Worthington
Evolving requirements are a fact of our software development life. As needs change, often the ideal data structures to represent our domain change with them. So how do we persist in a way that will support domain evolution?
Many systems are state sourced. Each time a change happens, we update something in our data store. When we want to make a decision, we query the latest state. By contrast, event sourcing saves every change, capturing both the data involved in the change and the reason for it. With a full history to hand, we can build any representation we wish, whenever we wish, and evolve it as we need.
Of course, this flexibility is not without its implications and complications. In this joint session we will explore the opportunities and costs of event sourcing, and discuss some of our experiences with it.
Eventstore - the dragon that is eating its own tail
​
Carl Mäsak
There's no magic to storing events -- we could do it directly in a relational database if we wanted -- but there are some tricks a truly event-aware data store can do for us. Events are immutable; once you add them, you're not meant to remove or change them. And the basic read operation is "get the events after this point". By using these two facts, we can beat the performance of relational databases. And that's just the start of it. In this talk, Carl Mäsak will showcase Eventstore, a way to store and process events in a production setting.
2012
.NET Best Practices
For our 2012 .Net Best Practices event, we invited Andreas Öhlund of NServiceBus fame to speak. Other sessions, delivered by some of Edument's top teachers, focused on the latest ideas and technologies in the .Net world: C# 5's async and await, Web API and the trend towards functional style programming.
PROGRAM
How Functional Programming
Influences My C#
Jonathan Worthington
C# in 2012 is a multi-paradigm language. While its OO roots are still clear to see, many of the more recent additions to the language have been inspired by functional programming. But what is FP anyway?
Taken in its purest form, functional programming presents a wildly different approach to software development than many of us are used to.
While imperative programming sees us writing programs that perform a series of steps that mutate variables and objects along the way, FP defines programs through a function application and puts the focus firmly on immutable data structures.
In this talk, I'll start by taking a look at the C# language features that have been inspired by functional programming: lambda expressions and LINQ. However, that's only one part of the story; the influence of functional programming on my C# development goes deeper than just using certain language features. I'll discuss some of the ways this influence plays out in the code I write, and why you might want to do similar in your own development.
Death to the batch job
Andreas Öhlund
When most developers are tasked to implement time-bound business requrements the de facto solution is to create the dreaded batch job. While a batch job might solve the immediate problem, their brute force nature makes them resource intensive and forces us to run them at night when the system is under less load. But what if we run global operations that put constant load on our system? What if that window of time is too short to get all the work done?
When everything is getting more and more "real time" we need to run our jobs more often. But how often can we really run them given the load they put on our database?
Join Andreas for some real-time solutions to time-bound processes with the latest and greatest sagas from NServiceBus that will help you keep your events small and fit for the purpose thus mitigating the problems above.
Command-Query Responsibility Segregation (CQRS) explained
​
Andreas Öhlund
Command-Query Responsibility Segregation (CQRS) can help you come up with a more appropriate architecture for multi-user collaborative enterprise applications. We learn how to exploit factors like data staleness and volatility to create simpler and more scalable constructs. We will also see how CQRS is a key enabler for both Domain Driven Design and ultimately storing your business data using Event Sourcing.
Web API and REST
​
Eric Lavesson
The MVC4 RC has been released, and Web API is perhaps the most exciting addition. Web API brings us new ways to build web services, especially RESTful services. But what constitutes a RESTful service? The idea of REST has been around for some time, and writing services in this manner has been possible before Web API. So what functionality does the new ASP.NET Web API framework offer? And how does it compare to other web service frameworks on the .Net platform, such as WCF?
In this talk, I’ll look at what REST is and how to implement a simple service using ASP.NET Web API.
Reliable integrations with NServiceBus
​
Andreas Öhlund
In this talk, Andreas Öhlund will discuss how developers use NServiceBus in the core parts of their systems for the reliability it brings, but aren't aware that it can also help with integration as well. Further to this, Andreas will show how the saga capabilities in NServiceBus make integration code simpler, more robust, and testable.
Async Programming Awaits You
​
Jonathan Worthington
C# has come a long way since the first version arrived. Now version 5 of the language is around the corner, and its focus is on asynchronous programming.
Traditionally, asynchronous programming has been fiddly enough to keep many developers from doing it widely. At the same time, the need for it has quietly crept up on us. Users demand ever more responsive applications, calling out to web services has become the norm and the multi-core world is pushing us to do more work in parallel, which of course we have to manage and synchronize somehow.
Asynchronous programming is applicable to all of these scenarios. The new async and await keywords in C# 5 aim to make asynchronous programming much easier. Rather than having to break your program up into dozens of callbacks, you can continue to program in an imperative style and leave the compiler to do the hard work for you. What would once have been a major refactor can now be achieved with a few small additions and tweaks.In this example-focused talk, I'll take a bunch of synchronous code and turn it asynchronous, exploring the benefits of doing so.
Putting your events on a diet
​
Andreas Öhlund
A common problem when designing service oriented architectures is that events going across services tend to be very large in terms of properties they carry. This has the negative effect of making development tougher, testing harder and deployment a risky operation.
In this talk, NServiceBus and Enterprise Software Expert Andreas Öhlund will analyse the checkout process of an online retailer to identify some of the misconceptions that lead to fat events.
The Pain of Relational Dominance
​
Jonathan Worthington
We all know the drill. Design a database. Write code against it, maybe helped along by some ORM. As the system grows, add more tables to the database... And where does it lead us? All too often, to databases with hundreds of tables, monolithic applications, and all sorts of other pain.
It's not that relational databases are bad per se; they're just somewhat overused, and widely misused. In this talk, I'll pick apart the causes of some of the pain this can lead to. I'll discuss why using events can help to free us from this situation, and lead to some powerful unifications.
Along the way, I'll also show how the CQRS architectural pattern points the way to a migration strategy to something better.
2011
Tackling Complexity
in Software
This wide-ranging day of talks paired Mats Bryntse, a JavaScript developer working with ExtJS, with two of Edument's leading teachers.
Together, they explored a diverse range of topics, from the well known (ExtJS, Git and web security) to some less well known, but still important areas (aggregates,
Unicode, and lessons from compiler theory that everyday developers can learn from).
PROGRAM
Rich web applications with Ext JS
​
Mats Bryntse
Ext JS is a powerful platform for designing web applications that work across multiple browsers. The JavaScript library includes support for grids, trees, windows, and charts, but its greatest strength is the pure component model that makes it very easy to customize and extend existing classes and widgets. We will look at some pre-packaged Ext JS widgets, and also show how to write web applications and custom components.
Git for business development
Carl Mäsak and Jonathan Worthington
The Git version control system is becoming increasingly popular. Many open source projects have embraced it, and an increasing number of proprietary projects are also changing. Why this wave of interest? And does Git make the development process more complex, or less?
In this talk, two experienced Git users demonstrate how it works, and guide you through various development workflows that Git simplifies. From basic things like feature branches to more advanced distributed scenarios, such as moving versions of code from development, through testing and into production ... We show how to do it and explain why it makes it easier.
Git for business development
​
Carl Mäsak and Jonathan Worthington
The Git version control system is becoming increasingly popular. Many open source projects have embraced it, and an increasing number of proprietary projects are also changing. Why this wave of interest? And does Git make the development process more complex, or less?
In this talk, two experienced Git users demonstrate how it works, and guide you through various development workflows that Git simplifies. From basic things like feature branches to more advanced distributed scenarios, such as moving versions of code from development, through testing and into production ... We show how to do it and explain why it makes it easier.
Why test devices in JavaScript?
​
Mats Bryntse
JavaScript device testing is new to most of us, and web applications have always been difficult to test. At the same time, web applications are becoming more and more complex with all the new JS / MVC / Ajax libraries appearing all the time. Fortunately, there are now popular tools that can help. We will talk about how to device test your applications. How can we test pure JS? What about testing bits of DOM, and how do you avoid having to run the tests manually in your browser?
Text and strings. Not so easy after all
​
Jonathan Worthington
Code points! Grapheme! Surrogate couple! Combining characters! Forms of normalization! And here it was thought that strings were a simple data structure.
It turns out that representing all the world's languages ​​digitally is difficult. Therefore, the Unicode standard is packed with complexity. In this lecture, we will take a look at why this is a difficult problem, and unravel how Unicode works. We will discuss the difference between characters and codings and how to keep track of everything. You will learn a number of things that you always wanted to know about text - and probably one or two things that you did not want to know as well.
A compiler hacker wanders into the corporate world
​
Carl Mäsak
Oh no! Someone has hand-rolled an expression evaluator built entirely of hack solutions! And someone else has built a markup parser of a hundred regular expressions. Where are the headache tablets?
​
One might think that the techniques behind compilers have nothing to do with the daily development of business software, but the two fields have more in common than one might think. As the saying goes, "those who do not understand compilers are doomed to reinvent them ... in a worse way". Add a real power tool to your toolbox: compiler pattern. With it, you can capture incorrect data before it becomes a problem in production, and you can save code from yesterday's unfortunate design decision. With compiler pattern you are boss over your code base, not the other way around.
Aggregat
​
Jonathan Worthington
You've done everything right, followed object-oriented principles ... but your project still takes on complexity like a sinking ship, and problems with scaling pile up. What to do?
We introduce aggregates. They are larger than objects, and they establish a new boundary within which everything is consistent. Learn how to take advantage of aggregates, why transactions are not the answer to everything, and how a little duplication can sometimes be helpful.
Web security: ways to mess it up
​
Jonathan Worthington
From classics like SQL injection and XSS, to Web 2.0 compliant incompletely secured Ajax, as well as the slightly more subtle CSRF; there is definitely more than one way to mess it up. In this lecture, we will address a number of them, and go through how to protect yourself.
2011
Software Architecture
For this event, we went all out to bring together some great speakers and talks. Jimmy Nilsson discussed Domain Driven Design, sharing his practical experiences of applying it. API expert Andreas Krohn talked about the importance of APIs and presented a range of best practices.
Meanwhile, Edument's Carl Mäsak introduced CQRS and Event Sourcing, while Jonathan Worthington put on his linguistic hat and looked at the role of language in software development, as well as delivering an entertaining, yet challenging session about common failings in software architecture.
PROGRAM
The Role of Language in Software Development
​
Jonathan Worthington
Our use of language is part of what makes us human. To know a language is to be part of the culture that speaks it, and it's through language that knowledge is passed down from generation to generation. For many, language is a source of fascination.
While the role of mathematics and engineering is often discussed in the realm of software development, the role of language has been given less attention. In this talk, we'll see what happens if start to take language seriously. From domain analysis to API design, from multi-paradigm development to security, we'll discover some new ways of looking at familiar things, which will help us to design and develop better solutions, and provide a better framework for understanding some of the challenges we face as architects and developers. Föreläsning på engelska
Introduction to DDD
​
Jimmy Nilsson
In this presentation, we will compare a database-driven way of developing software with a more DDD-inspired way. Along the way, we will touch on various DDD concepts: the basic building blocks, the common language and strategic design. We will also focus on the question "why?" by discussing the motivation behind these concepts.
The end of CRUD?
​
Carl Mäsak
As an industry, we have invested heavily in frameworks and architectures that are built around only four verbs: "Create", "Read", "Update" and "Delete" (CRUD). With this mindset in the spinal cord, we often end up in paths where we substantiate verbs crosswise, throw away information about the purpose of operations, and build user interfaces around a certain storage model instead of around the information the user cares about.
CQRS - "Command / Query Responsibility Segregation" - is an architecture that challenges us to think differently. Instead of starting from the "editing" of a number of entities, we are encouraged to think in terms of semantic operations. Instead of CRUD-based user interfaces, we are encouraged to build task-based UIs. Instead of expecting data to be sent into a system in the same way as the user wants it presented, and at the same time trying to scale OLTP for a large number of read operations, we make sure to completely differentiate between the read and write architectures.
The result is systems that work better for users, are easier to scale and provide higher returns.
DDD in practice
​
Jimmy Nilsson
If you have decided to get started with DDD, this presentation will take you in the right direction. We will explore a sample project and take a closer look at different aspects: the process, the architecture, the code, the automated tests and persistence.
Why APIs are important
​
Andreas Krohn
APIs are a great way to communicate data. With APIs, it is easy to build systems that are loosely connected, both internally and externally, and to let others be innovative on one's platform. Companies like Salesforce, Twitter, Facebook and Netflix build much of their business and success on APIs, and it's becoming increasingly clear what the competitive advantage is of having a popular API. In this lecture, we will go through why APIs are important from a technological as well as a business point of view.
Ways to fail it at architecture
​
Jonathan Worthington
Heaps of code that's sufficiently hard to test that nobody really knows how. Error handling designs that seem optimized for letting problems go unnoticed. Logic in Data Transfer Objects. Tens of thousands of lines of generated data access code that doesn't know what a join is. So many different frameworks in a single application that new developers take months to get up to speed. And that's just the start of it...
In this talk, we look through a range of architectural problems spotted in real world applications, try to get to the heart of what's really wrong, and consider how to avoid falling into the same traps. Föreläsning på engelska
Introduction to Event Sourcing
​
Carl Mäsak
The concept of "events" has become increasingly popular in IT, and it's not surprising. They disconnect the part of a system that knows something has happened, from the parts that want to react to the event. This creates a natural model for building user interfaces, but has also found a large number of other applications.
​
We usually think of events as something with a short lifespan. The user clicks a button, an event is created, handlers are triggered ... and that's all. In this lecture, we start from what happens if you stop considering events as volatile, and instead see them as our primary data source. Instead of registering a new Order by creating a new row in a database table, we store an OrderPlacedEvent. Instead of registering that a hotel room has been canceled by deleting a row in a database table, we store a RoomCancelledEvent.
This approach - known as Event Sourcing - is receiving increasing attention, not least because it makes previously quite challenging scenarios trivial. Of course, there are trade-offs involved, and a number of new issues - such as "how should I be able to ask questions at all?" - which we will also address during the lecture.
API Best Practices
​
Andreas Krohn
Building a successful API means building a stable, secure, and easy-to-use solution, and providing developers with the tools they need to get the job done. It is important to follow the ever-renewing de facto standards and to avoid reinventing the wheel. REST, OAuth and JSON are some of the key technologies, but more important than any specific technology is to build a solution that invites developers to use one's API. Because if no one even uses the API, why build it at all? The focus of this lecture is on building open APIs, but the same tips can also be applied to internal APIs.
2010
Community Connection -
.NET Best Practices
MALMÖ
This event brought together a wide range of .NET experts to talk about the topics they knew best. With a focus on good quality code, maintainability and testing, the day was packed full of inspiration and good ideas.
PROGRAM
Tools to improve code quality
​
Dag König
At Microsoft Research, there are several teams working with tools to improve the code quality of the code we write. In this presentation we will go through some of them: Code Contracts, Pex and Moles.
Writing maintainable code
​
Hadi Hariri
We spend more time reading and understanding code than we do writing it. As such, it is very important to create applications that are easily readable. They not only provide us with a better understanding of the software, but also allow for creating extensible applications. In this session we'll cover a series of concepts that are required to create sustainable code and do away with anti-patterns that cause issues in the short and long term.
Writing maintainable code
​
Hadi Hariri
We spend more time reading and understanding code than we do writing it. As such, it is very important to create applications that are easily readable. They not only provide us with a better understanding of the software, but also allow for creating extensible applications. In this session we'll cover a series of concepts that are required to create sustainable code and do away with anti-patterns that cause issues in the short and long term.
BDD: Adding value to the business
​
Hadi Hariri
BDD is hot! It's the next best thing. You need to learn it! Actually, who cares? If you want to come to a talk that explains an acronym and points you to some tools, then this is the wrong session for you.
BDD isn't new; in fact, once you understand the concept behind it, you're realize that it's just common sense. If you want to see how to improve the software you write, eliminate the misunderstandings you and your team have with the business analysts, and ultimately add value to the customer, then come along. As a bonus, you might even get to see a couple of frameworks that help you accomplish things. But more importantly, you'll understand how communication is key.
Putting BDD to practice
​
Hadi Hariri
In this session we will put to use some of the concepts we say earlier regarding Behavior Driven Development and drive out a Web Application using MSpec. From user requirements, driving down to internal components, we will use a combination of testing frameworks, mocks and good design principles to drive out specifications and implement functional, working software.
Pimp Your Process: Working towards Continuous Integration
​
Jonathan Worthington
Developing any large and complex piece of software isn't just about individuals writing great code. It's also about creating an environment where members of a team can get quick feedback on their changes, and stay aware of development work going on around them. It's about quality control being an on-going process rather than a waterfall step towards the end of the project. It's about releases and deployments being smooth and effortless rather than panicked all-night hacking sessions.In this talk, we'll draw on a range of experiences - good and bad - from projects we've been involved in, both closed and open source. We'll discuss and demo the tools that have helped streamline the development process and the techniques we've seen used successfully, as well as warn of some of the pit-falls. Along the way, we'll lay down a roadmap of the things you need to get in place - each of them bringing their own benefits - in order to deploy and get a return on investment from continuous integration.
Unit testing with dynamic mocks
​
Mark Seemann
A good unit test follows the Arrange Act Assert (AAA) pattern. In the Assert phase, we verify that the outcome of the test was as expected. There's basically two different ways we can do that: State-based Verification and Interaction-based Verification - that latter is also known as mocking. In this talk we will look at the concept of manual and dynamic mocks using Moq for examples. We will also discuss the different types of available mocking libraries, and their relationship to application design.
Things that all .NET developers should know about SQL Server
​
Peter Larsson
There are new things in SQL Server 2005 and later that make life easier as a developer. Windows functions, MERGE and filtered indexes are some of these.
Better XML handling and compression are some others.
Dependency Injection patterns and
anti-patterns
​
Mark Seeman
Dependency Injection (DI) is a set of easily understood patterns and principles. However, despite its simplicity, it's one of the most misunderstood concepts of object-oriented design. In this talk we will explore DI patterns and anti-patterns through simple code examples in C#. Level: basic/intermediate
Getting wrapped up with Aspect Oriented Programming
​
Jonathan Worthington
While C# doesn't directly support Aspect Oriented Programming, with a little dose of PostSharp magic you can start taking advantage of it today. I'll start off with a short discussion of the ideas behind Aspect Oriented Programming and how it fits in with other paradigms. Then I'll jump straight into some practical use cases for AOP, and explore how it can reduce boilerplate and thus improve maintainability and developer productivity. I'll finish up with a summary of the pros and cons of the paradigm and putting AOP into action today.
2010
Community Connection -SQL & .NET
Informator, Pass Scania and Edument hosted a complimentary day of SQL and .NET. Exploring topics from execution plans to business intelligence, the day also featured talks on some of the most common mistakes that are made with SQL Server and how to choose from the huge number of ways to do data access on the .NET platform.
PROGRAM
Most common mistakes that developers make in SQL Server
​
Peter Larsson (MVP)
What are the common mistakes developers make in SQL Server in the beginning? Why can not so fast anymore? The questions are many and there are fortunately few simple answer! We will go through the most common mistakes and how to fix problems to get better performance and more reliable results.
Overview
Calculations on indexed columns
Time and date calculations
Incorrect data types
Executable (Row-by-agonizing-Row)
.NET Data Access: Too many ways to do it?
​
Jonathan Worthington
Today's .Net developers have more choice than ever when it comes to data access. To simply select some data from a database, one could use the SqlConnection, SqlCommand and SqlDataReader objects (with an SQL query or through a stored procedure), Linq, Enity Framework (POCO or not) - and that's before we even consider non-Microsoft offerings, such as NHibernate, or the possibility of generating data access layers from templates and database schemas.
No one of these approaches is right for every application; indeed, applications may legitimately make use of more than one approach. In this talk we'll look through the strengths and pitfalls of a range of the options, their performance both in terms of development time and execution time, and see what tasks they lend themselves to.
SQL CLR
​
Matt Whitfield (MVP), Atlantis Interactive
CLR Integration Within SQL Server Allows developers and administrators alike to harness the power of the. NET Framework from Directly Within Their databases. This seminar will cover the basics of Implementing all types of CLR objects, claen types, aggregates, procedures, triggers and functions, as well as showing some examples of how the CLR objects havebeen put to good use. SQL CLR Overview
* Overview of the CLR in SQL Server
* Explore all types of CLR object
* The differences in CLR permission sets
* Worked examples of problem-solving with the CLR
Execution Plan Basics
​
Peter Larsson (MVP), PASS Scania
As a developer, the execution plan in SQL Server can be deadly, and tedious and ... and absolutely wonderful! In this session we show how you can interpret the results in what seems like an alien and complicated map and how you can draw conclusions from the results. We also show how to compare two queries and see which one is most effective.
Introduction to BI for developers
​
Hadi Hariri
Business intelligence is one of the hottest areas on the market today. Why should I, as a developer, care about Business intelligence. What adds components such as Analysis Services and Integration Services that can not be solved in T-SQL or .Net. What can I do in Sharepoint and why is that product needed in a BI solution.
PowerPivot
​
Thomas Ivarsson (MVP), PASS Scania
PowerPivot is a new client add in for Excel 2010 and a Sharepoint 2010 Server application that can query extremely large datasets, with millions of rows, with an instant response within a second.
PowerPivot is based on the older Analysis Services archtecture but with a new column based in memory engine called Vertipaq that surpasses all previous limits for Excel clients. In this seminar you will get a general introduction to this new application.
* PowerPivot for beginners
* What is PowerPivot and why is it important
* Data sources supported in PowerPivot * Import data into PowerPivot
* What can you do with the new DAX-expressions language for PowerPivot calculations?
Most common mistakes that developers make in SQL Server
​
Peter Larsson (MVP), PASS Scania
What are the most common mistakes developers make in SQL Server in the beginning? Why is it not going so fast now anymore? The questions are many and fortunately there are a few simple answers! We will go through the most common mistakes and how to fix the problems to get better performance and safer results.
Overview
Calculations on indexed columns
Time and date calculations
Incorrect data types
RBAR (Row-By-Agonizing-Row)
Things that all .NET developers should know about SQL Server
​
Peter Larsson
There are new things in SQL Server 2005 and later that make life easier as a developer. Windows functions, MERGE and filtered indexes are some of these.
Better XML handling and compression are some others.