Well another Dev Summit is in the Books. This conference still remains the best technical show that Esri does, and it gets better every year. I was a bit worried when it started. The plenary was a little bit lighter technically than it usually gets and there was a surprising absence of the Microsoft Office efforts. But the tech sessions came through with high quality material throughout. Mansour brought his game once again, so much so that he got to do an add-on session at the very end; kudos to him for maintaining his energy level to the end.  Art Hadaad had a couple of Esri/Microsoft sessions as well, but it didn’t quite feel like it was mainstreamed with the rest of the messaging. Not sure if that was intentional or accidental. Hmmm.  I think that Microsoft Office integration is going to really drive a lot of adoption of spatial tools and thinking for folks that otherwise just wouldn’t do it.

The picture is becoming clearer with how the technology stacks are all coming together. The ArcGIS runtime “Core” seems to be the engine going forward for “devices”, with each of the SDKs for those Platforms/Devices leveraging that, and each of the SDKs have, or will have shortly, the built-in components of the API to ArcGIS Online.  There were some hints in the plenary that something was up with desktop, but they weren’t saying, until the Closing Session where one fellow asked the question, “what are your plans with desktop?” Credit to him when he didn’t accept the attempt to brush it aside, and we ended up with Scott Morehouse revealing that, yes, they are heading for desktop to be driven by the core code being developed for runtime as well. Looking back to previous conversations and presentations, you could see that this was where we were heading; the ArcObjects libraries were dated and with all of the effort of creating the C++ code for runtime, it just makes sense.

This is going to be a fun year as we all start to implement the new technology stack and struggle through the challenges that we don’t even know about yet.  One thing seems certain to me; many of us will be doing our jobs differently in the near future.

Mike Haggerty

As I write out this recap of the last day at the Esri Dev Summit, I’m sitting on a rock on the side of a mountain overlooking Palm Springs. I wanted to get away from the crowd, the perfectly conditioned air, and the cucumber flavored water, to clear my head and think for a bit about all that I’ve experienced in the last 72 hours.

What have I learned in the last few days? I’ve left my family back on the east coast, temporarily ceased work on billable projects, cost the company a decent chuck of change, and for what reason? Was it worth it? I think yes.

Certainly, I’ve gained a lot of practical skills. Just today, I learned how to use the Geodatabase API to get access to data without the need for the entire ArcObjects library. I learned about a tool called X-ray, that can be used to compare a client’s geodatabase against the Local Government Information Model, which will help determine a migration path.  I learned that node.js, HTML5 Web Sockets, and ArcGIS Online can be used to create a real time collaborative web application. Finally, I learned that Flex can be used to communicate with a brainwave scanning device and a flying inflatable shark (well, this might not be immediately practical).

But more than this and all the rest of the practical skills and information that I’ve picked up over the past week, I think the “why” which has been communicated is even more valuable. Why do I do the work I do? With what purpose? With what motivation?

Jack Dangermond started off the week by reminding us during the plenary that software has the potential to help alleviate many ills we see in the world around us. Does software in and of itself contain power though? I would suggest no; it is but a tool in the hands of those who create it. At least for the present (and hopefully the future), computers are not sentient beings; the instruction sets which they execute must be programmed by us—the humans. Hang with me, hopefully all my philosophical waxing will tie in nicely at the end.

Certainly we all have reasons for doing what we do; pointers and guideposts in our lives that give us direction and motivate us to press on when the going gets tough. Being out here this afternoon among the rocks, lizards and yellow-flowered bushes has reminded me of my reasons for being. One of which Scott Morehouse expressed quite well during the closing session this afternoon when he said, “We exist to serve you.” Serving others by placing their needs above my own certainly ties in with my personal ethos, and I believe it supports GISi’s core values as well.

So, to conclude, why was it worth the time and expense to come out here to Palm Springs? Because the information I received here will allow me to better serve our clients as they serve their constituents, customers, or citizens. And together, with the assistance of GIS, we can all help make the world a better place.

Chris Bupp

Building Applications with the Android SDK 

Esri is releasing version 1.1 of the SDK next week; it has the following features:

• Support for multiple maps
• Advanced Symbology
• Support for ArcGIS Online Portal and WebMap loading
• Group Layers
• Improved Secure Service
• Support Google’s ADT r17
• (Currently, Emulator is not supported, but it’s Google’s fault not ESRI’s)

The Demo for the Android SDK was really neat.  It stored all of the map’s information on an SD card, and was able to edit and store the features to the SD card as JSON strings.  They also utilized the Android’s sensor package to rotate the map to magnetic north; as the tablet was rotated, the map was visually pinned to north.  But the demo hid one glaring fact; while the SDK supports offline feature editing, it doesn’t yet support the Server Sync (which is why they were serializing data to the SD card).  Compared to the iOS SDK, the Android SDK is still playing catch-up.

Another cool feature that the Android SDK supports is Message Processing, which is a method that allows the device to receive a message, and simply call process Message.  The message can contain Symbol and Feature information that will then be added to the map, without requiring the application’s code to parse, or attempt to understand the message.

Killer Apps: HTML 5 and Flex

Monsour Raad and Sanjit Thomas gave a great talk about their love for Flex and HTML 5, and how to utilize both to make stunning apps.  They demoed 10 applications; here are some highlights:

• Monsour used an HTML5 wrapper to support drag and drop feature onto a Flash application running in the browser.
• Monsour used his mind (concentration/activity) and blinking to control the zoom level of a map.
• Monsour created a real time TSA twitter map that computed the poster’s sentiment, and displayed it on the map.
• Sanjit used a HTML5 map to create a heat map of pedestrian injuries to calculate the odds of injury for any given bike path.
• Sanjit used chromes built-in voice command libraries to control a map.

Developer’s Guide to ArcGIS Online REST API

The ArcGIS Online Rest API tech session was a quick run through of the REST API available to interact with the ArcGIS Online portal.  It allows you to authenticate users, perform searches, manage users/groups/communities, and manage items.  When users are authenticated, they are given a token to interact with the REST services.  Here’s the big “Gotcha”: for scenarios where the app owns the data, the best practice is to have the mobile devices interact with a server, which will interact with the ArcGIS Online server.  This will keep the token secret from the application (and the evil user/hacker).  Just make sure that the first server isn’t an Amazon cloud instance that references the ArcGIS Online services; otherwise you’ll end up being charged twice for all the data transfers.

Sean Savage

Today was the final day of the Dev Summit and it was an experience that certainly didn’t disappoint! Talking with and listening to so many people who share a passion for GIS, development, and technology was extremely impressive. Though it appears that I may not be able to rely solely on my Dodgeball skills to earn me another invitation, I would jump at the chance! And, I should say that my impression of the experience was not solely based on presentations and discussions with the Esri folks and the slew of developers and technical attendees from other organizations, but also from being able to interact with the GISi team over the past three days!

As for the sessions of the last day, in several cases they were deeper dives into topics introduced in previous blog entries and have already been discussed, but I was able to sit in on an Esri and Microsoft Technology Update, which was pretty interesting. Esri Maps for Office looks pretty interesting, making it as easy to create interactive maps from a spreadsheet within Excel as it is to create a chart. The maps can be readily shared (through ArcGIS Online) or inserted into a PowerPoint presentation as a slide. Likewise, there is a map ribbon within PowerPoint that can be used to insert maps directly. The business model for this product is still being evaluated and wasn’t ready for discussion. Additionally, it was made clear that Esri is definitely trying to further align with Microsoft, perhaps especially when it comes to Azure, in order to better play in that space and offer more flexibility on the cloud.

As I mentioned, this has been a great week. There was so much to see and hear that I am certain I will continue to realize just how much is changing as I pour through my notes over the coming days and weeks. There were so many sessions covering such a range of material, it was something of a whirlwind. Nonetheless, there were several consistent and pervasive themes throughout the conference that we should closely watch and actively pursue:

• The cloud, the cloud, the cloud…
• ArcGIS Online
• ArcGIS Server redesign and process streamlining
• Consolidation of ArcGIS Runtime (including into Desktop?!)

I think the 10.1 release is going to be quite significant and exciting and I am looking very much forward to getting my hands on all of the technology I have seen over the past few days!

