Boundless is heading to Portland for FOSS4G 2014!

FOSS4G 2014Next week, several members of the Boundless team are heading to Portland for the annual FOSS4G conference. We look forward to this conference every year as it’s the best place to exchange ideas about open source spatial software with our customers, partners, and friends. We’re proud to be sponsors and be participating in at least nine presentations and nine workshops — even more than last year!

Come by booth #16 to meet our experts and learn about the newest version of OpenGeo Suite and other tools we’re working on. Don’t forget to register for field trips and check out the social calendar as well!

Here’s a list of many of the events we’re involved with:

DateEventStart TimeSpeaker/Attending
9/8/2014OpenLayers 3: First Contact8:00Andreas Hocevar with Marc Jansen, Éric Lemoine, and Tim Schaub
Building Apps with OpenLayers13:00Andreas Hocevar
Introduction to PostGIS13:00Paul Ramsey
9/9/2014GeoTools DataStore Workshop8:00Jody Garnett and Eva Shon with Tom Kunicki
Introduction to GeoServer8:00Mike Pumphrey
Versioning Spatial Data with GeoGig (formerly GeoGit)8:00Benjamin Trigona-Harany
GeoServer Cartography and Styling13:00Jody Garnett, Eva Shon
GeoWebCache in Production13:00Mike Pumphrey
QGIS for Analysts13:00Benjamin Trigona-Harany
9/10/2014GeoServer Feature Frenzy10:00Jody Garnett and Justin Deoliveira with Andrea Aime and others
The Manager’s Guide to PostGIS11:00Paul Ramsey
GeoScript: A Geospatial Swiss Army Knife13:00Justin Deoliveira
OSGeo Incubation13:30Jody Garnett
Getting Started with OpenLayers 315:00Andreas Hocevar with Tim Schaub
9/11/2014LocationTech Projects13:30Jody Garnett and Justin Deoliveira with Andrew Ross, Rob Emanuele, and others
MapStory: The next plateau16:00Ian Schneider
9/12/2014State of GeoServer and GeoTools10:00Justin Deoliveira and Jody Garnett with Andrea Aime, Martin Davis, and others
PostGIS Feature Frenzy13:00Paul Ramsey

OpenGeo Suite 4.1.1 Released!

We’ve been hard at work fixing bugs, and polishing OpenGeo Suite, so we’re proud to announce the release of OpenGeo Suite 4.1.1!  This release focuses exclusively on performance and stability updates.

For those who don’t regularly follow our blog, the OpenGeo Suite 4.1 release included many new features and improvements:

Try it!

Download 4.1.1 and try our census map tutorial or heat map tutorial to learn more. Details about this release are included in the release notes and, as always, we strongly advise you to read the upgrade instructions and backup your data before installing.

OpenLayers 3.0 Released!

 
OpenLayers 3 has been a long time in the making but we’re proud to announce that the project is ready for release! This release includes a ton of new features such as an easier to use API as well as improved vector rendering and image manipulation.

While we’ve confidently supported OpenLayers 3 in production since the OpenGeo Suite 4.0 release and have long offered professional services for developers looking to build web applications, we hope this announcement marks a significant step forward in adoption of the library.
Openlayers.org

Check out some of our previous blog posts to learn more about using OpenLayers 3:

And don’t forget to check out the project website for some great documentation and examples.

OL3 vector rendering

Announcing the OpenGeo Suite App Contest!

OpenGeo Suite

Boundless wants to know how you’ve been using OpenGeo Suite! We already know what customers such as NYC DoITT, FCCSan Jose Water Company, and Howard County are building with our software but we are launching an app contest where developers, like you, can show off applications that use components of OpenGeo Suite.

Winners will be promoted on our website and will receive free access to our online training offerings. We know you are making some awesome real-world applications, and we want everyone to know because, in the end, OpenGeo Suite is only as great as the apps it helps power.

FCC National Broadband Map

The process is simple. All you have to do is provide the following information through our submission form:

  1. Describe what you’ve built. What’s its purpose?

  2. What technology does it use, including specific OpenGeo Suite components?

  3. Why did you choose OpenGeo Suite?

  4. What are your future plans for this app?

  5. How did you architect and build the app?

  6. Is this available to the public, if so, what is the URL?

  7. Is this your first time using OpenGeo Suite or any of its components?

