Today we're launching enhanced query support across our iOS, Android, and Web clients, and the Firebase REST API! You can now query your data by any child key in Firebase. Querying has been a frequently requested feature and we’ve made great strides based on developer feedback since our beta release last month.

This release dramatically improves the way you can query your data in Firebase. With our new querying methods you can order and retrieve your data using a child key, by key name, or by priority. Our existing priorities-based ordering will continue to work, but I encourage you to try out the new queries features as it is much more flexible.

A basic Firebase query starts with one of our orderBy functions: orderByChild(), orderByKey() or orderByPriority(). You can then combine these with five other methods to conduct complex queries: limitToFirst(), limitToLast(), startAt(), endAt(), and equalTo(). Since all of us at Firebase agree that dinosaurs are pretty cool, we’ll use this sample firebase of dinosaur facts to demonstrate how you can write complex, realtime queries. To start, we can use orderByChild() to retrieve dinosaurs ordered by height:

var ref = new Firebase("https://dinosaur-facts.firebaseio.com/dinosaurs");
ref.orderByChild("height").on("child_added", function(snapshot) {
  console.log(snapshot.key() + " was " + snapshot.val().height + " meters tall");
});

Firebase *ref = [[Firebase alloc] initWithUrl:@"https://dinosaur-facts.firebaseio.com/dinosaurs"];
[[ref queryOrderedByChild:@"height"]
    observeEventType:FEventTypeChildAdded withBlock:^(FDataSnapshot *snapshot) {

    NSLog(@"%@ was %@ meters tall", snapshot.key, snapshot.value[@"height"]);
}];

Firebase ref = new Firebase("https://dinosaur-facts.firebaseio.com/dinosaurs");
Query queryRef = ref.orderByChild("height");

postsQuery.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot snapshot, String previousChild) {
        System.out.println(snapshot.getKey() + " was " + snapshot.getValue().get("height") + " meters tall");
    }
    // ....
});

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"'

We can also use our limit methods to return the two heaviest dinosaurs in our Firebase:

var ref = new Firebase("https://dinosaur-facts.firebaseio.com/dinosaurs");
ref.orderByChild("weight").limitToLast(2).on("child_added", function(snapshot) {
  console.log(snapshot.key());
});

Firebase *ref = [[Firebase alloc] initWithUrl:@"https://dinosaur-facts.firebaseio.com/dinosaurs"];
[[[ref queryOrderedByChild:@"weight"] queryLimitedToLast:2]
    observeEventType:FEventTypeChildAdded withBlock:^(FDataSnapshot *snapshot) {

    NSLog(@"%@", snapshot.key);
}];

Firebase ref = new Firebase("https://dinosaur-facts.firebaseio.com/dinosaurs");
Query queryRef = ref.orderByChild("weight").limitToLast(2);

queryRef.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot snapshot, String previousChild) {
        System.out.println(snapshot.getKey());
    }
    // ....
});

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="weight"&limitToLast=2'

Adding it all together with our range methods (startAt() and endAt()) we can find all dinosaurs that are at least three meters tall:

var ref = new Firebase("https://dinosaur-facts.firebaseio.com/dinosaurs");
ref.orderByChild("height").startAt(3).on("child_added", function(snapshot) {
  console.log(snapshot.key())
});

Firebase *ref = [[Firebase alloc] initWithUrl:@"https://dinosaur-facts.firebaseio.com/dinosaurs"];
[[[ref queryOrderedByChild:@"height"] queryStartingAt:@3]
    observeEventType:FEventTypeChildAdded withBlock:^(FDataSnapshot *snapshot) {

    NSLog(@"%@", snapshot.key);
}];

Firebase ref = new Firebase("https://dinosaur-facts.firebaseio.com/dinosaurs");
Query queryRef = ref.orderByChild("height").startAt(3);

queryRef.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot snapshot, String previousChild) {
        System.out.println(snapshot.getKey());
    }
    // ....
});

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&startAt=3'

The best part is that all these queries will update in realtime as the data changes in your Firebase. There’s more I haven’t covered, so be sure to read the documentation for the iOS, Android or Web clients or the REST API to learn about all the new features.

