On Agile teams, collaboration is the way of life. Our leaders want their team members to work closely with each other, have shared goals and even think as one entity. Why? Because we believe that collaboration leads to happier, more productive teams that can build innovative products/services.

It's strange that companies use the word collaboration very tightly with innovation. Collaboration is based on consensus building, which rarely leads to visionary or revolutionary products/services. Innovative/disruptive concepts require people to independently test out divergent ideas without getting caught up in collaborative boardroom meetings.

In this presentation, Naresh Jain explores the scary, unspoken side of collaboration and explains in what context, collaboration can be extremely important; and when it can get in the way or be a total waste of time.

Through the conference, we would have heard different speaker's perspective and experience with Data Science and AI. In this closing panel, we want to step back and look at any unanswered questions that the audience would have.

This talk will help you understand the vision behind ODSC Conference and how it has grown over the years.

Looking to move to Continuous Delivery? Worried about the quality of your the code? Helping your developers understand clean-code practices and getting the right testing strategy in place can take a while. What should you do to control the quality of the incoming code till then? This talk shares our experience of using PRRiskAdvisor to gradually educate and influence developers to write better code and also help the code reviewer to be more effective at their reviews.

Every time a developer raises a pull-request, PRRiskAdvisor analyzes the files that were changed and publishes a report on the pull request itself with the overall risk associated with this pull request and also risk associated with each file. It also runs static code analysis using SonarQube and publishes the configured violations as comments on the pull request. This way the reviewer just has to look at the pull request to get a decent idea of what it means to review this pull request. If there are too many violations, then PRRiskAdvisor can also automatically reject the pull request.

By doing this, we saw our developers starting paying more attention to clean code practices and hence the overall quality of the incoming code improved, while we worked on putting the right engineering practices and testing strategy in place.

Looking to move to Continuous Delivery? Worried about the quality of your the code? Helping your developers understand clean-code practices and getting the right testing strategy in place can take a while. What should you do to control the quality of the incoming code till then? This talk shares our experience of using PRRiskAdvisor to gradually educate and influence developers to write better code and also help the code reviewer to be more effective at their reviews.

Every time a developer raises a pull-request, PRRiskAdvisor analyzes the files that were changed and publishes a report on the pull request itself with the overall risk associated with this pull request and also risk associated with each file. It also runs static code analysis using SonarQube and publishes the configured violations as comments on the pull request. This way the reviewer just has to look at the pull request to get a decent idea of what it means to review this pull request. If there are too many violations, then PRRiskAdvisor can also automatically reject the pull request.

By doing this, we saw our developers starting paying more attention to clean code practices and hence the overall quality of the incoming code improved, while we worked on putting the right engineering practices and testing strategy in place.

By working with some of the most successful tech-product companies, I realised that code is NOT an asset, it's a liability. We should strive hard to minimise code. In 2011, when I started to hack on ConfEngine, I questioned my belief in TDD. I had also started playing around with APL style Array-Programming and Functional Programming. I felt, may be, I was getting a bit too dogmatic about TDD and automated tests in-general. As a thought experiment, I decided to build ConfEngine without ANY automated test. At first, it was really scary not to have the safety-net of automated test (something I took for granted for almost a decade.)

As I scaled ConfEngine without any automated tests, I had certain interesting realisations:

• How to embrace Simplicity and Minimalism WITHOUT automated tests
• Why Throwing Away Code frequently helps you achieve a better decoupled-design and how this helps in better experimentation
• Fear of Refactoring WITHOUT Tests is over-rated (Good IDE and safe-refactoring techniques can take you a long way)

ConfEngine grew from a pet-project to a 8 member product team. It has over 60K users and has done financial transactions worth over half-million USD. And we continue to push forward without ANY automated tests. Its not perfect, but it has certainly helped me challenge my dogma around TDD.

Background: In 2001, I stumbled upon the Test Infected paper. For the next 2 years, I struggled to really apply the test-first concept on real projects. Finally in 2003, I felt that I had fully internalised TDD and was able to apply on almost all projects. Then I started playing around with FIT and FitNesse, using ATDD on some of the projects. In 2006 I published "Avatars of TDD" paper in which I explained various styles of TDD and its design implications. Until 2011, I was a very big advocate of TDD, ATDD and BDD. I still like those practices, however I would not recommend it in all projects.

