Fearless Change: Patterns for Introducing New Ideas

(Opening key note)

We attend conferences or read books and articles; discover new ideas we want to bring into our organizations; but we often struggle when trying to implement those changes. These changes are pretty much applicable to our personal lives as much as it is applicable to organizations.
Unfortunately, those introducing change, are not always welcomed with open arms. Linda Rising offers proven change management strategies to help you become a more successful agent of change in your organization. Learn how to plant effective seeds of change, and what forces in your organization drive or block change. In addition to using these approaches to change your organization, you can use them to become a more effective person. Come and discuss your organizational and personal change challenges. Linda shows how the lessons from her book, Fearless Change: Patterns for Introducing New Ideas, can help you succeed. Learn how to overcome adversity to change and to celebrate your improvement successes along with your organization's new found practices.

Naresh JainHands-on geek, Technology and Process Expert

From Oh-Oh to Functional

Given a problem, most of us have a decent idea of how to model the problem in an Object-Oriented world. We can use principles like SOLID, GRASP, "Keep It DRY, Shy, and Tell the Other Guy" and so on to guide our design.

In my experience, if you apply these principles recursively, (esp. on certain problems) you will notice, that you start drifting towards functional style of programming.

For example, your object evolve to have single functions and gradually you can make the classes immutable. This leads to pure function without side-effects. At that point, you can turn them into closures (a poor man's object.) Eventually this leads to higher-order functions, which can be used as first class-citizens. Further more, you can express your domain behavior in terms of generic functions like map and reduce, which can be chained or composed to really simplify your logic and make your design more communicative. At this stage, you can really feel the difference between a declarative vs. imperative style of programming.

If time permits, we can also look at how to apply concepts like partial function application, currying, lazy evaluation and infinite data-structures to tackle complexity and design for scalability.

If this sounds interesting, join us for a code-along session, where we'll take a problem and incrementally evolve the design from OO to more of a functional style.

Johannes BrodwallCode Empowerment Evangelist

Let's get this project started

So your project is just getting started. Or maybe you're just about to embark on a new release. Or new members just joined the team. What now?
Most agile teams face a dilemma when they get started. Either the team will spend too much time worrying about a future that may never come, or they may find themselves wandering in the wilderness with no map.
In this workshop, we will use real-life examples to practice techniques that will:
• Uncover what the project or release needs to be complete
• Forecast actual progress based on experience
• Plan yourself out of the rush
The workshops will bring the team to a place where they can confidently discuss functionality, implementation and features with their customer through break-out conversations with a clear task. By opening up to communication lines in the beginning of the project, the customer will find out what the team really understands and, more importantly, what they don't yet grasp.
The workshops are designed to make a team gel, give them a clear purpose and get going towards a goal. During the talk, you will get to practice Discussion, Visualization and Drama to effectively get your team pointed in the same direction and infused with extra energy.

Shahani WeerawaranaCo-Founder, President and CTO, Auxenta Inc

Characteristics of Crypto Currencies: A pure P2P architecture in action

Await session details

Srinath PereraWSO2 Director, Research

Big Data Analysis : Deciphering the haystack

A primary outcome of Bigdata is to derive useful and actionable insights from large or challenged data collections.
The goal is to run the transformations from data, to information, to knowledge, and finally
to insights. This includes calculating simple analytics like Mean, Max, and Median, to derive
overall understanding about data by building models, and finally to derive predictions from data.
Some cases we can afford to wait to collect and processes them, while in other cases we need to
know the outputs right away. MapReduce has been the defacto standard for data processing, and we
will start our discussion from there. However, that is only one side of the problem. There are
other technologies like Apache Spark and Apache Drill graining ground, and also realtime
processing technologies like Stream Processing and Complex Event Processing.
Finally there are lot of work on porting decision technologies like Machine learning into
big data landscape. This talk discusses big data processing in general and look at each of
those different technologies comparing and contrasting them.

Dilan PereraChief Technology Officer, Innovative-e

Software in the Cloud: An Architect's Journey

The cloud has been around long enough to see its own patterns and practices emerge. However, the many choices facing software architects when constructing Software as a Service (SaaS) still makes engineering cloud solutions a challenging task.
Furthermore, project deliveries are frequently affected by being located offshore in an outsourced model (through time and language differences) and the choice of process approach (Agile or Waterfall), amongst other factors ranging from technical to human resources.
In this session, we look at building cloud solutions from a software architect's perspective, revisiting the issues faced and the approaches used across several projects, while operating under these constraints.

Imran VilcassimCountry Manager at Microsoft Sri Lanka

Microsoft approach to Mobile First Cloud First

Pragmatic approach for implementing SAFe™

The Scaled Agile Framework® (also known as SAFe™) is an interactive knowledge base for implementing agile practices at enterprise scale".
We build increasingly complex and sophisticated software systems. Doing so requires larger teams and continuously rethinking the methods and practices – part art, science, engineering, mathematics, social science – that we use to organize and manage these important activities.

The Scaled Agile Framework represents one such set of advances.
This session will cover a high-level introduction to SAFe and discuss few practices you can extract from the framework even though your projects don’t have 100s of developers.

Linda Rising Author, Consultant and Public Speaker

The Power of Retrospection

Project Retrospectives are an important part of any software development process. The Principles Behind the Agile Manifesto state that, “At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.” How can this be done? By taking the time to reflect and learn and proactively determine what should be done differently in the next iteration, release, or project. Linda’s presentation will introduce techniques for project retrospectives, whether they are agile or not.

The techniques help teams discover what they’re doing well so that successful practices can continue and identify what should be done differently to improve performance. Retrospectives are not finger pointing or blaming sessions, but rather a highly effective process in which teams reflect on the past to become more productive in the future. Linda will share her experiences with leading retrospectives of several kinds for dozens of projects—successful and unsuccessful, small and large, in academia and industry. Her lessons learned can be applied to any project to enable teams and organizations to become learning organisations.

Johannes BrodwallCode Empowerment Evangelist

JS all the way: Feedback-driven development with NodeJS

How do you build real applications with JavaScript all the way? In this talk, Johannes will show how you get client-side and server-side testing, deployment and databases all to work together for this popular new technology.

So you want to be a Software Engineer

The talk is about what is expected from a Software Engineer in the current industry. Currently there is a big tendency where Developers are aspiring to be Software Engineers. But do they really know what it takes to be a Software Engineer, what are the differences going from a Software Developer to Software Engineer?
I am trying to give a glimpse in to what a professional Software Engineer would need to have in their arsenal and what their attitude, skill set and thinking should be.

Julian HartyIndependent Consultant

Mobile Developer's Guide to the Galaxy

Executable Agile Requirements for behaviour driven development (BDD)

For many people, a requirement specification is part of “traditional” document-centric engineering
practices. Although running software is the primary measure of progress in an agile project, well-
formed requirements are relevant than ever before.
In this talk I will focus on how can we capture
requirements of an agile project to enable Behaviour Driven Development (BDD) approach engaging
the Product Owner, Developers and QA Engineers.

Naresh JainHands-on geek, Technology and Process Expert

Problem Solving Techniques For Evolutionary Design

In this workshop, Naresh Jain explains what are the core techniques one should master to effectively practice evolutionary design while solving real world problems. To summarize:
1. Eliminate Noise - Distill down the crux of the problem
2. Add constraints to future simplify the problem
3. Focus on one scenario at a time & incrementally build your solution
4. Refactor: Pause, look for a much simpler alternative
5. Be ready to throw away your solution & start again

Gogula G. AryalingamMVP, Technical Architect at Navantis

Serve Yourself: Self-Service Business Intelligence

Data is all around. As a developer you encounter it in different forms, find it in different places, and work with it in different ways to provide solutions to your clients. But have you looked at how you could make data work for you?
Businesses have, for a long time, used business intelligence or data analytics to get insights into their data: To do better in their trade with the intelligence that they had gathered. In recent times the focus appears to shift towards getting results faster, by users building solutions themselves from whatever sources that they could lay their hands on. We call this Self-Service Data Analytics.
As a developer, have you thought of how you could enhance your value to the organization? How you could analyze your social media feed to get a glimpse of your socializing patterns? Or probably crunch some numbers for that research that you are doing? Or even do an analysis of your favorite sports tournament – you could even probably predict the winner! The possibilities are endless…
Make data work for you, using just the tools that you already know

Next wave of Analytics using BigData

Current Business Analytics and Intelligence needs of large progressive organisations go beyond processing of traditional data. 3rd part data and data that were never collected or processed are now becoming relevant and valuable. Storing and processing multi-structured data sets in large quantities has presented organisations with challenges that need to go beyond traditional architectures. Let’s look at BigData and its relevance to businesses and the architectures involved from an Oracle point of view

Julian HartyIndependent Consultant

Anti-Fragile

To thrive, software needs to deliver value to users. However, software can fail because it is fragile and fails in use. There are many causes of these failures. Failures include incompatibilities, missing dependencies, and unmet expectations or assumptions.
For software to deliver value in these circumstances, it needs to be able to adapt and continue working, albeit in a degraded mode of operation. We may even be able to design and implement software that thrives in uncertain operating conditions, where provides a basic, adequate service, while taking advantage of resources being available to provide enhanced services.
Some considerations when creating anti-fragile software include: coping with errors, corruption, missing content, missing dependencies, incorrect versions, impractical assumptions, and unavailable resources (temporary or longer-term). Engineering principles include: Fault-tolerance, efficient recovery, dependency injection, and choice of software design & implementation.

Sinnathamby ShanmugarajahDirector - Mobile Architecture WSO2

Enterprise Mobile Application Development - Different Approaches

Enterprises entering today's mobility space requires significant decisions about the development technology they want to use; whether to use a native app, web app or a hybrid app; what's the development tool to use - whether a native tool or cross platform development tool.
Also the most important thing, which is least looked at, is the level of security used to protect the sensitive information.
These decisions are made without adequate knowledge on industry trends and relevant data. In this session we will look into how important it is to protect the enterprise sensitive data and what are the different approaches to developing the enterprise mobile apps.