With querying, we’re also introducing a new indexOn rule type to the Firebase Security and Rules language. You can use indexOn to tell your Firebase which child keys your app uses in queries. A node's key and and priority are indexed automatically, so there is no need to index them explicitly. Using indexOn is optional and can be left off for prototyping, but it will dramatically improve performance so you'll want to add it once you've figured out the indexes your queries will use.

There's more coming!

While this represents a big step forward in terms of our querying capabilities it also lays the groundwork for even more improvements. We have a number of exciting features in the pipeline for our SDKs, including more queries improvements. And as always, we'd welcome your feedback on what you'd like to see next.

Let us know what you think in our Google Group or on Twitter, and send any suggestions to firebase-support@google.com.

Over the past three years, we’ve gone from a crazy idea that ‘just might work’ to a proven product used by 110,000 developers. Today, I couldn’t be happier to announce that we’ve joined Google.

Why?

Two big reasons.

First, Google’s backing allows us to dramatically scale Firebase. We’re proud of what we’ve built over the last three years, but we’ve only scratched the surface of the opportunity ahead of us. With Google’s engineering talent, resources, and technical infrastructure, we’ll be able to do much more, much faster.

Second, our products and missions are highly complementary. Both the Firebase and Google Cloud Platform teams come to work each day for the same reason: to help developers create extraordinary experiences. By joining forces, Firebase developers will gain access to a powerful cloud infrastructure suite, and Cloud Platform customers will gain access to our rapid development capabilities. Together we’ll deliver a complete platform for mobile and web apps.

What's next?

Firebase is here to stay and grow. You can continue to count on the same great development experience, tools, libraries and community commitment that have become synonymous with Firebase. If you’re a developer who has built an app on top of Firebase, nothing will change for you, and you can continue to use Firebase as you normally would. We’ll continue to be platform agnostic and provide clients for iOS, Android, the web, and more.

To our developer community, thank you. Building Firebase has been a challenge and you’ve helped immensely with your encouragement and support. Thank you for your API feedback, answering StackOverflow questions, submitting pull requests to our open source projects, and building your apps on Firebase. Many of you have bet your startups and careers on us -- we’re constantly humbled by this and look forward to serving you for many years to come.

You can read Google’s announcement here. Also, we'll be sharing more at Google Cloud Platform Live on November 4th in San Francisco. We'd love for you to join us in person to meet our team and learn about the great things we're working on. If you can't make it, don't worry - everything will be streamed live.

Finally, if you’d like to come and help us write the next chapter of Firebase, we’re hiring.

Happy coding,

James Tamplin

Co-Founder & CEO

With the fall hackathon season underway, we’ve had a chance to introduce a ton of talented college students to Firebase. We continue to be amazed by the hacks students are building in just a few hours (with barely any sleep!).

Last month we participated in MHacks, where students used Firebase to build things like “collaborative graffiti via text” and “real world Pokemon”. At CalHacks this past weekend, the best hardware hack used Firebase for a shirt that tracks your posture in realtime. See below for a recap of our favorite Firebase hacks from MHacks and CalHacks.

MHacks

Abe, Chris, Joey and Mike from Firebase traveled to Ann Arbor, Michigan to support 1,100+ hackers from across the country at MHacks. At the end of the hackathon, 34 teams used Firebase to store and sync their app’s data in realtime. These were the Firebase top two:

VoteApp

Our top prize went to VoteApp, a web based voting platform where users can create a new poll and display the results in realtime. Designed to replace an expensive and specialized device currently used for voting in class, these four students wanted to build a universal and free solution. Use it to run your next classroom poll, it’ll be the easiest one you’ve ever done!

City Paint

Our second place prize went to City Paint, which aims to reduce the prevalence of graffiti in urban areas by creating an online graffiti wall. These virtual walls can be placed around cities, and residents can text ASCII art to the wall and watch as their tags are added in realtime.

CalHacks

Over half of the Firebase team had the opportunity to meet the 1,000+ hackers at the amazing Cal Memorial Stadium last weekend. We had a great time helping hackers, and were impressed by their uses of the Firebase API. Both winners of our prize connected hardware to Firebase for realtime IoT awesomeness.

