Gone Mobile-logo

Gone Mobile

Technology Podcasts

All the latest in .NET Mobile & MAUI (formerly Xamarin) developer technologies, covering in-depth topics ranging from Android, iOS, macOS and Windows, to mobile marketing, design and more!

Location:

United States

Description:

All the latest in .NET Mobile & MAUI (formerly Xamarin) developer technologies, covering in-depth topics ranging from Android, iOS, macOS and Windows, to mobile marketing, design and more!

Language:

English


Episodes

95: Xamarin.Forms to MAUI

2/23/2024
In this episode, Jon and Allan discuss the migration experiences from Xamarin.Forms to .NET MAUI. They highlight the opportunity for architectural improvements during the migration process, such as cleaning up code and removing static untestable components. They also explain the evolution of Xamarin.Forms into .NET MAUI and the introduction of handlers. The benefits of the single project structure and the ease of migrating third-party libraries are discussed. The conversation also covers the customization of entry handlers and the migration of resources, including images and fonts. This conversation covers various challenges and solutions related to image management, including the use of vectors, app icons, and splash screens. It also discusses the migration process from Xamarin.Forms to .NET MAUI, highlighting the importance of a methodical approach. The conversation concludes with a recommendation for the Maui Community Toolkit as a valuable resource for developers. Takeaways Migrating from Xamarin.Forms to .NET MAUI provides an opportunity to improve the architecture of the app. The introduction of handlers in .NET MAUI allows for cleaner and more testable code. The single project structure in .NET MAUI simplifies the development process and improves compile times. Migrating third-party libraries may require finding alternatives or porting them to .NET MAUI. Customizing entry handlers and migrating resources, such as images and fonts, can be done more easily in .NET MAUI. Image management in mobile app development can be challenging, especially when dealing with different resolutions and densities. Using vectors can simplify image management by allowing for easy scaling to different sizes. App icons and splash screens can be generated automatically in .NET MAUI, reducing the manual effort required. When migrating from Xamarin.Forms to .NET MAUI, it is important to approach the process methodically, starting with dependencies and gradually bringing over pages and components. People Hosts: Jon Dick, Allan Ritchie Chapters 00:00 Introduction and Migration Experiences 01:11 Opportunity for Architectural Improvements 03:16 Evolution of Xamarin.Forms to Maui 06:27 Architecture of Maui Handlers 09:30 Benefits of Single Project Structure 13:56 Migration of Third-Party Libraries 18:13 Handling Dependency Service and Renderers 25:09 Porting Plugins and Controls 32:48 Customizing Entry Handlers 35:45 Migration of Resources 37:23 Image Management Challenges 39:25 Building a Solution: Resize-itizer 41:03 Vector Images in Maui 44:05 App Icons and Splash Screens 46:38 Migrating Resources to Maui 49:35 Font Handling in Maui 51:37 Replacing Frames with Borders 53:10 Avoiding Tap Gesture Issues with Stack Layouts 55:12 Namespace Changes in XAML 56:45 Methodical Migration Process 59:28 Package of the Week: Maui Community Toolkit

Duration:01:01:41

94: Anatomy of an App

2/16/2024
In this episode, Jon and Allan discuss the process of building a mobile app, starting with the analogy of building a lightsaber at Disney. They explore the anatomy of a mobile app, including the use of MVVM architecture and the importance of gluing logic together. They also delve into navigation and the use of Shell in Xamarin.Forms. The conversation then shifts to the benefits of using dependency injection in app development and the considerations for cross-platform development. In this episode, Allan and Jon discuss various aspects of app development, including dependency injection, core services, and cross-platform services. They emphasize the importance of creating a base set of services and thinking outside the box when faced with UI design challenges. They also highlight the significance of solving business problems first and introduce Prism as a comprehensive app architecture framework. Takeaways Building a mobile app involves various components, including the user interface, logic, and navigation. MVVM (Model-View-ViewModel) architecture is a popular approach for separating the presentation logic from the user interface. Shell in Xamarin.Forms provides a convenient way to handle navigation in mobile apps. Dependency injection (DI) can simplify the management of dependencies and improve testability in app development. Cross-platform development allows for code sharing and reduces development time and effort. Use dependency injection and service injection to manage dependencies and improve code maintainability. Create a base set of services that are core to every page in your app to simplify dependency injection. Think outside the box and consider alternative approaches when faced with UI design challenges. Solve business problems first and focus on reusability only when patterns emerge. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Building a Lightsaber 03:11 Anatomy of a Mobile App 08:15 Gluing Logic with MVVM 17:36 Navigation and Shell 23:42 Using Dependency Injection 30:34 Cross-Platform Considerations 33:24 Dependency Injection and Service Injection 34:35 Core Services and Cross-Platform Services 36:25 Creating a Base Set of Services 37:11 Anatomy of a Maui App 38:19 The UI as the Top Bun 39:17 The Importance of Connectivity 41:14 Thinking Outside the Box in App Development 44:48 Navigating UI Design Challenges 48:09 Custom Controls and Creative Solutions 54:29 Solving Business Problems First 58:38 Prism: A Comprehensive App Architecture Framework