You can enter the contest starting today and we will be taking submissions through September 13th, the last day of FOSS4G. Throughout the contest, we will promote the best submissions on our blog and through our Twitter account. We’ll announce semi-finalists the week after FOSS4G and then welcome the community to cast a vote for the finalists, which we will announce at the GeoNYC Meetup in October.

We can’t wait to see, share, and celebrate what you’ve been creating with OpenGeo Suite so submit your app!

Ice Cubed (Part 2): Building an Application

Matt Richards

OpenGeo Suite is a complete geospatial platform for managing data and building maps and applications. In the newest versionBoundless makes it even easier to create complete, enterprise-grade web applications. While we’ve previously show how to build applications using OpenGeo Suite, this post follows our previous post in describing how to create an application to visualize changes in Arctic sea ice.

Ice3

Our first demo application, Ice3, is a mapping application that visualizes changes in Arctic sea ice over a 33 year period (1980-2013). The maximum August sea ice extent is shown in the timeline slider beneath the map. Additionally, an outline of the 30-year (1981-2010) median August sea ice extent is included for comparison. All data is from the National Snow & Ice Data Center, a source for consistently processed ice extent and concentration images and data values since 1979. A third dataset showing the average snow extent in August (1967-2004) is also included for reference.

Defining the User Experience

To begin, we’ll think about the desired user experience. We’d like an interface that displays the ice extent while also allowing the user to toggle between sea ice extent for different years. As shown above, we’ll present a map and provide radio buttons to allow the user to select between the various years.

Creating the HTML & CSS

To make it easier to follow along, all of the source code for the Ice3 application is available on GitHub.

Let’s start off with the implementation of the HTML. This is a very standard implementation, and can easily be included in a web app, content management system, or a simple static HTML page. In this case, we’ll just generate a static, flat HTML file for this demonstration. To follow along, a great starting point is the HTML5 Boilerplate.

The CSS implementation is also straightforward. OpenLayers 3 plays very nicely with CSS by making it easy to provide a style that fits the look and feel you are going for. We also wanted to create a fluid, responsive CSS layout that supports mobile, tablets, and desktops. OL3 completely supported this with no additional changes needed out-of-the-box. As the viewport and layout change using CSS media queries, the map supported this by simply changing the containing elements and using a width and height of 100% of the map itself.

Working with JavaScript

Next, we’ll walk through the JavaScript for the application itself, which will be used to set up the map, wire up the behavior, and manage the interactions.

Determining layer extents and projections

First, we set up the extents for the layers that we’ll be using. We found these extents by looking at GeoServer’s layer preview, and noting down the numbers that were used there for each relevant layer:

var extent3408 = [
  -4938036.174191093, -2573213.9925217666,
  5084539.232734008, 3938318.148811234
];

var extent3413 = [
  -2700000, -3600000,
  2350000, 2100000
];

While the previous post described how to reproject the data in QGIS, in this example we’ll instead setup the projection objects to cover pulling in the data in different projections and have GeoServer reproject them in real time:

var projection3408 = ol.proj.get('EPSG:3408').setExtent(extent3408);
var projection3413 = ol.proj.get('EPSG:3413').setExtent(extent3413);

Defining the base map

Next, we’ll set up the base layer. We’ll be using the Natural Earth base map, which we reprojected to 3408:

var wmsUrl = 'http://apps.boundlessgeo.com/geoserver/icecubed/wms';
var workspace = 'icecubed';

var baseLayer = new ol.layer.Tile({
  source: new ol.source.TileWMS({
    url: wmsUrl,
    params: {
      LAYERS: workspace + ':NaturalEarth1_3408_basemap',
      TILED: true
    },
    extent: extent3408,
    serverType: 'geoserver',
    projection: projection3408
  })
});

Working with layers

Now we’ll make the preparations for the remaining layers: sea ice extents for each year, median sea ice line, and an external average snow extent layer.  On page load, we want to show the first snow ice extent layer. The median and average snow extent layers will be visible as well, with separate controls to toggle their visibility.

We’ll use a couple of helper functions, and populate a lookup of layer name to layer object. This will be used later on to lookup the layer to display when the user clicks on a radio button.