Nextile Shurt

The Nextile Shurt team built a device with flex sensors and accelerometers that ran on two Intel Edison boards. It captured motion data in realtime and displayed the data on a web app. The best part? They attached their device to a shirt, so that when you move the degree of motion is stored in Firebase. It can be used to track posture or for physical therapy.

Pomsafe

Our second place prize went to the Pomsafe team. Pomsafe is a home security and automation platform running from a Texas Instruments LaunchPad, powered by Firebase. When the device is attached to a door, it monitors temperature in realtime and reports when the door is opened to detect possible break-ins.

We're always excited to see what students build with Firebase in such a short amount of time, and we can't wait for the next hackathon! Follow us @Firebase on Twitter to find out which hackathons we'll be attending next.

Today Y Combinator is launching an API for it’s popular startup-focused news aggregator, Hacker News. As a YC company that launched on HN ourselves, we’re thrilled that they are putting their public data into Firebase. This means that developers can easily get realtime access to HN’s data
through the standard Firebase Web, iOS, Android and REST APIs.

With 2.6 million unique visitors per month, Hacker News (HN) has a huge audience of programmers and entrepreneurs. HN users submit interesting stories from around the web that are upvoted by other users. When a post receives enough upvotes it makes it to the front page. This results in a lot of interesting content and discussion, and a rapidly changing set of articles. HN is so popular that developers have taken to scraping the site in order to access its content. Using Firebase now makes it much easier for developers to build apps using data from HN.

Firebase is an ideal way to distribute HN in realtime across a variety of clients. With our scalable, easy to use platform HN now has a realtime API available to Web, iOS, and Android developers. The API is also accessible on other platforms through our REST API.

To quote Kevin Hale from YC:

“In addition to giving developers near real-time access to our data, we got out of the box well designed, easy to use SDKs for iOS, Android and the Web, in addition to a REST API for developers building server apps. It should hopefully making switching your apps fairly painless.”

Get started

You can access the HN API today, here’s a simple example that displays the top rated HN article and updates in realtime.

See this example running live on JSFiddle.

var ref = new Firebase("https://hacker-news.firebaseio.com/v0/");
var itemRef;

ref.child('topstories').child(0).on('value', function(snapshot) {
 if(itemRef) {
  itemRef.off();
 }

 //Get the ID of the top article
 var id = snapshot.val();

 //Get the article details and update in realtime
 itemRef = ref.child('item').child(id);
 itemRef.on('value', function(snapshot) {   
  var item = snapshot.val();

  document.getElementById("score").innerHTML = item.score;

  var anchor = document.getElementById("article_a")
  anchor.innerHTML = item.title;
  anchor.href = item.url;

  document.getElementById("comments_a").href = "https://news.ycombinator.com/item?id=" + item.id;
 });  
});

Firebase *ref = [[Firebase alloc] initWithUrl:@"https://hacker-news.firebaseio.com/v0/"];
__block Firebase *itemRef = nil;
Firebase *topStories = [ref childByAppendingPath:@"topstories"];
Firebase *firstStory = [topStories childByAppendingPath:@"0"];

FirebaseHandle handle = [firstStory observeEventType:FEventTypeValue withBlock:^(FDataSnapshot *snapshot) {
    if(itemRef != nil) {
        [itemRef removeObserverWithHandle: handle];
    }
    
    NSString *itemId = [NSString stringWithFormat:@"item/%@",snapshot.value];
    itemRef = [ref childByAppendingPath:itemId];

    [itemRef observeEventType:FEventTypeValue withBlock:^(FDataSnapshot *itemSnap) {
        NSLog(@"%@", itemSnap.value);
    }];     
}];

final Firebase ref = new Firebase("https://hacker-news.firebaseio.com/v0/");
final Map<Long, ValueEventListener> valueEventListenerMap = new HashMap();