Duration:01:01:18

93: These aren't your grandma's Templates

2/9/2024
In this episode, Jon and Allan discuss the importance of templates for mobile app development. They explore the challenges of remembering details like Android manifest and info.plist, and how templates can help simplify the process. They also discuss the default templates in Maui and the benefits of item templates in VS Code. The conversation covers the balance between complexity and simplicity in templates, and the value of custom templates for saving time. They also touch on managing permissions and entitlements, and the power of MSBuild and CSProj files in customizing projects. The episode concludes with a discussion on the benefits of community templates. In this episode, Jon and Allan discuss different types of templates available for building mobile apps with .NET Maui. They cover item templates, Maui templates, solution templates, Visual Studio templates, VS Code templates, and command line templates. They also talk about the benefits of creating custom templates and how they can help standardize development practices within an organization. Takeaways Templates are essential for simplifying mobile app development and helping developers remember important details. Default templates in Maui and item templates in VS Code provide a starting point for building mobile apps. Custom templates can save time and help manage permissions and entitlements. MSBuild and CSProj files offer powerful customization options for projects. Community templates provide additional resources and options for developers. There are various types of templates available for building mobile apps with .NET Maui, including item templates, Maui templates, solution templates, Visual Studio templates, - VS Code templates, and command line templates. Item templates are used to add specific elements, such as XAML pages or views, to an existing project. Maui templates provide a starting point for building cross-platform apps with .NET Maui and include pre-configured project structures and dependencies. Solution templates allow developers to generate a complete solution with multiple projects and project references. Visual Studio templates offer a rich mechanism for creating templates with dynamic interfaces and advanced features. VS Code templates focus on command line interactions and provide a more lightweight and streamlined experience. Command line templates are used with the 'dotnet new' command and offer a simple and flexible way to generate project structures. Creating custom templates can help standardize development practices within an organization and simplify the onboarding process for new projects. Using templates can save time and effort by automating repetitive tasks and providing a consistent starting point for app development. Consider using existing templates or creating your own templates to improve productivity and maintain coding best practices. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 00:31 The Importance of Templates for Mobile Apps 01:38 Default Templates in Maui 02:35 Item Templates in VS Code 03:28 The Challenge of Remembering Details 04:11 Customizing Templates 05:38 Balancing Complexity and Simplicity in Templates 06:55 Different Needs for New and Experienced Users 07:45 Creating Custom Templates 08:23 Managing Permissions and Entitlements 09:44 The Power of Templates in Saving Time 11:05 The Challenge of Changing Requirements 13:21 Managing Permissions in Templates 14:42 Working with Templates in Different Environments 15:23 Using Conditional Logic in Templates 17:42 Generating Entitlements in Templates 19:14 Simplifying Project Files 21:17 The Power of MSBuild and CSProj Files 23:01 Overcoming Fear of Project Files 25:21 Using Project Files for Customization 26:41 The Benefits of Plugin Templates 30:51 Including Popular Packages in Templates 32:33 The Value of Community Templates 33:32 Introduction to Templates 34:05 Different Template Options 35:39 Item Templates 36:09 Maui...

Duration:00:48:22

92: Background Tasks can be Shiny