By working with some of the most successful tech-product companies, I realised that code is NOT an asset, it's a liability. We should strive hard to minimise code. In 2011, when I started to hack on ConfEngine, I questioned my belief in TDD. I had also started playing around with APL style Array-Programming and Functional Programming. I felt, may be, I was getting a bit too dogmatic about TDD and automated tests in-general. As a thought experiment, I decided to build ConfEngine without ANY automated test. At first, it was really scary not to have the safety-net of automated test (something I took for granted for almost a decade.)

As I scaled ConfEngine without any automated tests, I had certain interesting realisations:

• How to embrace Simplicity and Minimalism WITHOUT automated tests
• Why Throwing Away Code frequently helps you achieve a better decoupled-design and how this helps in better experimentation
• Fear of Refactoring WITHOUT Tests is over-rated (Good IDE and safe-refactoring techniques can take you a long way)

ConfEngine grew from a pet-project to a 8 member product team. It has over 60K users and has done financial transactions worth over half-million USD. And we continue to push forward without ANY automated tests. Its not perfect, but it has certainly helped me challenge my dogma around TDD.

Background: In 2001, I stumbled upon the Test Infected paper. For the next 2 years, I struggled to really apply the test-first concept on real projects. Finally in 2003, I felt that I had fully internalised TDD and was able to apply on almost all projects. Then I started playing around with FIT and FitNesse, using ATDD on some of the projects. In 2006 I published "Avatars of TDD" paper in which I explained various styles of TDD and its design implications. Until 2011, I was a very big advocate of TDD, ATDD and BDD. I still like those practices, however I would not recommend it in all projects.

A resilient organizational can not only adapt and respond to incremental change but more importantly, can respond to sudden disruptions and also, be the source of disruption in order to prosper and flourish.

The traditional risk management approach focuses too much on defensive (stopping bad things happen) thinking versus a more progressive (making good things happen) thinking. Being defensive requires consistency across the organization and this is where methodologies like Plan-Do-Check-Act (PDCA) come in. However, PDCA approach does not bake in the required progressive thinking and flexibility required for a fast company organization which operates in a volatile environment.

Professor David Denyer of Cranfield University has recently published a very interesting research report on Organizational Resilience. He has identified the following four quadrants across to help us think about organizational resilience:

• preventative control (defensive consistency)
• mindful action (defensive flexibility)
• performance optimization (progressive consistency)
• adaptive innovation (progressive flexibility)

In this talk, I'll share my personal experience of using this thinking to help an organization to scale their product to Millions of users. I've dive deep into how we structured our organization for Structural Agility and how we set-up a very lightweight governance model using OKRs to drive the necessary flexible and progressive thinking.

A resilient organizational can not only adapt and respond to incremental change but more importantly, can respond to sudden disruptions and also, be the source of disruption in order to prosper and flourish.

The traditional risk management approach focuses too much on defensive (stopping bad things happen) thinking versus a more progressive (making good things happen) thinking. Being defensive requires consistency across the organization and this is where methodologies like Plan-Do-Check-Act (PDCA) come in. However, PDCA approach does not bake in the required progressive thinking and flexibility required for a fast company organization which operates in a volatile environment.

Professor David Denyer of Cranfield University has recently published a very interesting research report on Organizational Resilience. He has identified the following four quadrants across to help us think about organizational resilience:

• preventative control (defensive consistency)
• mindful action (defensive flexibility)
• performance optimization (progressive consistency)
• adaptive innovation (progressive flexibility)

In this talk, I'll share my personal experience of using this thinking to help an organization to scale their product to Millions of users. I've dive deep into how we structured our organization for Structural Agility and how we set-up a very lightweight governance model using OKRs to drive the necessary flexible and progressive thinking.

All transformations have to start from within. This session was an attempt to create awareness on Diversity and Inclusion.

"Shipping is not success; let it sail" has been my mantra. Many organizations fall into the trap of project-based thinking and for them launching a product/service is success. We should step back and ask, "by launching this product/service, has it created any value (economic or otherwise) for the business and/or customers?" If the answer is no/not-sure, then it's premature to celebrate. Organizations want to achieve certain goals, expressed via measurable outcomes. Unless we see quantitative progress on those outcomes, our job is not done.