ref.child("topstories").child("0").addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot snapshot) {
        if(!valueEventListenerMap.isEmpty()) {
            for(Long id : valueEventListenerMap.keySet()) {
                ref.child("item").child(String.valueOf(id)).removeEventListener(valueEventListenerMap.get(id));
            }

            valueEventListenerMap.clear();
        }


        //Get the ID of the top article
        Long id = (Long) snapshot.getValue();

        //Get the article details and update in realtime
        ValueEventListener articleListener = ref.child("item").child(String.valueOf(id)).addValueEventListener(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
                Map itemMap = (Map) snapshot.getValue();

                // Print the title to the console
                System.out.println(itemMap.get("title"));
            }

            @Override
            public void onCancelled(FirebaseError firebaseError) {

            }
        });

        valueEventListenerMap.put(id, articleListener);
    }

    @Override
    public void onCancelled(FirebaseError firebaseError) {

    }
});

Check out the full HN documentation at hacker-news.firebaseapp.com.

Firebase is your API

With more than 100,000 developers using our platform, we’ve seen Firebase used both as the entire backend for apps as well as to power specific realtime features in apps. A growing use case has been loading data into Firebase to expose an API to other developers. Traditionally, building and maintaining a public API is a big undertaking; often entire teams are dedicated to it. It’s not easy to give third party developers access to your data in a way that’s both safe for your users and powerful for those developers. With Firebase, all you need to do is sync data to your Firebase and API consumers can then use one of Firebase’s realtime clients or the REST API to consume that data. You don’t have to worry about scaling with developer usage and or documenting anything beyond your data structure. You can learn more in a blog post we published last year.

We can’t wait to see what you build!

Last week, we released v1.0.0 of our open-source apps Firepad and Firechat! These are two great open-source modules built on top of Firebase that you can take and use in your own apps.

Firepad is a collaborative text editor. It lets you bring the features of Google Docs right into your app. Firepad can handle both code and rich text, and is currently being used in production by Atlassian, LiveMinutes, and CoderPad to name a few.

Firechat is a realtime chat app built with Firebase. Firechat’s features include multi-user / multi-room chat, flexible authentication, moderation, presence, private messaging, chat invitations and more. CBS is using Firebase to power the realtime chat for their Big Brother TV series.

Orginally we built both of these modules to showcase the realtime and collaborative power of Firebase, but they’ve grown into full-featured, production-ready pieces of functionality. Both projects have reached the point where they’re stable, full-featured and well-documented, so we’ve decided to officially tag them as 1.0!

Here's what's new in the 1.0.0 releases:

Firepad 1.0.0

With help from the community, we’ve added some highly-requested features and fixed many bugs over the past few months.

We added a headless mode for interacting with documents programmatically with no GUI (e.g. from your backend server code). It can run in Node or in a browser. To use it from Node, just run npm install firepad, require the module, and add a headless instance of Firepad using the following code:

var Firepad = require('firepad');
var headless = new Firepad.Headless('');

We've made a number of API improvements to make writing apps using Firepad easier. For instance, there's a new defaultText option to specify initial text to be loaded in Firepad, and there's a new "synced" event to notify you when your changes have successfully been synced with Firebase so you can provide notice to the user. See the API docs for full details.

We've also fixed many minor bugs and UI issues to make the collaborative editing as fluid and seamless as possible! Firepad is now available on the Firebase CDN as well as Bower, making it even easier to include in your app.

Firechat 1.0.0

Our Firechat homepage is now hosted on Firebase Hosting. In addition to this, we’ve improved the documentation, fixed bugs, and added warning messages to make development easier. Firechat now works well with other frameworks like Twitter Bootstrap, so you can customize the app’s default styling.

We'd like to hear from you!

If you’re using Firepad or Firechat in your apps, we’d love your input. Email us any feedback at firebase-support@google.com or submit a pull request on GitHub. We’re excited to see what you build!

Ever since we released GeoFire for JavaScript, we've seen many requests for mobile ports of the library. Today, we're happy to announce GeoFire for iOS and Android!

GeoFire is now supported on our three major platforms - web, iOS and Android - and each library is open source! Each version comes with a sample app, which queries and displays San Francisco public transportation data in realtime.

You can find the corresponding sample apps as part of the GeoFire repos for Objective-C and Java.

What is GeoFire?

