Rhiza Blog Events

Rhiza CEO to be Keynote Speaker at Carnegie Mellon Event

Josh Knauer, Rhiza’s CEO, will be the keynote speaker at a Carnegie Mellon University event that is intended to help inspire students and alumni to build their careers by featuring alumni “who have successfully and interestingly navigated their way forward.” The event is titled Under Construction: Building Your Future and happens this Saturday, February 23rd. Read more about the event.

Rhiza CEO Speaks on World Financial Symposium Panel

Rhiza CEO, Josh Knauer, is speaking today on a panel hosted by the World Financial Symposium titled, “Where is Everywhere: M&A in Geospatial & Location-based Technology”. Josh will be speaking about emerging trends in the marketing and advertising markets’ use of location-based data to increase ad sales, better target messaging and understand/grow audiences.

Here’s the announcement from WFS:

World Financial Symposiums invites you to attend the Market Spotlight Web Event “Where is Everywhere: M&A in Geospatial & Location-based Technology”.

The convergence and maturation of several markets and technologies–geospatial, GPS, business intelligence, mobile marketing and much more–is driving high valuations among companies that doing cutting edge work related to location data. Some analysts predict a wave of consolidation as both traditional and new players seek to geo-enable their application suites.

This spotlight examines the specific causes and potential ramifications of this wave, with examples of transactions, valuation data and how to profit as an owner in the current market.

Hear from…
Josh Knauer, CEO, Rhiza Labs
Allan Pym, COO, APOS Systems, Inc.
Rob Gorrie, Founder, Adcentricity
Steve Coast, Principal Architect, Bing Mobile/Microsoft and Founder, OpenStreetMap
Elon Gasper, VP & Director of Research, Corum Group
David Sonnen, Analyst, IDC
Ward Carter, Chairman, Corum Group

Event Details:
Tuesday, August 14, 2012
1:00 pm (NYC)

Rhiza Helps PepsiCo Rock South by Southwest

The Rhiza team is proud to have been a part of the PepsiCo Central presence at South by Southwest (SXSW) 2012. Rhiza teamed up with fellow Pittsburgh-based companies MAYA Design and IonTank to design and build the space out for PepsiCo. Rhiza’s role was to aggregate, analyze and visualize data from around the social web, sensors on-site around SXSW, data collected within the Pepsico Central area and from people walking around Austin collecting data using Livescribe pens.

Check out the video summary that the folks at PepsiCo put together about the event:

Special thanks go out to our data partners, who helped set up special feeds of data to Rhiza: CivicScience, PeopleBrowsr, Livescribe, ImmersiveLabs and many more.

Honing the Craft

This past Saturday Rhiza hosted a Coderetreat for members of the Pittsburgh development community. Coderetreat is a global organization dedicated to helping programmers become better programmers. It does this by helping local groups organize workshops – the code retreats – that let developers focus on key elements of the craft of programming without the day-to-day distractions of deadlines and bottom lines.

It’s also a lot of fun, and a good way to meet other programmers!

Despite the fact that Saturday was one of the few unabashedly wintery days we’ve had all year, turnout was really strong. I think just about the whole slate of 25 signed up people showed up for the day (which starts at 8:30am – not necessarily a congenial hour for your average programmer).

The day is highly structured. We were led by the intrepid Jim Hurne through a series of six 45 minute exercises. Each exercise is built around Conway’s Game of Life, which I’ve had a soft spot for going back to my nerdy high school days.

Here’s an animation of what the Game of Life can look like, from Wikipedia:

And here are some coders, hard at work implementing and testing it:

(There are more nice photos that Jim took of the code retreaters making the magic happen.)

One of the important things to grasp about Coderetreat, though, is that you’re not there to build a working implementation of something. The goal is to work on the process – if you actually finish a working implementation, you are probably giving the process short shrift. In fact, after each 45 minute exercise, you delete all your code and start over.

This is painful. Most working programmers are deeply invested in making things, and the idea of tossing out code that you’ve worked hard on, only to start all over is hard. But once you’ve done it a couple of times, it becomes a little easier.

Now, I have to admit, one of my partnerships did perform the dubious feat of finishing a minimal implementation. I’ll share the implementation here because it’s cute (and short!).

Warning: this blog post is about to get technical and nerdy. (Take me to a cute picture of dogs instead!)

One of the exercises revolved around designing the implementation in a “functional” rather than a traditional imperative or object-oriented style. Functional programming is actually one of the earliest programming styles, going back to the Lambda calculus that Alonzo Church developed back in the 1930s (before “computer science” was really a discipline – Church was a logician and interested in the formal foundations of mathematics). However, it is still very important today. “Functional” programs avoid explicit mutable state and “side effects”; instead, every operation is expressed as the evaluation of a function, and programs are expressed as compositions of those functions.