2/2/2024
In this episode, Jon and Allan discuss backgrounding in mobile development. They start by reviewing the virtual list view and how it solved Allan's problem. Then, Jon reveals the story behind his nickname 'Red.' The conversation then shifts to backgrounding in mobile development, covering common scenarios such as data synchronization, image uploads, and real-time GPS. They explore the different approaches to backgrounding on Android and iOS, including the use of services, broadcast receivers, foreground services, and job scheduling. Finally, they discuss background transfers on both platforms. This episode explores background transfers, background tasks, and code execution in mobile apps. The hosts discuss the challenges of handling slow APIs, managing state in background jobs, and scheduling one-off and periodic jobs. They also delve into the intricacies of background GPS in iOS and Android, as well as the considerations for background tasks in Windows. The episode concludes with a brief mention of background tasks in CarPlay and Android Auto. Takeaways Backgrounding in mobile development is the ability to execute code when an app is not in the foreground. Common scenarios for backgrounding include data synchronization, image uploads, and real-time GPS. On Android, backgrounding can be achieved using services, broadcast receivers, foreground services, and job scheduling. On iOS, backgrounding is more restricted, with foreground services and background transfers being the primary options. Developers should consider the specific platform guidelines and limitations when implementing backgrounding functionality. Background transfers are useful for uploading or downloading large files or data sets. Managing state in background jobs can be challenging, but there are various ways to handle it, such as using preferences or messaging frameworks. Background GPS in iOS and Android allows for tracking location and other data, but it should be used judiciously to avoid excessive battery drain. Background tasks in Windows can be achieved using WinRT APIs, but they may be less relevant in desktop scenarios. Consider the specific use case and user needs before implementing background tasks, and be mindful of the impact on battery life and data usage. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Virtual List View 05:28 The Story Behind the Nickname 'Red' 08:50 Backgrounding in Mobile Development 19:21 Backgrounding on Android 27:45 Backgrounding on iOS 30:31 Background Transfers on Android 31:55 Background Transfers on iOS 32:42 Background Transfers 33:45 Handling Slow APIs 34:38 Background Tasks in iOS 13 36:46 Managing State in Background Jobs 37:45 One-Off and Scheduled Jobs 40:20 Background Execution in iOS 41:36 Passing State to Background Jobs 44:22 Challenges of Data Synchronization 45:45 Background Execution in Windows 46:19 Background GPS in iOS 47:39 Background GPS in Android 51:53 Considerations for Background Tasks 55:12 Background Tasks in CarPlay and Android Auto

Duration:00:58:28

91: ListViews and CollectionViews

1/26/2024
In this episode, Jon and Allan discuss the challenges and history of implementing lists in mobile apps. They start by addressing a listener question about the difference between CLI commands in MAUI and other UI frameworks. They then dive into the topic of dealing with lists in mobile apps, including the challenges of performance and dynamic sizing. They explore the history of list implementations on different platforms and the limitations of the current CollectionView in MAUI. They also discuss alternative list view controls and the misuse of observable collections in list views. In this episode, Allan and Jon discuss various aspects of building performant lists in mobile apps. They cover topics such as using observable collections for data in motion, optimizing list performance, choosing the right list control, and introduce the Virtualized List View plugin. Takeaways Implementing lists in mobile apps can be challenging due to performance and dynamic sizing issues. The history of list implementations on different platforms, such as ListView, RecyclerView, and UICollectionView, has influenced the current state of CollectionView in MAUI. The current CollectionView in MAUI tries to do too much and can be complex to use in certain scenarios. Alternative list view controls, such as Sharpnado and Syncfusion, provide different approaches and features for handling lists in mobile apps. Observable collections are often misused in list views, leading to performance issues. It is important to use them appropriately and consider using a regular list when the data is not changing frequently. Observable collections are useful for handling data in motion, such as real-time updates or changing distances. Optimizing list performance should be done based on actual needs and user behavior, rather than prematurely optimizing for potential issues. Consider the specific requirements of your app when choosing a list control, and don't be afraid to explore alternative solutions like Blazor or web technologies. The Virtualized List View plugin by Jon is a powerful tool for building performant lists in Xamarin.Forms and can be a great solution for complex scenarios. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Weather 01:14 Listener Question: CLI Command in MAUI 05:36 Topic: Dealing with Lists in Mobile Apps 19:35 History of List Implementations 25:51 Challenges with Collection View in MAUI 30:17 Alternative List View Controls 35:38 Observable Collections and List Views 39:18 Observable Collection and Data in Motion 46:11 Optimizing List Performance 52:26 Choosing the Right List Control 56:25 Virtualized List View Plugin 01:00:53 Optimizing List Performance (Continued) 01:04:08 Conclusion and Plug-in of the Week