If you're new to GeoFire, it's a geolocation library that maps string keys to locations and stores them in Firebase. Using GeoFire, you can answer a simple but important question: Which keys lie within a given geographic region? But GeoFire's features don't stop at simple location queries, it's true power is that everything happens in realtime. When objects move, events will be fired as they enter, exit and move around the region.

GeoFire opens a wide range of possibilities: You can build an app that displays who's going for a run within a mile radius of yourself and show their location in realtime. You can display taxis within a search radius and animate them as they move. Or you can build an app that simply lists all interesting bars nearby.

Building your next app with GeoFire

The GeoFire libraries are available as a XCode Framework and as a Java jar-file for easy integration. Add them to your app, include the Firebase library and you're ready to go.

All three versions are compatible with each other. If you are storing locations in your iOS or Android app, you will be able to query them in the web and vice versa.

Take a look at our quick start guides for the Objective-C and the Java versions to get familiar with GeoFire on each platform.

Structuring your data

GeoFire is designed to be a lightweight add-on for Firebase, not a replacement. As such, you will continue to store your data just as you would normally do in Firebase and use GeoFire to query keys by location.

Let's assume we're building a social running app, where we want to display stats for all runners in our area. We'll start by storing basic data for each user like the following:

{
  "users": {
    "steve123": {
      "displayname": "Steve T.",
      "age": 29,
      "location": [37.12314, -122.49182],
      "stats": {
        "averageSpeed": 11.2,
        "currentSpeed": 9.7,
        ...
      }
    },
    "nikky_kay": {
      "displayname": "Nicole",
      "age": 37,
      "location": [37.67134, -122.32990],
      "stats": {
        ...
      }
    },
    ...
  }
}

Now that we've stored our user information in Firebase, we'll use GeoFire to search for nearby runners in realtime. In this example, we're storing each user by their username, and the user's location as a pair of latitude-longitude coordinates. By keeping the location key as a child of the user key, we can listen for realtime updates for a single user. Everytime we update the location of a user we simultaneously update the location for that user in GeoFire.

We'll now use a GeoQuery to retrieve all keys (usernames in this example) in a given geographic region. Using the key entered and key exited events, we can keep track of all users currently matching the query, e.g. with a NSMutableSet in Objective-C or Set<String> in Java.

NSMutableSet *runnersNearby = [NSMutableSet set];

// query around current user location with 1.6km radius
GFQuery *query = [self.geoFire queryAtLocation:currentUserLocation withRadius:1.6];

[query observeEventType:GFEventTypeKeyEntered withBlock:^(NSString *username, CLLocation *location) {
    [runnersNearby addObject:username];
    // additional code, like displaying a pin on the map
    // and adding Firebase listeners for this user
}];

[query observeEventType:GFEventTypeKeyExited withBlock:^(NSString *username, CLLocation *location) {
    [runnersNearby removeObject:username]
    // additional code, like removing a pin from the map
    // and removing any Firebase listener for this user
}];

final Set<String> runnersNearby = new HashSet<String>();

// query around current user location with 1.6km radius
GeoQuery geoQuery = geoFire.queryAtLocation(currentUserLocation, 1.6);

geoQuery.addGeoQueryEventListener(new GeoQueryEventListener() {
    @Override
    public void onKeyEntered(String username, GeoLocation location) {
        runnersNearby.add(username);
        // additional code, like displaying a pin on the map
        // and adding Firebase listeners for this user
    }

    @Override
    public void onKeyExited(String username) {
        runnersNearby.remove(username);
        // additional code, like removing a pin from the map
        // and removing any Firebase listener for this user
    }

    ...
});

We're ready to update our UI in realtime! Now that we know which users are nearby and we want to display, we can add a normal Firebase listener to each user and keep their stats updated in realtime. Remember, adding a listener in Firebase is a very lightweight operation, and adding thousands of listeners is not a problem. If a user ever moves outside the query, all we need to do is remove that listener and update our UI.

Build the future of realtime location apps with GeoFire

We're excited to see the amazing apps you build with Firebase and GeoFire! If you have any feedback on our new mobile libraries, you can email me at jonny@firebase.com or send us a pull request.

