Talks and Appearances
You will often see us talk about our work, practices, experiences and culture
Design Masterclass: 1
Engineering Masterclass: 1
Design Masterclass: 2
Engineering Masterclass: 2
Design Masterclass: 3
Engineering Masterclass: 3
Design Masterclass: 4
Jetpack Compose — Next Gen Kotlin UI Toolkit for Android
Reactive applications are the norm on the web. Android applications have begun increasingly reactive using architectures like MVVM, MVI, Redux, etc., The reactive nature of these applications are due to the underlying architecture rather than the UI framework itself. This has resulted in some big wins like testability and strong separation of concerns while trading-off attributes like time-to-market and quickly on-boarding new developers to an existing project.
The API surface of the Android UI framework has been the same for the past decade. This was largely because of the limitations imposed by old tooling and the programming language. With Kotlin bringing in DSLs, functional programming and compiler plugin capabilities – the members of the Android UI Toolkit team have rolled up their sleeves and are taking a new direction. The new UI toolkit is backed by principles and techniques like – one-way data flow, function composition, declarative programming, optimistic concurrency control, isolation of side-effects, etc.,
This shift in API design also demands a shift in thinking about the app architecture and building UIs. In this talk, we’ll see how Jetpack Compose is radically different from the existing Android UI framework and how it adopts several ideas and programming patterns from web frameworks like React, MobX, and Vue.js. We will also see examples of these patterns and use them to build Android apps
TCR – A cocktail for extreme productivity
What slows us down? Bad code. What if someone waved a magic wand and made bad code disappear? Imagine a world where everyone checks-in only good code. That opens up a lot of possibilities.
TCR (test && commit || revert) is a new workflow invented by Kent Beck. The idea is simple – write tests and production code. If the tests pass, code gets checked-in automatically. If it fails, then the tooling performs a “git reset –hard”, discarding any code that was written. You may have a lot of mixed feelings about this and so did I, but it works!
TCR is surprisingly fast and effective. In this talk, I’ll demonstrate how we can use TCR to build a mobile app in Kotlin using IntelliJ IDEA.
Jetpack Compose — Next Gen Kotlin UI Toolkit for Android
The Android UI toolkit’s API surface has remained the same for the past decade. With applications and UI becoming more and more demanding, we need a new programming model to handle this complexity. With Kotlin bringing in DSLs, functional programming, and compiler plugin capabilities – the Android UI Toolkit team is taking a new direction with Jetpack Compose.
This shift in API design also demands a shift in thinking about UI and app architecture. In this talk, we’ll see how Jetpack Compose is radically different from the existing Android UI framework and look at various examples to build reactive Android apps.
Leveraging sealed classes in Kotlin
Sealed classes are much more than fancy enums. They are powerful composite types which can be useful in many ways. Common problems like exception handling and state representation become easier to manage with sealed classes. We will contrast traditional solutions written in Java, with modern ones using Kotlin.
Adopting Web Front-end Architectures for Native Mobile Apps
Let’s face it, the web is a powerhouse of innovation. The pace at which the web is innovating is hard for native mobile app developers to catch up. Its larger developer community is constantly coming up with refreshing ideas and also attaining maturity faster than the native mobile app counterparts. Frameworks and libraries like Redux, React, Cycle.js, Vue.js, etc., have changed the way web apps are built. It’s easier for web developers to build predictable apps using any of the technologies listed above.
This talk will guide and encourage native mobile app developers to adopt ideas from some of the popular front-end frameworks on the web and apply them to native app development.
The audience will be able to:
Evaluate different front-end architectures.
Embrace patterns and development techniques from web front-end architectures while building native mobile apps.
Functional programming with Arrow in Kotlin
With a rising trend in programming languages adding more and more functional capabilities, developers are working at a much higher level of abstraction. The declarative style of programming allows us to write readable and maintainable code that focuses on “what” (larger picture) rather than “how” (nuts and bolts). Functional programming also promotes immutability by default which makes dealing with concurrency an easy and a fun affair. Kotlin already supports some of these features like functions as first-class citizens, lambdas, anonymous functions, immutability, persistent collections, explicit nullable and non-nullable types, declarative constructs, etc., However, these features lack capabilities offered by purely functional languages.
Arrow is a Kotlin library that pushes the envelope further by introducing typeclasses, functional data types, optics, etc., It achieves this by clever usage of Kotlin language features and by generating code using annotation processors.
This talk will walk you through several ideas and code examples that will help you get started with functional programming using Arrow.
Audience will be able to:
- Use functional data types from the Arrow library.
- Use functional programming patterns.
- Solve problems using functional ideas and gradually move away from imperative programming.
- Deal with immutability and use optics to modify deeply nested data structures efficiently.
On the Panel: Plenary-GIDS 2019 Townhall with Software Experts
- Ragunath Jawahar
Dr. Venkat Subramaniam
Led by Dr. Venkat Subramaniam, this is a forum that is not bound by one session, one topic or one speaker. Bring along the questions that are burning in your mind and learn from the perspectives, opinions, and observations of experts. Curious about how they learn, how they have taken the journey to becoming the expert they are? This is an excellent opportunity for you to hear directly from them.
Building Flexible and Testable Applications
This talk introduces participants to the concept of Seams, and how you can use them for quick feedback cycles during development, decoupling teams from one another, troubleshooting bugs, producing hard to replicate states in a system and making lives easier for other teams that collaborate with developers.
Building Predictable and High Performance Workflows for Mobile App Development
Software development itself is a practice that is filled with entropy. Even though there are factors in software development that are beyond our control, there are quite a few parameters that can be controlled and tuned. One of the ways to maximise predictability in software projects is to reduce the number of unknowns. Most teams start with an architecture that sets expectations to a degree. How can we push this even further? What if we can build a degree of predictability on how software is built by individuals? What if we could extrapolate the same ideas to a team and across several teams?
This talk focuses on how various architectures (imperative and functional) influence individual and team throughput during development and maintenance. We’ll acknowledge how software development is a very creative profession but can also withdraw inspiring ideas from efficient systems like turn-key businesses and production lines that can help build software faster and better. We’ll focus on how the choice of architecture and tooling affect various phases of development. Once we gain an understanding of the architecture, we’ll create and tune a workflow by sequencing activities, establishing processes and building custom tooling around it.
Validating Design Ideas through Prototyping & User Research
- Dhruv Saxena
In most of user research practiced today, designers build click-through prototypes to get quick user feedback, which saves the product team a lot of time and money. The practice is extremely useful, but only during the infancy of a product.
After a few iterations the team has learnt all it could from a prototype and needs to build the real product with real data and interactions to learn more. Months of painstaking engineering goes into building this ‘real product’. When the product is finally out, the team realises that it was built on a shaky foundation of incomplete research. Many more months of work goes into fixing problems that could have been surfaced had the research been more sophisticated.
What if we could use a dash of engineering bandwidth to turn a prototype into real software which could be used to run quick and dirty design experiments? Could this experimental software with real interactions and data, actually facilitate more sophisticated research than a prototype? Could this software help the team gain new research insights every week, leaving no room for unpleasant surprises when the actual product is launched? In this talk, we answer all these questions using product design for “Simple” as a case study.
Sprinting into the future – rapid co-creation with your users
How do you rapidly prototype and build UX? Is it possible to co-create these prototypes with users? Drawing on his experiences with this methodology, Rahul Gonsalves will walk us through the process and the learnings.
Designing and Implementing with Fidelity
Well crafted details require a process that prevents design details from getting lost in translation to code. Designers often see a considerable gap between their specifications and the developers’ implementation. Similarly, developers often complain about missing details and unclear inputs from designers. These are outcomes of a mismatch between the languages that designers and developers speak and their understanding of each other’s domains, which leads to poorly crafted products.
In this workshop we will explore how developers can draw from design tools and techniques to help them implement designs better and to help them collaborate more effectively with designers. Participants will be taken through the entire product building cycle, covering design, handover, implementation and iteration, all compressed into a span of a couple of hours.
Exploring Android Path APIs
We explore some effects created using Paths, deconstruct their behaviour and reproduce them using the Path Operations API.
Scaling the biggest design system: your design team
How do you do your best work? A lot of this conference is devoted to the matter of “craft” – of becoming a better designer, a better developer and so on. However, how do you do your best work when part of a larger team? Throwing more people at the problem is not always the solution; and design management has historically been worse than other types of management. Most business leaders aren’t designers, and many design leaders have risen due to their proficiency in the practice of their craft – not because of their managerial, emotional or operational skills.
This talk is an attempt to provide an answer to that question. What structures do you need? What new processes does one put in? How do you ensure that designers (designers are often hyper-sensitive to the imposition of structure and restraint) do not chafe against these? What organisational structures are right at different points in a company’s growth?
Persistence as the Single Source of Truth
Simple is better than complex. Complex is better than complicated.
In the world of Android, where all sources of information and user interactions are asynchronous, UI state can become hard to reason about, especially in large apps. This is not only difficult to maintain but also increases complexity with the addition of every new feature.
This talk explores the idea of “persistence as the single source of truth” as a way to simplify state management, where persistent storage becomes the source for all data changes, and the UI is reduced to a reactive representation of persisted data. This forces the flow of data to be unidirectional which makes it easy to follow. The pattern is architecture agnostic and can be used in any MV-anything.
It also talks about other benefits of persistence where screens can stop exchanging data through serialized Bundles, get state restoration across Activity recreations for free, and deliver offline support out-of-the-box. UI interactions receive immediate feedback and the user is never forced to wait.
The Lesser Known World of Spans
Do you know what’s common between the blinking cursor, hyperlinks and text highlighting in TextViews? They’re all implemented using spans. Spans are tiny objects that Android uses heavily across the framework.
If you’ve worked with text styling such as bold or italics, then you’re already familiar with the basic usages of spans. But they are capable of much more than just modifying the visual representation of text like changing indentation, receiving URL clicks, listening to text changes, displaying spelling suggestions, images and much more.
This talk does a deep dive into the various spans that Android offers out of the box as well as custom spans and how they can be used for displaying text in any way imaginable.
The slides for this talk can be found here.If you see this
Make your Designers love (working with) you
This talk introduced participants to some of the advanced custom drawing operations available on Android, and using them to create effects in code without requiring constant changes to assets from designers.
Effective and Efficient Mobile Engineering
Unlike traditional software engineering, building mobile apps involves a whole new set of challenges that companies have to deal with on a day-to-day basis. Apart from being new operating systems, these platforms and their users are unforgiving towards badly behaved apps. This requires teams to adopt strict engineering practices and stay on top of new developments. In this talk, we discuss the pitfalls and challenges inherent in building mobile apps, as well as some potential solutions to those problems. The intended audience is project managers, engineering managers, or anyone else who finds themselves leading a mobile development team.
Deflating the LayoutInflater
Android developers spend a lot of time writing XML layouts every day. This talk will explain how Android’s LayoutInflater works.
By the end of this talk, you will have an understanding of how XML gibberish gets converted to Views in Java, how AppCompat is able to back-port Material Design for pre-Lollipop devices auto-magically and how libraries like Calligraphy work.
Workshop: Delightful apps with Material Design
With the release of Lollipop in November last year, we moved a step forward with the introduction of Material Design. This new design paradigm greatly improved the user experience across the board with new concepts, controls and guidelines. Redesigning your apps for Material is important for the user to feel right at home with the rest of the system. This session is going to focus on the tools and skills needed to build a great Material Design experience for your app.
We will start with the basic principles that make up Material Design and talk about the available documentation and libraries. After this, we will cover the patterns and components in detail, with examples in code. For example…
- Appcompat controls like Button, FAB, EditText, Dialog, NavigationDrawer, Toolbar etc.
- SwipeRefreshLayout, CardView, RecyclerView etc.
- Palette tinting library
- Percent support library
- Fully supporting Lollipop and Marshmallow while maintaining backward compatibility
Ruby Monk: From Design to One Million Page Views in Four Weeks
RubyMonk is an interactive platform for learning Ruby. RubyMonk was conceptualized in September 2011 and was up and running three weeks later. This talk will give you a ringside ticket to watch as the site went from concept to wireframe, to design and then finally; to implementation.