• 'Globally resilient websites with Front Door' with Callum Whyte.

    Delivering maximum uptime and the fastest response to our end users all over the world is very important... So we deploy our application to multiple regions and route traffic to the nearest available servers. But managing and visualising each component of our infrastructure, how it everything hangs together, detecting and handling failure, as well as deployments, can all be a challenge. This session will dive in to the tools we can use, like Cloudflare and Azure Front Door, to add world-class resilience to a globally distributed Umbraco website - for maximum uptime and speed. We'll look how to tackle other interesting challenges, like cache busting and routing our users to the best / fastest server for them.

  • From four to forty in four years - trials and tribulations of growing a team

    Between 2016 and 2020, the PureGym IT Team grew from 4 to 40 people. During that time Rich worked closely with them to navigate the tricky process of scaling. This talk is a journey through that growth period and discusses the variety of processes and practices that were applied in order to stay "Agile". We'll touch on the various approaches taken including topics such as Scrum, Lean, Kanban, GIST planning, Lean Startup, DevOps, IaC, Azure, Story Mapping, BDD, TDD, Project vs Product and we'll be looking at the successes, failures and lessons learned. We'll also look at how concepts from Team Topologies were applied, what team structures and interaction models were chosen and how that shifted the team dynamic. We will discuss what, in Rich's opinion, has worked well and what hasn't worked well during that time. At very least you will walk away from this session with a long list of books to read and hopefully some insights into whether you might want to try some of the approaches discussed during the talk.

  • Nailing down distributed workflows with microservices: Ben Arroyo

    IMPORTANT. Due to the coronavirus crisis we have decided to make this meeting an online event only. Ben has kindly offered to live-stream his talk via Zoom. All attendees should receive a link to the live stream in the next couple of days. Note that it will still occur at the same time as originally planned. If you'd cancelled your RSVP but can now attend remotely please amend it accordingly so you receive the link. Many thanks for you understanding. Workflows are present in every business. These bring up different challenges such as integration with different systems, long-lived transactions, failure recovery and more. In this session we’ll learn how to address these issues with a distributed, event-driven architecture based on microservices that I’ve been using successfully in the last three years across different projects. We also learn how to implement this architecture with MassTransit and Automatonymous and run it on containers with Kubernetes. The session broken down into three parts. In the first part of the session we’ll brush up some DDD patterns and microservices patterns such as sagas, orchestration and different communication patterns. On the second part we’ll put those patterns in practice by building up the sample architecture for an imaginary business, which requires integration with external systems with different communication protocols and built with different technologies (Python, Node, …). On the final part we’ll see how to implement the architecture. Ben Arroyo is a .NET developer and chicken keeper. Has been playing with Microsoft technologies for over 20 years. Full stack developer, although a bit lopsided onto the frontend. Worked as independent contractor for the last 9 years. Currently working as team leader at Supplier Assessment Services.

  • Building next generation web apps with Blazor


    The widespread adoption of WebAssembly, by all major browsers, has opened the world of front-end development to languages other than JavaScript. The platform leading the charge is Blazor - a new client-side UI framework from the Microsoft (http://asp.net) team. Blazor allows developers to write client-side applications using C# which runs inside the browser without needing plugins or transpilation - how cool is that! In this code-focused session, we'll explore the Blazor platform. We'll start by looking at fundamentals such as how to structure Blazor applications for flexibility. The component model, looking at life cycle methods and inter-component communication, as well as forms and validation. We'll then explore some more advanced topics such as authentication, authorisation and JavaScript interop. Chris Sainty is a Microsoft MVP, software engineer and blogger with over 15 years experience working with (http://asp.net). He currently works at Flagship Group, a housing association in the east of England, leading a team building repairs and maintenance solutions using .NET Core technologies. Chris is passionate about sharing his knowledge with the community. He is an avid blogger and user group speaker. He maintains several open source projects under the Blazored banner and regularly contributes to open source projects. Chris is also a proud member of the .NET Foundation. You can find Chris online at his blog http://chrissainty.com and on Twitter as @chris_sainty

  • A double bill of talks from Jon P Smith.


    'An introduction to Domain-Driven Design, with examples from Entity Framework Core'. Eric Evans book Domain-Driven Design (DDD) says on page 4 "The heart of software is its ability to solve domain-related (business-related) problems for the users.”. But for us developers it’s sometimes hard to see where and how to apply DDD in our projects. In this talk Jon will give you examples of how he has applied DDD in real-world applications, especially using Entity Framework Core, with his impressions of how hard/useful each DDD feature is to use. 'Using an event-driven architecture with Entity Framework Core'. Following on from the first talk Jon will describe an event-driven architecture where events are used to execute business logic/database updates in an application using Entity Framework Core. Jon has been using such an event-driven design for one of his clients, so he can talk first-hand about the good and bad parts of this approach. Jon Smith is an Independent back-end senior developer with special focus the .NET Core and Azure. He wrote book "Entity Framework Core in Action” and author of series on ASP.NET Core authorisation, which he spoke about at NDC OSLO 2019. His tech blog can be found at https://www.thereformedprogrammer.net/.

  • Git Deep Dive and Reading Matters for .NET Developers - James World

    Git Deep Dive Git is now the de facto version control tool - most developers use it every day. But it's notoriously difficult to harness its full potential and most of us only end up scratching the surface of what it can do. In this talk, we dive under the covers of git, and take a look at the surprisingly simple and elegant design hidden within. With this knowledge, we'll be better equipped to make sense of the sometimes enigmatic tooling. We'll then step back and a look at some techniques to harness the power of git and Powershell together to help us understand more about source code under git's control. Reading Matters for .NET Developers What are your favourite technology books of all time? What was the last technology book you read? When I ask that question in job interviews, I usually get a politely embarrassed response mentioning blog posts, or Pluralsight or twitter. It seems that books have fallen out of favour with many of us - perhaps we feel that with all the pace of technology we just don't have the time? In this talk I will: - Explain why books should be an essential part of your learning approach. - Share my "must reads" for .NET developers - and invite you share yours. - Break books down in the four essential categories I think you should explore. - Explain how to get the best from a technical book in the shortest possible time. You will walk away inspired to read a great book - I promise you! About James World James World is an independent contractor with 25 years of professional software development experience, a regular presenter at user groups on a variety of development topics and the co-founder of Azure Oxford Meetup. He worked at Microsoft as a software consultant for a decade, ran the Microsoft UK Performance & Scalability Labs and has worked in the City of London on a range of trading systems. Over the last few years James has worked as a consultant improving software development at companies by leading the adoption of agile and software-development best-practices. He has also founded two successful tech start-ups. Always a coder, he makes sure to never stray too far away from his latest programming project. Find him on twitter at @jamesw0rld and on LinkedIn at http://linkd.in/james-world.

  • Ctrl-Alt-Del: Learning to Love Legacy Code with Dylan Beattie

    The world runs on legacy code. For every greenfield progressive web app with 100% test coverage, there are literally hundreds of archaic line-of-business applications running in production - systems with no tests, no documentation, built using out-of-date tools, languages and platforms. It’s the code developers love to hate - it’s not exciting, it’s not shiny, and it won’t look good on your CV - but the world runs on legacy code, and, as developers, if we’re going to work on anything that actually matters, we’re going to end up dealing with legacy. To work effectively with this kind of system, we need to answer some fundamental questions. Why was it built this way in the first place? What’s happened over the years it’s been running in production? And, most importantly, how can we develop our understanding of legacy codebases to the point where we’re confident that we can add features, fix bugs and improve performance without making things worse? Dylan Beattie worked on the web application stack at Spotlight (www.spotlight.com) from 2000 until 2018 - first as a supplier,then as webmaster, then as systems architect. Working on the same codebase for nearly two decades has given him an unusual perspective on how applications go from being cutting-edge to being ‘legacy’. In this talk, he’ll share tips, patterns and techniques that he’s learned from helping new developers work with a large and unfamiliar codebase. We’ll talk about virtualisation, refactoring tools, and how to bring legacy code under control using continuous integration and managed deployments. We’ll explore creative ways to use common technologies like DNS to create more productive development environments. We’ll talk about how to bridge the gap between automated testing and systems monitoring, how to improve visibility and transparency of your production systems - and why good old Ctrl-Alt-Del might be the secret to unlocking the potential of your legacy codebase. Bio: Dylan Beattie is a systems architect and software developer, who has built everything from tiny standalone websites to large-scale distributed systems. He’s currently the CTO at Skills Matter in London, where he divides his time between working on their software platform, supporting their conference and community teams, and speaking at various conferences and events they organise in London. From 2003 to 2018, he worked as webmaster, then IT Manager and then systems architect at Spotlight, where his first-hand experience of watching an organisation and its codebase evolve over more than a decade provided him with a unique insight into how everything from web standards and API design to Conway’s Law and recruitment ends up influencing a company’s code and culture. Dylan is actively involved in the international software development community. As well as his work with Skills Matter, he runs the London .NET User Group, he’s served on the programme committee for conferences including NDC London, BuildStuff, FullStack and ProgNET, and he’s a frequent speaker at conferences and technical events around the world. Dylan grew up in southern Africa, moving to the UK with his family when he was nine. He’s a Microsoft MVP and holds a degree in Computer Science from the University of Southampton. He’s a guitar player and songwriter, known for creating musical parodies about software development. He’s into skiing, scuba diving, Lego, cats, travel and photography, and he’s often found hanging around user groups, pubs and rock bars in London wearing a big black hat.

  • Rich & Johns Leaving Meal: Global Buffet, Southampton

    JRC Global Buffet Southampton

    Rich and John have stepped down after 12 years of running the usergroup, come along and say goodbye (leaving gifts welcome!) and share memories over tasty food :) Oh, and also... Woo, Birthday! In celebration of Developer South Coast's birthday, we invite you to join us at Global Buffet, Southampton for a gloriously diverse meal to suit all palates. https://www.jrc-globalbuffet.com/restaurant/southampton/

  • Kubernetes, Raspberry Pis, and more! - Dan Clarke


    The speaker for this meetup will be Dan Clarke! He's been using Kubernetes a lot lately, and thought it would be fun to install Kubernetes on a cluster of Raspberry Pis. There will be real hardware, and we'll create a basic .NET messaging architecture using Rabbit MQ - run it locally natively, then with Docker, then we'll install and run it on our Raspberry Pi cluster. Along the way, he'll explain some of the core concepts and benefits of Docker, Docker Compose, Kubernetes, and message queues. He'll also explain how to install Kubernetes on a cluster of Raspberry Pis and discuss the hardware. This talk is suitable for both those who have never used Docker or Kubernetes before; those who have and are interested in installing Kubernetes on bare-metal; or those who just like Raspberry Pis and shiny things! --- Dan (@dracan on Twitter), is an independent software developer with over 20 years of commercial experience. He works for his own company, Everstack Ltd, providing software development and consultation services for multiple businesses. He's very passionate about software development, productivity, and ongoing learning and self-improvement. His blog can be found at https://www.danclarke.com.

  • Inside the CLR (Common Language Runtime) by Chris Bacon

    Running C#/.NET code is something we do all the time. But how does the .exe/.dll file produced by the compiler actually get executed? What's going on inside the dotnet[core]/Mono runtime? In an attempt to answer these questions we'll investigate the contents of a .NET executable file and the things that the runtime needs to have in place in order to execute .NET code. With examples from a very simple interpreted .NET runtime, demonstrating that this may not be as complex as you imagined! This will be based on the (inefficient, pointless, and obsolete!) DotNetAnywhere runtime that Chris wrote many years ago (you may also recognise the name as it's what Steve Sanderson used for his original Blazor demo) https://github.com/chrisdunelm/DotNetAnywhere About Chris Bacon: Chris is a software engineer, currently at Google, and has been using .NET since C# version 2.