In this session, Naresh will share his experience helping organizations shift from project/output based thinking to product/outcome-based thinking. Not just at one team level, but at the entire organization level. Once we have the thinking in place, then how do we create a governance model which brings transparency and encourages collective ownership.

With Functions as a Service (FaaS), the smallest billable unit of computation is a single function execution. It's a beautifully simple idea, rejecting the metaphor of a server, and freeing developers to design smaller and simpler services. We can iterate on our code with a high degree of isolation, without fear of affecting other parts of the system; deploy systems in seconds with zero downtime, and always be available regardless of load.

However, building serverless apps is relatively new and filled with complexity:

• Configuration tooling was designed for the last generation of computing metaphors (and often lags behind the releases of new functionality)
• AWS is massive and overwhelming with many similar, but not the same, products
• The web console is confusing, with divergent interfaces between interlocking services
• Deep proprietary knowledge is required to configure and maintain common infrastructure primitives

In this talk, Naresh will walk you through a new approach to architecting applications with plain text using arc.codes to create apps in minutes and subsequently deploy in seconds with zero downtime and unprecedented availability.

This talk is an inspiration from Brian LeRoux's presentation Architecture as Text: Setup AWS Lambda, API Gateway, SNS, and DynamoDB on Easy Mode at YOW! 2017 Conference.

The ability to get the latest greatest version of your product into the hands of users, safely and quickly in a sustainable way, a.k.a Continuous Delivery is the need of the hour for every enterprise out there. Over the years, we've got very good about Continuous Delivery for server-side, web-applications. However, it's not as streamlined for Mobile or Desktop Apps.

This talk will cover the typical aspects we need to address while setting up a Continuous Delivery culture in the context of a large-scale mobile app:

• SCM/Version Control: moving from Feature Branches to a trunk-based development model
• Build/Test Environments: Decentralising the build & test environments using Containers(Docker) and CI Server(Jenkins)
• Microservices Architecture: Segregating and containerize the micro-services. Also refactoring the mobile apps to be more container friendly.
• Device Farm: Setting up a mobile device farm (using STF or ADF)
• Code-reviews: Improving the quality of code-reviews (using SonarQube, PRBuilder & PRRiskAdvisor)
• Test Pyramid: Building the right Test Pyramid to get rapid feedback by creating different kinds of automated tests to align with the CI Pipeline
• Code Quality: Visualising the health of our code-base (using C3)

The ability to get the latest greatest version of your product into the hands of users, safely and quickly in a sustainable way, a.k.a Continuous Delivery is the need of the hour for every enterprise out there. Over the years, we've got very good about Continuous Delivery for server-side, web-applications. However, it's not as streamlined for Mobile or Desktop Apps.

This talk will cover the typical aspects we need to address while setting up a Continuous Delivery culture in the context of a large-scale mobile app:

• SCM/Version Control: moving from Feature Branches to a trunk-based development model
• Build/Test Environments: Decentralising the build & test environments using Containers(Docker) and CI Server(Jenkins)
• Microservices Architecture: Segregating and containerize the micro-services. Also refactoring the mobile apps to be more container friendly.
• Device Farm: Setting up a mobile device farm (using STF or ADF)
• Code-reviews: Improving the quality of code-reviews (using SonarQube, PRBuilder & PRRiskAdvisor)
• Test Pyramid: Building the right Test Pyramid to get rapid feedback by creating different kinds of automated tests to align with the CI Pipeline
• Code Quality: Visualising the health of our code-base (using C3)

Array-oriented Programming (AoP) dates back to 1960s.The fundamental idea behind AoP is that operations apply at once to an entire set of values. This allows the programmer to think and operate on whole aggregates of data, without having to resort to explicit loops of individual scalar operations. At ConfEngine.com, a platform for organising and managing technical conferences/events, we've been heavily influenced by the APL style of AoP. In our context, this means each function focuses on applying one transformation to an immutable array (ordered-map) and then spitting out a new array, which can be piped to another function thus achieving functional composition. This has allowed us to build a very modular, decoupled design, which is extremely simple to reason about.

