Ash Davies

Privacy Policy

Sun, 19 Jul 2026 00:00:00 +0000

Privacy Policy

This privacy policy applies to the Playgorund: Conferences app (hereby referred to as “Application”) for mobile devices that was created by Ashley Davies (hereby referred to as “Service Provider”) as a Free service. This service is intended for use “AS IS”.

Information Collection and Use

The Application collects information when you download and use it. This information may include information such as

Your device’s Internet Protocol address (e.g. IP address)
The pages of the Application that you visit, the time and date of your visit, the time spent on those pages
The time spent on the Application
The operating system you use on your mobile device

The Application does not gather precise information about the location of your mobile device.

What will you be building this weekend?

Fri, 12 Jun 2026 00:00:00 +0000

I read this question today, which triggered me a little. In the context of software engineering, many of us have always had pet projects, side projects, or just whacky things we’d like to spend some time coding. Because mostly it’s kinda fun to learn new things, to play, or just practice our love of coding, trying, failing, trying again, failing in different ways.

This was something that was typically invisible to the wider world. I was ok being labelled a nerd working on some project that probably had no real world application, but let me play with a new API or tech that became available. If anything this felt somehow exclusive.

Crafting Idiomatic APIs with Kotlin and Compose

Wed, 25 Feb 2026 00:00:00 +0000

In this talk, we’ll dive into the principles of idiomatic Kotlin and explore how they apply to designing Compose APIs.

You’ll learn how to leverage Kotlin’s language features, from DSLs and inline functions to advanced type safety and composable conventions, to craft APIs that are a joy to use.

By mastering these techniques, you can deliver APIs that not only “work” but truly feel like Kotlin.

Beyond the UI: Compose as a Foundation for Multiplatform Apps

Thu, 30 Oct 2025 00:00:00 +0000

In this talk, we’ll explore how Compose Multiplatform can reshape not just the user interface, but the entire architecture of your app.

You’ll learn techniques for structuring state, managing business logic, and creating modular, testable, and maintainable systems across platforms.

Whether you’re targeting mobile, desktop, or beyond, this session will give you the tools and perspective to design applications that exploit the efficacy of Compose.

Hype Driven Development: How I Learned to Stop Worrying and Love the Failures

Thu, 23 Oct 2025 00:00:00 +0000

Ever wondered what it would take to combine all the experimental features of a language you love (Spoilers… It’s Kotlin!) into one big bundle?

I’m a lover of new and shiny stuff, so let me share with you my experience of using everything shiny, and new, in my pet project, to show you how to not do all the things you might want to do with yours!

JetBrains Compose for Desktop, Unstable Coroutines APIs, version catalogues, Gradle composite builds, multiplatform navigation support, multiplatform paging, GraphQl, Firebase Cloud Functions, Molecule, Mosaic, what could go wrong?!

Crafting Idiomatic APIs with Kotlin and Compose

Wed, 24 Sep 2025 00:00:00 +0000

What’s in a language? What does it mean to be idiomatic? Writing clean, intuitive APIs isn’t just about functionality — it’s about designing interfaces that feel natural and intuitive. With Kotlin and Compose, we have a powerful set of tools and syntax that, when used effectively, can reduce cognitive load and make your APIs both elegant and expressive.

In this talk, we’ll dive into the principles of idiomatic Kotlin and explore how they apply to designing Compose APIs. You’ll learn how to leverage Kotlin’s language features, from DSLs and inline functions to advanced type safety and composable conventions, to craft APIs that are a joy to use. By mastering these techniques, you can deliver APIs that not only “work” but truly feel like Kotlin.

Beyond the UI: Compose as a Foundation for Multiplatform Apps

Wed, 30 Jul 2025 00:00:00 +0000

In this talk, we’ll explore how Compose Multiplatform can reshape not just the user interface, but the entire architecture of your app.

You’ll learn techniques for structuring state, managing business logic, and creating modular, testable, and maintainable systems across platforms.

Whether you’re targeting mobile, desktop, or beyond, this session will give you the tools and perspective to design applications that exploit the efficacy of Compose.

Beyond the UI: Compose as a Foundation for Multiplatform Apps

Tue, 03 Jun 2025 00:00:00 +0000

Much in the same way that Coroutines revolutionized reactive architecture, Compose challenges us to rethink how we design applications.