Duration:01:06:36

90: Push Notifications are Hard!

1/19/2024
Summary In this episode, Jon and Allan discuss the complexities of implementing push notifications on iOS and Android. They delve into the history of push notifications and the challenges developers face in tackling this topic. They explore the setup and configuration process for both platforms, including the use of certificates and entitlements on iOS and the use of Firebase on Android. They also discuss the lifecycle of notifications, handling background execution, and the differences between iOS and Android in terms of permissions and notification handling. In this episode, Jon and Allan discuss various aspects of push notifications on Android, including permissions and changes, setting up notifications, specifying intents in notification payloads, silent notifications, sending notifications to tags, handling multiple devices, and the Shiny Push library. They also touch on source generators and boilerplate code. Overall, the conversation provides valuable insights into the complexities and best practices of implementing push notifications on Android. Takeaways Push notifications are a complex topic that require careful setup and configuration on both iOS and Android. Developers face challenges in implementing push notifications due to the differences between platforms and the evolving nature of the technology. The setup and configuration process involves obtaining certificates and entitlements on iOS and using Firebase on Android. The lifecycle of notifications and the handling of background execution differ between iOS and Android. Permissions and changes in Android, such as the introduction of post-notifications, add another layer of complexity to push notification implementation. Permissions and changes in Android can impact the implementation of push notifications. Notifications on Android can be set up to route directly to an activity by specifying an intent in the notification payload. Silent notifications on Android can be used to wake up the app and perform background tasks. Sending notifications to tags allows for logical grouping and targeted delivery on Android. Handling multiple devices and ensuring notifications are received on all devices can be challenging. The Shiny Push library simplifies the implementation of push notifications on Android. Source generators can help reduce boilerplate code and make implementation easier. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 01:09 Tackling Hard Problems 04:00 History of Push Notifications 08:30 Setup and Configuration on iOS 13:02 Registering for Notifications on iOS 15:22 Lifecycle of Notifications on iOS 17:43 Silent Notifications on iOS 19:27 Handling Background Execution on iOS 22:06 Complexity of Cross-Platform Implementation 24:19 Setup and Configuration on Android 28:35 Handling Notifications on Android 32:19 Permissions and Changes in Android 33:16 Permissions and Changes 35:27 Setting Up Notifications on Android 36:43 Specifying Intents in Notification Payloads 38:19 Silent Notifications on Android 41:48 Sending Notifications to Tags on Android 44:29 Handling Multiple Devices on Android 49:15 Shiny Push Library 52:21 Server-to-Server Notifications 56:08 Source Generators and Boilerplate 57:44 Plugin Pick: Shiny Push

Duration:01:00:05

89: Bound for greater Bindings