If you think of typical web-apps, they are generally CRUD applications. Data comes in, you apply a set of transformation and you pass it to someone else via an API or you save/query a data store. And on the way out, you get data from somewhere (data-store, API, etc.), apply a set of transformations and render the transformed data as HTML or JSON. Now we can visualise most web-apps using standard Pipe-and-Filter Architecture. With this, applying some of the functional programming concepts becomes more intuitive.

At ConfEngine.com, we use the standard LAMP stack. We've used PHP's philosophy of shared-nothing-architecture to address concurrency and scalability concerns. PHP itself has all the basic ingredients required for Functional Programming - first-class, higher-order functions, lambda, closures, partial functions, recursion and so on. We use array (ordered-map) to hold the data. PHP provides 79 array functions that allows you to do pretty much everything you need to in terms of transforming arrays including map, reduce, filter, merge and so on. One needs to be careful, but most of these are pure, higher-order functions.

If you are interested to learn more about AoP, I'll give a walk through of our design. Also I'll take a couple of problems to explain how to think in terms of AoP and how its really helps with functional programming.

As developers, we often shy away from making changes to existing (legacy) code base due to the fear of breaking existing functionality. While we've enough industry wisdom on how to refactor large monolithic applications, its usually hard to find team members, who can champion the cause. For many folks, refactoring code without having automated tests can be scary. And quite often, it ends up being an egg-and-chicken problem, .i.e. to write tests one needs to refactor the code. But to refactor the code, we first need tests. Even if we break the egg-and-chicken problem, where do we start and how do we visualise the progress, becomes a big challenge.

This hands-on workshop will equip you with the necessary tools, technique and skills to confront legacy code. It teaches you how to use various safe-refactoring strategies, while breaking dependencies and writing first few scaffolding tests to guide your excavation. These techniques are very useful to get existing code safely under test for refactoring. You will also learn how to use these techniques in conjunction with TDD to breathe new life into large existing code bases.

You have a great idea and you want to build the product and launch it in market as soon as possible. Before anyone else can launch it. Great! But building the product takes time, money and opportunity cost. While building and launching a successful product, several things can go wrong:

• Have you really understood the core problem from the user's point of view?
• Will your users like the user experience?
• Have you validated your core-loop which makes your product very engaging?
• Is your business model flushed out and validated?
• And so on...

So how do you minimise these risks? 

In this 90 mins workshop, you will run some real tests with real users to de-risk yourself and gain validated learning.

By working with some of the most successful tech-product companies, I realised that code is NOT an asset, it's a liability. We should strive hard to minimise code. In 2011, when I started to hack on ConfEngine, I questioned my belief in TDD. I had also started playing around with APL style Array-Programming and Functional Programming. I felt, may be, I was getting a bit too dogmatic about TDD and automated tests in-general. As a thought experiment, I decided to build ConfEngine without ANY automated test. At first, it was really scary not to have the safety-net of automated test (something I took for granted for almost a decade.)

As I scaled ConfEngine without any automated tests, I had certain interesting realisations:

• How to embrace Simplicity and Minimalism WITHOUT automated tests
• Why Throwing Away Code frequently helps you achieve a better decoupled-design and how this helps in better experimentation
• Fear of Refactoring WITHOUT Tests is over-rated (Good IDE and safe-refactoring techniques can take you a long way)

ConfEngine grew from a pet-project to a 8 member product team. It has over 60K users and has done financial transactions worth over half-million USD. And we continue to push forward without ANY automated tests. Its not perfect, but it has certainly helped me challenge my dogma around TDD.

Background: In 2001, I stumbled upon the Test Infected paper. For the next 2 years, I struggled to really apply the test-first concept on real projects. Finally in 2003, I felt that I had fully internalised TDD and was able to apply on almost all projects. Then I started playing around with FIT and FitNesse, using ATDD on some of the projects. In 2006 I published "Avatars of TDD" paper in which I explained various styles of TDD and its design implications. Until 2011, I was a very big advocate of TDD, ATDD and BDD. I still like those practices, however I would not recommend it in all projects.

Over the last few years, as agile has gained traction inside the enterprises, we've seen many scaling frameworks have sprung up. These scaling frameworks claim to retain the core agile values & principles and aim to provide a simple yet comprehensive way to scale agility across the organisation. There have been several success case-studies that have been published. We also hear and see many horror stories of failed scaling attempts. 

In this panel, let's have a critical view of the entire scaling framework eco-system.