While traditionally seen as a UI toolkit, Compose — and specifically Compose Multiplatform — can play a much larger role in our applications.

By leveraging its declarative and state-driven nature, we can build, model, and manage application state in a way that is consistent, scalable, and platform-agnostic.

Terms & Conditions

Wed, 11 Dec 2024 00:00:00 +0000

Terms & Conditions

These terms and conditions applies to the Conferences App app (hereby referred to as “Application”) for mobile devices that was created by Ashley Davies (hereby referred to as “Service Provider”) as a Free service.

Upon downloading or utilizing the Application, you are automatically agreeing to the following terms. It is strongly advised that you thoroughly read and understand these terms prior to using the Application. Unauthorized copying, modification of the Application, any part of the Application, or our trademarks is strictly prohibited. Any attempts to extract the source code of the Application, translate the Application into other languages, or create derivative versions are not permitted. All trademarks, copyrights, database rights, and other intellectual property rights related to the Application remain the property of the Service Provider.

Navigation in a Multiplatform World: Choosing the Right Framework for your App

Fri, 01 Nov 2024 00:00:00 +0000

Navigation in mobile, desktop, and web applications is such a fundamental part of how we structure our architecture. In order to both obtain functional clarity, and abstraction from platform level implementation.

For a long time, there have been options available specific to each platform, and even options part of the platform framework itself. Though it can be difficult to find the right option for platform-agnostic code, ensuring consistency. Some go one step further, providing an opinionated guide on how to architecture your application.

Navigation in a Multiplatform World: Choosing the Right Framework for your App

Thu, 19 Sep 2024 00:00:00 +0000

Testing in Practice: Keeping Your Tests Concise and Declarative

Wed, 03 Jul 2024 00:00:00 +0000

Testing isn’t always everybody’s favourite task, but that doesn’t need to be the case! Writing tests can be an enjoyable way to practice your coding techniques!

But with conflicting opinions on writing test code that is declarative, explicit, terse, concise, and isolated, it can be tough to know how to satisfy all of these whilst still retaining your will to live.

I’ll be covering a few techniques, and mechanisms, for writing idiomatic Kotlin code that leaves you with a beautiful test case that not only fulfils all this but gives you accurate code documentation for your project.

Refactoring and Test Fakes: Crafting Resilient Code with Confidence

Tue, 23 Apr 2024 00:00:00 +0000

Crafting resilient code is one of the most important things we do as software developers, but it’s much easier said than done! Building with confidence requires an appropriate test harness and automated safeguards to ensure your software is robust.

In most real world scenarios, we don’t have the luxury of working with a green field project, so it can be difficult to apply best practices whilst maintaining legacy code. How then can we refactor, and effectively utilise test fakes appropriately?

Naming is Hard: How Naming Can Bite You in the Ass

Wed, 28 Feb 2024 00:00:00 +0000

Naming is hard, it’s no unfamiliar thing to software engineers that describing our software can sometimes be just as hard as writing it in the first place. But did you know that the names we give our well-intentioned ideas can come back to haunt us?

It would turn out that naming is not just hard, but it has implications! Gradle will often not actually report when names collide! Which means you might end up with unexpected class resolutions! Which leads us down the rabbit hole of, how does Java resolve classes in the first place?!

Refactoring and Test Fakes: Crafting Resilient Code with Confidence

Fri, 27 Oct 2023 00:00:00 +0000

What a Long Strange Trip it's Been: This Year In Android

Fri, 29 Sep 2023 00:00:00 +0000

The Android community is a fast evolving society of excellent people who passionately involve themselves in their ecosystem. This means the progress of developments can be fast, blazingly fast!

Inspired by other content creators and newsletters that keep us informed about the most recent events, I decided to document news, events, and releases every week for a year. Starting from the end of Droidcon Berlin, the world’s best Android developer conference.

Beyond the Mockery: Why We Should Embrace Testing Without Mocking Frameworks

Thu, 28 Sep 2023 00:00:00 +0000

In software development, mocking is a popular technique used to simulate dependencies and test behaviour without relying on external systems. However, as with any technique, there are pros and cons to using mocks.

In this talk, I’ll discuss why using mocks may not be the best approach and why we should instead use fakes or in-memory implementations of well-defined interfaces. We will explore the drawbacks of mocks, including how they can lead to brittle tests, slow down development, and make it difficult to refactor code.

Beyond the Mockery: Why We Should Embrace Testing Without Mocking Frameworks