This past weekend Y Combinator hosted a hackathon, YCHacks. 540 developers answered the call. Over the weekend they turned pizza, energy drinks, and APIs into 123 projects.

At Firebase we really love hackathons, so it didn't take much effort to convince about half of the team to attend. This gave us a great opportunity to exchange high fives with developers who use Firebase. It turned out to be quite a few high fives because 34 teams used Firebase including two of the top three prize winners. In fact, so many developers used Firebase, that nearly 4% of the total network traffic was to our API servers.

All of the presentations were impressive, but a couple stood out as the best realtime apps.

Awear

Awear combines the Myo gesture detection arm band with Bluetooth location beacons to provide you with a way to control the technology near you by waving your hand. For example, when you're in the living room, a hand gesture might turn on the music, and in the kitchen the same gesture could flip through a digital cookbook.

Awear is a great example of how ubiquitous Internet connectivity is going to change the way devices talk to each other. With so many devices interacting with each other, the team found inter-device communication challenging. At 3:00 AM on Saturday they decided to give Firebase a go. Within a couple hours, all of the hardware was working in harmony. To quote them, "Firebase, you saved our lives!"

Vrniture

Virtual reality makes a lot of new, amazing experiences possible, but the Vrniture team also thinks it can change the way we do some more mundane tasks. Specifically, shopping for furniture. Vrniture used Firebase to wire up 3d models of your room with models of furniture you might like. It then presented a preview on an Oculus Rift so that you can experience new furniture in your home without having to rent a truck.

Other cool apps

Those were our favorite examples of realtime development with Firebase, but there was other cool stuff too. A lot of it happened to be powered by Firebase.

Quantified High Fives

High fives keep many of us running. They're an effective way to smack back the things that get us down. But as effective as they are for happiness, they're hard to track. It's hard to know if you've had your prescribed dose.

Quantified High Fives changes all that. It uses the motion sensor in the Pebble smartwatch, and a Firebase to accurately and effectively track your intake of High-5s. It even displays your current count in realtime. Now when you wonder, "Have I had enough?" your Pebble smartwatch and Firebase can tell you.

Athelas

Tanay Tandon of team Athelas added a hemispherical lens to an iPhone and discovered that the optically enhanced camera was able to image individual blood cells. He then threw OpenCV at in an attempt to identify blood borne pathogens, like Malaria. In other words, he turned commodity electronics into a low cost blood scanner. The scanner app then stores test results in Firebase.

Thanks everyone

YCHacks was great fun. We really enjoyed seeing all of the ways that people used Firebase, and we can't wait for the next one!

There was some celebration in our office yesterday as the total number of concurrent network connections to our servers topped one million for the first time. This is a much bigger milestone than simply one million total users; it means that at this very moment there are one million users active on Firebase-powered apps.

We’ve Grown Up

Firebase is no longer the scrappy little startup you might remember from our launch more than two years ago. We’ve grown up. More than 83,000 developers have created over 100,000 applications using our platform. Our servers handle 24,000,000 user sessions every day, and in the last month we’ve seen traffic from over 50,000,000 unique IP addresses (over 1% of the IPv4 address space!). Our customer list now includes large companies like Google, Yahoo, and Citrix, as well as up-and-coming startups like Instacart, Nitrous.io, and Invision.

Our team has grown as well. One year ago, there were seven of us. Today, there are 24 (plus an intern), including new folks hailing from great companies like Google, Microsoft, and Salesforce. We’ve even welcomed our first PhD to the team.

The Future

The last couple years have been a whirlwind, but we’re far more excited about what’s coming next. Nearly every part of our product has new features currently under heavy development. In fact, most of the work we’ve done over the last year has been on features that have yet to be announced. Expect big upgrades to our core API, mobile support, security API, tooling, educational resources, and framework integrations in the near future.

Mobile is an especially bright spot for us. Our sync-based API is especially powerful on mobile devices where network connections are spotty or absent. As a result, Android and iOS are now our fastest growing platforms, and we’re putting a ton of resources into improving our mobile featureset.

Thank You!

None of this would have been possible without a ton of community support. Thank you for your help, whether that was providing API feedback, contributing to our open source projects, answering questions on our Google Groups, or simply telling a friend about our service.