var extentLayerNames = [
  'extent_N_198008_polygon',
  'extent_N_198308_polygon',
  'extent_N_198608_polygon',
  'extent_N_198908_polygon',
  'extent_N_199208_polygon',
  'extent_N_199508_polygon',
  'extent_N_199808_polygon',
  'extent_N_200108_polygon',
  'extent_N_200408_polygon',
  'extent_N_200708_polygon',
  'extent_N_201008_polygon',
  'extent_N_201308_polygon'
];

function makeExtentLayer(layerName, isVisible) {
  isVisible = !! isVisible;
  return new ol.layer.Tile({
    source: new ol.source.TileWMS({
      url: wmsUrl,
      params: {
        LAYERS: workspace + ':' + layerName,
        TILED: true
      },
      serverType: 'geoserver',
      projection: projection3413
    }),
    visible: isVisible
  });
}

var iceLayers = [];
var layerLookup = {};
extentLayerNames.forEach(function(layerName) {
  var layer = makeExtentLayer(layerName);
  layerLookup[layerName] = layer;
  iceLayers.push(layer);
});
var medianLayer = makeExtentLayer('median_N_08_1981_2010_polyline', true);
var cryoLayer = new ol.layer.Tile({
  source: new ol.source.TileWMS({
    url: 'https://nsidc.org/cgi-bin/atlas_north',
    params: {
      LAYERS: 'snow_extent_08',
      TILED: true,
    },
    projection: projection3408
  }),
  visible: true
});

var allLayers = [baseLayer]
  .concat(iceLayers)
  .concat(medianLayer)
  .concat(cryoLayer);

Now that the layers are set up, we can create the OpenLayers map object.

var map = new ol.Map({
  target: 'map',
  renderer: 'canvas',
  layers: allLayers,
  view: new ol.View({
    center: [-5049.84109515, 825838.67673878],
    zoom: 2,
    projection: projection3408
  })
});

All that’s left is now is to add the appropriate behavior to the controls, including radio buttons that display each layer as well as a toggle for the external WMS layer.

First, let’s wire up the radio buttons. This is fairly typical JavaScript code looks up the layer that was clicked on, marks everything as invisible first, and then sets the layer chosen visible:

// turn on the single layer that is clicked on
$('#radios').click(function(e) {
  var target = e.target;
  var layerName = target.getAttribute('data-radio');
  if (!layerName) {
    // user clicked in area but not on radio
    return;
  }
  var layer = layerLookup[layerName];
  if (!layer) {
    throw new Error('Could not find layer name: ' + layerName);
  }
  iceLayers.forEach(function(iceLayer) {
    iceLayer.setVisible(false);
  });
  layer.setVisible(true);
});

Next, we need to wire up the external average snow extent layer. This is just a matter of toggle that particular layer’s visibility:

$('#cryo').click(function(e) {
  cryoLayer.setVisible(this.checked);
});

And finally, we’ll want to display the first layer on page load:

iceLayers[0].setVisible(true);

Learn more!

Interested in building your own apps using OpenGeo Suite? Find out how with our training and professional services.

Ice Cubed (Part 1): Data Preparation with QGIS

Victor Olaya

OpenGeo Suite is a complete geospatial platform for managing data and building maps and applications. In the newest version, Boundless makes it even easier to build and deploy applications by adding better data management tools to QGIS and improving the SDK with support for OpenLayers 3.

This post is the first of a series of posts describing how to create complete, enterprise-grade web applications using these and other features. While we’ve previously shown how to configure OpenGeo Suite from QGIS, this post will describe a typical workflow to show how easy it is to analyze and style on the desktop using QGIS and then publish to the web using GeoServer. Our next post will describe how to use this data to create an application to visualize this data.

Ice3

Our first demo application, Ice3, is a mapping application that visualizes changes in Arctic sea ice over a 33 year period (1980-2013). The maximum August sea ice extent is shown in the timeline slider beneath the map. Additionally, an outline of the 30-year (1981-2010) median August sea ice extent is included for comparison. All data is from the National Snow & Ice Data Center, a source for consistently processed ice extent and concentration images and data values since 1979. A third dataset showing the average snow extent in August (1967-2004) is also included for reference.

Preparing the Data