The lack of explicit state and side-effects makes functional programs a lot easier to reason about, so they tend to have fewer bugs. It is also often much easier to execute them in parallel, so high performance systems are easier to write. Functional programming languages are also often very “expressive” – meaning you can write short, clear programs easily. As programs get bigger and more complex and bug-prone, and computers tend to get performance from parallelism rather than from faster clock speeds, it’s likely that functional techniques will get even more important.

(There are downsides too: side effects are hard to avoid in most real-world programs, and some algorithms and data structures are hard to implement efficiently without explicit mutable state. Fortunately, you can often mix functional ideas with imperative ideas effectively. The code I’m about to show is very much a mutt in that way.)

At Rhiza we use Python and Javascript for a lot of our development. Both of these languages are imperative, object-oriented languages, but they both have “functional features” like first-class functions. (In fact, if you don’t know how to use closures effectively, you aren’t going to get very far programming non-trivial applications in Javascript.)

Jim had sent out email to all the attendees before the retreat that the exercises would revolve around the Game of Life. I happen to have been spending some time learning NumPy recently, a very nice numerical programming library for Python. It’s good at implementing linear algebra and scientific computing problems (optimization, curve fitting, data analysis, machine learning, etc.) Anyway, these two things had collided in my head in the shower, and I kept thinking that there ought to be a good way of expressing the Game of Life in terms of operations on matrices, which are efficient to use in NumPy.

There is!

It helps to start out by thinking of a functional decomposition of the Game of Life. You can imagine the Game of Life as a big two-dimensional array of cells that are either on or off, 1 or 0. Then the game undergoes a “step” and the board evolves to a new state based on a few simple rules:

1. Any live cell with fewer than two live neighbors dies, as if caused by under-population.
2. Any live cell with two or three live neighbors lives on to the next generation.
3. Any live cell with more than three live neighbors dies, as if by overcrowding.
4. Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

But before we get to implementing the rules, just think of the evolution of the system as looking like this:

step(X) -> X'

That is, you call the step function on your matrix of cells, and it yields a new array of cells that represent the next generation. But now we need to break the step function down further. If you look at the rules, each rule depends on two pieces of information: the state of the current cell, and the number of live neighbors it has.

So you probably need a function like this:

neighbor_count(cell) -> integer

and a function like this:

state(cell) -> 1 or 0

If you had those, you could write a “decide” function that took those two pieces of information and implemented the rules above. I’m going to switch to Python here, and show some real code:

def decide(state, neighbor_count):
    if state == 1:
        return 1 if neighbor_count in (2, 3) else 0
    else:
        return 1 if neighbor_count == 3 else 0

And that’s the heart of the Game of the Life!

Now, it turns out that if you use a NumPy array to represent your matrix of cells, you don’t really need an explicit “state” function. You can just look up the index of the cell you are interested in and the value in the array is the state.

So that’s great and all, but you still need a way to calculate your neighbor count, and you need a way to evaluate your “decide” function for each cell in the array.

For the second part NumPy can help us. It has a neat trick built in called “vectorization”. Just change the code above to read:

@numpy.vectorize
def decide(state, neighbor_count):
    if state == 1:
        return 1 if neighbor_count in (2, 3) else 0
    else:
        return 1 if neighbor_count == 3 else 0

What does that “@numpy.vectorize” do? It means that instead of needing to call “decide” individually on each state and neighbor_count for each cell in the matrix, we can call “decide” on a matrix of states and a matrix of neighbor_counts, and it will yield a new matrix. NumPy takes care of the details of iterating over the two matrices and assembling all the results into a new matrix. (It’s also much more efficient than writing nested for loops by hand.)

So you could write “step” like this:

def step(X):
    return decide(X, neighbor_count(X))

Which is exactly what we want to do!

But we still have a crucial missing piece. We don’t have a neighbor_count function at all, much less one that can operate on a matrix. But we can take advantage of some representational cleverness here.

X is a two-dimensional array of binary numbers: every cell is either 0 or 1. In signal processing, there is a concept called convolution. I’m not going to go into a lot of detail about what a convolution is, but here’s a nice simple example. If you’ve ever used Photoshop and applied one of the edge detection filters, or a Gaussian blur, you’ve used a convolution.

The cool thing is, on a binary matrix, there is a simple convolution kernel that exactly corresponds to “count my live neighbors”. It looks like this:

kernel = numpy.array([ [1, 1, 1],
                       [1, 0, 1],
                       [1, 1, 1] ])

Now, with a little help from the NumPy and SciPy libraries, we can write our neighbor count function:

kernel = numpy.array([ [1,1,1],
                       [1,0,1],
                       [1,1,1] ])
def neighbor_count(X):
    return convolve2d(X, kernel, mode='same', boundary='wrap')