We’d invite you all by our office so we could thank you in-person, but we know most of you are not in San Francisco. So instead, if you’d like us to send you some delicious Firebase Hot Sauce and other swag, shoot us an email and we’ll hook you up. Or, if you are in fact in San Francisco, you’re welcome to come by for office hours any Friday.

Thanks again, and we look forward to updating you again at 10,000,000 concurrents!

Greg and Mark are the Co-Founders of Pathwright, an online education platform built with Firebase and hosted on Firebase Hosting.

What is Pathwright?

Pathwright is a platform for online education that allows anyone to teach and sell online courses under their own name and brand.

What inspired you to build the app?

Education is something that is easy for us to get excited about. Most of our team is comprised of former or current professional educators. Drawing from past experiences, we saw a great opportunity to fix some of the problems we saw with online learning.

Most software developed for education has been designed to supplement classroom use, not to deliver a full education online. Additionally, the user experience for teachers and students is often very poor. We started Pathwright to give forward thinking teachers an easier, more attractive way to share knowledge online.

How are you using Firebase in your app?

The most heavily trafficked system being powered by Firebase is our notification system. It allows us to notify students and teachers about important events that are happening in real time.

Secondly, we use Firebase to host our Pathwright.com marketing website. We previously hosted our website on Amazon S3 behind CloudFront, but the cost of using our pathwright.com SSL certificate with CloudFront was significant in comparison to Firebase.

Given that we are a small team, making use of Firebase has saved time and money from a development and operational standpoint. We have been able to continue working on our core platform instead of hassling with the additional infrastructure.

Since Pathwright was one of the first production apps to use Firebase Hosting, do you have any feedback for other developers using this service?

The automatic provisioning of SSL certificates was a time-saver, and a great value. Additionally the documentation was simple, and the whole process took about ten minutes from start to finish.

Since we were a very early adopter, we contacted support to ask about a feature that we didn’t see available yet. Firebase support responded quickly and helped us get a workaround in place within 24 hours, allowing us to re-launch with Firebase almost immediately. Customer service was fast, friendly, and thorough.

Firebase Hosting has been great for us and our customers. We recommend it without hesitation.

What other technologies are you using?

On the server side we’re running on Amazon Web Services. Some of the more critical pieces of our stack include Linux, Postgres, Python, Django.

On the client side we develop in CoffeeScript, Sass, and Backbone.js with Marionette.

What are some of your favorite use cases of Pathwright?

We have a variety of customers covering a wide range of topics on Pathwright. Some of our favorites include Integral Calc, GetElected and Ligonier Connect.

GeoFire is an open-source JavaScript library that allows you to store and query a set of items based on their geographic location. GeoFire uses Firebase for data storage, allowing query results to be updated in realtime as they change. GeoFire does more than just measure the distance between locations; it selectively loads only the data near certain locations, keeping your applications light and responsive, even with extremely large datasets.

Live Demo

To showcase the power and simplicity of GeoFire, we built a demo which uses it alongside our Firebase Transit Open Data Set. The demo allows you to drag a circle around San Francisco and see all MUNI (the public transit system for the city) vehicles which are currently within it. Since GeoFire is built on top of Firebase, the demo updates in realtime as you drag around the circle and as new data comes in.

The GeoFire data for this demo is stored in a public Firebase which is freely available for use by any developer. We also provide GeoFire data for our latest open data set, launching today, Parking.

In addition to the MUNI demo, we created several other examples which show you how to perform common tasks in GeoFire. The code for all examples, including the MUNI demo, is available in the GeoFire GitHub repository.

GeoFire 2.0

A growing number of apps and websites - from car-sharing services to food recommendation apps to local event aggregators - alert users to places or things near them. While server-based solutions for geolocation queries are nothing new, there was nothing which allowed you to do them efficiently in Firebase. So we introduced GeoFire last September to provide you with an easy way to do client-side, on-the-fly filtering of geolocation data.