The workflow that we have to execute involves loading and reprojecting several layers into the same coordinate reference system (CRS), styling them, and then publishing them to GeoServer. It is not strictly necessary to reproject layers, as GeoServer can do that on the fly, but if we expect most requests to use a given CRS then reprojecting them in advance will avoid having to reproject them at request time and thus make our service more performant.  In order to show the capabilities of GeoServer, other posts in this series will use layers in their original CRS, but in this one we will be reprojecting them to a common one using QGIS. We will be using the following datasets:

Setting up GeoServer

Before preparing our layers, we need configure the GeoServer catalog. From the QGIS plugin, we can connect to our GeoServer instance and create a new workspace that will contain our layers.

newws

Base map layer

To reproject the Natural Earth base map layer into a polar projection, we will use the Reproject vector layer algorithm in the Processing toolbox. Doing so will generate a new layer in the EPSG:3408 CRS, which will be our target for all layers.

reproject

We can then define a style for the layer on the layer properties dialog. Once the layer is ready to be published,  we can drag and drop the layer into the desired catalog and workspace using the QGIS plugin.

Average snow extent layer

The average snow extent layer is based on an an existing WMS service. Currently, cascading a WMS service can only be configured from the GeoServer administration interface, but an upcoming release of OpenGeo Suite will make it possible to define a new connection in QGIS…

wmsconn

…and then add a corresponding layer from the list provided by that service.

wmslayer

Sea ice layers

Preparing and publishing the sea ice layers is the most complex part, since there is a large number of them. We will show how to automate the process to simplify it.

All layers will have the same styling, since we do not plan to show them together, but as different snapshots. That means we can reuse the style definition. We style one of the layers and then save the style as a QGIS QML file.

savestyle

The operation that we need to perform for all the layers in the sea ice set is reprojecting them and then applying the style that we have just saved. To make it easier to run repeatedly, we can define this small workflow as a model in the QGIS processing framework. This is what the model should look like:

model

The reprojection algorithm uses EPSG:3408 as the destination CRS, and the Style vector layer algorithm uses our QML style file.

To run this model in all of our layers, we can run it as a batch process. Selecting the sea ice layers as inputs for the batch process will generate a new set of reprojected and styled layers, ready to be published to GeoServer.

batch

Another way of using our model is by setting it as a pre-publish hook. Our QGIS plugin makes it possible to define an operation to be performed to any layer as it is published. If we set our model to run when publishing then there is no need to run the batch process. Simply publish the set of sea ice layer from our QGIS plugin by dragging and dropping them on the destination workspace item they will be reprojected and styled as they’re published.
hook

Preparing the cache

Once all layers are published, we can also create the corresponding cache layers and seed the cache from the QGIS plugin. To create a cache layer, just right-click on the GeoWebCache item and select the GWC layer and then specify the layer to cache.

Clipboard01

Or, even easier, just drag a Geoserver layer into the GeoWebCache item. You can then cache the layer to its full extent, or, if you just want to cache a given region, define its bounding box by clicking on Define in canvas button and then dragging and dropping the QGIS map to select the bounding box.

Clipboard02

Conclusion

Now we have configured all the layers for our Ice3 demo application by reprojecting and publishing from QGIS to GeoServer.  In the next post we will see how to create an interface for the application using OpenLayers 3.

Boundless Growth

Eddie Pickle

Boundless is growing but our focus remains helping customers build the best web mapping applications. We’ve recruited a stronger leadership team and are enhancing our current products while also developing new products and services to help customers in new ways.

We recently added Ann Johnson as our new CEO to strengthen our team and leadership. Ann’s experience with enterprise software, particularly her deep knowledge of security, greatly expand our expertise in critical areas of Spatial IT.

At the same time, we have been steadily adding capabilities to OpenGeo Suite to enable easier, more scalable web services deployments. To help our customers successfully build enterprise mapping applications, we’re advancing open source software like OpenLayers 3 and providing new SDK templates that leverage this new technology. We continue to “lower the cost of free software” by making secure, fault tolerant, and scalable deployments of our open source stack simpler, faster, and easier.

Additionally, some of our key initiatives include:

With Ann joining Boundless, I’m focusing my efforts on developing these and other capabilities to grow our business, with a particular emphasis on developing new partnerships to create a new geospatial ecosystem based on open source software. We believe the future is bright for open source–based solutions to address a variety of challenges, from publishing data to asset management to customer services. I look forward to working with our customers and partners to reshape this industry!

Build applications using OpenLayers 3 and OpenGeo Suite (Part 2)

