Session voting is now open. Please read through the sessions and vote for those that you would like to see on the agenda.
Modern infrastructure is often managed using error prone and specialist domain languages which often leads our engineers to specialise and not apply our core skills.
Let's power up our infrastructure using Typescript and Pulumi. We can write our infrastructure using a language we already know, with tools we already use and version it all along with our code.
I'll show examples and demos using Typescript to manage serverless APIs, docker containers and Kubernetes clusters
Documentation isn’t always straightforward. Tutorials, QuickStarts, References. It can be difficult to know where to start. In this talk, we will look at the different types of documentation and how to strategically balance them for maximum impact.
We will walk you through building a simple website with an api backend all in AWS Serverless technologies.
The hands on workshop will covers hosting front end code in S3, writing an AWS Lambda in python, setting up an API gateway and finally setting up Security Groups.
This workshop is suitable for beginners, and no prior AWS experience is required.
System requirements : Please ensure you have :-
NoSQL is a fertile environment where new theories in distributed systems can grow and be heavily tested. Some of those theories end up being implemented in the most popular relational/non-relational databases. In this session, we will talk about the greatest features launched in the last 2 years, the current state of the art technology and what is coming next.
Databases were historically the biggest bottleneck of most applications, but with new software architectures and the rise of the so-called NoSQL databases, the scenario has completely changed in the last 20 years.
Modern theories in distributed-systems have solved issues with scalability, performance, availability, consistency, and data distribution and now we are on the edge of transactions, analytics, and self-management solutions.
In this session, we will talk about the vision of what is coming in the next few years and walk through some of the current key theories and architectures. talk about advantages, drawbacks and best use cases, so you can properly evaluate what is the best storage type for your next projects or how you can improve your current ones.
We will cover a practical example writing our web assembly using Rust. We will go through everything from writing your web assembly code to publish it as a npm package and finally use it in an existing web application.
By now most of us have a rough idea of what ML is all about, right? Good, but what do we do when ML, alone, just doesn't cut it, when there's either too many variables, or their starting values are non deterministic? Well that's a question we'll answer in this talk - we'll also have some fun as we use what we learn to try to predict the winner of a horse race run during the talk.
*Fully updated since the last time this talk was delivered.
If we want computers to be intelligent and able to interact with us we need to ensure that they can recognize, understand and express emotions. This is the basic assumption of Affective Computing.
First an introduction to the field will be described starting with established findings from psychology on how we best can measure emotions. Technology enablers that has made Affective Computing a hot topic will be highlighted as well as examples of API and services that we can use today.
The second part will cover application scenarios such as retail, medical, education and social. The presentation concludes with some recommendations on how Affective Computing affects us as developers going forward.
I/O is the source of the majority of blocking operations in most systems, and with blocked threads, the overall throughput of your application is compromised. Unfortunately, threads are expensive on the JVM and in other platforms, and even if they weren’t we would still need to deal with faulty networks and slow requests.
Spring Framework 5 introduces support for reactive programming with Spring Webflux, which is really awesome, but wait… aren’t we forgetting anything? What about databases? Database access should be reactive too!
In this session, we will get an overview of R2DBC and live code an end-to-end reactive application using Spring 5 and Couchbase Spring Data, which allows you to dive down to the native reactive interfaces when you need to optimize until the last mile.
With the rise of Kubernetes StatefullSets and CRDs, we started thinking about running databases on it. But why should I do that in the first place? How hard is it? Which are the challenges? Is it production already? All those questions will be answered during a live demo where we will deploy a database, deploy an operator, fail nodes, scale up and down with nearly no manual intervention.
Let's face it, we've all done it at some point. You have a value in your code that you don't want to hard code as it will vary in different environments or needs to change in a runtime environment, so you want to make it configurable in a file. That's where the fun begins.
In the.NET Framework, you usually create an XML configuration file and reference it using some static methods. Or maybe you use the designer in Visual Studio to do the work for you? In .NET Core, you are given a JSON file by default and access it through the IConfiguration interface. Job done ...or so you think.
.. and the questions go on and on.
In this talk, we start with a brief overview of the history of configuration in .NET Framework and how Microsoft handed developers a loaded gun to shoot themselves in the foot. Moving on to .NET Core, things are much better, but there are still some gotchas.
Lastly, the talk goes on to deal with the questions raised above with a "SOLID" based approach that makes configuration not only fully testable, but adds enhancements to handle encrypted configuration values (because you're not storing passwords as clear text in source control are you?) and validation of the configuration data before it hits your code.
The talk aims to help new developers avoid the pitfalls that others have fallen down and give experienced developers some food for thought as to how they might want to reconsider how they do configuration.
In order to start out with machine learning you typically would need to learn Python, Tensorflow, Jupyter Notebook etc. But what if we could run our machine learning algos straight in the browser. This can be done through Tensorflow.js. In this session you will get an introduction so that you can use it in your own projects.
As we move resources into the cloud, and we look to implement a more DevOps focussed approach, developers are having to learn more and more about deploying Infrastructure. In particular, Infrastructure as Code.
In this session, we will explore the concept of Infrastructure as Code (IaC0 and what it means for developers. We will dive into using Terraform, one of the most popular and versatile IaC tools and use this to deploy some infrastructure into the cloud. We will look at how we define deployments, how we work with parameters, variables and secrets, how we manage the infrastructure life cycle and much more. Most importantly, we will look at how we bring together application and infrastructure development in a world where developers need to be aware of all of this.
This is a demo-heavy session looking at real-world examples of IaC deployments, using real-world tools and techniques.
You all know what a Fermi Problem is, even if - as a dev - you didn't know that was what they are called. They are those annoying questions you get asked at interview, you know, the ones that go "So, can you tell me how many filling stations there are in the UK?". The ones where you think, "What a pointless question". Well, the fact is - to a data scientist - they are extremely important in predictive analytics and in this session, we'll lift the lid on Fermi Problems and I'll show you exactly where, and why, they are useful.
In daily basis where billions of billion devices are connected to the internet, browsers can actually take control Things like lightbulbs, robots, printers, NFC tags, toys, drones, and many more Things via web standard APIs such as WebBluetooth, WebUSB, WebNFC, Shape Detection API and etc. How about connecting to IoT gateway which supports Wifi via BLE ?!
On the other hand, Progressive web apps open a new era to build web apps that work offline and resemble native apps. PWAs are installable too, therefore, your solution to controlling Things in the real world can be written once for web and reuse everywhere.
In this session, I am going through some of the web capabilities to connect devices into a progressive web app and demonstrate how the web, eventually, could go beyond the browsers.
Do you love well-tested code but hate thinking of test cases? Do you often forget important cases when writing the code, and forget those same cases when writing the tests? Me too! We have so much in common. I've found that property-based testing helps with that problem by making the computer do the boring work of finding test cases. In this session, you'll learn enough about property-based testing to apply it to any language, and you'll see examples of property-based testing of Rust code.
From the docs:
The Task Parallel Library (TPL) provides dataflow components to help increase the robustness of concurrency-enabled applications.
What it actually does is give you the tools to create in-process async pipelines in a simple, structured manner.
And I'm betting that like me (until recently), this is a library you'll never even have heard of.
I'll cover the basics - Sources, Targets and Blocks - and how to link them together into useful asynchronous and parallel pipelines within your programs. We'll handle error conditions, cancellation and how to control the degree of parallelism - with samples that give you a bit more than "Hello World".
When you look at functional programming conferences agenda you’ll see quite a few talks on “esoteric” stuff like dependent types or various kinds of generic programming. More often than not they end up in advanced scala or haskell, debating Martin-Löf type theories or event category theory. But why…? Why does reasonable developer would like to embark on such a journey?
This is not advanced FP conference so I’d like to talk about it from a bit different perspective - from perspective of 'regular' Java developer.
I’ll try to show how we can meet these and similar concepts in “normal” world - of course in “regular” Java it’s usually not possible to do “real” dependent types, but we hopefully discover some intuitions why such concept is useful. The talk will be partially based on my experience - currently I’m working on a tool which helps users create “programs” without “code”. Quite a few times familiarity with generic programming helped me with design.
We all know that Ada Lovelace is credited as the first computer programmer. But what did she write? What did it do? And how does it work?
We'll finish up with a discussion on the controversy surrounding her involvement in computing, aiming to answer the question once and for all - "Was she really the first programmer?"
The "Travelling Salesman" problem is a computational classic - but firmly grounded in the real world.
In this session I'll discuss how at REDACTED we used Google's Open-Source Optimisation & Routing (OR) Tools to generate recommended routes for hundreds of surveyors and thousands of jobs on a daily basis for one of the largest firms in the country.
We'll cover the basics of the problem, and some of the classic approaches before moving on to how to use the tools Google OR Tools library. We'll look at some pitfalls and limitations - as well as how we created a fluent API for describing general case routing problems to pass to the Google OR Tools library.
A book called 'Domain-Driven Design: Tackling Complexity at the Heart of Software' came out in 2004. In the book, commonly referred to as 'The Blue Book', the author, Eric Evans, categorises Domain-Driven Design (DDD) in two parts: Tactical and Strategic. The Tactical part talks about low-level design patterns like Entity, Value Object and Repository. These are defined in the first two-thirds of the book and will not be covered in this session. The chapters on Strategic DDD deal with analysing and modelling complex domains at a higher level.
As businesses and software solutions have become more complex over the last 20 years, the importance of understanding the business domain and producing better higher level designs have become essential to creating successful products.
In this session you will learn about the patterns described in the Strategic section of the book and how you can use them to help understand and model your domain. You will also learn how the ever growing DDD community have built on to Eric's original ideas over the last 15 years to make introducing and using DDD much easier and more beneficial for everyone.
Then when you finally decide, it can be a rollercoaster journey.
For new projects, companies can choose what to use, at the moment React is the king, before that it was Angular before that Backbone.
Looking at the job ads many companies still depend on 'legacy frameworks' and are locked in by what they thought was the right choice.
Then there's the case of having to deal with frameworks used in projects that were outside of the companies control such as when a company acquires another.
I've worked with companies who have development teams spread across the world using a variety of frameworks and libraries asking how they can share and reuse components.
In this talk, I'll share my experience of the good, bad and frustrating of how this was achieved.
Compute has been evolving into serverless and orchestrated containers nowadays. Looking back almost two decades ago, the big jump from bare metal to cloud computing was done by an unlikely player and took the world by surprise.
Why and how was it done? Who were the brains behind the breakthrough? What were the impacts in software and product development and deployment?
Let’s look into the journeys of two big cloud providers and how they change compute world into what we know it today.
In this session, you'll learn how to write C# code which executes faster and allocates less. This session is packed with practical examples and demos of where the latest high-performance APIs and language features can be applied in your applications.
During this session, we'll apply types such as Span and Memory to efficiently process data and to parse strings. We'll examine System.IO.Pipelines, offering high-performance I/O and we'll utilise ArrayPool to help reduce GC allocations. In .NET Core 3.0, we have new high-performance JSON APIs which we'll also add to our arsenal. Microsoft has made fantastic performance gains to the .NET Core framework; now it's time to apply them to your code!
We'll begin by discussing when and why performance matters in your applications. You'll learn how to measure your code, and use a data-driven approach to focus your optimisations.
These features can seem complicated, unapproachable and difficult to apply. In this session, Steve introduces high-performance newcomers to the features, showing you how they work, where they can be applied and how to measure performance improvements in your code.
This talk is for developers, who like Steve, are ready to begin their journey towards writing faster .NET code, which allocates less.
Developing microservices based applications is a hot trend in our industry. However the journey to microservices is fraught with problems, by trying to solve one problem we often introduce a set of new ones.
This talk introduces a "journey" to microservices and highlights some new problems that are created by adopting such an architecture.
We then step through how we can leverage cloud native technologies such as Kubernetes and service meshes such as Istio to try and address some of these new problems.
This talk along with demos will cover many topics in an area which is rapidly evolving however we'll try and focus on the fundamental problems, and demonstrate tools that can help make the experience better or simply easier to manage.
Attendees will learn: Why microservices introduce many new challenges. How cloud native technologies (such as Kubernetes, Azure Dev Spaces, Istio) can try and help address these challenges. Some general guidance on microservices architecture.
Some knowledge of microservices, containers and Kubernetes is useful but not essential we'll cover the basic topics
A cerebral dive into why code is like music, and literature - a primer to the text and the subtext in software design. You don't write code for a living - you read it.
We'll take a look at the different ways you can interpret codebases to discover authorial intent in software. We'll look at what I learn about you from the style of your programming. We'll look at the breadcrumbs to meaning that exist in the odd and unexpected corners of a codebase.
Hopefully we'll learn what makes code subjectively and objectively beautiful, and useful.
By using micro frontends companies can provide users with the same experience across multiple web sites and applications.
The promise of reduced development costs and faster time to market by breaking monoliths into reusable composable components make them even more appealing.
Are micro frontends more than design systems on steroids?
In this talk we will answer this question and cover things like:
What are the costs and benefits?
What approaches can be taken?
How to integrate micro frontends with existing solutions
How to ensure applications remain performant
What you can do to ensure they look and feel the same across browsers and devices regardless of whatever CSS is being used on a page
Users love dashboards… Dashboards give them that warm fuzzy feeling that they can see into your software and watch it working perfectly… And dashboards give you the same insight into what's actually going on.
Microsoft's new Azure PowerBI Embedded product lets you capture data, analyse it and present it on dashboards that live within your application.
In this session, I'll take an existing application, instrument it, pipe the data into Azure and demonstrate just how easy it is to create a rich dashboard to monitor the application's performance.
Monorepo is not only for huge companies like Google or Facebook. It has great advantages for a single user who maintains 2 and more repositories.
Do you think it's too complicated for you? I'll show you how it works and how to set up in 3 commands.
Machine Learning, Data Science, Artificial Intelligence. These all big words we hear coming into our businesses lately - but what does it all mean?! Microsoft has created a set of simple and scalable tools that any developer can use and integrate into their applications super quickly!! This session will focus on the various Cognitive Service offerings and show you plenty of demos on how to use them in your apps such as ASP.NET Core, SharePoint Framework and Flow. Come and learn how to take advantage of these awesome services for your everyday work!
This talk is an introduction to Domain-Driven Design which provides a formalized approach to developing complex, scalable and robust software.
We'll take a tour of Domain-Driven Design (DDD) to understand what it is and how it can help develop complex software by aligning software development closely with the business domain. We'll look at Strategic Domain-Driven Design which helps us to build a useful domain model upon which we'll base our software, then we'll look at Tactical Domain-Driven Design which we use to turn the model into software and helps us achieve our goals.
Many of us are used to working in Agile teams. But as time goes on, do you feel like retrospectives have become boring, uninspiring and less effective? Does it seem like the team are just going through the motions, but the process is failing you?
This session will take a look into the surprising cross-disciplinary history behind retrospectives, leaving you with a deep understanding of why we perform them and how feedback is the "engine" of Agile development. You'll learn how to engage your team in fun retrospectives and you'll leave with a renewed sense of focus to make Agile work for your team.
Power BI is an environment consisting of several reporting tools and platforms each utilizing different languages and capabilities for data modeling, data insights and report sharing. If you are new to the world of Power BI, this can all get a little overwhelming and leave you feeling confused and frustrated.
This session is designed to get you started writing beautiful reports and dashboards as quickly as possible. We will first lay the groundwork explaining how the whole Power BI stack hangs together, for both on-premises and cloud services and tools, and how you can use them to share your reports.
Next, we will focus specifically on how you utilize those reporting tools to create beautiful reports, dashboards, and paginated reports.
By the end of this session, you will be comfortable connecting to remote data sources, creating your data model, and designing and publishing your first Power BI reports and dashboards.
Fancy Bear, Stone Panda, Lazarus, Charming Kitten and Equation Group are Advanced Persistent Threat groups. Woah, sounds scary!
What are the threats from these groups? Do we really need to worry about them or do they just make attention grabbing news stories?
In this talk, we will explore why APT groups might not be the thing that application developers need to worry about and the things that should get attention in application security. You'll see some tools and techniques that help find the important problems to work on and the ways to resolve those problems. This is real world appsec.
Are you considering outsourcing functions within your business and are concerned about the impact this might have on your organisation? Or perhaps you are already working with a software development company and facing a number of challenges?
Let’s be honest, in some organisations “Outsourcing” has become a dirty word, synonymous with internal conflict, poor quality and boundless communication challenges.
But does it have to be that way? In my talk I will outline how comparethemarket.com has built an award-winning partnership with Godel Technologies in under 2 years. From culture to process, I will take you through our journey. Covering how we approached the partnership, how we managed the day to day, some of the challenges we faced along the way and how we addressed them.
The real challenge in search is not how to pick the best search engine framework or how to find a match, but how to bring the most relevant results first. Modern search engines have been heavily using machine learning to understand what is relevant for their users, but this approach requires tons of time and effort.
In this talk, we will show how to implement from scratch a clever search for your application using just a little bit of planning and standard features provided by any search engine framework: boosting, analyzers, tokenizers, fuzziness, facets, penalties, etc. We will also review some core concepts and show how to fix common relevancy problems.
There is a philosophical conundrum that has existed since antiquity, and problem that continues to be relevant to this day - especially to those of us that code for a living:
How many rocks do you need to make a pile?
We could put this all sort of other ways - how many hairs can someone have before you stop considering them bald? How many years old is someone before they start being old? How many Doctor Who stories have there been? None of these things have definite answers, just a vague sense of when an answer is definitely true, definitely wrong, and a whole load of fuzzy possibilities between.
Computers like strictly defined, easy to predict answer - "A pile of rocks is 10 rocks", but this doesn't help us to meet business requirements.
Philosophers, mathematicians and scientists have wrestled with this problem throughout the millennia, and all sorts of answers have been suggested. How can we use their findings in our day-to-day lives as developers?
What code patterns exist to allow us to give definite answers to fuzzy, vague questions?
We'll do our best to answer all of these questions - and more - and all with some nice, friendly C# code samples.
Over the last couple of years, I've presented 20 tricks and tips that I've found invaluable as a Tech Lead. But in this session, I want to turn things around and look at applying some of those to solving specific issues that are common within many software development teams.
I'll be taking lessons learned from the last 2 years of a major development project and using them to illustrate my points.
We'll look at managing your BAs and PMs and how to balance their need to understand exactly how long everything takes versus your team's need to not be over-pressured by artificial deadlines.
We'll see how a structured approach to analysing problems encountered in LIVE can make everyone's life easier, and how to prove whether the problem is (or is not) the fault of your software. And how to handle that inevitable case where it is.
And we'll look at the problems of implementing uniformity across multiple code-bases and multiple teams delivering multiple releases of multiple features... and where getting your tooling right can give the biggest benefits.
Amongst other things...
Think your democracy is safe? Better think again. In this session I'll demonstrate the techniques that the 'black hat data scientists' use to get the result they want from any election or referenda. In this entertaining talk, I'll demonstrate techniques, both at the macro level - how to attack an election systemically - and at the micro level - how I can manipulate individuals to do exactly as I want them to do.
*Fully updated since the talk was given at NDC Oslo 2019.
Managing a team in the corporate world has many known challenges: disengagement, lack of creativity and inspiration, and no focus on personal growth - all of which lead to poor performance.
For Gad Salner, a software engineer and manager with more than 10 years of experience in the Israeli startup scene, In addition to a lack of engagement, managing a recently formed team within WeWork Technology has come with other interesting challenges. As many companies experience when they go from being small startups to larger corporations, many employees tend to feel the growing pains. Some of these include losing aspects of the employee culture, shifting goals, making sense of the madness, and the fear of becoming a small fish in a big pond.
In this talk, we will learn how to create a winning engineering team by applying cultural, agile and functional aspects of the startup world.
We have traditionally built robust software systems by trying to avoid mistakes and by dodging failures when they occur in production or by testing parts of the system in isolation from one another. Modern methods and techniques take a very different approach based on resiliency, which promotes embracing failure instead of trying to avoid it. Resilient architectures enhance observability, leverage well-known patterns such as graceful degradation, timeouts and circuit breakers and embrace chaos engineering, a discipline that promotes breaking things on purpose in order to learn how to build more resilient systems. In this session, will review the most useful patterns for building resilient software systems and I will introduce chaos engineering methodology and especially show the audience how they can benefit from breaking things on purpose.
If you've heard of FizzBuzz, chances are that you'll think everyone has. Yet, over several years of interviewing developers, I've been surprised by how many people have never heard of this classic programming problem. So, if you've never heard of FizzBuzz, I can assure you you're not alone.
Though it's often the source of scorn and derision, I'm unashamed to by a fan of FizzBuzz as an interviewing tool. After dozens of interviews in two languages with candidates at a range of levels, I...
And since I've kept all the attempts by candidates in my interviews, I can start to quantify this stuff too.
In this talk, I'll start by giving an overview of the task and how we use it as a foundation for our technical interviewing. I'll then move on to the common approaches and pitfalls, before demonstrating some of the ways we can turn it up to 11. Throughout this talk, I'll explain why each of these things makes FizzBuzz an invaluably rich tool for the interviewer.
Think you know FizzBuzz? Think again.
Azure Cosmos DB is Microsoft’s premier NoSQL Cloud-based globally distributed database offering, providing scalable performance and resiliency, customizable consistency guarantees, multiple data models APIs, and comprehensive service level agreements.
In this session, we will explain how to get started in Cosmos DB and demonstrate simple administrative and development operations so you can learn how to go from zero to hero in no time. We will cover many fundamental topics which include: * Cosmos DB APIs * Accounts, Databases, and Containers * Geo-Replication * Partitioning and indexing * Consistency and throughput
Azure Cosmos DB is not just the future for Online-Transaction Processing, it is the present!
There are a number of architectural styles and syntaxes for APIs. Since almost two decades ago, REST API has been the de facto standard and it has been helping companies build their APIs and deliver products that their customers love. However, some companies found that they need another approach to solve some problems they face with their APIs.
This talk tells the story of why GraphQL was invented and what problems it contributed in solving. There’s also another story of how GraphQL was used by another company to solve a completely different problem by incorporating it into different levels of architectural stacks.
Authentication is a challenge at the best of times and running "serverless" adds some new challenges.
In this session, I will share with you how to authenticate your users and keep your application secure. I will illustrate the threats to your system and how to avoid pitfalls. You'll explore some of the options for Azure Functions and considerations for when they might be used.
How do you choose between home-grown, open-source, Azure or third-party authentication systems? You'll learn various ways to implement Authentication for Serverless and how you choose between them.
Some of the greatest innovations have come from failure. For every success we celebrate there are untold attempts, almosts, nice tries and utter failures that we don't hear about. Ask any entrepreneur how many times they tried before they succeeded and the chances are you'll be given a litany of ideas that were 'before their time', 'not ready for the market' or simply 'too disruptive'
But I have a hypotheses which is this. Our best learning comes from the failure, yet we spend miniscule amounts of time talking about these failures. If we want to improve as individuals and as teams we need to discuss failure more often.
In this session we'll explore failure, why we fear it, what happens when teams talk about it more and what you can do to celebrate failure
We know it's useful to split up complex systems. We've seen the benefits of modular deployment of microservices. Dealing with only one piece of code at a time eases our cognitive load. But how do we know where to draw the service boundaries? In complex business domains, it's often difficult to know where to start. When we get our boundaries wrong, the clocks starts ticking. Before long, we hear ourselves say "it would be easier to re-write it".
Join Adam for practical advice on discovering the hidden boundaries in your systems. Help tease out the natural separation of concerns in a sample business domain. During 20 years of developing complex systems, Adam has had plenty of time to get things wrong. Learn to avoid the common pitfalls that can lead us down the path to "the big re-write".
Software development is challenging, and cognitive overload is an enemy of productivity. We [software developers] probably spend more time in our IDE than we'd like to admit. We have the skills and ability to make our own lives better through technology, so why aren't we spending more time making our tools work better for us? In this session I'll talk about some of the ways we're making our own lives better through better tooling.
Just as adversity and overcoming shared problems tests and strengthens friendships, so can errors become crucial to your software's relationship with its users. Users might feel let down or helpless in the face of bad error messages. But what makes a good error message? We'll look at the three things users want from an error message, some examples of what happens if you miss out one or more, and put them together to make users feel good about errors.
Between 2010 and 2014 the tech industry had a huge adoption of Mobile Technology. Companies all over the world were investing heavily within this mobile industry.
During this time Facebook invested in delivering HTML5 experiences on mobile to customers and later hugely regretted it. Mark Zuckerberg even says that this is the biggest mistake the company has ever made. Facebook then went onto creating in house mobile development teams, but soon realised that the API's that were designed for the web could not scale with their new mobile platform.
On February 29th 2012 an internal idea was born at Facebook called "SuperGraph". "SuperGraph" was designed to help development teams move faster and increase the flexibility of their current APIs. A small team got together and released its first version into production 4 months later.
In 2015 Facebook open sourced this new technology as "GraphQL".
In this talk, we will take a dive into GraphQL and try to understand why so many companies are adopting it. We will look at what problems it is trying to solve, the fundamentals of the language and how you can get started today.
Walking away from this talk I'm confident that you will gain an understanding of GraphQL and hopefully inspire you to continue to explore GraphQL in the future.
Good logging practise is not very common. People mostly focus on writing business rules, testable code and great architecture designs. But they forget about keeping control over the application and proper logging. Especially when something blows out on production. The thing is to have good logging habits since very first line of the program. Not when it’s too late and one has to do “post mortem” investigation what went wrong. In my talk I will tell how to use loggers wisely, what to focus on, how to log efficiently and safely for you application, how to cope with masses of information, even in distributed environment.
Please join my presentation.
I don't know about you, but I'm a lazy developer. What do I mean by lazy? I don't mean I don't want to do my work - far from it - I mean that I hate to write out a great deal of code to get the job done. I want to accomplish my goals with as little effort as possible.
One of my pet hates is writing enhancements that involve copying and pasting blocks of code, changing a variable name, then leaving everything else the same. I hate having to consider each and every possible null reference exception, and adding in a whole ton of boilerplate to handle it. I hate having to spent ages jumping back and forth in a legacy codebase, trying to understand what it actually does!
What's the alternative? In this talk, I'll demonstrate a way of working that avoids all this unneccesary work, and gives you more time to do something more productive.
We'll look at:
Functional Programming - what benefits does this increasingly popular paradigm bring us to cut down coding effort
Linq & Generics - These have been a part of C# for a long time now, and are some of the most powerful features available in the language, but hardly anyone seems to be using them effectively
MetaProgramming - break open C# and take it to the next level with code that describes how to generate code
Our goal is to write code in as few lines as possible that provides the greatest amount of impact. We also want code that's readable, and easily maintainable. We want to think smart, and think...Lazy.
Why your cloud architecture might kill your software.
In this talk, we discuss what cloud native really means for your software - and more specifically why ignorant use of excellent technology can actually damage your application, rather than help it. We'll discuss some excellent features of the Azure platform, but also dive deep into the things that will definitely go wrong when you use them thoughtlessly - along with exploring some battle tested, cloud native patterns for avoiding certain disaster.
Progressive Web Apps (PWAs) enhance web applications and make them ready for the future. In this session we dive into the world of PWAs, looking at different caching strategies to boost performances and to increase users re-engagement. We will then bring those features to a next level with Cloud Firestore, showing how it is possible to provide our users a "never offline" experience by combining those technologies.
With the multitude of isolation levels, concurrency models, and specialist technologies available in SQL Server, it is no surprise that transaction throughput and correctness can be directly correlated to the ability and knowledge of the person that wrote the code.
In this session, we will reveal how SQL Server concurrency and correctness often goes wrong, how we can avoid this, and how we can use our knowledge to design and develop for optimal server throughput for our applications and processes using tips and tricks gained from real-world scenarios.
We will cover SQL Server’s traditional locking model, In-Memory OLTP, Columnstore, Delayed Durability, and many other technologies and techniques you can use to make your transactions more robust.
It doesn't matter what language you use, what platform you code on, or what editor you prefer; there's one underlying thread common to all code: people. It's also the hardest part of coding. Unless you're a team of one, writing code only you are going to use, people are always going to enter into the equation. So lets bypass the fancy algorithms, forget about the methodologies, and look at how we deal with the people aspect of code. The people we work with. The people we're coding for. The people who were here before us. And the people that will come after us. And maybe, just maybe, we'll come out of it better developers.
C# has a reputation as an enterprise language, but there’s an entire other industry of developers using C# to build videogames, virtual reality and even films. Unity is a massively popular platform that runs on mobile devices, desktops and consoles, providing an engine for graphics, physics and audio, used by the videogame industry and movies, and even manufacturing and sales. And the scripting logic is all powered by C# and Mono. Hey, I know C#. Fancy building a game?
In this session, let’s take a beginner’s look at how Unity works, from the ground up. We’ll see how to use the building blocks of game objects and physics, and how C# can add animation, logic and interactive to your game.
Looking for a new hobby project?
Cognitive Services are giving a lot of APIs that you can easily use with your application. But did you wonder how Microsoft comes to the data that help you to recognise object, faces and emotions? Come to this session if you would like to learn more about Machine Learning theories and see examples of Computer Vision APIs provided by Azure AI.
We know how to write code to do something now. What about code to do something tomorrow, or next year? Sometimes we use batch jobs. But as business grows, our "overnight" batch job starts finishing around lunch time. As we expand to new regions, we realise there is no "night". And it's only a matter of time before we make a change and break a batch job we forgot existed. What if tomorrow's code could live in the same place as today's code? What if it all looked the same? What if we could scale it all the same way?
Join me and discover how to embrace the future in the code we write now. Learn how to capture requirements as first class business logic, and avoid relegating them as second class citizens of the batch job world. Take a deep dive into techniques which combine off the shelf products with fundamental computer science.
Where we're going... we don't need batch jobs.
Skills for sharing knowledge are something that you are expected to pick up as you progress in your career, without much or any formal training. I want to share knowledge with you from my experience as a teacher and as a programmer. I will answer these and other questions around this important, but often overlooked part of being a software engineer.
I will help you make yourself understood. I will reduce that awkwardness when you can't make yourself understood, and just don't know what else to do.
I hope this will be an informative and entertaining interactive talk.
The Go programming language is a statically typed, compiled programming language designed at Google that was released in 2009. It grew quickly in popularity - holding a top 5 position in the most loved programming languages in the Stack Overflow developer survey for 5 consecutive years, and in 2018 was the fastest growing language on GitHub.
Much of Go's popularity can easily be attributed to it's clear and concise syntax, simple concurrency model, strong built-in tooling, and its ability to be easily compiled into a single statically linked binary. However, to me Go's greatest strength is its robust, "batteries included" standard library, which allows developers to rapidly build production ready applications with little to no external dependencies.
In this talk I will provide a brief overview of the Go programming language, and demonstrate how Go can be utilised to rapidly build production ready APIs with just the standard library - HTTP(S) server and all. Finally I will provide a brief demo of a simple API workflow, and talk about some small libraries and tools that can be used to improve the development process and general quality of life.
When I was young and took my CS classes I learned about ACID and it seemed sound and reasonable. Then I went to work and learned that it could mean different things (especially isolation…) for different database vendors… Around 2009 I’ve heard about CAP theorem - that was also sound and quite reasonable in the brave, new distributed world. And then one after another - NoSQL vendors started to claim they’ve beaten CAP theorem (* as they understand it of course…) And recently it got even more complex - stream processing engine have their notion of transactions - atomicity, isolation and so on.
In this talk I will try to make something out of this mess - we’ll look at some of definitions and try to figure out which use case require particular kind of isolation or transactionality. Of course some of it will be based on my own experience - including quite a lot of blood, sweat and tears ;)
In this demonstration-heavy session, we illustrate our latest techniques, tools, and libraries for developing a .NET application on AWS. From within Visual Studio, we will look at three different ways to run your .NET applications and show you how to integrate with various AWS services, including Logging, Managed SQL Server and Machine Learning Models. We will cover ways to build and run serverless and containerised applications as well as show you how you can move legacy.net apps to the cloud.
Your bot is doing well, but what if you add some more intelligence to it such as speaking? Or speaking and translating at the same time? Isn't this be great for your clients or your employees? Come and see how to add Microsoft Speech API to your bot and what to add more to find your business requirements for speaking and translating bot!
Crochet and other yarn crafts can be viewed as a form of “programming in the wild”. Without realising it, crocheters interpret their own patterns, thus becoming “computers”. This talk explores the analogies between a crafty — analogue — discipline and what we, as developers, know of programming.
It covers several notions that can be illustrated with crochet, such as: crochet patterns as programming instructions, language versioning, humans as computers/compilers, debugging, multithreading (quite literally). It also ties the discipline back to the origins of computing, and the inspiration behind Babbage’s Analytical Engine. Finally, we look at how crafts and programming can be intertwined, and create new ways to make analog and digital work together.
This talk is designed for a varied audience (new to programming or experienced), as it offers a new angle on the discipline and is language agnostic.
Did you know there are 7 meetups in Europe in 1 week? How many are there in the world? What is the longest held meetup? On what day programmers meet? How many talks are there in the month?
PHP community is bigger and active then you think. Come and numbers form world meetup analysis!
Many times when debugging the F10 and F11 keys get worked overtime, and maybe the occasional breakpoint. However Visual Studio has many functions to help with debugging. In this talk I will go through the debugging features from basic breakpoints to thread and processes windows, showing how these can be used to speed up the beginning, by getting quickly to the problem code. My talk will include:-
Breaking on exceptions
Breakpoints and tracepoints
Debugging multithread/parallel applications
Customising debugging information
Functional Programming (FP) has a reputation for being both difficult to learn and only useful in highly mathematical domains. In this session I will show you just how wrong that opinion is! If you use FP, your code will have fewer bugs, be easier to reason about, take less time to write and you'll be able to re-use more of it.
Want to use React at your company but feel too invested in old tech? Then fear not this talk is for you.
We take a look at how React has transformed the way comparethemarket.com does comparison. Serving millions of customers a year, we explore why it’s not too late to start re-thinking the wheel.
During this talk we are going to cover how we completely reinvented our tech stack to harness the power of React. How we use it to allow our teams to develop at scale and with confidence. While also giving you a heads up on what you should be looking out for and how you can best prepare your teams for success.
So come along, sit back and let’s discuss how React has changed the landscape, one component at a time...
Here’s a few reviews from previous audience members: **
“A talk not to be missed..." (Dan Abramov)
“Simply spellbinding” (Rory Cellan-Jones - BBC technology correspondent)
“Another sensational talk, leaves you wanting to go away and write more components” (Kyle Matthews - Founder of Gatsby.js)
** I have 100% just made all these up, please don’t @ me. 💃
So, you've heard of the amazing things you can do with Internet of Things devices, and can't live without an internet-enabled toaster that toasts today's weather forecast on one side and the news headlines on the other. Good for you! But...like Jeff Goldlum said in Jurassic Park, could it be we were too busy asking whether we could, to consider whether or not we should!
What are the consequences of allowing an IoT device unfettered access to your home network? Would you be surprised to hear that they could extend from stealing the data in your laptop, all the way to threatening the very infrastructure of the internet itself! This is no conspiracy theory either - it has already happened, and most likely will again.
Naturally, we don't want to have to abandon our IoT toaster out of sheer panic, we want to know what we can do to still have our weather-patterned bread and be safe.
This talk will look into the threats that exist our there to you - the home IoT user, and what steps you can do to mitigate them. We'll be covering simple steps that nearly anyone can implement, as well as briefly looking at some of the more advanced steps for experts.
Today's mission-critical applications demand support for millions of interactions with end-users. Traditional databases were built for thousands.
Couchbase Server is an open source, distributed, NoSQL document-oriented database. It exposes a fast key-value store with managed cache for sub-millisecond data operations, purpose-built indexers for fast queries and a powerful query engine for executing SQL-like queries.
In this talk, we develop a small microservice using a very productive combination: Couchbase, Spring Boot and Spring Data. We also will deploy both your application and database on Kubernetes, to show how you can build truly elastic microservices.
This talk is not about Cosmos DB. Well, actually, maybe it is a little bit. But it's really a case study of tricky problem-solving.
Come on an adventure with me, as I recount our efforts to tame an out-of-control database. Then, stroke your chin with me (I'll stroke my own) as I reflect on what we should have done differently, the factors that lead us down the paths we explored, and the lessons we can generalise from the experience.
Our Cosmos DB instance was struggling to keep up with our fast-growing user-base. Despite the rapid scaling, it should really have coped. "What's going on?" we asked each other. Over the course of several weeks, we tried several approaches, but the problem got steadily worse. Some of the things we tried were quite interesting, but they had varying levels of success. The eventual solution was infuriatingly simple, so why did it take us so long to work it out?
This talk will cover some real-world techniques for tuning and optimising Cosmos DB but will focus on the process of solving complicated operational problems with new (i.e. "under-tooled") technologies.
Throughout your career you have seen this, people with similar qualifications where success seems to come easily to one person whilst the other struggles up the career ladder. What makes some people "get along with everyone" whilst some of us struggle to make positive connections? Research has shown that besides IQ and personality, emotional Intelligence (EI) is the missing piece in trying to understand why where all things being equal some people have it easier than others.
Is it true that as far as emotional intelligence is concerned, you either have it or you don’t?
Not true, you can rewire your brain and supercharge your emotional intelligence levels, unlike IQ, which is constant from birth and cannot be changed, EI can be massively improved. In this session I will talk through what EI is and look at how you can improve your emotional intelligence and get over those invisible barriers to success in your relationships with people around you whether it’s at work, home or other areas in your life. I will focus on four components of emotional intelligence and give you some ideas on how to improve in these.
A lot of research has gone into the area of Emotional Intelligence in recent years but still a lot of people still do not realise how it can improve a big part of their everyday lives. Improving your EI will serve you well in your career, personal life and is applicable in a whole range of situations we find ourselves in each day. Come along for this session and learn a few things about how you can be smarter about your emotions.
Nowadays AI is all the hype, but what many might not know is that AI is an established discipline originating from a workshop in the 1950s. This talk will describe the historical milestones of AI from that workshop up until present days. In addition we will get an understanding of what the future of AI might have in store.
Initially we will investigate what happened at the workshop in the 1950s. Then we’ll be reviewing a number of areas where AI initially was put to use between 1950-1970. We’ll cover the AI winter in the coming decades.
In the second part of the talk we’ll cover applications and milestones from the 1990’s and onwards. Finally we’ll look into the crystal ball to see where AI will takes us in the future.
In this session, I'll introduce gRPC, a modern high-performance RPC framework for inter-service communication. We'll look at how gRPC stacks up against existing REST-based communication and explore the benefits this technology has to offer. gRPC uses HTTP/2 as its transport protocol and ProtoBuf encoded content for efficient, fast communication.
You'll see C# examples of how to build client and server gRPC components using ASP.NET Core 3.0, using the blazingly fast Kestrel web server. You'll learn how to define your proto3 service definition (contract) and integrate with MSBuild tooling to code gen the server and client components you'll need. You'll be amazed at how quickly a service can be created with little effort or boilerplate code required. You'll also see how additional clients can easily be generated for other languages such as Node.js to make connecting polyglot systems a breeze.
It's a great time to begin taking notice of gRPC as a worthy contender to take over from REST for inter-service communication in microservice-based environments. It's time we started to let service talk their own language!
Not all of you have very modern technologies in you project. In fact, sometimes you have very old language and/or libraries. Not all of you have mythical 20% spare time for experimenting. Not all of you have open-minded management that allows you to gather and have some internal workshops or spare time on research.
But there are various ways to learn new stuff even if you don’t have time or money available at your work or in your pocket.
I invite you to a story about things you can do as a developer to improve yourself and/or your team. It will be about workshops, hackathons, code review, writing blogs, doing open source, speaking at meetups and conferences and lot more. I did all of that and I want to share my wide experience with lots of advice how to do it right.
Some of them are expensive but most is quite cheap.
The purpose of that is to learn new things, experiment with technologies, advance and have fun. Without that we could have only our day to day tasks which can be boring or frustrating. I will share with you my wide experience with lots of advice how to do it right.
I will present algebraic data types idea on F# example with C# comparison. I will try to explain: why as functional programmers you won’t fall in the trap of breaking Liskov substitution principle? How to transform your problem into a nice language using algebraic data types.
Have you ever consider why functional programming makes things simpler? We tend to break problems to smaller chunks, but never think how to combine them back into the working mechanism. And this is what functional programming is about and give us this magic glue element. In this talk, I will focus on types. I will present:
The world of open source software has never been more exciting than it is right now. Communities spanning all platforms are thriving and more inclusive than ever. Even Microsoft have transformed their strategy, becoming the "number one" GitHub organisation. Why the big change? What's wrong with the "old" way of doing things?
In November 2014, I became the first community member to have a pull request accepted for .NET Core. With my 15 minutes of fame now over, I'd like to reflect on the journey that took me there. How did 'that Czechoslovakian guy' go from a curious OSS onlooker to a passionate OSS advocate?
We'll discover what OSS is, why it works and how easy it is to get involved. OSS is not only about coding and there are plenty of other ways to contribute. Even if you're not a coder, this talk is still for you.
React helps encapsulate Front End tech into components, but how do you go about sharing those components across your organisation - for everyone to use, as easily as they would open-source components? In this talk I’m going to speak about how we build and share our React component library internally at ComparetheMarket, the tools we use to assist us, and how we make it worth the effort.
Chatbots are commonly used in a wide range of user scenarios such as ordering pizzas, product suggestions, schedule meetings or customer support. But how can we as developers make our own chatbot?
In this session I will demonstrate how you can make a chatbot by using the Microsoft Bot Framework together with LUIS (Language Understanding Intelligent Services). The chatbot will be multi-lingual meaning it will adapt in real-time according to the user’s language (i.e. switching from English->Spanish->Norwegian).
Finally we will integrate our chatbot in a web application and demonstrate how we can use this in a realistic scenario.
This presentation will be code centric with the majority of time spent in Visual Studio and the Cognitive Services portal.
As engineers we often worry that we're imposters and our successes are freak accidents. Many of us don't feel we can contribute to open source as we feel we have nothing to provide to the wider community or that our skills aren't up to par.
I felt the same until I ended up being the maintainer of a project and falling down the rabbit hole, improving my skills in the process and learning a lot.
Using myself as an example I'll explain how I got involved, the mistakes that I made to help you avoid and some resources you can use to get you started.
Most PHP frameworks have own config language - YAML, INI, NEON etc. and they suggest you to use it to configure services, decorate them or create them.
services: App\Mailer: arguments: ["@=service('App\\\\Mail\\\\MailerConfiguration').getMailerMethod()"]
It's nice but it - remove static analysis, unteaches you coding in PHP, disables refactoring from PHPStorm and Rector and is harder to re-use.
How to do it the right, clear way that has all these benefits without losing the power of your favorite framework?
Come to my talk and I'll show you
Legacy code is present of any successful company. The longer your live and profit, the older your code is.
How to get out of this? You can rewrite (don't do that!) or refactor manual (don't do that either!). It's 2019 and there is a tool for that now - Rector.
I help companies to refactor their huge legacy code in a couple of weeks. You can also switch frameworks, from PHP 5.3 to PHP 7.4, from Laravel to Symfony... the sky is the limit :)
I will show you how you can make your legacy code shine again!