(Tragically for my place in human history, I’m not the first person to have thought of this trick. If you Google “convolution game of life” you’ll discover several similar implementations, some with interesting extra cleverness.)

To put it all together, along with an example of the famous Glider pattern.

import time
import numpy
from scipy.signal import convolve2d

kernel = numpy.array([ [1,1,1],
                       [1,0,1],
                       [1,1,1] ])
def neighbor_count(X):
    return convolve2d(X, kernel, mode='same', boundary='wrap')

@numpy.vectorize
def decide(state, neighbor_count):
    if state == 1:
        return 1 if neighbor_count in (2, 3) else 0
    else:
        return 1 if neighbor_count == 3 else 0

def step(X):
    return decide(X, neighbor_count(X))

def display(X):
    print X
    print '----'
    print

def glider():
    X = numpy.zeros((10,10))
    X[1][2] = 1
    X[2][3] = 1
    X[3][1] = 1
    X[3][2] = 1
    X[3][3] = 1

    while True:
        X = step(X)
        display(X)
        time.sleep(1)

    return

if __name__ == '__main__':
    glider()

There’s actually a way to write the “decide” function by indexing into arrays, which makes the code a bit more dense, but a little less clear. Clarity (or revealing your intent) is one of the code retreat virtues! And for you code retreaters out there: yes, we wrote unit tests ;-)

Rhiza CEO, Josh Knauer, to Keynote Canadian GIS Conference

Rhiza’s CEO, Josh Knauer, will be giving the keynote address at the GeoTec 2011 Conference in Vancouver, Canada on September 29, 2011. Josh will speak about emerging technologies and how they are changing the way organizations are using maps and data for decision making.

If you’d like to meet with Josh while he’s in Vancouver, please let us know.

Rhiza/Google Booth Presentation at AFCEA Homeland Security Conference @signalmag #afcea

AFCEA logoRhiza CEO, Josh Knauer, will be giving two presentations at the AFCEA (Armed Forces Communications and Electronics Association) Homeland Security Conference at the Ronald Reagan International Trade Center in Washington, DC. Both presentations will take place in Booth #611 (Google/Onix Networking Booth) in the Atrium Exhibit Area.

10:30am – Booth #611 – Go Get Your Data: Learn how to effectively use mobile data to create “eyes on the ground” for prioritizing emergency response whether in a forest fire, a toxic spill or a hurricane using Google Earth and a new mobile data app from Rhiza that works across many types of smart phone operating systems.

2:00pm – Booth #611 – Asset Tracking for Homeland Security: Mapping physical and soft assets is challenging under the best of conditions, but a crucial challenge to Homeland Security agencies. Come learn about how new, emerging technologies are being used to make it easier to track assets at a local, state and federal level. Solutions from Google Earth and Rhiza will be highlighted, as well as best practices in the industry.

Call or text Dana Kuan from Onix Networking Corp for more information at 202-596-6490.

Rhiza featured at Innovation Happens event

Rhiza has been selected to be one of six featured companies at the Innovation Happens event this Thursday, December 2 at 5:30pm at AlphaLab (2325 East Carson St, Pittsburgh, PA 15203). Innovation Happens is described by its organizers as an open forum for connecting Pittsburgh entrepreneurs and Pittsburgh corporations.

Here’s an overview of the event:
Corporations are being increasingly tasked with innovation and collaboration. Entrepreneurs are looking to grow their businesses and understand corporate needs and purchasing patterns. What can these two groups learn from each other? A lot! However no networking event is available to bring them together, until now. Innovation Happens is a regular event that helps make those connections happen!

Attending from corporations are leaders from research & development, IT, marketing & other change agents looking to make innovation happen!

We hope to see you there at the event!

Tune in: Crowdsourcing and the H1N1 Virus Webinar with URISA

This Wednesday, September 23 at 3:00 PM (EST) URISA, the Urban Regional Information System Alliance will be hosting an exciting Webinar about the controlled crowdsourcing technology behind Rhiza’s popular FluTracker website.

FluTracker is able to make outbreak data available to the public 5-10 days ahead of the estimates provided by the CDC. This Webinar will explain how you can utilize controlled outsourcing and take advantage of the newly developed technology and the omnipresence of the public to inform people of flu outbreaks. This is just one example of how Community Participatory Mapping is being used to make information more readily available to the public. You will learn how to best utilize this tool and get the maximum amount of benefits from the developing technologies.

“Crowdsourcing and the H1N1 Virus” will be presented by Maryl Widdows and Andrew Macurak of Rhiza Labs, located in Pittsburgh, PA. For more information, visit URISA.

We have 10 free registrations available to companies and government agencies interested in learning more about the technology behind FluTracker. Please email widdows at www.rhiza.com to reserve your space ASAP.

Close

Want to schedule a demo?

Get in touch with us and we’ll be happy to set up a time.