OpenLayersMany of our customers use OpenGeo Suite to build applications that address specific business needs. New York City and Howard County use our software to help residents better access government services while San Jose Water Company has built several applications for internal use by staff.

Our newest release, OpenGeo Suite 4.1, includes new templates built on OpenLayers 3 that make it even easier to build and deploy Spatial IT applications. We previously showed how to create a viewer application and in this post we’ll describe how to create an editing application.

Creating a new application

First off, we’ll start creating the application using the suite-sdk command-line tool:

suite-sdk create /path-to/myapp ol3edit
suite-sdk debug /path-to/myapp

Point your browser to http://localhost:9080 and you’ll see the editing application in debug mode:

Editor application

Let’s examine the functionality that this application provides in more detail.

Editing template

This application provides the Layers Control, which was also part of the viewer template, but in addition the following editing-related functionality is provided:

  • Draw a new feature and insert it using WFS-T
  • Modify an existing feature’s geometry and send an Update to the WFS
  • Select an existing feature and delete it
  • A feature table that shows the features in a tabular form

By default the usa:states layer in OpenGeo Suite is served from a Shapefile but this is not ideal for editing purposes.  We recommend serving data from a transactional database, such as PostGIS, instead.

Unlike the viewer template, which used WMS for feature display, this application uses a vector layer rendered by HTML5 Canvas. The vector data is retrieved using WFS with GeoJSON as the interchange format for read operations. A BBOX strategy is used for loading the data.

Let’s click one of the states on the map. This will select the vector feature on the map and will select the corresponding row in the feature table. Clicking on a record in the feature table will also select that same feature on the map and zoom to it.

Try modifying one of the existing geometries (hover over one of its boundaries) and, when you’re done, click somewhere else outside of the feature which is being modified. The feature will be deselected and the transaction will be sent to the WFS. This may trigger a basic authentication dialog in the browser depending on how GeoServer has been configured.

Now click on an existing feature and press the “Delete Feature” button in the toolbar. Confirm the dialog with OK. The feature should be deleted on both the client and the server (verify this by doing a reload of your browser application).

Lastly, use the “Draw Feature” button and digitize a new polygon feature on the map. This will get sent to the WFS as an Insert transaction.

Internals

As  promised in a previous blog post about editing in OpenLayers 3 using WFS-T, it is now much easier to create an editing application without having to worry about the OpenLayers 3 internals. Open up /path-to/myapp/src/app/app.js in your favorite text editor and look for a section labeled “config section”. This section should contain all the settings you need to tweak in order to have this application work on a different data layer.

Learn more!

Find out more about using the Boundless SDK and these new templates in this Tech Talk that Andreas and I recently presented to our colleagues.

Build applications using OpenLayers 3 and OpenGeo Suite (Part 1)

OpenLayers

Many of our customers use OpenGeo Suite to build applications that address specific business needs. New York City and Howard County use our software to help residents better access government services while San Jose Water Company has built several applications for internal use by staff.

Our newest release, OpenGeo Suite 4.1, includes new templates built on OpenLayers 3. Based on Bootstrap for responsive design and jQuery for leaner code, they make it easier to build and deploy applications on modern web browsers.

OpenLayers 3 is the next iteration of the successful client-side mapping library, rebuilt using the latest web technologies. Unlike OpenLayers 2, which includes features like layer switcher or a toolbar by default, this version leaves the choice of user interface elements to the application developer. This is where our new templates come in handy.

In this post we’ll discuss the first of these templates, which serves the purpose of creating a viewer application. In the next post, we’ll discuss creating an editing application.

Bootstrapping a new application

Once you install OpenGeo Suite 4.1 and the Boundless SDK, you’ll get a command-line utility called suite-sdk. We’ll use this utility, and more specifically its create command, to bootstrap our application.

suite-sdk create /path-to/myapp ol3view

/path-to/myapp is the file path (please adjust to suit your folder structure and operating system) where our application will be created, and ol3view is the name of the template we want to use.

To run this application in debug mode, we’ll use the debug command of the suite-sdk:

suite-sdk debug /path-to/myapp

This will start up an application server on port 9080 (the default port can be changed with the -l flag), which will proxy a GeoServer instance on http://localhost:8080/geoserver (the default GeoServer proxy can be changed with the -g flag).