Thu, 14 Sep 2023 00:00:00 +0000

What a Long Strange Trip it's Been: This Year In Android

Fri, 07 Jul 2023 00:00:00 +0000

The Android community is a fast evolving society of excellent people who passionately involve themselves in their ecosystem. This means the progress of developments can be fast, blazingly fast!

Beyond the Mockery: Why We Should Embrace Testing Without Mocking Frameworks

Thu, 06 Jul 2023 00:00:00 +0000

Résumé

Mon, 12 Jun 2023 00:00:00 +0000

Everything is an API

Thu, 25 May 2023 00:00:00 +0000

When creating a new app module, or modularising an existing one, it becomes easy to forget who might be consuming it. It becomes easy to forget that every decision you make will affect how it is used, or in the worst case, abused. We’re told that code should document itself, but how do these design decisions reflect in the understanding of intended use?

Just because we might not be exposing a module as a public or open-sourced library, doesn’t mean we can’t benefit from making good decisions towards an effective and sensible API.

What a Long Strange Trip it's Been: This Year In Android

Fri, 28 Apr 2023 00:00:00 +0000

The Android community is a fast evolving society of excellent people who passionately involve themselves in their ecosystem. This means the progress of developments can be fast, blazingly fast!

Hype Driven Development: How I Learned to Stop Worrying and Love the Failures

Sat, 03 Dec 2022 00:00:00 +0000

Ever wondered what it would take to combine all the experimental features of a language you love (Spoilers… It’s Kotlin!) into one big bundle?

Demystifying Molecule: Running Your Own Compositions for Fun and Profit

Wed, 30 Nov 2022 00:00:00 +0000

Molecule is a library for turning Composables into Flows. But how does that happen? And why would you want to do such a thing? And why not? In this talk, Ash and Bill will dive a bit into how Molecule does what it does, and help you understand where, when, and how you should use it.

Demystifying Molecule: Running Your Own Compositions for Fun and Profit

Fri, 28 Oct 2022 00:00:00 +0000

Demystifying Molecule: Running Your Own Compositions for Fun and Profit

Thu, 01 Sep 2022 00:00:00 +0000

Everything is an API

Mon, 01 Aug 2022 00:00:00 +0000

Just because we might not be exposing a module as a public or open-sourced library, doesn’t mean we can’t benefit from making good decisions towards an effective and sensible API. By taking the stance that every piece of code we write is an API we can build more versatile and scalable applications.

Hype Driven Development

Wed, 06 Jul 2022 00:00:00 +0000

Ever wondered what it would take to combine all the experimental features of a language you love (Spoilers… It’s Kotlin!) into one big bundle?

Everything is an API

Fri, 29 Oct 2021 00:00:00 +0000

Everything is an API

Wed, 20 Oct 2021 00:00:00 +0000

Everything is an API

Tue, 27 Jul 2021 00:00:00 +0000

How Much QA Is Too Much QA

Mon, 19 Jul 2021 00:00:00 +0000

It’s a common age-old adage, the ongoing war between Software Engineer and QA Engineer, the eternal struggle between the bright-eyed, and those tasked with enforcing practical reality.

I mean not to demonise either party here, this is exactly the picture that can be seen if both are performing their roles adequately.

It is very important to understand, at least from a Software Engineering perspective, that QA Engineers, not out to make your life difficult, and often will be happy to help you work out the kinks… mostly.

Material UX for Engineers

Thu, 27 May 2021 00:00:00 +0000

It’s a familiar story, it’s Monday morning, and you’re ready to start on the latest feature to solve all your user woes! You’re excited! You’re engaged! But then you see the design, your joyous smile fades, your world turns dark once more. Why? Another iOS carbon copy…

It doesn’t need to be this way. Learn how to share the joy of Material Design with your colleagues, and pitch the benefits of a truly native design with user affordance, effective navigation patterns, and usable usability.

Material UX for Engineers

Sat, 22 May 2021 00:00:00 +0000

It’s a familiar story, it’s a Monday morning, and your PM gathers the team together, ready to brief you all on the new, latest and greatest feature to grace your app, solve all your user woes, and bring in countless five-star reviews! You get excited! Why wouldn’t you? This is why we got into this in the first place right? To build exciting and shiny new things, and feel pride when we see our users enjoying the fruits of our labours.

Material UX for Engineers

