Dasith Wijesiriwardena

Information & Communications Technology

Software Design Software Development Software Architecture .net core Event Sourcing Domain Driven Design

Melbourne, Victoria, Australia

Dasith Wijesiriwardena

Lead Consultant - Telstra Purple (Formally Readify)

Dasith is a solutions architect, full stack .NET developer with distributed systems focus, keen problem solver and an improving cricketer. He's got close to 2 decades of experience designing and building software solutions and loves all things technology. After leading the development of an ERP solution for the construction industry and working on trade printing software for a while he now works as a consultant for Telstra Purple (Readify) working with clients of all sizes. As a consultant over the last few years he's worked on a broad technology stack which consists of all things from Serverless to IoT. He is a recovering competitive fps gamer who still talks about things like mouse sensitivity and ping over a frothy beverage.

Current sessions

Behaviour Driven Development With SpecFlow and Selenium

Behaviour Driven Development’s appeal and benefits are legion. To get the most out of the approach you need the proper tooling. I will explore how you can use SpecFlow and Selenium to test your system end to end while not losing focus of business requirements throughout. You will see how much value this can add to your software development practice and why many people use this combo. I will touch on the benefits of BDD and dive into some code samples to showcase the workflow during the presentation.

First delivery @ SeleniumDay 2018 - https://1point21gws.com/selenium/melbourne


Event Sourcing, from ancient Mesopotamia to modern software

Patterns are all around us, and in software, the design patterns we choose can give us the power of the ancient kings and queens. Event Sourcing is based on the idea that storing events as they happen is better than storing the current state. Imagine having the power to rewind and replay events, to debug, to generate reporting, to go back to ancient history...

We’ll get up close and personal with Command Query Responsibility Segregation (CQRS), which gives us the bonus of scalability out of the box, we’ll be designing and architecting applications at scale, just like the grand cities of the past, in no time at all!

First Delivery @ LevelsConf2018- https://www.levelsconf.com/


Modern Authentication 101

There has never been more emphasis in security than in the modern environment of distributed computing and increased sharing of data. Our data does not sit inside silos consumed by one application anymore. In this context the modern distributed applications need to securely access protected resources without having to share passwords. We need scalable solutions that work with things like single page applications. We will dive in and explore terms like `OAuth`, `OpenIdConnect` and `JWT` and how they relate to authentication and authorisation. This presentation hopes to give you a good understanding of what, where and how to get started with the modern approaches to authentication.

In my experience most software developers don't have a good understanding of why protocols like OAuth and OpenIdConnect exist. What type of problems they solve and what flow to pick to solve their problems. Most of all they lack the knowledge of the compromises they make when they choose a authentication flow. Because these authentication flows are abstracted away in most implementations, the novice developers don't get exposed to the nuts and bolts. There are more and more compromises that happen because someone doesn't follow the security best practice or pick the wrong tool for the job. My motivation is to transfer some of my knowledge to young developers so they make an informed choice when the opportunity presents itself.


The Shell Game Called Eventual Consistency

As we build distributed highly scalable systems the central data store and transactions are no longer a safety net we can afford. In the world of event sourcing and CQRS (Command Query Responsibility Segregation) we need to design clever systems that don't show cracks and seams where eventual consistency is at play. We will tackle those unpleasant invariants and race conditions head on to investigate some technical and non technical smoke and mirror solutions that we can use to deliver a positive experience to end-users while finding the performance sweetspot.

We are utilizing the various PaaS/Serverless solutions to build more and more distributed systems. Often these systems need to work together to produce a result. When performance and scalability is of high priority, consistency (CAP theorem) takes a back seat. We still need to find ways to shelter the end-user from these design realities. The aim of this talk is to find ways of doing it. Be it through changing the business process or by doing clever tricks on the front end while giving the backend has a heartbeat to catch up. There are countless ways to do it. My goal is to investigate a few of them and get the conversations happening.


A game of snake and ladders called Microservices

Microservices aren’t new but the last few years have certainly seen a lot of successful implementations of the pattern. The promise of high scalability has attracted engineering teams to it like moths to a flame. There are plethora of benefits but they are accompanied by an ever growing set of technical and nontechnical pitfalls. As the shininess of microservices gradually decline, there are important lessons to learn from our scars. We will look at why microservices implementation fail, How to avoid the pitfalls and most importantly whether you need to ditch your trusty monolith after all.


Not all “Microservices frameworks” are made the same

Developing a distributed system is hard. Understanding the domain is harder. Therefore it makes sense not to reinvent the wheel and use ready made solutions to help build your microservices right? or does it? Turns out the there is a lot to consider here. We will look at how to leverage the right tools to help you achieve a good outcome and a sustainable growth path. We will also explore strategies to not get locked in “frameworks” that only give you short term wins. We will see how our choices can have a long lasting impact and what to consider when making them.

Many developers make the mistake to locking themselves into frameworks that give them an easy win upfront. But as the software solution evolves you end up developing around the quirks of the framework rather than let the domain dictate the architecture. This eventually leads to un sustainable systems that make the domain harder to understand and reason with, making feature development painfully slow. I want to discuss ways to avoid this by picking "frameworks" that don't dictate how you solve business problems as oppose to being a tool or a layer which operates under the domain. Further I'll touch on the bad aspects of vendor lock-in and how to pick the tools that gives you the freedom to run on any cloud vendor.