If we point a browser to http://localhost:9080 we will see our application in debug mode.

Application running in debug mode

View template

The view template provides a few examples of functionality that OpenLayers 3 does not provide out of the box:

  • a layers control
  • a popup that can pan into view

The layers control can be configured with a set of groups, to group certain layers together. In OpenLayers 3, it’s possible to define any extra (observable) properties on a layer object (which inherits from ol.Object). In this case we use a property called group, and a property called title for the user-readable title of the layer. Groups can be exclusive, which will have the individual layers of that group show up as a radio group, or non-exclusive which will have them show up as checkboxes. The layers control uses the mechanism demonstrated in the custom controls example.

The popup extends ol.Overlay. When a feature is clicked in the map, the information from a WMS GetFeatureInfo response will be shown in the popup, and the selected feature will be highlighted on the map. By default the WMS GetFeatureInfo request uses GML3 in the template, but it can optionally use HTML as well.

WMS GetFeatureInfo shown in a popup

Customizing the template

In this section we will show how to add a company logo to the application and we will use a different layer for the application.

Add company logo

Open up /path-to/myapp/index.html in your favorite text editor. Search for Application Template and insert the following img tag in front of the Application Template text string:

<img class="company-logo" src="http://boundlessgeo.com/wp-content/themes/open-geo/images/logo.png">

In the style section, add the following CSS class for the company logo:

img.company-logo {
height: 30px;
padding-right: 10px;
}

Save your edits, reload your browser, and you should see the company logo in the application template now.

Use a different layer

Download the Fault Lines dataset from the GeoTech Center Data Library and open it in GeoExplorer, generally available at http://localhost:8080/geoexplorer in a default OpenGeo Suite install. Click the green plus button in the toolbar at the top of the layer tree, and select the Upload layers menu option. Log into GeoServer (the default credentials are “admin” and “geoserver”) and browse for the ZIP file. Since there is no PRJ file, manually specify the CRS as EPSG:4326.

Upload the new dataset using GeoExplorer

Use the Layer Properties dialog,  find the name of the uploaded layer. In our case, it is opengeo:FAULTS0.

Layer Properties dialog

Now open up /path-to/myapp/src/app/app.js in your favorite text editor. Look for the config section. We will use a WFS DescribeFeatureType request to find all the information we need, in our case this is:

http://localhost:8080/geoserver/ows?service=WFS&request=DescribeFeatureType&version=1.0.0&typename=opengeo:FAULTS0

In the response there is a targetNamespace attribute on the xsd:schema which we will need to configure our application properly (this is the value for featureNS). The following variables in the config section need to be changed to use a different layer in our application template. Most of its values can be derived from the WFS DescribeFeatureType output:

var featurePrefix = 'opengeo';
var featureType = 'FAULTS0';
var featureNS = 'http://opengeo.org';
var srsName = 'EPSG:900913';
var geometryName = 'the_geom';
var geometryType = 'MultiLineString';
var fields = ['TYPE'];
var layerTitle = 'Faults';

Our application will now look like this:

Application using a different layer

Deploying the application in production

Up to this point we have been using the debug loader. To deploy an application in production with the SDK, we normally create a WAR file and deploy that in a servlet container. This will replace the debug version with a full build of OpenLayers 3 which uses the Closure Compiler’s advanced mode. Also, our own application code will be prepared for better use in production. To create a WAR file we can use the package command:

suite-sdk package /path-to/myapp /path-to/myoutputdir

This will create a myapp.war package in the directory that we specified as the output directory (/path-to/myoutputdir).

Learn more!

Find out more about using the Boundless SDK and these new templates in this Tech Talk that Andreas and I recently presented to our colleagues.

Boundless Connections: Ann Johnson, CEO

Ann Johnson

Over the past year, Boundless has grown tremendously: becoming an independent company, expanding and enriching our offering of Spatial IT solutions and services, and deepening and broadening our team with experts and leaders from across the geospatial and enterprise IT fields. This marks a new chapter for our company, one designed to maximize what we see as a major inflection point in this industry. As the number and type of sensors and data sources proliferate, geospatial data collaboration becomes the key problem facing the Spatial IT industry.