Fri, 09 Oct 2020 00:00:00 +0000

Working with Dagger and Kotlin

Mon, 05 Oct 2020 00:00:00 +0000

Dagger has become one of the most widely used libraries in Android development, and is often one of the first to be thought of when bootstrapping a new project, but there are still many nuances and caveats that often get overlooked!

Many questions arose after the adoption of Kotlin on how to continue following best practices from Java, so whether you’re using dagger-android or vanilla Dagger, I’ll go through some tips and tricks to make sure you’re using Dagger to its best capacity.

Navigation and the Single Activity: Learnings from a Skeptic

Thu, 11 Jun 2020 00:00:00 +0000

Fragments have often been controversial, and to some, the stuff of nightmares, with the inconsistency of lifecycle events, complex UI interaction, and unexpected behaviours making many Android developers suspicious of their usage.

But with the development and recent stable publication of the navigation library, it may be the right time to give them a chance. Giving Fragments a second chance is not something I’d ever thought I’d be saying, but it’s a fantastic opportunity to find a solution to sharing data across a single screen.

Refactoring Legacy Code with Kotlin

Wed, 10 Jun 2020 00:00:00 +0000

In this session, you’ll learn how to get started with Kotlin in your projects, tips and tricks on how to preserve your version control history, some pitfalls when migrating from Java, and what new technologies you can make use of in your journey with Kotlin.

Refactoring Legacy Code with Kotlin

Thu, 30 Apr 2020 00:00:00 +0000

Legacy code can be quite the challenge to manage, often resulting from untested scenarios, quick fixes, or less than successful initiatives. With few developers wanting to deal with it, it can end up with little remaining knowledge of its inner workings.

We can take many learnings from Michael Feathers book on “Working Effectively with Legacy Code”, but we can also use Kotlin migration as an effective tool to leverage the management, reduction, and removal of legacy code in our applications.

Everything is an API

Mon, 20 Apr 2020 00:00:00 +0000

Refactoring Legacy Code with Kotlin

Wed, 26 Feb 2020 00:00:00 +0000

Navigation and the Single Activity: Learnings from a Skeptic

Sat, 16 Nov 2019 00:00:00 +0000

Fragments have often been the controversial, and to some, the stuff of nightmares, with the inconsistency of lifecycle events, complex UI interaction, and unexpected behaviours making many Android developers suspicious of their usage.

Working with Dagger and Kotlin

Sat, 09 Nov 2019 00:00:00 +0000

Refactoring Legacy Code with Kotlin

Tue, 01 Oct 2019 00:00:00 +0000

Working with Dagger and Kotlin

Tue, 24 Sep 2019 00:00:00 +0000

Implementing the Paging Library

Mon, 09 Sep 2019 00:00:00 +0000

The Android Paging Library makes it easy to integrate complex paging behaviour, gradually loading small chunks of data at a time to help reduce usage of network bandwidth and system resources.

The library allows you to implement this behaviour using compositional components in a decoupled architecture making your code more reliable, scalable, and testable. Furthermore, you’ll be able to use familiar components such as LiveData or RxJava to interface with your existing architecture.

Navigation and the Single Activity: Learnings from a Skeptic

Mon, 09 Sep 2019 00:00:00 +0000

RxJava and Coroutines

Mon, 09 Sep 2019 00:00:00 +0000

Kotlin has taken the Android world by storm, and is quickly becoming the most popular language of choice. With Coroutines now stable, does it make sense to replace your RxJava implementations for Coroutines?

Despite the hype, it may not make sense to jump on the bandwagon just yet. RxJava has already proven its stability and usefulness, and a comparison between the two frameworks shows that they are simply better suited for different purposes.

Refactoring Legacy Code with Kotlin and Coroutines

Fri, 30 Aug 2019 00:00:00 +0000

Implementing the Paging Library

Mon, 26 Aug 2019 00:00:00 +0000

The Android Paging Library makes it easy to integrate complex paging behaviour, gradually loading small chunks of data at a time to help reduce usage of network bandwidth and system resources.

Working with Dagger and Kotlin

Tue, 09 Jul 2019 00:00:00 +0000

Navigation and the Single Activity: Learnings from a Skeptic

Tue, 02 Jul 2019 00:00:00 +0000

A Short History of Android and Reactive Programming: Coroutines Edition

Mon, 03 Jun 2019 00:00:00 +0000

Preface