1/12/2024
This conversation discusses the concept of bindings in a mobile.NET, Maui world. Bindings are used to integrate native libraries into the.NET ecosystem. The conversation covers the challenges and complexities of creating bindings for Android and iOS platforms. It explores the differences between Android X libraries and platform APIs. The concept of slim bindings is introduced, which involves creating a simplified interface for interacting with native libraries. The conversation also touches on the use of platform channels for message passing between.NET and native code. The future of bindings and the need for improved tools and processes are discussed. The conversation discusses the challenges and considerations when integrating platform channels in Xamarin projects. It explores the difficulties of referencing native frameworks and dependencies in Xcode projects and suggests the need for improved tooling to simplify the process. The conversation also delves into the complexities of handling AndroidX dependencies and the potential issues with duplicate libraries. Additionally, it highlights the concept of platform channels in Maui and the potential for creating a seamless integration experience. The recommended plugin for this episode is Xamarin Binding Helpers. Plugins, Packages, and Products This week we're talking about Xamarin.Binding.Helpers (https://github.com/Redth/xamarin.binding.helpers) which helps make it easier to create slim bindings on Android, as well as Platform Channels (https://github.com/Redth/Microsoft.Maui.Platform.Channels) which is an experiment for creating a message passing interface between native code and .NET MAUI apps. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 01:09 Understanding Bindings in a Mobile.NET, Maui World 02:00 Projections of Native APIs into the Managed.NET World 03:41 The Evolution of Bindings 04:06 The Challenge of Android X Libraries 05:00 Dealing with Bindings in Xamarin 06:07 The Complexity of Android Libraries 07:03 Creating Android Bindings 07:30 The Process of Android Binding 08:16 Challenges with Java and Kotlin Libraries 09:08 Handling Complex Inheritance in Java and Kotlin Libraries 10:22 The Sprawl of Android X Libraries 11:31 The Challenges of Binding Android X Libraries 12:09 The Simplicity of Binding Platform APIs 13:16 The Differences Between iOS and Android Bindings 14:22 Creating iOS Bindings 15:48 The Challenges of Objective-C and Swift Libraries 18:36 The Need for Slim Bindings 20:00 The Challenge of Dependency Chains 21:54 The Concept of Slim Bindings 23:46 The Advantages of Slim Bindings 27:11 Determining When to Bind the Whole Library 29:34 Debugging Slim Bindings 34:52 The Concept of Platform Channels 38:58 Performance Considerations of Platform Channels 40:37 The Future of Bindings 40:46 Integration with Xcode Project 42:41 Challenges with Tooling 46:48 Handling AndroidX Dependencies 50:15 Platform Channels in Maui 53:00 Plugin Recommendation: Xamarin Binding Helpers

Duration:00:53:48

88: Return of Gone Mobile and the State of .NET MAUI

1/5/2024
Summary In this episode, Jon and Allan discuss the state of .NET Maui, the challenges of mobile development, and the benefits of using Blazor WebView in Maui apps. They also talk about the evolution of the Mono runtime, the use of handlers in Maui, and the transition from custom renders to source generators. Overall, they highlight the improvements and advancements in the .NET Maui framework and its potential for creating cross-platform mobile apps. In this episode, Jon and Allan discuss app profiling and performance optimization, highlighting the use of tools like DS router and DS dotnet trace to profile apps and identify performance issues. They emphasize the importance of measuring and optimizing early in the development process to avoid potential problems. The conversation then shifts to the introduction of a new segment called 'Plugin Package or Product,' where they showcase a library called compiled bindings that enhances the XAML experience by providing additional operators and reducing verbosity. They express their interest in incorporating such concepts into the core product. The episode concludes with a call to action for listeners to subscribe, leave reviews, and provide topic suggestions for future episodes. Takeaways The .NET Maui framework has made significant progress, with improvements in tooling, performance, and support for modern mobile app development. Blazor WebView in Maui allows developers to leverage their existing Blazor skills and codebase to build hybrid mobile apps. The transition from custom renders to handlers in Maui simplifies the development process and improves performance. Source generators in Maui enable automatic code generation, reducing the need for manual coding and improving productivity. App profiling and performance optimization are crucial for identifying and resolving performance issues in apps. Tools like DS router and DS dotnet trace can be used to profile apps and gather trace files and speed scope logs for analysis. Early measurement and optimization can help prevent performance issues and improve the overall user experience. Compiled bindings is a library that enhances the XAML experience by providing additional operators and reducing verbosity, making it easier to work with XAML. Plugins, Packages, and Products This week we're talking about Compiled Bindings: https://github.com/levitali/CompiledBindings which provides {x:Bind} Markup Extension for WPF, MAUI and Xamarin Forms. Chapters 00:00 Introduction and Changes to the Podcast 06:17 State of .NET Maui 09:24 Dependency Injection in .NET Maui 11:12 Evolution of the Mono Runtime 13:14 Challenges of Mobile Development 19:22 Long-Term Release of .NET Maui 21:20 Blazor Hybrid App 23:43 Benefits of Blazor WebView 25:49 Mixing Blazor and Maui 31:35 Handlers in .NET Maui 35:13 Porting Custom Renders to Handlers 37:03 Source Generators in .NET Maui 38:56 App Profiling and Performance Optimization 41:29 Plugin Package or Product: Compiled Bindings 47:04 Closing Remarks and Call to Action