With that in mind, we are accelerating our transformation with the addition of Ann Johnson as our new CEO. This new chapter requires an additional set of leadership skills, and Ann delivers them in spades with her strong background in cloud computing, security, and enterprise IT software broadly. She joins us from leading security software companies, where she served in a range of executive positions and developed her expertise in infrastructure, storage, and security. Her knowledge and executive experience will greatly strengthen our leadership and team as we continue to enhance solutions like OpenGeo Suite, develop new offerings, and maximize the significant opportunity ahead of us.

Welcome to the team! What was your role before you joined us?

Thank you! I’m excited to join the team, and have spent the last few weeks developing a better understanding of the company, solutions and industry.  My background maps very well to the changes taking place in the Spatial IT industry and the transformation at Boundless. My last fourteen years have been dedicated to the cloud computing and security software industry, most recently working with the talented team at Qualys. I spent the majority of that time at RSA, leading the global fraud team, which was a very rewarding experience as the company has an excellent vision and strategy and truly allowed me to grow my career in a meaningful way.

What are you most proud of from your time at RSA?

Team building! The most rewarding part of any leadership role is the ability to recognize talent and work with individuals to help them realize their career goals. Providing the guidance, coaching and support along the way as individuals grow and develop is what I enjoy most, by far. I was fortunate to be surrounded by amazing professionals at RSA and was able to function in a true leadership role by enabling talent to make an immediate and meaningful impact.

What made you interested in working at Boundless?

Boundless has an impeccable reputation amongst customers and the wider industry for employing highly talented and passionate geospatial professionals and developing high quality, innovative solutions. The software we develop has the ability to transform the GIS industry and help it pivot into a new Spatial IT industry built on proven open source tools. The depth of talent at Boundless, the quality of the software, and the feedback I received from customers made the opportunity at Boundless too compelling to pass.

What excites you most about the tools and products that Boundless is currently developing?

Timing is everything! My arrival at Boundless coincided with the release of OpenGeo Suite 4.1, which supports deployments on AWS and VMware as well as a new MongoDB connector and QGIS package. These enhancements continue to differentiate Boundless from the competition as a true leader in the Spatial IT sector.

What do you see as some of the benefits of using open source tools?

I come from a very strong infrastructure and software background, so I’ve experienced many different technologies, solutions, services, and tools throughout my career. The most compelling case for open source is the richness of the various communities, and the speed at which they can iterate and deliver highly innovative solutions. The passion of developers who are committed to open source is evidenced by both the quality of code they develop and the creativity and dedication they use in solving problems. It is not uncommon for a problem or idea to lead to an all-night development effort with the entire community contributing in an inspiring way. This leads to an energizing culture and collaborative dynamic for companies, like Boundless, that contribute to the community and address customer challenges faster and more affordably than any proprietary solution.

Where do you see the geospatial industry moving in the future?

We’re at a major inflection point in our industry. We’re on the cusp of Spatial IT as being truly ubiquitous. As the “Internet of Things” continues to proliferate, the ability to provide contextual mapping to any manner of objects and devices, whether used by consumers or business people and professionals, will become increasingly relevant. It will just become what people expect – an integral part of how we live, work and play. We need tools that are highly scalable, flexible, easy and affordable to deploy, and easy to integrate. Geospatial is not just about producing the best or prettiest maps, it is also about providing context and producing the best geospatial data that provides real value. We are solving a major “big data” problem and looking toward the future. The company that can balance strength in the core geospatial market with a vision for the future that takes into account the larger contextual global data opportunity will be the next generation of leaders in the Spatial IT segment.

What are your plans for the future of Boundless?

That’s a great question! You can expect to see us continue to honor our open source heritage while developing the highest quality solutions for both on-premise and platform-as-a-service delivery, allowing our current and future customers to develop their geospatial-enabled applications with the utmost confidence. We have a strong reputation to maintain for industry leadership, quality, and vision. The opportunity to continue to grow the company with our current offerings while bringing unique and disruptive solutions to market is endless. We will focus on where we are strong and continue to lead the industry in the next evolution of geospatial data collaboration.

What’s an interesting fact about yourself (that you haven’t already said)?

Outside of work, I am actually quite a homebody, which often comes as a surprise to people. My non-work life revolves around my family. I am passionate about gardening, cooking, reading, and anything related to water sports. I am also a large supporter of animal rescue organizations such as Best Friend Animal Society and take pride in playing “Mom” to a houseful of rescue mutts.

Continue reading