Ben Taylor

I attended a few user sessions the first half of the morning, starting with a presentation that featured the JavaScript API, coupled with several other third party JS frameworks, such as RICO and Scriptabulous to create a decorative UI. The presenter also utilized a few tools to help improve performance. There were a few that I’d like to take a closer look at—the first being YUI compressor, that shrinks the size of CSS and JS files. The second product was Squishit, which combines all of the CSS and JS files into one.

The second presentation dealt with a custom security solution within the Flex Viewer. Users and roles were stored in SQL Server. Enabling of widgets was controlled by adding a provisioning tag to the widget’s config file that contained the various roles needed. And based upon the login information provided, the widgets would be made available. The presenter pointed out that this approach will be much more streamlined when 10.1 is released, due to the inherent security that will be provided in ArcServer.

Caleb Carter

The closing session, after covering some alarming statistics regarding the vast consumption of the week, featured a presentation on the ongoing efforts of Esri to support the developer community through resources both electronic and not.  The overall theme was defragmenting developer resources while increasing the flexibility of the available tools, to make finding the information you need as simple as possible.  Here are some of the areas where these goals are being pursued.

• In the Forums, there are several enhancements to make the user’s experience more valuable.  Forum posts can now be voted on, RSS feeds for individual posts can be consumed, and go ahead and try it from your mobile device!  There were several other enhancements also, go check it out!
• Training and Certification offerings continue to grow and expand.
• The Esri Blogs include navigation by Community, Author, Category, Tag and Search.
• Esri sponsors Dev Meetups across the map.  Find a meetup near you!, or if there isn’t one, then speak up!

Scott Morehouse took the stage to give us a taste of his overarching perspective of the state of the art and what the future holds.  And just as the summit opened with a musical metaphor, Morehouse invoked Bob Dylan’s “Gotta Serve Somebody” to remind us all again why we’re here. It’s not for Esri’s sake. In most cases it’s not even for our own sake.  And in some, it’s not even for our clients.  We’re all here to do what we can to serve our end users.  And that’s what makes this event so important.  Through the sessions, demonstrations, discussions and networking, we are collectively improving our ability to serve our users.

As for the technical sessions of the day, I found gems in two geodatabase sessions:

Effective Geodatabase Programming

This was a great overview of some of the most common and presumably most useful dos and don’ts of programming against a geodatabase.  From how to access data most effectively and efficiently, to where to start looking when things aren’t working as expected, the topics were concise, relevant and in most cases accompanied with clear examples.

I won’t repeat the whole session, but some of the important points for me were:

• Not all cursors are created equal. Some utilize cached results, others do not.  Some are bound to the class that created them, others are not. If you’re going to use a cursor, make sure you know which one you need and understand how it behaves.
• Recycling Cursors – These are cool, but be careful; the whole point here is that the cursor only uses one object for the current row. Great for some things, but if you need an object to persist or pass around a particular row, a recycling cursor is probably not the answer.
• Plug In Data Sources – Now this was a cool topic!  Basically you can create a plugin to consume any data format you need (okay, maybe not any) in ArcGIS.  You develop the plugin (using C#, C++ or VB .Net) and define how data from the source can be translated to feature classes, tables, feature datasets.  There’s extensive help documentation on how to accomplish this.  Once your plugin is coded, you can read data in ArcGIS, browse, preview, manage in catalog, select, render, query, and more.  You can’t write data, but I can live with that.  They gave a great walkthrough of how they assigned an unsuspecting developer to create a plugin (which he had not done before) to work with MongoDB (which he had not used before), and he was able to have it fully functional in a week’s time.  Great stuff!

At the end of the presentation they gave a rundown of the most common mistakes based on support inquiries.  Many of these are covered in the above bullets, but some noteworthy mistakes were:

• Overuse of FindField – It’s recommended to use this method rather than a hardcoded field index, however, if you are using it in a loop to find the same field over and over, you’re asking for performance issues.  This was actually a good example of a point that the presenter was repeatedly coming back to: Whenever you can, perform your setup steps before you lock resources and get into the meat of accessing data.
• Calling Store in store_triggered event handler – this is a classic case of infinite recursion.
• And Careless variable reuse – let’s be honest…we’re all offenders here.

Accessing and Administering Your Enterprise Geodatabase through SQL and Python

So this was a double feature.  An overview with examples of how much you can do right in SQL with 10.1, followed by an overview with examples of how much you can do with Python at 10.1.  I’ll admit that I was a latecomer to this session, so I missed some of the intro SQL stuff, but I did gain a few tidbits that I’ll share.

• Working with your GIS data directly in the DB can be a great thing. Performance and simplicity can be gained from bypassing the ArcGIS stack for certain tasks.
• Working with your GIS data directly in the DB can be risky.  After all, you’re bypassing the ArcGIS stack….eek!
• All database items are cataloged in the GDB_items table, with a definition field containing an XML structure defining the object.  For instance, in the case of Coded Value Domains, the XML contained the entire CVD definition….values and all.  This meant that you could construct a fairly straightforward query to list out all of the Coded Value Domains…pretty neat.  Beware though; you can also edit the XML so make sure you understand what you’re doing!
• ArcCatalog provides a new mechanism for creating a spatial view.  Simply right click on the database connection, select New->View, and in the dialog shown enter a name for the view and the SQL query text that defines the view.

As far as the Python side of things, here’s a quick look at the capabilities at 10.1:

• Create Geodatabases – that’s right, an alternative to the SDE post-install.
• Create Database Roles
• Create Database Users
• Generate Schemas from XML Workspaces
• Change Privileges
• Manage Versions (Register, create, reconcile, list)
• Disable/Enable DB Connections (doesn’t disconnect current sessions, but does block new ones)
• Disconnect Users (this one does disconnect current sessions)
• Compress Databases
• Rebuild Indexes and Statistics

My most important take-away:  With great power comes great responsibility.

Thanks all for a great week!

Steve Riley of Riverbed Technology gave the Keynote Speech today. He spoke about how the Cloud isn’t anything like we think it is and proceeded to tell us why.  One of the points he made helped solidify some of my thoughts from yesterday. He was talking about how a system administrator will no longer be unpacking boxes and plugging in power and network cables; he will be doing it with a line of code in a scripting language. The System Administrators of the world are going to become programmers, at least if they want to keep working. I think we all will be adapting how and what we do as we implement solutions with these new technologies.

I spent the middle of the day in the RunTime SDK for iOS sessions. Though I don’t know Objective C at all, the team did a great job of walking through a pretty deep application in a way that I could appreciate and that the developers in the room got some value from.  They spent a good bit of time describing the modular design patterns they employed, and as a bonus they spent a good bit of time talking about the Apple User Interface design guides and showed how they implemented these in the application.

I went to see the only session on the ArcGIS for MS Office talk by Art Hadaad and his team. They had shown this solution two years ago as an early prototype, but pulled it last year. Well it has risen again and is currently in beta with release of v 1.0 due out right before the User Conference this summer. Art showed the slick integration of the map control in Excel (as simple as making a chart) and PowerPoint. The solution task spreadsheet takes data of just about any form and geocodes it against services running on ArcGIS Online, and returns a map. You can add basemaps and other services from ArcGIS Online or Portal if you have it. Furthermore, once the map is created and in Excel, you have some modest but nice controls to do some different renderings, and the map navigation is fully functional. If you like what you see, click a button and create a slide in a PowerPoint. The map in the slide can be static or dynamic, meaning it goes full screen and fully interactive.  Once you have created your map in Excel, you can publish it, but to ArcGIS Online or your Portal.  This is going to put authoring and publishing map services in the hands of everyone in an organization. Again, this is changing what and how we do work.

Finally, Dodge Ball capped off the day. Our team, Gone in 60 Seconds, lasted 3 rounds this year. It was a great team effort.

Chris Bupp

Day 2 started with a Keynote speaker whose topic was “the cloud”.  He talked about security in the cloud, and did a good job driving home the point that the cloud is secure.  (Every talk so far has mentioned the cloud and demonstrated how to integrate it with ArcGIS Online)

The first two tech sessions I went to were “Building Applications with ArcGIS Runtime SDK for iOS, part 1 and 2.  I still think that Objective-C “looks weird”, but I have less reason to argue against native apps now.  The SDK supports local basemaps, web maps on ArcGIS Online, and going offline.  They still need to roll their own offline editing structure, but they promised that disconnected editing will be supported in the Q4 release.  Also, they’ll be posting the source to the slick looking demo app next week to the resource center, so make sure to check it out.

The third tech session was “Software Development and Design Using MVVM”.  It was focused entirely in WPF, but I could see using the principles used in other languages, and even in other patterns.  Jeff Jackson, the presenter, did a great job demonstrating testability and maintainability even with a simple app.  He started off creating a simple WPF app, and then converting it to MVVM.

The last tech session was “Using Geoprocessing Services with ArcGIS Web Mapping APIs”.  The geoprocessing services were published to ArcGIS Online from ArcMap, and then accessed via URL calls.  The new features include the ability to create geoprocessing services that (if enabled) will automatically create temporary map layer feature services, which is great for large datasets and raster outputs.  Another feature that impressed me was the “File Upload” feature: an application is able to upload a file, and then perform a geoprocessing task on the uploaded file.  The demo for the file upload was pretty slick; it involved uploading geo-JPEGS in a zip, then creating a temporary feature layer with the image attached to the points.

Finally, a quick note about dodge ball—we lived by the ball, and we died by the ball.  Hopefully next year’s recruits can make it to the championship.

Mike Haggerty

Today started off with a keynote presentation by Steve Riley, CTO of Riverbed Technology.  He gave an engaging and provocative talk about everyone’s favorite buzz word: The Cloud.  He started out with a good working definition of the cloud: “if you’re still paying for it when it’s switched off, it’s not the cloud.”

Steve went beyond the marketing fluff and gave us some categories and terms to help us ask better questions about cloud-based technology.  It is imperative that we begin asking these questions, because according to Steve, we must “adapt or die.”  To really drive that point home, he showed a photo of an electric turbine in a Belgian museum.  The turbine was used to generate power for an adjacent brewery.  But eventually, the brewery was connected to the public grid, and they had no use for the turbine any longer.  Steve asked, “What happened to the guy whose job it was to operate and maintain that turbine?”  Well, he either went to work for the utility company or he retrained to operate brewery equipment.

We can’t be afraid of The Cloud, but we must adapt or die.  That is the story of our lives in the tech sector I suppose.  I walked out of the keynote talking with Dan about punch cards…

Since I’m a developer and not a system administrator, I’m not too terribly afraid of The Cloud, as I don’t really care where my code runs.  I am, however, more than mildly curious as I survey the RIA landscape and try to determine which client technologies are going to be waxing into and waning out of favor in the next few years.  I currently program in Flex, but I’ve attended a few HTML5/JavaScript sessions to brush up on the latest in that space.  I think Mansour Raad gave a good, balanced perspective in his HTML5 for RIA developers talk yesterday.  He doesn’t think Flex is going anywhere any time soon, but with Microsoft, Adobe, and Apple all promoting HTML5, we would be fools to ignore it.

In that vein, I attended Jeremy Bartely’s session about building a large JavaScript application.  He shared many lessons learned in the last three years of developing ArcGIS Online.  One challenge they faced was creating a stateless application that had to store user interaction history – for that they ended up using the Persevere Framework.  In addition, he shared how to make a single page Ajax application crawlable, why they used Dojo widgets (ease of localization and accessibility), and how to fallback when browsers don’t support certain HTML5 features.  One of the slick HTML5-enabled features he showed was being able to drag and drop a CSV file on top of the web map (this has been around for a while, but I just learned of it today).  He showed how that file would be opened using the FileSystem API, the data used to create graphics, and the graphics displayed on the map.

In his session entitled “Advanced Flex API Development”, Mansour showed how HTML5 and Flex could be complementary.  Though the Flash Player can’t access the local FileSystem via drag and drop, with a dozen or so lines of JavaScript, you can handle this in the browser and pass the data into the Flash application via the External Interface.

Change is afoot in our industry, but that’s really always been the case, hasn’t it?  At GISi, we plan on adapting.

Steve Mulberry

Day 2 started off with an entertaining keynote from Steve Riley, technical leader at Riverbed Technology. A couple quotes stand out, such as “adapt or die” as it relates to using the cloud. An interesting statistic he shared was that virtualization is vastly out-numbering physical machines they run on. Another quote, “Systems Administrators will become developers…” With the ability to standup, manage, monitor, and scale systems in the cloud literally through scripting processes, sys-admins no longer need to unpack computers and go through the rigors of standing them up on premise. Steve did his best to distil the cloud non-secure myths and concerns, stating that in his opinion the cloud is probably more secure than any internal IT environment.

Securing Applications at 10.1

ArcGIS Server 10.1 introduces the new feature level edit and ownership base access controls. Through the web API’s, developers will use a new Identity Manager class to automatically manage user access at the feature level by the owner of the feature. These new controls add the ability of tracking time and date users edit features, either at the desktop or over the web. The new web adapter adds a new layer of security and replaces the need for a reverse proxy configuration, as well as taking the place of ArcGIS Instances prior to 10.1.

Esri is trying to address the number one idea submitted to the Esri’s ideas web site, which is the need for high quality printing over the web. Their initial response is to offer a 3 tiered approach.

• Simple
• Custom Configuration
• Advanced Scripting using ArcPy.Mapping

The idea is for the developer to use one of the API’s to access the WebMap control and use the new ConvertWebMapToMapDocument method, make any adjustments to the MXD, and then export to PDF.  The WebMap will hold all the definitions for each layer or graphic added to the map. There will be a new printing widget available for each API that will be used to construct JSON for communicating to the new print service. You can read more about it here.

Caleb Carter

This morning the main event for the developer summit was the first topic of discussion.  I bet you think I’m talking about the keynote, but I’m referring to the Dodge Ball tournament.  It seems that there were a couple of open slots left, and so the audience was encouraged to recognize the vast similarities between Dodge Ball and a host of other sports.  Once our mindset had been properly adjusted, the keynote was introduced.

Steve Riley joined us at the summit to talk about the cloud, how to develop for it, how to administer it, and how to secure it.  I sat back in my seat and prepared to take rapid notes on the nuts and bolts of getting going in the cloud.  What we got was something different altogether.  First off Riley set the stage by illustrating the human tendency to fear change and to predict outcomes based on those fears.  He then made a bold statement (maybe even crazy given the audience): “Location doesn’t matter.”  What? Wait…does he know where he’s standing?

Well I think he did know very well.  He was standing in a crowd of technical professionals, many of whom are fairly fond of seeing, housing, and having physical control of their own servers.   And he was hitting home the point that physical control over our servers is not all it’s cracked up to be.  He wanted to put our minds at ease in terms of this mindset of “if it’s here, then it’s mine, and it’s secure”, whereas “if it’s not here, then it’s not mine, and it’s not secure”.  I personally haven’t had this sentiment in relation to the rise of the cloud.  Honestly I would have said that my lack of concern is due to naivety and a lack of deep understanding of server infrastructure security, but from now on I’ll be claiming that I knew all along that this cloud thing was legitimate (keep that under your hat please).

In the end Riley made a compelling and logical case as to why under the right circumstances the cloud can be more secure than maintaining your own servers, with dramatically less time and effort spent.  I went into this session expecting to come out with a pile of new information and knowledge about how to work in the cloud.  What actually happened was that I came away wanting to set aside some time to try out the cloud.  In my mind the inspiration to try out something new is far more valuable than knowing how to do it.  That inspiration will drive the learning.

It was a great presentation—engaging, on point, and relevant.

Then came more technical sessions…

ArcGIS for Sharepoint

Esri provides a configurable and ready-to-deploy Sharepoint extension based on their Silverlight capability, which I learned a little bit about yesterday.  The extension to Sharepoint consists of three basic parts, a Map web part, a Geocoding workflow, and a Location field type.  With these three capabilities, Sharepoint lists or libraries, which include address information, can come to life very quickly and easily in the Map.  Here’s a quick rundown of the capabilities (some of them at least):

• Add point location fields to any Lists or Libraries that contain address information.
• Load ArcGIS Server and ArcGIS Online maps to the web part.
• Select Sharepoint items in the map and the corresponding item is highlighted in the list, and vice versa.
• Generate locations for Sharepoint data using the Geocoding workflow.
• Interactively select the correct address match from the workflow results – this was particularly slick.
• Move the pin location in the map to fine-tune the location of a list item – also very cool!
• Configure any available locator (even custom locators).

This capability is very tightly integrated, and all of the use and configuration of the web part and workflow is available right in the ribbon, like it was made for it J.  And if the out-of-the-box capability, as great as it is, is not enough for you, the web parts can be extended using the extensibility SDK for Silverlight.  Extension can consist of Tools, Behaviors, Layouts, or custom Controls.

It’s pretty cool stuff, and best of all there’s a pretty thorough site in the Resource Center.

Introduction to MVVM and Custom Controls

This user presentation was cool.  It was a short presentation that consisted primarily of a simple example of a Silverlight application, using MVVM with a straight-forward code and process walkthrough.  As a newcomer to MVVM, I primarily was interested in getting the basics: what are the pieces, how are the lines drawn, and what is the payoff.  I certainly got this…and I’m excited to try it as soon as I have the opportunity.

So what are the parts/lines of concern?

• The Model is the low level data access.  It generally runs on the server, and is often mostly auto-generated.  The interface to this conceptual layer consists of web services.
• The View is the markup (XAML), which makes up the user interface.  There is little or no code behind it, and the creator of this layer should be a designer.
• View Model is the layer that facilitates communication between the Model and the View, which is for good reason “speaking different languages”.  The interface to the Model consists of service calls.  The interface to the View consists of binding properties, collections, and commands.

And what do we get for following this model?  The ViewModel contains the real logic of the application, and it is VERY testable.

There were a couple of important points that were made at the end of the presentation to help make your MVVM adoption successful:

• Do the tests…if you don’t do the tests, you’re not taking advantage of the most important reason for using MVVM!
• If you have to put a little code behind in the view…don’t worry about it.  Set your sites on the ideal implementation, but don’t let the realities of the task at hand force you to do more than necessary in order to adhere strictly to the pattern.

ArcGIS Runtime SDK for Windows Phone

I know this is going to sound familiar, but this SDK is also based on Silverlight, which we covered yesterday.  The list of new features and capabilities is nearly the same, so I’ll jump right into the few things that set this SDK apart.  First, the one limitation that this SDK has as compared to the other Mobile SDKs, seems to be the inability to work disconnected.  This isn’t really an Esri issue, it has to do with the fact that the OS is pretty restricted in terms of access to resources, so copying data onto the device and accessing it there is not as straight forward as with other platforms.

Where I really got excited in this talk was when I discovered that the Resource Center for Windows Phone includes an emulator packed full of sample capabilities and their corresponding code snippets.  Very cool!  Not sure I’ll have a WP project in the near future, but the Emulator seems to be more than sufficient for further exploration!

That rounded out the second day of technical absorption.  More tomorrow!

Sean Savage

So, the cloud…”adapt or die”, according to Steve Riley during his keynote address. It sounds dramatic, but he put it into context through strange, but relevant analogy, involving John Philip Sousa and a gramophone! Essentially, the point was that the cloud is changing the way we do business and will continue to do so. Those who don’t embrace the change may, well…die, at least within this career/industry. In reality, he presented the cloud from a different perspective, arguing that it could be debated that the cloud is more secure than the traditional on premise model. Likewise, the changing paradigm could inspire creativity in solutions, offering freedom and flexibility that can and will offer new opportunities. Of course, freedom and flexibility don’t mean no responsibility, and we can still undermine the cloud as a valid and robust solution with poor development, implementation, and decision making in general. It was an entertaining and thought provoking presentation, if not always politically correct.

Following the keynote, I attended a session on Agile Software Development. I am admittedly not well read in the agile approach, and as I mentioned in my post from yesterday, I have no experience to speak of. Nonetheless, I thought the content was quite good (though the delivery a little dry, which made it just a touch hard to stick with it), and very informative to the untrained ear. Unlike the agile session yesterday, this session did provide a solid overview of the agile approach and its origins. Although many of our projects on the State & Local Government side may not be justify or support team sizes that fit within the recommended range (5-9 or 6-10, depending on who was speaking), the basic approach seems like it would be a good fit for the pace and suitable to meet the needs of the clients. I thought some of the discussion could have implications on the way we approach huddles, both project and team. That is, leveraging the huddle to have each individual strictly speak to three things every day:  (1) what have you done since the last huddle? (2) What are you going to do until the next huddle? And (3) what are your impediments? But, I also actually found the approach to estimation among the most intriguing concepts, such as relative estimations, wherein you identify a prioritized backlog of items (PBI) that you can digest and understand well. All other PBIs are then estimated relative to that, not by hours, but rather by complexity (i.e., 2x harder, etc.). If I understood it correctly, you can then use the hours for that one baseline PBI to calculate the estimates for the others. I have a lot to learn!

I then attended a session on Leveraging OGC Capabilities for ArcGIS Server. It was an interesting presentation on another topic that I haven’t gained much experience, but ultimately the presentation and demonstration showed mostly out-of-the-box Server administration to expose the OGC capabilities for each service type, and then consuming those capabilities with open source client applications. Like I said, it was interesting and may be applicable for non-Esri clients who want to consume hosted services (either by Esri or other parties). I need to give some more thought about how widely applicable it could/would be.

The third session of the day was on Extending ArcGIS Server 10.1 Services. With the push to migrate to SOEs as 10.1 looms, I thought this was quite a relevant and interesting session. The presenter walked through the process from writing, through deploying and publishing, to consuming a 10.1 SOE. They were quick to point out that many Esri clients and partners had developed services that may now be addressed by other features coming with 10.1, and therefore not all services may require migration. However, consistent with so many other features of Server at 10.1, the process of deploying a SOE is substantially simplified, and now completed directly through ArcGIS Server Manager. The examples were simple, but well worth the time of the session.

The final session of the day was on Map Caching in ArcGIS 10.1 for Server. Although I missed the first several minutes of the session due to a mistake in the agenda (I swear!), I walked in to see that once again the process has been streamlined at 10.1, with much greater flexibility and far more reporting. Access to cache management tools is now facilitated by context menus directly on the services in ArcCatalog. There are tools to estimate the cache size per the configuration of the service, and even new tools and data to support very detailed review of what has been cached and when. Caches can also be fired off through the Catalog window and then run asynchronously, allowing the user to continue to interact with ArcMap and even close the application and check on status later. Of course, there are also advances in publishing to the cloud and ArcGIS Online, a very consistent theme throughout!

Ben Taylor

The day began with a lively keynote speech concerning cloud development. Steve Riley of Riverbed Technology gave an inspired speech that attempted to demystify and debunk misconceptions surrounding cloud development. Steve touched on a broad range of topics, including software architecture and security.

During the afternoon, I attended technical sessions focusing on the JavaScript and Flex APIs. The JavaScript session rehashed a few functionalities new to 10.1 that were showcased in the plenary session. Network connectivity problems hindered the presentation a bit but the presenters pushed through…a difficult task considering they were demonstrating performance enhancements regarding how geometries coming back from ArcServer are now generalized based on the scale at which the request was made. The end result was a dramatically smaller JSON object coming back across the wire.

The second afternoon session dealt with Flex API. Some of the new features scheduled to be available in the 3.0 release include a content navigator, ability to cancel gp jobs, improved KML support, and editor tracking. One of the more impressive features was the new dynamic layers, which includes the ability to change layer ordering and symbology via a rest request.

I wrapped up the day with a couple of presentations that included Mansour Raad as the presenter, which is always a treat. The first session dealt with some advanced topics in Flex. Mansour demonstrated a few example applications that highlighted the benefits of using MVC. Then by combining HTML 5 JavaScript and AS3’s ExternalInterface class, he demonstrated how it was possible to perform drag and drop functionality in Flex (similar to the JavaScript API’s D&D). He wrapped up the session by showing a solution he developed that utilized NoSql and MongoDB. He showed how he extended the spatial filtering capabilities of MongoDB to include complex polygons, which can only handle simple circles and squares by passing an envelope of a polygon and clipping the results using Flex’s native point-in-polygon filter.

The last presentation featured both Sajit Thomas and Mansour. It was one of the most entertaining presentations I’ve seen in a while. They demonstrated several applications written in HTML 5 and Flex. The slide content and scripted banter between them was priceless, and kept the audience in stiches.  The applications included such functionalities as voice control, an attempt at mind reading, and ending with a helium-filled shark that was controlled by a Flex app. So it was an entertaining session to say the least.

Here we go again. The GISi Development team at the 2012 DevSummit is seven strong this year… well six developers and myself, and I am really here for the Dodge Ball.  Once again we will be posting a daily blog to describe our reactions to the different presentations each of us attend.

Well I have to say, everything is about to get easier, from publishing data, geoprocessing, and map services, all the way to standing up scalable Amazon Cloud clusters and managing all of the AGS services on the cluster. Everything is wizard driven, drag and drop, point and click. Well not everything of course, but a significant portion of the processes in the ArcGIS stack have gotten simpler. For a developer, this is going to minimize the amount of time getting everything set up so they can actually spend time developing.

I also see these efficiencies really changing the analysts’ day-to-day activities. The ease with which we can now publish geoprocessing tasks into discoverable easy-to-use apps and get them in the hands of the end users is also going to free up the analysts from some of the mundane, allowing them to do the interesting stuff.  Figure out a problem; publish the solution, then on to the next problem.

The vision is that the map, with the data and geoprocessing task, serves all devices – defined as web, mobile, and desktop clients; and ArcGIS Online being the central service mechanism is compelling.  However I think as Esri develops this technology stack there are some things we as solution providers will need to tackle and I am still getting my head around these. First, while ArcGIS Online (and Portal for Organizations) is an Enterprise GIS, there is little talk of how the GIS can be integrated with the rest of the Enterprise Stack. While there is ArcGIS for SharePoint and ArcGIS for Cognos solutions, these are not core products, yet.  However, the fact that the services are all exposed as REST endpoints does offer tons of opportunities to integrate these GIS capabilities into the rest of the Enterprise.  I think we’ll start seeing demos shortly showing how these can be accessed by other enterprise solutions.  Second, we have been spending a lot of time helping clients consolidate systems and defining databases of record and implementing solutions around that. I think without some significant planning and workflow design, the simplicity of publishing data services could lead to entropy of data again – remember when everyone had their own shape files and personal geodatabases, and the mess that that created? Organizations are going to need to get in front of the wave and be creating services that serve databases of record for all to use, just to prevent everyone in the organization from publishing their own little piece of data to serve a specific application.

Any way you look at it though, the new technology brings many efficiencies, and with that new opportunities to solve different problems. It’s going to be a fun year!

Steve Mulberry

Another DevSummit underway in sunny Palm Springs; check out the plenary videos here.

It seems like just yesterday I was blogging  about the many SaaS (Software as a Service) offerings Esri released. Now at this year’s DevSummit the word of the day is GaaS. That’s right—GIS as a Service. ArcGIS Online version 1.6.3 will be available at the same time ArcGIS 10.1 is released in June of this year, and offers much more than just pretty maps. ArcGIS Online becomes a GIS in the cloud as a subscription-based offering for hosting and managing data, maps, applications and organizational portals. We also saw the new and improved resource center, with the focus of many sessions around the new ArcGIS for Communities.

Each community offers free hosted or downloadable solution templates for web or mobile devices, data models, desktop tools, and access to online maps and services for your specific area of interest.

We saw a whole new paradigm in authoring, publishing, and using services with the re-engineered ArcGIS Server, as well as a Flex Air tool for managing ArcGIS EC2 instance on the Cloud.

This year’s DevSummit is off to a great start…..stay tuned for more.

Caleb Carter

Things kicked off this morning with a delightful welcome animation illustrating the coming-of-age journey of a hard-core coder, with an accompanying rendition of the Johnny Cash classic “I’ve Coded Everywhere, Man!”  And once our adrenalin was pumping Jack took the stage and gave us something important to think about as the development community, that works to marry the expanding capabilities of GIS with the ever-evolving needs of our customers:

“We have to believe as humans that we can make a difference.”

The remainder of the summit will serve to educate us on how the capabilities are expanding, as well as to brainstorm and daydream about how we can use what’s coming to better meet our clients’ needs.

Following the introduction, there was a demonstration by Phoenix Skyharbor International Airport detailing their efforts to use ArcGIS to streamline some basic parking capacity workflows, as well as their subsequent exploration of where GIS could take them (check out their mobile site).

Then we got down to business with the overview of what 10.1 will bring to the table.  There were many little goodies that we’ll see (and share) more details on over the next couple of days.  Two high level themes that were very clear at the morning session were:

• ArcGIS Online is moving toward the center of the universe (or vice versa?)
• Everything builds on top of ArcGIS Runtime

The following are the highlights from the technical sessions I was able to attend this afternoon:

Choosing a Mobile Deployment Platform

This session was a little more introductory than I’d hoped for, but the content was at the very least a re-affirmation of the lines of reasoning that I have observed and participated in in terms of choosing platforms.  Also it served to set my frame of mind in preparation for some in-depth mobile sessions to follow.

The bottom line is you need to know your client—know their business, know their GIS expertise, know their budget,  and know their data requirements.  If you have a solid handle on these areas, then the device and platform will usually present itself.

What’s New in Silverlight?

There are some expected items in this list, which we’ll probably hear repeated in most sessions—make use of new ArcGIS Server capabilities, and include/utilize a Runtime SDK. Beyond that, the Silverlight team has added the following (probably not comprehensive) list of capabilities in version 2.4, which was released in January:

• An Application Builder with an Extensible Framework
• Integration with ComponentOne

And with version 3.0 RC released this month, we’ll also see:

• Server 10.1 capabilities:
  • Additional Map Service support (Dynamic Layers and more)
  • Feature Service support, including Editor Tracking, Versioning, and Ownership-based editing.
  • Print Service support
  • Image Service support (there was a slick demo of image georectification using Silverlight in the plenary session)
  • Upload (images, attachments)

Developing with JavaScript for Multiple Platforms

This was a user presentation of one team’s process for targeting multiple platforms with as little effort as possible (isn’t that what we all want?) The team used a tool called Appcelerator which compiles JavaScript to native executables for six (I think) platforms.  There are drawbacks of course.  Appcelerator will not target Windows Phone 7 for one, which was an acceptable sacrifice for this team.  Also there is no visual UI builder, so if you’re not comfortable with control placement and sizing in code, you may want to reconsider.  Finally, and this is a pretty big one in my opinion, Appcelerator doesn’t provide access to all of the capabilities of every device.  If one of your target devices supports a capability the Appcelerator hasn’t accommodated yet, then you have a significant hurdle to overcome if you want to use that capability. On the other hand, if your requirements are pretty basic, and if you don’t mind a device or two left out, this may just be a good way for you to achieve what this team was shooting for, which is to increase market penetration through a presence in the native app stores/markets.

Building Applications with ArcGIS Runtime SDK for Windows Mobile

This was my favorite presentation of the day.  Having been neck-deep in the ArcGIS Mobile SDK for the last several months, I was anxious to see what was coming in 10.1, and in particular, what the migration to the Runtime SDK would mean. As it turns out, the migration to Runtime SDK was very well illustrated.  We were walked step-by-step through taking an application built for 10.0 and upgrading it to 10.1.  We saw what broke, and we saw how to fix it.  Aside from some obvious stuff, such as dll names, namespaces, and a couple of class names, there were a few changes worth noting:

• Several components were pulled from the designer—specifically map actions. Rather than adding them by dragging and dropping on your form, you create and add them in code.  This is done mostly for consistency.  Only a subset of map actions was available in the designer to begin with.
• A 10.1 application cannot consume a mobilecache created using 10.0.  However you need not upgrade your entire ArcGIS infrastructure to make this work.  Simply installing ArcGIS Mobile 10.1 will replace all of the mobile geoprocessing tools with new versions.
• The map control no longer has a DataSources property.  Data layers are added using the Map.MapLayers property.

There are several other changes.  Here’s a brief list of some of the highlights:

• Mobile Project Center has added a Validator (similar to mxd validation in ArcMap).
• MPC integrates extensions seamlessly.  It’s as if they were part of the core capability.
• Added attachment support.
• Routing with Streetmap Mobile (only for the SDK, and only on the Windows platform, not Windows Mobile)
• The next release version of what is now “ArcGIS Mobile 10” will be “ArcGIS for Windows Mobile 3.0” in order to better align with the versioning of the runtime.

And finally there’s the roadmap. What’s coming later?

• Support for Tables
• Relationship Classes
• Laser Range Finder support
• Ad-Hoc Schema Creation
• Expanded Routing Capabilities

All in all it was a good first day.  I’m anxious to see what is revealed tomorrow.

Sean Savage

The DevSummit started with the full flair of an Esri-style production for the plenary session, which featured glimpses into the newly overhauled 10.1 version of ArcGIS Server—perhaps  one of the most enticing aspects of the opening session. As a native 64-bit application and streamlined code under the covers, the upcoming release appears to be quite a significant deviation from what we have come to know (SOM, SOC, etc.). Performance gains were presented through a series of quick demos, including a drive time analysis that updated based on the position of the mouse as it hovered across the map (the drive time polygons and a route from the origin to the current mouse position updated in very near real time!). Completely based on http calls to web services with APIs to facilitate programmatic administration/manipulation, it looks to be much simpler to deploy and manage.

Similarly, ArcGIS Desktop has undergone some corresponding changes that mirror the simplicity of Server. Publishing or sharing services from ArcMap (optionally including the required data) is nearly as easy as saving a map document, especially when the target is a cloud server. Likewise, the process of deploying a geoprocessing task follows the same streamlined path, and can be published with or without pushing the data along with the task. And with extended Python capabilities (better data access, cursor control, rendering, etc.), the geoprocessing tasks can be easier to use and more powerful than ever.

There were a flurry of demos focusing on ArcGIS Runtime that illustrated consistent functionality across the APIs (Android, iOS, Windows, etc.). I was impressed by the performance of each, though the advances they have made in the Runtimes was highlighted through a side-by-side comparison of the ArcGIS Runtime for Windows that showed a dramatic improvement in rendering graphics. The demos also emphasized ArcGIS Online hosted services, with the new capability to take your data and work offline/disconnected with subsequent synchronization, which is largely made possible by hosted feature services and tiled services. Esri also made a point that they are shifting perspectives away from considering mobile vs. Desktop, and they are now looking at Desktop as just another device and not a separate framework.

The last topic of the plenary session was a brief glimpse into the future. A quick demo showed that even the geoprocessing tasks and the data required to perform them will capable of disconnected analysis and performed offline in the field (i.e., routing, geocoding, etc.). Esri teased about the widgetized windows framework that won’t require any manual configuration. The demo showed creating a simple application that included a map with an ArcGIS Online hosted map that displayed dynamic content. The map and associated widgets can point to common data feeds that are all configured through the UI. They also presented what they are calling “Metro Style” Windows 8 applications, which have the whole screen display, and the look and feel of an iPhone/iPad app.

The whirlwind plenary was pretty impressive, but obviously could only hint and tease at many of the features—most to be covered deeper in sessions.

The first session I attended was focused on testing within an agile development approach, that is, looking at Test Driven Development (TDD). Not knowing what to expect, I actually found it to be very interesting. Certainly, the key takeaway for me was that while I have used the “agile” buzz word, I have never participated in a project that followed that development approach, but rather than focusing on the tenets of agile, the session focused on the discipline and extensive testing efforts that are required to support agile development. While somewhat intimidating, the discussion also made me that much more curious about attempting to follow this path on a project!

I also attended a session on ArcGIS Server Performance and Scalability analyses. This was a good session, but ultimately represented a high-level summary of a training opportunity I was able to participate in last fall in the GISi Birmingham office, but this time without the cool tools to actually perform the analysis. The message was really more about the components of performance and where to look or what to consider when things aren’t behaving as expected, and less about designing a responsive and scalable system.

The last session I participated in on Day 1 was ArcGIS Server for Amazon Web Services. This was a very interesting session! What started out as what appeared to be a high-level review quickly turned very interesting when Esri introduced their new Cloud Builder tool. Cloud Builder is an Adobe Air application that leverages the EC2 API to allow administrators to quickly and easily spin up new cloud instances based on either the Esri AMI or a user customized AMI. The application facilitates creating the instance (along with starting/stopping the instance), authorizing the Esri software, establishing the required key pair, setting up auto-scaling, and backing up the AMI. With Cloud Builder, the Esri folks showed that you can create a new cloud instance, get the software authorized and running, and publish services (and data) without ever logging into the cloud server itself!! This is all facilitated by architectural changes made with ArcGIS Server at 10.1. They also discussed aspects of responsible cloud usage (planning/understanding the costs, managing AMIs and security, etc.), but my mind was spinning around the new tool far too quickly to care about that stuff yet!

Mike Haggerty

As I found my seat 10 rows back to the left of the stage in a comfy faux-leather couch before the Esri DevSummit plenary session this morning, I was worried whether the comfort of the seat and the darkness of the room would overcome the forces of my morning coffee.  Thanks to the engaging presentations and exciting announcements, though, I remained wide awake.

After Jack welcomed us to the 6^th DevSummit and inspired us with the notion that software could perhaps overcome the darkness of the world, we dove into updates and demos from web API team, ArcGIS Online teams, and runtime teams.  One gem from the runtime team – everything is a device.  Your desktop computer is a device.  Your phone is a device.  Your tablet is a device.  Stop thinking in terms of mobile platform / desktop platform, and just get it into your head that everything is a device.  And every device needs the capability to run native apps; therefore every platform needs a runtime.

A nice surprise was the announcement of an OSX Runtime with a native Cocoa API.  This now rounds out the runtime suite of Windows, iOS, Android, and Linux.  If you asked me a few years ago, I wouldn’t think native platform development would be getting much attention these days.  I would have said, “It’s all about the browser, baby.”  But with the hardware available in the thinnest form factors today, it makes sense to tap into that with a runtime whose core is written in C++ and can fully exploit all the available resources.

There was good content today and much was learned.  Can’t wait for tomorrow!

Ben Taylor

The plenary session promised several welcomed and potentially profound changes coming to AGS Server, the web APIs, and the runtime engines. Highlights for the 10.1 release include a noticeable increase in performance, tile layer packaging, and simpler creation and configuration of geoprocessing services. The APIs boast custom symbology and enhanced printing capabilities. Perhaps the biggest change revolves around native application development. There is a shift in the development philosophy surrounding the ArcGIS runtimes that attempts to blur the distinction between mobile and desktop applications, and view these platforms as just another device and not disparate technologies. We got a sneak peek at some of the goals of future releases of the various runtimes for mobile apps that drive this point home. Functionalities will include disconnected geocoding, networking, and 3D modeling. In addition there was a demonstration that focused on configurable desktop/mobile applications (think widgets).

I attended a few sessions dealing with the JavaScript API. Though the content was geared more towards beginners, I did pick up a few good tidbits. One is how to utilize ArcGIS Online to take care of all your layer and cartographic configurations. All that is then needed is a reference to the map in your JavaScript, which I thought was a pretty clever shortcut.

I wrapped up the day by attending a few user presentations. The first topic dealt with converting an existing Flex application over to AIR in order to achieve disconnected capabilities. Python and Django were employed to tease out tiles into byte arrays, which were stored in a SQLite database. The methods used to pull the data back into AIR were the same that will be used for tile layer packages. The second topic focused on web design in Flex. The presentation drove home the point of only giving the users what they need in order to accomplish their given goals, rather than serving up the entire API, which in many cases can clutter the UI and cause unnecessary confusion. The final talk dealt with an interesting approach to try and determine the root cause of performance issues in a Flex app. The developer wrapped each component with a custom timer to help highlight any code that may be slowing the application down.

Chris Bupp

This being my first DevSummit, I didn’t really know what to expect.  But they really brought out the “wow” factor.  Demos went well, and I’ve already started rethinking how my projects need to be reworked to target the new directions.  I started things off light with a refreshing “Projections, Spatial References, and Geometries” session; I had several “Oh, that’s why we do that” moments.  (Did you know that there was also a vertical project model? I think I’ll be spending some time on Wikipedia researching that tonight)

Next I sat in on “Getting Started with ArcGIS Online”.  They didn’t get nearly as technical as I wanted, but I plan on tracking down the speakers and asking them some more questions; ArcGIS Online looks really awesome.

Finally, for the third tech session today, I went to “.Net Add-ins for ArcGIS Desktop”.  They’ve drastically simplified the add-in architecture.  It’s going to be very frustrating the next year(s) until my projects have upgraded to 10.1; they did a great job making ArcGIS 10.0 look completely archaic.

While the applications are 95% similar, there were some key differences. For example, on the kiosk version, the UI elements needed to be larger (e.g. touch screen friendly) and we wanted to be able to print directly to the thermal kiosk printer without displaying a print dialog. This lead to a decision to utilize a shared library to contain much of the business logic, web service delegates, and presentation logic while creating distinct target-specific application projects which would override or extend the shared library code when necessary.

With the advent of Mobile AIR, this concept can be taken one step further. I gave a talk at the 2012 ESRI Mid Atlantic User Group which expands on this concept to utilize a shared code base to power web, desktop, iPhone, and Android clients. In the video below, notice how the web application displays identify results in an Info Window, but the mobile application displays the results as a new view in the view stack – yet, they use the same code to retrieve the data from the server, store that data on the client tier, and render that data on screen.

If you want to dive further into this concept, feel free to fork this application on GitHub.

We at GISi have been very happy with our client successes using GISi HealthCheck and GISi ArcGIS 4 Local Government (AG4LG)  jumpstart toolkit.  Most recently, the GISi & the City of Southfield, MI GIS group has been working diligently to implement Esri’s AG4LG information model into the City’s existing Enterprise GIS infrastructure.  The City has adopted the newly released common information model, core GIS tools, templates, and applications to help the City improve operations and communicate more effectively with the public while saving both time and money.

We are very excited that Southfield has joined our client, Effingham County, GA, to become one of the first communities in the country to truly embrace the new information model, applications and services being provided by GISi & Esri. The work GISi and the City have been doing in the AG4LG space has already generated a wealth of positive word of mouth throughout the region.

The City of Southfield GIS group has deployed the apps and maps gallery template: Destination Southfield and three applications; “GISi Silverlight Template Viewer”, “Polling Places”, “Parks & Rec Finder” and the City plans to have many more apps added in the coming months.

The GISi Silverlight Template Viewer application provides a wealth of geospatial information to its residential and business community, supporting public service delivery 24/7.  The City and GISi migrated its current WebADF application to the ArcGIS Server 10 platform using Microsoft Silverlight™ version 4.  Resources like the City’s Internet Mapping Portal reflect the type of investments Southfield is making to ensure a vibrant business climate exists.  This site helps promote the growth of existing business and attract new investments into the city while providing vital information to its citizens. Residents and nonresidents alike are able to view property ownership, zoning, voting districts, refuse and recycling information and many more commonly used data layers.

The Election Polling Places application helps citizens locate their election polling place and obtain information about current elected officials. This application is typically used by citizens during an election season, but can be used throughout the year to determine which elected official represents the precinct they reside in. To locate a polling place, simply click on the map or enter an address in the search box. The polling place and respective voting precinct will then be highlighted on the map and relevant information about the polling place and elected officials will be presented in two tabs at the bottom of the application. The application will also provide directions from the searched address to the associated polling place location.

The Park and Recreation Finder application helps residents locate a park and obtain information about recreation activities in their community. This application is typically used by residents in a community, but can be used by visitors to locate a park or recreation area near them, or one that offers the activity they are interested in. To locate a park, simply enter an address or activity in the search box. The park(s) or recreation area(s) will then be highlighted on the map and relevant information about available recreation activities are presented to the user.

The City now plans to release new applications on a consistent basis over the upcoming months. Sally Price feels the release of these applications will offer significant value to both City of Southfield staff as well as its citizens.  The City is using the GISi HealthCheck prescription to guide these future apps.

I would like to thank everyone at Esri who made this implementation possible through education and commitment to the success of our clients, to the GISi staff (Steve Gogola, Sean Savage & Christopher Fricke) and Sally Price sprice@cityofsouthfield.com.

GISi will soon be deploying AG4LG apps to ArcGIS online, visit: http://www.arcgis.com/home/item.html?id=881d4967817241db818795135a12ab09

For more information on the GIS HealthCheck, visit http://www.GISHealthCheck.com

For more information on AG4LG, visit: http://resources.arcgis.com/content/local-government/about

For a link to Destination Southfield, visit: http://maps.cityofsouthfield.com/destinationsouthfield/

For more information on the GISi Silverlight Template Viewer, contact sales@gisinc.com and try it live: http://maps.cityofsouthfield.com/GISViewer/

For more information on Elections Polling Place Template, visit: http://www.arcgis.com/home/item.html?id=14290c7441b34ea984ad9310f4cf6435 and try it live: http://maps.cityofsouthfield.com/Apps/Elections/PollingPlaces/

For more information on the Park and Recreation Finder Template, visit: http://www.arcgis.com/home/item.html?id=734512384d3b4b849aba2db0e33a80f2 and try it live: http://maps.cityofsouthfield.com/Apps/Recreation/ParkFinder/

In the beginning, there were scientists. Remember we are talking GIS, okay? The scientists were trying to figure out how do analyses with these cool computer things and apply that to maps and spatial questions. Those smart scientists started developing computer applications to help them do their day jobs. GIS was an applied science. One guy could do it all. The GIS guy.

Fast forward a few years and those GIS guys began migrating away from their scientific day jobs, because, well, GIS was just so cool! They began to see how GIS could be applied to a wide variety of problems, not only scientific, but economic, demographic and sociological avenues. It could be used as a real differentiator in understanding and solving business problems.

We started seeing the GIS guy get stretched thin on his ability to know it all, but most of them could still do it, and most of them still started somewhere else before they came to be the GIS professional.

Then, something happened. In conjunction with the rapid development in desktop computing power, application of GIS in scientific and demographic communities, the GIS guy became a specialist who actually went to school to become a GIS guy. We needed it to be that way, and so the paradigm of the GIS professional shifted. It is analogous to what happened in the broader computer science industry 2 decades earlier. The mathematicians and engineers who adopted computers and were the early programmers were replaced by the computer science graduates who specialized in all sorts of areas in the “computer science” industry.

The thing that fascinates me about the paradigm shift is how quickly it seemed to happen. Can we look to the broader computer science landscape and see what is possible with GIS? Are we already there? Have we simply been absorbed into computer science as a niche market or are we something altogether different? The old scientist in me says the latter, but I could be convinced otherwise.

ArcObjects is thread-safe, but some of ArcObject’s operations lock out concurrent processing to ensure thread safety.

I discovered this fact while working on an algorithm that performs several calls to ISurface::GetLineOfSight.  After profiling the algorithm, I discovered that the line of sight operation was the algorithm’s bottleneck.  To get more speed, I multi-threaded the algorithm.  The result was unexpected: The algorithm took twice as long to process and required twice as much processing power.

I came to the conclusion that I needed to write my own line of sight algorithm.

After a bit of research, I decided to use a Triangle-Ray Intersection technique (used by some ray tracing methods).  The method requires converting the surface to a collection of 3D triangles.  To determine the intersection point, search through the triangle collection for an intersection with the ray.

(Source: http://www.cs.cornell.edu/courses/cs465/2003fa/homeworks/raytri.pdf)

The reason to use triangles is that the math becomes much simpler (and faster).  In fact, there are no computationally complex (and slow) mathematical operations.  Take a look at the code:

Granted, the math is complex, but the math isn’t computationally complex.  The above method, “flattens” the surface and then determines the intersection of the triangle’s plane with the ray.  The PointInTriangle method then determines if the intersection point is inside the triangle.

The way the PointInTriangle method works is by checking which “side” of each of the triangle’s lines the point is on.  If the point is outside of the triangle, the point will be on the left side of 2 of the lines, and on the right of the other (1: Left, 2: Left, 3: Right).  If the point is inside of the triangle, the point will be on the same side of each line.

So far, my implemented version is 10x slower, but just as accurate as the ArcObjects line of sight operation (the trick is to use the same points to build the triangle collection).  But not to worry, there is plenty of room for improvement.

Currently, the triangles are stored in a 2D array.  A more efficient data structure will greatly improve performance.  Another positive note is that this implementation is thread-safe and doesn’t lock out concurrent processing.

This implementation can be modified for GPU processing.  Using a GPU technique, every triangle can be checked for intersection at the same time.

In conclusion, there is a lot of potential using GPUs to perform line of sight operations.  Transferring the surface’s data to the GPU is a relatively considerable investment (about 2-3 ms).  Luckily, when performing thousands of line of sight operations, the data transfer happens only once at the beginning.  Compared to ArcObjects running on a single thread, we can expect to see at least a 14 times speed up.  This means an algorithm that previously took an hour to run could potentially run in 4 minutes.

It took a bit of research to determine a good method of implementation.  Luckily there were several sources out there to read and use:

http://www.cs.cornell.edu/courses/cs465/2003fa/homeworks/raytri.pdf

http://en.wikipedia.org/wiki/Ray_tracing

http://en.wikipedia.org/wiki/Line-plane_intersection

http://www.codeproject.com/KB/graphics/Simple_Ray_Tracing_in_C_2.aspx

http://t-ray.googlecode.com/svn/trunk/ORayTracer/RayTracer/tTriangle.cs

Like Christopher mentioned, integration was certainly a buzz word tossed around a fair amount.  Demos given during the main session talks showed how a user could fairly easily push maps and data from ArcGIS Desktop to ArcGIS Server and ArcGIS online.  As Clint Brown, Director of Software Products at Esri, was casting vision for the future of ArcGIS, he liked to refer to ArcGIS as a system.  To paraphrase, “What is ArcGIS?  It is a system that enables people to work with your online maps and associated geographic info.”  It would seem that Esri’s heavy investment in cloud technology (in the form of ArcGIS Online) is the key to the advancement of this vision.

In line with this vision is the idea that maps are windows into our data.  Maps are way more than a way to find directions from A to B.  Thanks to Google, the general public is familiar with the idea of using a map to explore data from the world around them.  Esri wants to harness this general population spatial awareness.  Again, Clint Brown: “Everyone knows how to use a map.  The map is the window into everything else GIS related.  It is one of the most universally recognized ways to present information.”  He encouraged us to think of new ways to use the map as a window into our respective organization’s business data.

Like Christopher mentioned in his previous post, the Esri MUG was a very inspirational event.  In addition to the array of fine user presentations, I was particularly inspired by the recipient of the First MUG Community Service Award, Dr. Jay Morgan of Towson University.  This man has used his career to increase the public’s awareness of GIS and how it can be used to create a better world.  He inspired us to find ways to volunteer in the community and transfer our passion for GIS to the next generation.

If I could choose one buzz word to describe the future of GIS it would be Integration. With Esri’s upcoming 10.1 release and increasing push into cloud infrastructures, it is becoming easier to push data developed in ArcGIS Desktop to map services hosted by ArcGIS online, that feed applications hosted on a webserver to clients anywhere in the world.  It is a different concept than what I am used to.  I think Clint Brown said it best when he proclaimed ArcGIS Online the Flickr of GIS.

In addition to integrating a number of their software products, it sounds like Esri has invested a lot of time simplifying the everyday maintenance of their ArcGIS Server and ArcSDE products.  ArcGIS Server is getting a total make over, dropping support for DCOM connections and trimming down the number of installed users from three to one.  Also, I really like the incorporation of more Database Administration tools into ArcCatalog.  Hopefully gone are the days of cracking open SQL management studio to manage users.

I was left really inspired by this year’s MUG.  There were a bunch of presentations that showed the increasing role that GIS plays in disseminating information to typically non-GIS users.  The Flex Site the Baltimore City Fire Department set up for emergency responders working the Grand Prix showcased how GIS can be used to help dispatchers make decisions on the fly in a rapidly changing environment.   I also thought the model the National Capital Region Geospatial Data Exchange utilized to distribute data between local governments, private industry and non-profits was really innovative.  Silos of data are nice and all, but real information comes when multiple data is shared throughout the community.

Let’s try to demystify things a little.

Mobile Hardware and Software

There are two basic types of mobile hardware: smartphones and tablets. There are big variations in each category, one of the most critical is size. Size as it relates to portability, and more importantly screen. Smartphone screens vary from 2.1″ to just over 4″; in contrast tablets have a range of 7″ to 10.1″. Why is screen size so critical? Try interacting with an ArcGIS map on a 2.1″ screen!

Users can interact with mobile applications in one of two ways. They can use their Web browser to access a Web site, or they can download and install an application from one of the Mobile App stores. Most Web pages have been built for the PC. This means mouse interaction. Increasingly, Web sites are being optimized for mobile viewing and interaction. This means built for use on smaller screens, and allowing for finger interaction. This usually requires multiple Web sites; one for PC’s and one or more for mobiles. Now suppose your company has taken advantage of the excellent Flex Viewer for ArcGIS to give access to your spatial data. You share with your users the news of a new widget you have added, one perfect for use on mobiles. The deluge of angry iPhone and iPad users, complaining they cannot access the Web site, makes you regret your announcement. It’s an unfortunate reality that both Flash and Silverlight will not run on the browser of any Apple device.

Visiting Apple’s App store or Google’s Android Market, users can access an array of mobile apps. These are installed mobile apps; both free and fee based. A simple search on GIS or maps in an App Store produces a nice list of mobile apps. Let’s imagine you have a unique idea for a mobile application; one you’d like to push into one of these stores. Where do you begin? In the old days, we are talking here about months not years, you would first choose the platform to target for the app. That was usually Apples iOS, for running on the iPad or iPhone. Next hire an Objective C programmer. And build a so-called native mobile application. Once done, launch it into the Apple marketplace and watch it jump off the shelves, figuratively. Android from Google has seen increasing popularity. Suppose you wanted to take your app and push it into the Android market. Stop. Rewind. Hire a Java programmer. Have him rebuild the application. Push it to the Android Market. You get the idea; a single mobile app running on different platforms requires multiple rewrites. When you add in bug fixing and updates, this has the potential to be expensive.

Cross Platform Mobile Apps

In a perfect world we should be able to write an application once and run it across all mobile devices. Whether it be a Web or installed application respectively. Thanks to HTML5 and Adobe Air this is now possible. HTML5 is an augmentation of the current HTML 4.01 specification, which adds new features that designers and developers will be able to use. Important new additions include multimedia elements and dynamic graphics, allowing for improvements in data visualization, image manipulation, and video. In combination with Javascript, HTML5 presents some new and exciting possibilities for Web development. Apple iOS, Android, BlackBerry 6, and HP/Palm WebOS devices all support HTML5 features. HTML5 can be a compelling Web solution for multi-device and multi-screen applications.

Adobe AIR is a sister technology to Adobe Flex. AIR does not run in a browser like Flex; it is used to create an installed application, which has access to more local resources than are available to Flex. Mobile AIR is a new flavor of AIR, designed specifically for mobile devices. Adobe has made some important changes to their existing development tools. Now a project built in mobile Adobe AIR can be cross compiled to run on Apple iOS, Android and Blackberry. That is one code base for multiple platforms!

So now an application built in HTML5 will run on ALL mobile web browsers. An application built in mobile AIR, and distributed in the App stores, can be installed on all major mobile devices. That is huge. One more thing. If you build your HTML5 app for the mobile Web and at some time in the future decide you want this to be an installed app. Step forward PhoneGap; an open source tool to convert an HTML5 app to a cross platform installable app. So there is one code base for both Web and installed apps!

We live in exciting times. It could well be that we are seeing the end of the PC. Applications which are location-focused are a huge part of the new mobile revolution. The cross platform development tools, described in this article, available to designers and developers, will simplify the building of state of the art mobile solutions.