Session voting is now open. Please read through the sessions and vote for those that you would like to see on the agenda.
Now that you have created your first Cake Build Script, it is time to take it to the next level.
In this session we will look at making use of the various IDE and Continuous Integration Server integrations for Cake, including:
On top of this, we will look at how to utilise Modules within Cake to customise the internals of how Cake works, to allow you to fine tune your build processes.
Finally, we will look at how you can distribute your Cake Scripts to allow them to be re-used across multiple projects.
This is a level 201 talk that assumes that you already have some understanding of how Cake (http://cakebuild.net/) works.
Is the visitor to your website friend or foe?
Authentication is the sentry to your web application or API. "Bad dudes" are ready to march into your app but you have to control who gets through the gate.
This session will show you how to authenticate your users and keep your application secure. We'll look at the threats to your system and how to avoid pitfalls. We'll compare options in the .NET ecosystem and consider when they might be used.
We'll look at examples in .NET Framework and .NET Core, tackle integration with Identity Server and look at third-party authentication systems. By the end of this session, you'll have learned how to change your authentication for the better or what to choose if you're starting out.
Is your software working as intended in production? It may have worked when you tested it, but is it working now?
Too often monitoring is something developers leave to "the ops people". Too often we build systems that are hard to monitor. Too often our monitoring ends up focused on symptoms like "my application is not running" rather than business problems like "we are not making money"
Let's explore the idea of applying the extreme-programming concept of test-first development to our monitoring. We'll see how it helps us monitor the right things, build systems that are easier to run, and incrementally improve our architecture.
I'll also cover some of the techniques we can use to avoid common pitfalls such as brittle and unreliable checks, and how to stop side effects polluting our production data.
Designing a system is hard, it’s even harder to build a distributed microservices style architecture…
Let's try and walk through a simplified example of carving our our entities, bounded contexts and carving out the processes on the road to building better applications.
Whether you develop for the web, desktop, or mobile there are benefits for you and the people who use your software if you make using it easy.
This session will present 10 (ish) simple things you can do for your software to help make it easier for the people using it.
Devices nowadays offer a wide variety of form factors and capabilities. On top of this, connectivity – whilst widely available across many markets – varies considerably in quality and speed. This presents a huge challenge to anyone who wants to offer a great user experience across the board, along with a need to carefully consider what actually constitutes “the board”.
In this session I’m going to show you how to optimize the client experience. We’ll take an in depth look at Chrome Dev Tools, and how the suite of debugging, data collection and diagnostic tools it provides can help you diagnose and fix performance issues on the desktop and Android mobile devices. We’ll also take a look at using Safari to analyse and debug web applications running on iOS.
Topics covered include:
Slides for the last time I gave this talk can be found at https://www.slideshare.net/bartread/client-side-performance-for-back-end-developers-camb-expert-talks-nov-2016.
How easy it is to set up an actual, useful Alexa skill? With the newly added reminder functionalities in Amazon Alexa, what are the possibilities? In this session, we will look at what’s involved in building reminder functionality tailored to individual needs using Amazon Alexa, Lambda, Simple Notification Service (SNS), and some machine learning as well. Hay fever sufferers rejoice!
“The Pragmatic Programmer” first introduced me to the idea that writing software is like planting a garden. Over the years I’d forgotten the importance of the metaphor, until recently when I started working on my real-world garden. Musing on my day in the office whilst tending my plants, I realised gardening really does have a lot in common with working with legacy code.
With a 10-year-old, monolithic code base that’s being updated every day, staying on top of maintenance at FreeAgent is no easy matter. In this talk I’ll share how thinking about development in terms of gardening has helped me to understand the maintenance burden. I’ll talk about how we handle routine and exceptional maintenance in the product teams at FreeAgent and I’ll share some of the techniques we use to balance maintenance with feature development.
Smart Cards are everywhere. Just open your wallet. Eurosmart reported that 9.6 billion devices incorporating smart card technology will ship globally in 2016, a 3% growth over 2015. In this talk I'll present an overview over some of the relevant markets (EMV/Banking, Telecom, ID cards, RFID, NFC, Pay TV) and specifications (ISO 7816, ISO 14443, Java Card, Global Platform, ETSI specs). We'll see the typical structure and architecture of a smart card operating system. And finally, I'll talk about some of the security aspects, what attacks could be performed to hack smart cards and how smart cards defend themselves.
You wouldn't allow any Tom, Dick or Harry to add code to your application; but cross-site scripting (XSS) vulnerabilities allow exactly that.
This session aims to prevent these issues from keeping you awake at night. We'll look at the mechanics of XSS, how protections can be bypassed and how defence in depth is your friend. We'll demonstrate XSS in action using the Browser Exploitation Framework Project to illustrate the power of this attack. Examples are in C# and React.js; lessons will be useful to any web developer.
We’ll learn how to protect ourselves from XSS so we can all get a better night’s sleep.
This talk goes into my experience during the last year as part of a team building a system that is based on microservics architecture.
Whilst I'll mention the technology used this talk won't be about the technology more about the lessons I've learnt.
I'll cover how we built the system, deploying the code & most importantly how to support the system.
Securing a web application is a challenge. The internet is awash with malicious traffic and web applications are globally accessible. Don’t make it easy for them and the baddies will move on and find someone else to annoy.
We’ll look at the risks facing web applications, the basic steps you can take so that you don’t make yourself a target and the things you should do to avoid becoming a data breach statistic. We’ll also look at lessons that can be learnt from mistakes that others have made.
We’ll demo some of the techniques and tools in both attack and defence with examples for any web application developer.
Whether you have existing services or containers or whether you are building a new system from scratch there are numerous ways in which you can deploy. Managing and deploying your microservices application can be complicated. This talk introduces the Azure Service Fabric and shows how you can take existing services and containers and deploy then on your own infrastructure, in Azure or another cloud provider and how you can manage these applications and build new services to take advantage of the Service Fabric platform.
Us software developers have a lot of power. Software can do all kinds of good stuff. But software can also do all kinds of bad stuff. In this talk, I will remind us of the responsibility that comes with power. The arc goes from maintainability via Clean Code over safety and death by software and security to green code and the impacts on the environment. We will look at a few prominent examples like the Ariane rocket or the Toyota firmware bug and discuss whether a code of conduct for our profession might be necessary and how it should look like.
In this session we'll learn advanced Bayesian modelling techniques (in R), using the medium of predicting which football team will win the '17-'18 season. Don't worry if, like me, you have no time for the lawn fairies, this session will be heavy on applied Bayesian statistics and light on football. By the end of the session, you'll have all the skills you need to code up your own sophisticated predictive, Bayesian models.
The .NET platform has been in decline over the last four years, losing half if its available positions in server-side development. In this presentation we look at the data behind that decline and ask what happened and what can we do to reverse it.
In 201I, Bob Lee called for a Java Renaissance to capitalize on new developments on the Java platform and fight off the competition from frameworks like Ruby on Rails. The numbers show that Renaissance having an impact on server-side Java development, and many web scale companies have returned to Java for their server workloads.
Can we make a similar move in .NET and create a renaissance that will see .NET taking a role server-side in web scale deployments?
Part-history lesson, and part call to action, this talk tries to set out where we could go, if the community can create a .NET Renaissance around the .NET Core developments.
Today's applications need to continuously delivered, as much as hundreds of times a day, and scale from hundreds to hundreds of thousands of users. At the same time these applications need to be safe, with high availability rates. Cloud Native is emerging as a set of best practices to help us meet this paradox: to both embrace change but yet remain stable. In this talk we will identify the key pillars of a Cloud Native application, and discuss how to move your development towards high-scalability software engineering. Along the way we will cover everything from Microservices and Antifragility to Agile Application Infrastructure.
In this presentation, we will be discussing 5 main common myths around Artificial Intelligence as well as what it can actually deliver at this moment of time. We will then see a few demos of interesting AI examples that span beyond personal assistants, and that should leave you with some practical ideas on how you can get started in this space.
Performance is a critical aspect of modern web applications. Recent developments in hardware, software, infrastructure, bandwidth, and connectivity have raised expectations about how the web should perform.
Increasingly this attitude is applied to internal line of business apps, and niche sites, as much as to large public-facing sites. Google even bases your search ranking in part on how well your site performs. Being slow is no longer an option.
Unfortunately, problems can occur at all layers and in all components of an application: database, back-end code, systems integrations, local and third party services, infrastructure, and even – increasingly – the client.
Complex apps often have problems in multiple areas. How do you go about tracking them down and fixing them? Where do you begin?
The answer is you deploy the right tools and techniques. The good news is that generally you can do this without changing your development process. Using a number of case studies I’m going to show you how to track down and fix performance issues. We’ll talk about the tools I used to find them, and the fixes that resulted.
That being said, prevention is better than cure, so I’ll also talk about how you can go about catching problems before they make it to production, and monitor to get earlier notification of trouble brewing.
By the end you should have a plethora of tools and techniques at your disposal that you can use in any performance analysis situation that might confront you.
The slides for an extended version of this talk can be found at https://www.slideshare.net/bartread/longer-version-2-x-45-mins-with-break-how-to-speed-up-net-and-sql-server-web-apps, although I obviously plan on giving a shorter (45-60 minute) version at DDD East Anglia.
When people say Azure, they mostly think about hosting application in the cloud and scaling it up when needed. But it can be useful for integration with client applications too. In this talk I will cover our way of exchanging data with SAP.
If you are interested in WebJobs, interacting with Blob Containers and Azure Service Bus, this will be the main part of this talk. I want to show you full process, getting data from SAP to our main application and back. I will as well show you which tools and libraries we find useful. We mostly integrate with SAP, but our solution can easily work with different applications.
Mistakes are always interesting, so I will share with you, what didn't work for us. If demo gods are kind, we will create full integration process during this presentation.
You've seen the adverts from agents seeking rock star and ninja developers, but what does that even mean?
In this session we'll look at what it takes to be a true rock star developer. Like true rock stars, we'll eschew software development and instead focus on attitude, volume, tone and to a lesser extent skills.
Leave your laptops at home and bring in your guitar or uke instead. Expect to hear both C# and F#, as well as some lesser know notes like A, D and E.
Empower your Ops team to order a new deployment with instant delivery at the click of a Dash Button. *Amazon Prime subscription not required.
Amazon recently started selling the AWS IoT Dash button in the UK, just like a regular Dash button it's a simple one button WiFi device, however this one connects to the AWS IoT service which allows us to do more interesting things with it.
Learn how to connect your IoT Dash button to the AWS IoT service, invoke a Lambda function when the button is clicked and trigger Octopus Deploy to deploy your application.
Have you ever needed to control the version number of your open source application on GitHub? If so, you will likely know that it can be hard! You may have tried to use some form of auto incrementing number, or stored the version in a text file hoping that someone will remember to update it. Both of these approaches (and there are plenty others) will work, but they are fragile, and don’t account for some of the more complicated scenarios.
And then, after controlling the version number, you then want to generate Release Notes for that newly released version. How can you do this without manually trawling through the revision history?
In this session, we will look at how we can improve the versioning strategy of your application using a combination of branching strategy (Gitflow), Semantic Versioning, an open source tool called GitVersion, and the commit history of your Git repository. With the version number in place, we will then use the Issue and Milestone tracking functionality in GitHub to automatically generate a set of concise release notes using a tool called GitReleaseManager.
.NET Core has dominated the hype for a while, but, what’s it really like running in production, on different operating systems?
We ported our 15 year old codebase (you read that right) to be running on the shiniest new thing in the .NET world, and yes, we hit some problems. Luckily, we managed to solve or work around those problems successfully.
Living on the bleeding edge with our legacy application has taught us a lot. We learnt very quickly it's better to embrace the platform, and the operating system to really reap the benefits. I can pass on some more of the lessons we learned to help you decide whether or not you should make the leap, and to ease your transition if you do.
We've been building hypermedia APIs in one shape or another for a long time.
As JSON continues to take over the world, many new specifications promise to deliver an easier way to create and evolve our APIs. After covering what problems ReST 3.0 tries to solve, we'll evaluate the specifications and tools we can leverage. To the cloud and beyond!
You’ve worked the Product Owner and ensured the feature matches requirements. You’ve collaborated with the Architect to achieve the best design. You’ve paired with the QA to ensure everything works as expected. Then, you’ve thrown it over the wall to Ops and moved onto the next feature.
Job Done. Or is it?
Development of a feature doesn’t stop at deployment, your involvement continues for the lifetime of the product. If you want great power to control the choice of tooling and approaches, then you accept the great responsibility of ensuring it works, and remains working, in Production.
In this talk I’ll explore the topic of Developers supporting their own features in Production. I’ll cover the benefits of this approach, including greater understanding of your product, its usage and performance, and how this data can be fed back to improve your product. I’ll also talk about the downsides of being on-call, combined with the strategies from Ops teams on how to handle these. You’ll come away from this talk feeling empowered to own your own work.
We've all worked with a monolith and we all know the unbearable pains associated with them. Controllers fatter than Thomas the Tank Engine's Fat Controller, repositories that quickly become a dumping ground for data access with zero cohesion and arbitrary services that make the SOLID principles cry. All of these violations make for a codebase that's hard to maintain, tough to evolve and a terror to work with.
In this talk we'll look at an alternative architectural approach utilising the Command/Query Responsibility Segregation pattern to better isolate and decouple our business logic from our framework whilst separating our read models from our write models. Whilst on our CQRS journey we'll stop and take a look at libraries such as MediatR and Brighter that enable such an architectural pattern. We'll also look at how this separation can lead to organising our API into feature folders for a better project structure and the additional benefits that come with such a concept.
We'll also look at how we can utilise pipelining features in MediatR and Brighter to introduce cross-cutting concerns such as monitoring, metrics gathering, logging and caching to our API.
We will take a closer look at why we care about async, how it works and then deep dive into async issues.
By the end of this session we will understand what SynchronizationContexts are, when to use ConfigureAwait, how deadlocks occur and how to detect and avoid them. On the way we'll touch on some C#7 features.
Whether you're building web apps or shared libraries, there will be something for everyone.
We spend our lives working with systems created by other people. From the UI on our phones to the cloud infrastructure that runs so much of the modern internet, these interactions are fundamental to our experience of technology - as engineers, as developers, as users - and user experiences are viral. Great user experiences lead to happy, productive people; bad experiences lead to frustration, inefficiency and misery.
Whether we realise it or not, when we create software, we are creating user experiences. People are going to interact with our code. Maybe those people are end users; maybe they're the other developers on your team. Maybe they're the mobile app team who are working with your API, or the engineers who are on call the night something goes wrong. These may be radically different use cases, but there's one powerful principle that works across all these scenarios and more - and it's called discoverability. In this talk, we'll draw on ideas and insight from user experience, API design, psychology and education to show how you can incorporate discoverability into every layer of your application. We'll look at some real-world systems, and we'll discuss how how discoverability works with different interaction paradigms. Because, whether you're building databases, class libraries, hypermedia APIs or mobile apps, sooner or later somebody else is going to work with your code - and when they do, wouldn't it be great if they went away afterwards with a smile on their face?
Everybody wants their web apps to be scalable and resilient. Its easy to do when you build it in but what about those existing applications. Building web apps that are both scalable and resilient is challenging. How can you take your existing on-prem application and move it into Azure? Azure is so big what services could I use to help me? This talk discusses the issues around making an existing web app scalable and resilient and talks about some of the Azure services and how they can help you achieve your resilience and scalability goals
Service Oriented Architecture has been around for a while, now Microservices is the new black, that’s cool, but can we learn from when we failed and succeeded implementing SOA? There are some really useful lessons we can take and avoid the pitfalls.
Along with the rest of the framework, one area of ASP.NET Core that's seen a lot of change is Razor, ASP.NET Core's powerful view templating engine.
In this talk we'll dissect what's changed in the Razor view engine, how we can utilise Razor's new tag helpers to create cleaner, more manageable markup. the new View Components concept to create more modular, reusable views and how we can extend Razor to go further than we thought possible. We'll also take a look at the upcoming Razor features in the much anticipated .NET Core 2.0 release.
By the end of the talk you'll be able to go away and build better ASP.NET Core MVC applications with your deeper understanding of what new features are available to you and how best to utilise them.
It doesn’t matter what point you’re at in your career, mentoring and being mentored is the key technique for personal improvement at any stage.
Knowing your weakness is a strength of its own, and mastering how to mentor will help you in achieving just that, by not only revealing your greatest strength but also your weakness. Learn how to offer help and support to others is actually the best way to help yourself.
The talk will help attendees to learn how to use mentoring not only as a skill to support others, but as a technique to achieve your goals.
Save yourself the trouble of clicking that Dash button when the toilet paper is running low, this automated toilet paper monitoring system will let you track usage and add new supplies to your Tesco.com basket.
The Photon from Particle is a small but powerful WiFi dev kit that enabled software developers like us to quickly and easily build secure and fun IoT products. In this session we will learn how this was used to build Roll Pole, The Internet of Toilet Paper.
We will cover the basics of using a Particle Photon, from unboxing and connecting the Photon, writing our application in the online IDE, deploying over the air and securely publish messages to the Internet from the Photon.
We will also see how to monitor the state of the toilet paper via Tinamous.com and reorder fresh supplies from Tesco.com via IFTTT
You can read more about Roll Pole over on Hackster.io: https://www.hackster.io/TinamousSteve/roll-pole-the-internet-of-toilet-paper-19eb81
End to end tests written with webdriver have a reputation for being slow, unreliable (failing for spurious reasons), and brittle (breaking with any change). So much so that some recommend not using them, but they can be invaluable for catching problems before end users are affected.
I'll share some of the top pitfalls, and most useful techniques for reliability and speed that I've encountered in a continuous deployment environment - having hundreds of tests that need to run reliably in less than 10 minutes.
We'll look at how to deal with asynchronicity using implicit waits, avoiding point-in-time assertions, stubbing infrastructure dependencies, and how to get meaningful diagnostics for tests that only fail once in a thousand runs.
I'll also explain how the page object and screenplay patterns enable tests that are easy to keep up to date as your user interface changes.
Do you know what the testers on your team do, exactly, and how they do it? Have you been asked to pick up some "testing tasks", but aren't quite sure what that entails? Have you ever wondered how you can better find issues in your own code before you hand it over?
In this practical talk we'll have a look behind the scenes of testing to help you in this. I'll outline the testing mindset and the value it brings to a team, the difference between testing and checking, and how exploratory testing and test automation complement each other.
I will share useful testing techniques that are flexible enough to take your specific context into account: using oracles and heuristics for test ideas, prioritising test areas by assessing risk, organizing and executing tests using exploratory charters. Combined with a habit of stepping back and looking at the bigger picture these methods can enable you to provide fast, valuable feedback to yourself and your team.
Machines are doing things today that were unthinkable even a few years ago. From computer vision, to understanding human conversation, to translating text, or even generating art; they're encroaching on domains previously thought to be strictly human realms. The technology behind this is actually fairly old; neural networks have been around for decades. However, modern hardware capabilities have made them technology feasible to such a degree that they can now drive cars.
Tensorflow is Google's open source framework for deep learning. It makes it relatively straightforward to apply these techniques. In this session, we'll cover the basics of image recognition, and use Jupyter Notebooks, and Tensorflow to apply it.... with a dash of GPU processing to boot.
Last year we introduced React into comparethemarket and React is now our selected framework of choice. I have been leading a team of awesome full stack engineers over the past year and I will share with you our highs, lows and ugly parts of our journey with React, Redux and friends.
I will cover our vision we have with React and how we are trying to share components throughout the company and technical challenges we face with that and solutions we have come up with. We will also dive into some patterns we have established when creating our journeys and reasons why.
We will look at some mistakes we have made in the past and parts that have really bitten us so you don’t make the same mistakes.
So if you’re on a similar journey to us or you are just interested. Jump in this talk and join me on this journey and hopefully take away a few tips and tricks or at least enjoy some gifphys.
Yes, we're going to look at file parsing. Sounds a bit boring, right? Wrong.
In this talk, just for fun, we'll find out how to parse a file. We'll look at simple, hand crafted parsers. We'll finally figure out just how lex and yacc work. And we'll pick apart structured parsers that build abstract syntax trees as you type - ReSharper style. How is an IDEs parser different to a compilers? How do you handle sensible error recovery? What about significant whitespace?
Everything you always wanted to know about parsing a file, but were too afraid to ask.
Visual note-taking (or sketchnoting) is the art of summarising information in a visual manner, to improve the discoverability and readability of your notes. I want to show people that there is no magic, just a series of simple techniques that can bring impressive results.
This is a practical session, you start by learning the simple techniques that I use when sketchnoting (hopefully dispelling the magic) and for the last part of the session I will be showing a video for you to practice note taking from.
It would be good if you could bring:
(I will have some limited supplies available)
Sometimes it is difficult to work out how to prioritise the backlog and effectively work iteratively while still holding on to the big picture. What do you put in your MVP (Minimal Viable Product)? What then goes in each incremental release to give your users more and more useful functionality? Storymapping is a technique for solving this problem and getting your solution to your users faster.
In this highly interactive session I’ll explain how you go about creating a story map and I’ll get you to create one. Lots of sticky notes later you should have a fairly good grasp and be able to use the same technique on your own projects to better manage your backlog and keep everyone aware of the big picture while still working on individual stories.
Sticky notes and sharpies will be supplied.
Making apps for people with a disability with Xamarin tells you about making apps for people with an intellectual disability. Former, people thought people with an intellectual disability cannot read, thus a smartphone isn’t really realistic for them. But nonprofits and startups started to explore this userbase and found out a way of apps people with an intellectual disability can use. Why is this important? Well there are two big reasons: first of all: If people with an intellectual disability can use your app, they can get info about their life-situation and that empowers quality of life. Smartphones by example uses Text-To-Speech and principal the need to “can read” isn’t there anymore. For you as developer or startup there’s also a big benefit of apps for these people: nearly every market is discovered for mobile apps. Every market has big concurrency. But the market of apps for people with a disability is quite less discovered, so if you are good, you can rule a complete new market!
"Introduction to Event Sourcing" is a beginner level introduction to event sourcing, a data storage idea that works on capturing the change history of the system as a sequence of events and recreating the state from this history, and I will also show how it fits into the larger concepts of CQRS and up to DDD - with some discussion on how to host and use event sourcing in microservices.
Beginner's level talk (101), no code but mostly diagrams, interactive discussion and Lego.
In this session we’ll take a look at GraphQL – the language-agnostic server-side library from Facebook. It provides an alternative to REST-based APIs, making your data queryable, explorable and efficient from a networking point of view.
We will implement a GraphQL schema in .NET and demonstrate the awesome interactivity that a GraphQL endpoint opens up!
The story of the web is a story about freedom. It's a story about information, about breaking down barriers, about creating new ways for people to communicate, to collaborate, and to share their ideas. It’s also a story that has as much do with marketing, money and meetings as it does with research and innovation. It’s a story of mediocre ideas that succeeded where brilliant ideas failed, a story of compromises, rushed deadlines and last-minute decisions. And it could so easily have been very, very different.
What if IBM had hired Digital Research instead of Microsoft to develop the operating system for their first PC, way back in 1980? What if Marc Andreessen and Jim Clark had gone to work for Nintendo in 1993 and never founded Netscape? What if one of the gang at CERN had said “Tim, won’t it sound a bit silly if everyone spends the next fifty years saying double-you-double-you-double-you all the time”?
So strap in, hold tight, and join us as we take you on a journey through the web that never was.
Since being introduced by Eric Evans in 2003, there is plenty of evidence that Domain-Driven Design (DDD) has gained significant traction in the .Net world, particularly the Tactical patterns (Aggregate, Entity, Repository etc). However the most powerful aspects of DDD are the Strategic patterns (Ubiquitous Language, Bounded Context, Context Map etc) and these have been ignored or misunderstood by development teams. In this session you will learn just how important and powerful the Strategic patterns are in determining how we structure and architect our applications.
So you've used git for version control for a while? You've mastered the basics, but now it's time to move faster and not break things. This session will focus on personal git tactics to increase your productivity. In increasing order of awesomeness, we will cover:
Our day to day lives as developers can be quite divorced from from the architects we are working with. The aim of this talk is to demistify the responsibility and encourage developers to take a more active role in the architecture of the solutions they're working on.
Chocolatey - The Package Manager for Windows!
With the recent release of the licensed versions of Chocolatey, a number of new and exciting features have been released that make Package Management on Windows with Chocolatey even easier and more secure.
In this session we will look at some of these new features, including:
and others. As well as looking at how you can use Chocolatey to orchestrate the complete installation of all your tools and applications, and how you can very quickly use Chocolatey to package and re-distribute your own applications either internally or for your customers.
Manually delivery software can be a time consuming and error prone affair. Why have a valuable person sit and manually do this? They’re bored, and as a result they’re not paying full attention and mistakes happen. It isn’t repeatable so all those deployments to the testing environment count for nothing when it all goes horribly wrong when deploying to the production environment. There must be a better way of delivering software.
Amazon reportedly deploys to production every few seconds, GitHub do it several times a day. What makes this possible is a continuous delivery pipeline - a set of processes and a culture of development that ensure that get you to the point where every commit to your source repository is a potential for production system.
Continuous Delivery aims to remove the issues with building, testing and ultimately deploying to production in a safe, repeatable, well tested and highly confident way. I aim to show you how to get started on this journey. It isn’t as daunting as it first looks.
This is a high level talk that discusses processes, what gains can be made, and how to overcome or navigate around the pitfalls you may encounter. It is therefore technology neutral.
The majority of web projects in .NET are written with ASP.NET MVC/Core and EntityFramework with SQL Server. This seems odd to me, there are some fantastic alternatives that seem to be scarcely used. Everyone knows there is no such thing as a silver bullet, so let’s check out some alternatives. Exploring some common problems, we’ll take a look at NancyFX, Dapper, and Postgres, to help us solve them.
Let's step out of our comfort zones, and let's start looking up.
One of the cornerstones in Microsoft’s digital assistant Cortana are cognitive services. Instead of the traditional Screen / Keyboard / Mouse combination for user interaction with your application, it offers different ways of handling user input.
Think about vision, speech and language – the new way of communicating with your devices – but also how to analyze and structure these kinds of user input.
This session will give you an introduction on the Cognitive Services Platform – show how it can help your end-users – and with live coding examples you will experience how easy it is to start using this incredibly cool API.
The buzz is all around Cloud Native: continuous deployment and easy scaling of your server side code. You have heard about Docker and Microservices, but what are 12-factor apps? The Twelve-Factor App methodology (https://12factor.net/), was created by engineers with experience of delivering apps on Heroku, and is a "recipe for success" when authoring code for cloud native senarios. In this presentation we will look at what a Twelve-Factor App is, and demonstrate how to meet the requirements when creating .NET applications. We will show examples using ASP.NET Core, Brighter and Darker of authoring code to meet these requirements, and show its deployment to containers using Docker. By the end of this talk you will know enough to be able to approach another pillar of Cloud Native.
Entity Framework (EF) Core is the new lightweight and extensible version of the popular Entity Framework data access technology. However, there are still a lot of misconceptions on what EF Core does and its suitability for a new project.
In this session we'll explore the new features available in EF Core including; shadow properties, batching, supported database providers and tooling. We will also walkthrough how it compares to other ORM’s including classic Entity Framework and highlight the practical uses cases.
Rider is a new cross platform IDE from JetBrains, integrating the language analysis features of ReSharper inside the IDE functionality of IntelliJ. Wait, what? ReSharper is a plugin to Visual Studio, running in .NET, and IntelliJ is a JVM application! Cats and dogs, living together, mass hysteria!
So how does this work? Rider runs ReSharper out of process, as a headless language server. All of the .NET language features - inspections, navigations, refactorings and more - happen in the ReSharper process, with the results being displayed in the IntelliJ based user interface, running on the JVM.
How would you tackle this? JSON and REST? Protobuf and named pipes? Or something a little more made-to-measure? In this session, we won’t be looking at Rider’s (impressive, comprehensive, some would say attractive) feature set. Instead, let’s geek out and see how and why we built our own custom, asynchronous, declarative, reactive, inter-process, cross runtime communications protocol.
In this session I'll walk you through a solution, built for the UK's leading chicken farmer, which allows a picture to be taken of the chickens, after they have been locked in their barn for the night. An ML app then analysis the image and counts the number of chickens in the image, therefore providing the customer with a daily count of his livestock, something that they've never had before.
I'll also show you how I use machine vision to processes the images and I'll present they ways in which I amended the K-Nearest Neighbour algorithm in order to implement this solution.
This talk has a DevOps feel to it but is mostly a call to arms around treating our databases as first class citizens like we would do with our code. As a development community we've matured greatly with CI and CD around our code but databases are often neglected.
I'd like to talk about some simple but effective techniques to version, test and deploy SQL Server databases.
This talk is not cutting edge, it's not revolutionary. It's not even particularly clever - just a series of techniques to super charge database development and deployment. Oh, it doesn't involve Entity Framework either.
This will be a hands on session where I open Visual Studio (or maybe VS Code!) and I walk through how to manage SQL scripts, use DbUp to manage versioning and show how to spin up instances of our databases for Integration testing.
In this talk I will show how we can build deploy and monitor (micro) services using the .NET platform.
The code and demo will demonstrate how you can decompose your domain and also show a UI Composition example
Java 9 will come and bring Jigsaw, the module system. I will walk the audience through the most important new features of Java 9. The main topic will be the Java 9 module system. I will demonstrate the nuts and bolts, engage the audience in a discussion about the pros and cons, benefits and drawbacks, and the situation in the Java Community Process. I will finally show some real-world examples of how to deal with the Java 9 module system that involve Maven, Cucumber and maybe Spring.
What if you could not only automate end to end tests which test the happy and functional paths of your applications, but also tests typically carried out by manual or exploratory testing?
What if you could pick up on minor changes to layouts, sizes of elements, colours, text etc? What if these tests were also less flaky, easier to maintain and also faster to execute.
Using Visual regression testing discover how you can gain extra value in the automated tests you create, having the ability to see and assert what the user sees and to assert the sotware UI meets our expectations.
Have you ever wanted to create a build script:
for your application, but been faced with learning a new language, or DSL, or writing more XML than any person should ever need to?
that will work cross platform?
that has first class support for the most common build tools like XUnit, WiX, SignTool, and many others?
that uses a language that you already know, and love?
If you have answered yes to any of these questions, then the Cake (http://cakebuild.net/) Build Automation System is for you!In this session we will start with a standard .Net Solution and incrementally add a build and orchestration script to compile the application, run unit tests, perform static analysis, package the application, and more, using the C# skills that you may already have.