Building distributed systems on the shoulders of giants

Developing a distributed system is one of the hardest things you will do as a software developer. You will end up having to deal with topics like network inconsistencies, load balancing and service discovery etc. Only to find that solving these problems require expert level knowledge. What if I told you there was a way to leverage the expertise of industry leaders like Google/Microsoft and benefit from their research so you don’t have to reinvent the wheel? Let’s investigate some tools you can use today to build modern, resilient and scalable microservices. Technologies like Service Fabric, Knative, Istio and DAPR can give you the right foundation to build on top of so you can concentrate on solving the business domain problems and be productive.

Developing a distributed system requires expert knowledge that not every mortal software developer has. This results in most Microservices failing in production scenarios under load or intermittent network conditions. There is a better way than expecting every developer to do these complex calculations. We can leverage the knowledge from experts by using some modern distributed applications runtimes and tools that give us a good foundation. (Standing on the shoulders of giants) This frees us to focus on the domain and solve it better. In this talk I want to introduce (compare and contrast) developers to some of these choices.


Using Dapr and Tye to accelerate your your distributed systems journey

Building a distributed systems or microservices are on of the hardest things you will do as a software developer. Specially if you want to do them properly. Dealing with non trivial concerns like service discovery, tracing and fault tolerance can be tough for smaller teams to solve by themselves. Even if you do, the long term maintainability of it requires significant investment. With Kubernetes being the platform of choice for deploying modern containerised workloads, the ability to debug and test these applications locally is becoming more of a challenge. Lets see how we can leverage Tye and Dapr to accelerate this process. This talk aims to introduce you to the building blocks of Dapr, how you can use them to build your microservices and then use Tye to run them in your development machine with minimal setup. We will look at sample code to better understand what Dapr offers and how you can utilise the Dapr building blocks to compose a well rounded distributed solution. You will see how Tye can be used to orchestrate your dependent microservices and get a "fake but real" kubernetes experience on your local machine with just enough to validate, test and debug your services.

Most development teams today have at least a few distributed pieces of they software solution. Not all teams have experience to deal with the fallacies of distributed computing. As a result many systems they build are very brittle. Using Dapr, they can leverage the industry best practices and knowledge to compose their solutions based on building blocks. This still doesn't solve the challenge of easily running and testing them locally. This is where Tye comes in. I want to show the capabilities of these two exciting projects from Microsoft and get more development teams engaged.


Past and future events

NDC Sydney 2020

11 Oct 2020 - 15 Oct 2020
Sydney, New South Wales, Australia

API Days 2020

Apidays is about the opportunities and technologies enabled by the programmable economy. As APIs become mainstream, our world becomes more connected, more automated and more intelligent. APIs are the gateway to data, services, devices and emerging technologies. APIs put power into the hands of developers, citizens and consumers.

Learn from the best about Business Models, Design & Documentation, Lifecycle Management, Security & Identity Management, Testing & Monitoring, Banking APIs and Open Banking, Developer Marketing, Digital Transformation, GraphQL, Microservice Architecture, Mobile & IoT APIs
15 Sep 2020 - 16 Sep 2020
Melbourne, Victoria, Australia

DDD Adelaide 2019

22 Nov 2019
Adelaide, South Australia, Australia

Platform Engineers Meetup

Technology platforms let us solve cool and wicked problems while standing on the shoulders of others. This meetup is for those Platform Engineers that love to design, discuss, probe and evangelise the platform technologies and scaled approaches that have helped them make a difference.

This meetup will cover a huge breadth of technology, by doers and for doers, so that we may all learn from each other.
17 Nov 2019
Melbourne, Victoria, Australia

API Days 2019

APIdays is the leading industry tech and business series of conferences in APIs and the programmable economy. As APIs become mainstream, our world becomes more connected, more automated and more intelligent. APIs are the gateway to data, services, devices and emerging technologies. APIs put power into the hands of developers, citizens and consumers.
19 Sep 2019 - 20 Sep 2019
Melbourne, Victoria, Australia

Microservices, Containers & Serverless Day 2019

The Microservices, Containers & Serverless day is a forum for the discussion of all aspects of Microservices, Containers & Serverless : their design, programming, and operations. Speakers from industry report success stories, best practices, current challenges, and will participate to discussion panels on the adoption and evolution of Microservices, Containers & Serverless.
6 Sep 2019
Melbourne, Victoria, Australia

DDD Melbourne 2019

9 Aug 2019
Melbourne, Victoria, Australia

Readify Back2Base

Quarterly consultant get together for Readify victoria
15 Feb 2019
Melbourne, Victoria, Australia

Selenium Day 2018

Enthusiasts exchanging ideas on advancing the present and future of Selenium.
1 Feb 2019
Melbourne, Victoria, Australia

LevelsConf 2018

Australia's first conference crafted for building technical careers, from the very beginning.
7 Jul 2018
Melbourne, Victoria, Australia