GeoFire 2.0 is a complete rewrite of that GeoFire library. We simplified the API and aligned it closer to the Firebase JavaScript client API you are already familiar with. You can now do even more with smaller, cleaner code. This version of GeoFire is now "production ready" - we have improved performance, added several common feature requests, and are ensuring its quality with a comprehensive test suite.

Quick Walkthrough

The best way to see what GeoFire can do is to jump right into the code. GeoFire has dependencies on Firebase (for realtime data storage) and RSVP (for an implementation of JavaScript promises), so we need to include them in our HTML file along with the GeoFire library:

<head>
  <!-- RSVP -->
  <script src="path/to/rsvp.min.js"></script>

  <!-- Firebase -->
  <script src="https://cdn.firebase.com/js/client/1.0.17/firebase.js"></script>

  <!-- GeoFire -->
  <script src="https://cdn.firebase.com/libs/geofire/2.0.0/geofire.min.js"></script>
</head>

The necessary files are also available via Bower and npm. See the GeoFire documentation for full download instructions.

GeoFire stores its data at whatever Firebase location you choose to pass it:

var firebaseRef = new Firebase("https://<your-app>.firebaseio.com/geofire/");
var geoFire = new GeoFire(firebaseRef);

Once you have created a GeoFire instance, you can add locations to it using set(). It takes as input a unique, arbitrary key to represent the location as well as the location's latitude-longitude pair:

geoFire.set("some_key", [37.785326, -122.405696]).then(function() {
  console.log("Provided key has been added to GeoFire");
}, function(error) {
  console.log("Error: " + error);
});

To retrieve the location of a key at any time, pass the key to get():

geoFire.get("some_key").then(function(location) {
  if (location === null) {
    console.log("Provided key is not in GeoFire");
  }
  else {
    console.log("Provided key has a location of " + location);
  }
}, function(error) {
  console.log("Error: " + error);
});

GeoFire's real utility is shown by creating a GeoQuery. Say you are making an app for cyclists which shows the bicycle shops within a mile (1.609 kilometers) of a user's current location. The first thing you need to do is add the bike shops you care about to GeoFire. Then, create a query centered at the user's current location (let's say they are at [37.4, -122.6]):

var geoQuery = geoFire.query({
  center: [37.4, -122.6],
  radius: 1.609 //kilometers
});

A query on its own is not very useful. However, GeoFire allows you to add callback functions which are fired when important query events happen. Since you want to display every bike shop which matches the query criteria, listen for the key_entered event. Every time a key (that is, a bike shop) enters the query, the callback you defined will get called with data about that location:

geoQuery.on("key_entered", function(key, location, distance) {
  console.log("Bicycle shop " + key + " found at " + location + " (" + distance + " km away)");
});

It is important to realize that the key_entered event works like typical Firebase events. That is, it will be fired for every key in GeoFire which matches the query criteria, both keys which are already in GeoFire and those which are added at any point in the future. Thanks to Firebase, you receive these events in realtime.

GeoFire is smart about how it looks for keys within the query. It does not need to load all of the GeoFire data into memory. If your user is looking for bicycle shops in San Francisco, GeoFire will not load data for locations in New York only to realize that they are on the opposite side of the country. It only checks on locations which are actually nearby. This keeps your app light and responsive, regardless of how big your data set is.

If your user is biking around while looking for a shop to visit, it is possible that shops which were within a mile of them are now further away. To deal with this, GeoFire will fire the key_exited event for each key which leaves the query:

geoQuery.on("key_exited", function(key, location, distance) {
  console.log("Bicycle shop " + key + " left query to " + location + " (" + distance + " km away)");
});

That is really all you need to make your app work. GeoFire offers other features not covered here, including:

• Removing locations
• Updating query criteria
• Canceling queries
• Dealing with keys which move around within a query
• Alerting you when initial data is processed

To learn more about these features, read the full documentation and view the code samples.

Go Forth And Build!

GeoFire 2.0 is available today and is ready to be integrated into your website or app. If you have any questions or feedback, post them in our Firebase Google Group or reach out to us on Twitter. We cannot wait to see what you build with GeoFire!

Cy is the Founder of Crowdsound, a realtime audience engagement tool built with Firebase and Angular.

What is Crowdsound?

Crowdsound is a one-stop shop for live events.