Duration:00:48:48

87: Couchbase Mobile Update with Robert Hedgpeth

7/10/2019
It's been a few years since we've talked Couchbase on the show, so with their recent release of Couchbase Mobile 2.5 we thought we'd bring Robert Hedgpeth on to catch us up! Special Guest: Robert Hedgpeth.

Duration:00:50:30

86: Building PepTown with Eric Sink

4/16/2019
You may know Eric Sink from the database syncing product Zumero, or perhaps the source control versioning system SourceGear. Now, Eric is building a platform for High School sports fundraising, and he's doing it in .NET. Special Guest: Eric Sink.

Duration:00:52:06

85: Creating Low-Code Apps Using OutSystems with Stacey Levine

3/6/2019
OutSystems allows you to do some pretty amazing things with Low to No Code. We talk to Stacey Levine about their platform to see just how much you an accomplish without coding! Special Guest: Stacey Levine.

Duration:01:04:44

84: Creating Apps From Spreadsheets Using Glide with Jason Smith and Mark Probst

2/11/2019
Creating apps from spreadsheets? You bet! In this episode we're joined by Jason Smith and Mark Probst, formerly of Xamarin/Microsoft, to talk about their new endeavor called Glide. Glide's goal is to let you build beautiful, data-powered apps quickly and easily, so tune in to learn what it's all about! Special Guests: Jason Smith and Mark Probst.

Duration:00:47:18

83: Diving into GrialKit and Gorilla Player with UXDivers

1/15/2019
We finally sit down with Leonardo and Diego from UXDivers to talk about their products GrialKit and Gorilla Player. GrialKit is a collection of Xamarin.Forms user controls, templates, pages, and basically a really simple way to make your app look great. Gorilla Player lets you live preview and hot reload XAML from your Xamarin.Forms products on a device or simulator. Special Guests: Diego Rivero and Leonardo Rodriguez.

Duration:00:59:16

82: Building Fabulous Apps Using F# with Jim Bennett

12/31/2018
It's been awhile since we've had a good F# discussion, so for our final episode of 2018 we decided to fix that. Join us as we talk to Jim Bennett about the latest and greatest in the world of F# and how it's becoming a better option than ever before for building mobile apps! Special Guest: Jim Bennett.

Duration:00:52:50

81: Shiny and New at Microsoft Connect 2018

12/10/2018
We discuss and recap some of the more interesting highlights from Microsoft Connect 2018.

Duration:00:55:21

80: Building IoT Apps using .NET and Meadow with Bryan Costanich

11/12/2018
Bryan can finally share what he's been working on, and "IoT" is full of .NET goodness! On this episode we talk to Bryan Costanich about Meadow, a new microcontroller where .NET is king. This isn't your typical microcontroller, give us a listen! Special Guest: Bryan Costanich.

Duration:01:00:35

79: Flutter with Thomas Burkhart

10/29/2018
Thomas Burkhart talks with us about what Flutter is, what it's like to program in Dart, and the pro's and con's of Flutter as a mobile development platform. Special Guest: Thomas Burkhart.

Duration:01:01:48

78: Building a Software Business with Matthew Robbins

10/15/2018
Building a business around software is hard work, and often it's hard to come across detailed advice from those who have dared to give it a shot. In this episode we're joined by Matthew Robbins, founder of MFractor, to talk about his experiences building a company around developer tooling, and what he's learned along the way. If you're curious to peek behind the curtain of building MFractor, this is the episode for you! Special Guest: Matthew Robbins.

Duration:00:38:38

77: Revisiting ReactiveUI with Kent Boogaart

9/10/2018
Somehow five years have gone by since we last did an episode on ReactiveUI, so we figured it was time to fix that! In this episode we're joined by Kent Boogaart, author of the recently published book You, I, and ReactiveUI, and we dig into what ReactiveUI is, what's changed over the years, and why you should use it in your apps. Special Guest: Kent Boogaart.

Duration:00:43:36

76: Building Untappd with Greg Avola

8/27/2018
Cheers to the creator of Untappd! We talk about the beer app's humble beginnings and how it grew into a keg-sized success. Find out how it's built, what the backend is like, and what new suds are to come! Special Guest: Greg Avola.

Duration:01:05:12