Last year, there was a hot topic on Twitter about how relevant RxJava was with modern Android development, which garnered a pretty interesting debate with some convincing arguments from both sides.

The claim was that given the popularity of modern frameworks, RxJava is too bloated and should be removed. The debate was even given a catchy title, which prompted a panel discussion at Droidcon Berlin last year, with Hasan, Ivan, x, and myself.

RxJava and Coroutines

Fri, 31 May 2019 00:00:00 +0000

Kotlin has taken the Android world by storm, and is quickly becoming the most popular language, with coroutines approaching stability, does it make sense to replace your RxJava implementations for Coroutines?

Despite the hype, it may not make sense to jump on the bandwagon just yet, with RxJava having already proven its stability and usefulness, and in many cases the comparison between the two frameworks showing that they simply fit different purposes.

Android Jetpack: Navigation Component

Tue, 07 May 2019 00:00:00 +0000

A brief overview of the Navigation Component presented at Google IO Extended at the Google office in Berlin.

Activity Lifecycle Under the Hood

Sun, 28 Apr 2019 00:00:00 +0000

So many candidates nowadays are using live data on interview but less than half of them know how it works and what exact a problems with activity destroy during rotation and keeping activity in the backstack. We have GDE from Berlin Ash Davies to solve that puzzle and show clear picture what to do to deal with the state.

The Dangers of Language Abuse

Sat, 09 Mar 2019 00:00:00 +0000

Much of our responsibility as software engineers is based upon problem-solving, we are required to use our knowledge of available tools, and our experience, to find the most appropriate solution to a given problem.

That’s what I’d like to focus on here, on finding the most appropriate solution.

More often than not, the solution to a problem can be quite simple and doesn’t require over-engineering, which is perhaps where the age-old KISS and YAGNI principles come from.

RxJava and Coroutines

Wed, 30 Jan 2019 00:00:00 +0000

Diving into Flutter: An Android Perspective

Tue, 04 Dec 2018 00:00:00 +0000

Earlier this year I demonstrated the strengths of Flutter by developing a showcase application, in this presentation I talk about my experience with the platform, and how you can use the strengths of Flutter to build fast prototypes and beautiful UI’s with a blazingly fast development cycle.

RxJava and Coroutines

Thu, 22 Nov 2018 00:00:00 +0000

Leveraging Android Data Binding With Kotlin

Mon, 12 Nov 2018 00:00:00 +0000

Android Data Binding is a support library that allows us to bind UI components to data sources declaratively rather than programmatically, it’s potentially really powerful and complex, but used effectively it can really cut down on presentation boilerplate.

We started off with Data Binding beta in 2015 when Google announced it after Google IO as a support library that can be used right back down to Android 2.1 which is API version 7, to write declarative layouts and minimise the glue code required to use your application logic in layouts.

Preparing Your App for Google Play Instant

Fri, 26 Oct 2018 00:00:00 +0000

Android Instant applications are becoming increasingly available, and thanks to the work from the Android platform team can already be installed on devices running Android Lollipop or later.

As an application developer for a large application, or one with plenty of untested legacy code, preparing an application that might be tightly coupled into a single module requires us to carefully de-tangle and move concerns to independent modules.

This talk covers how we managed to prepare our application for instant apps by breaking off base elements and isolating essential key features into self-contained, independent modules, with all the difficulties that this entails and how you can avoid the common pain points and pitfalls.

Leveraging Android Data Binding with Kotlin

Fri, 27 Jul 2018 00:00:00 +0000

Android Databinding is considered as both a powerful toolchain, empowering your views with access to view data without the necessity to build cumbersome presenters, and conversely as an overly complex, convoluted mess of binding statements opening the door to unnecessary, irresponsible domain logic in your view layouts.

Whilst the latter of these statements can be true, Databinding offers a very powerful code generation syntax, allowing you to utilise the power of the compiler to ensure that your binding statements are runtime safe. Combining this with the concise syntax afforded by Kotlin allows us to dramatically cut down on boilerplate and build complex user interfaces with relative ease.

Rx Must Die

Fri, 27 Jul 2018 00:00:00 +0000

Is the learning curve of Rx too steep? Do we overuse Rx Java? Is LiveData an alternative? Do Coroutines and Kotlin build-in features make it obsolete?

The Context: Episode 21: Rx Must Die

Berlindroid: Kotlin Test Robots

