What you can expect from the Bangalore edition of Fragments on 30 March:
Fragments was launched in response to the fragmented nature of engineering and software development for mobile. Much changed for mobile engineering in 2017 when React Native entered the landscape and cross-platform mobile development took off in a big way.
At the recently concluded ReactFoo, we talked not only about the ecosystem emerging with ReactFoo, but also how organizations are structuring teams for Android, iOS and cross-platform mobile development.
Coming back to Fragments, the Android versus iOS debate seems to be settled with Android winning the turf. Now, with Flutter taking off as a platform for mobile engineering, the battleground has opened between React Native versus Flutter. Who will win is not only a matter of adoption and user base metrics, but also which platform has a stronger community around it.
On 30 March, speakers Priyanka Sabhagani and Ajin Asokan will share BookMyShow’s and Zerodha’s experiences (respectively) with React Native and Flutter, helping participants evaluate each platform’s strength and weaknesses. We look forward to deeper discussions around Flutter, where the platform has piqued a great deal of interest from developers (who have to write less code), but greater skepticism about Flutter’s capabilities with respect to data storage and related issues from senior developers.
Apart from Flutter, the Bangalore edition of Fragments will feature talks on Kotlin and native app development. An interesting question to discuss here is the decision to go native versus when not to go native with your app. Which factors inform such a decision?
The other discussion which Raghunath Jawahar, Varsha Saha and Abhinav Rastogi will take up is what native app developers can learn from the mature web front-end architectures. The discussion will steer around the following topics:
- Expectations and user experience on web versus mobile.
- The asynchronous nature of mobile platforms and their lifecycles – the unique challenges this factor presents.
Finally, Fragments Bangalore will showcase talks on:
- Image uploads and Contraint and Motion layout.
- Optimizing the size of your mobile app.
- Voice, and its role in building augmented experiences for mobile apps.
- How the concept of Seams can be applied for building flexible and testable apps.
- Building predictable and high performance workflows for mobile app engineering.
Who should participate in the Bangalore edition of Fragments Conference?
- Mobile engineers working on Android and cross-platform apps.
- Senior developers and tech leads.
- Backend developers and fullstack engineers.
- Product managers.
- Product engineers
Date: 30 March 2019
Time: 9:00 AM to 5:30 PM
Venue: TERI auditorium, Domlur, Bangalore
For more details, call us on 7676332020 or write to us on firstname.lastname@example.org
Future editions of Fragments:
Fragments will be held in Kochi and Hyderabad in 2019. Dates will be announced in April. If you wish to speak at any of the future editions of FragmentsConf, submit a proposal here: https://hasgeek.com/fragments/fragments-round-the-year-proposals-2019/
Jitin Sharma, Android engineer at GO-JEK
Architectures with Kotlin multiplatform
- A brief introduction to kotlin multiplatform
- Using various architectures such as MVP/MVI to create a multiplatform app for Android and iOS.
- Designing a common layer for storage and networking operations
- Using available multiplatform libraries such as SQLDelight, ktor
- Developing your own multiplatform library
Vinay S Shenoy, lead product engineer at Obvious
Building flexible and testable applications
We will introduce the concept of Seams, and how they enable developers to build software that is safe, flexible, and testable. We’ll see in-depth how they can help in creating quick feedback cycles during development, decouple teams from one another, troubleshoot bugs, produce hard to replicate states in a system and make lives easier for other teams that collaborate with developers.
Led by Ragunath Jawahar, Abhinav Rastogi and Varsha Saha
Birds of a Feather: 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 Birds of Feather (BOF) session 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.
Sourabh Gupta, mobile engineer at Flipkart
How to optimize app size to below 10 MB
Session will cover -:
-: What are the best practices to make sure apk Size is optimized.
-: How to correctly use Proguard and how to validate if your apk is correctly using it.
-: How to make sure Apk Size should not increased drastically release per Release.
-: Even after adding new Framework like React Native how we are able to keep check on our Apk Size and able to make it within a single Digit figure.
-: Learnings of over 2 year and various steps we have done time by time to reduce it.
Imran Mohammed, mobile engineer at Uncommon
Responsive UI with constraint and motion layout
What is this talk about?
ConstraintLayout implementation is similar to RelativeLayout, a more powerful and flat view implementation. ConstraintLayout children position based on the constraints of a child to its parent layout or another child, make the view hierarchy flat.
We will talk about how constraint layouts reduces the time taken to create a complex layout, reduce developer time and add easy animations. We will also briefly look into MotionLayout.
Who should attend this talk?
Android developers who would like to build complex layouts faster. Responsive UI with more control over scene changes.
This talk will also be helpful for iOS developers who have experience using AutoLayout and want to start Android development.
Abinash Mohapatra, senior engineer with Flipkart Lite team
Image uploads for mobile web
I wanted the process of uploading images on the web to be as good as native in terms of capability and smooth/performant as well. Based on our requirements, when we upload an image, the application was supposed to show a thumbnail which should take into account the EXIF orientation factor so that the thumbnail is shown in thr correct orientation. The next big challenge was to reduce the overall upload size during submitting the file to the server. Here we resorted to a Hermite resample filter that allowed us to further reduce the payload size. Since a user could upload maximum of 5 images in one go, we wanted to keep the main thread as free as possible so all of the above-mentioned tasks actually run in a worker. Using transferrables to reduce the time invokved in an othetwise structure clone postMessage was another area of investment. Moving all work into. a worker gave us the opportunity to work on the new amazing OffscreenCanvas API which enabled us to move all computations to the worker thread. Finally a final optimisation (WIP) is to encode our images to webp format to check if the payload size could be further reduced. Since browsers do not support encoding of images as a native construct, we resorted to Webassembly for achieving the desired result.
Ragunath Jawahar, lead product engineer at Obvious
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.