Thu, 28 Sep 2017 00:00:00 +0000

Following the announcement at this years Google IO we’ve seen a dramatic uptake in Kotlin and over the last few months we’ve learnt how we can use it to improve and produce clean architecture applications and supercharge our unit tests, but what about our UI tests?

In this session, I’ll show you how you can utilise Kotlin with the Robot pattern to build concise, terse and easy to read UI tests

Embracing Impostor Syndrome

Fri, 21 Jul 2017 00:00:00 +0000

Early on in my career, you could say I had what you might like to call a mentor, we were friends, we still are, and naturally he taught me a few things.

Things like how to be taken seriously in the workplace as a young developer, how to deal with office politics, but also something quite significant, which has stuck with me since then.

Something that I’ve always believed to be his mantra, to, as he would put it, “fucking own it”.

The Highs and Lows of Developing for a Digital Europe

Tue, 27 Jun 2017 00:00:00 +0000

This event will focus on the state of the mobile economy in Europe. Data shows that the ecosystem is thriving, for the benefit of consumers, business and investors. Such a growing and innovative space needs an enabling regulatory environment to continue to prosper. Come and join us for a discussion with developers and decision makers about the future of mobile innovation in Europe.

Dagger 2: Module Parameters

Mon, 19 Jun 2017 00:00:00 +0000

Last month, I went into detail about how to use the recently released Dagger 2 Android modules, and how you can make your injection code much more concise.

Google have gone through a lot of effort to enable developers to use Dagger with very little integration and more importantly on how to use a common injection paradigm without the injection target being concerned with how it is being provided with it’s necessary dependencies.

Dagger 2: Android Modules

Mon, 01 May 2017 00:00:00 +0000

Many of the articles I write tend to involve application structure or architectural design patterns; and one of the most recurring topics I tend to visit is that of dependency injection.

Dependency injection is probably one of the most important topics of modern application development, whilst often overlooked as a necessity, it allows us to build highly scalable, powerful applications and platforms.

Dependency inversion works seamlessly with many other design principles and in many ways facilitates them, most specifically single responsibility. Effective dependency injection is achieved by providing dependencies through the constructor, usually as interface types, thereby allowing the class in focus to not worry about the instantiation of these types. I’ve gone into further detail about this in my previous article Effective Dependency Injection.

Effective Naming Conventions

Sun, 30 Apr 2017 00:00:00 +0000

Modern day development can be one of the most tasking professions around, but without a doubt also one of the most rewarding. Amongst the trialling tasks we must go through each day, one of the most arguably difficult necessities is how we name our types.

This is partly due to the different naming conventions that come into play when using multiple words, underscores, hyphen, camel-case. Though we usually have code style guidelines to enforce a consistent use, this doesn’t really address the original problem.

Effective Dependency Injection Scoping

Mon, 10 Apr 2017 00:00:00 +0000

The concept of dependency injection is a relatively simple one, and can usually be adhered to with a small set of rules when writing your code.

Specifically, avoid creating new instances of objects within your classes, and opt to have the instance provided through the class constructor. This allows your class to focus on the key operations without having to worry about the state or creation of it’s dependencies.

This means that your class will be small, concise, readable, and most importantly, easily maintainable since it only contains the logic required to perform the necessary operation.

What the IOException!?

Wed, 30 Nov 2016 00:00:00 +0000

Mobile Innovation Day

Mon, 14 Nov 2016 00:00:00 +0000

Europe’s mobile economy is a hotbed for innovation - driving growth, and jobs and enabling millions of consumers to access the world’s information while they’re on the move.

What is needed to ensure this mobile ecosystem remains competitive and innovative in the future? What policies can boost the impact of mobile on the wider economy and remove barriers to future growth?

Join app developers, business leaders and policymakers at an event to discuss ways to power growth in the mobile economy.

What's New in Firebase

Sat, 12 Nov 2016 00:00:00 +0000

After this years Google I/O, Firebase was upgraded and become an even more important role in the range of Google services available. Now properly integrated with Google Services, Firebase offers developers much more than than just a database for “personal” projects.

The new updated Firebase however has left many developers a bit puzzled on how to properly include Firebase in their projects, how it integrates into Google Services, and how they can make use of the new features available.

Google IO Agile Retrospective

Wed, 27 Aug 2014 00:00:00 +0000

Google Glass

Mon, 18 Aug 2014 00:00:00 +0000