These are some of the things I’ve been up to lately, while the blog has been quiet:
At work, I’ve continued delving into BigQuery. Our FME jobs are running like clockwork and I’ve been spending a lot of time writing queries and doing analysis for various stakeholders across the company. The next phase of the project is to expose a BI infrastructure to make the data a little more self-service. That will most likely start out in Google Data Studio and then we’ll assess from there. We also have a few more systems to integrate, but the ease of data fusion across the ones we have so far is already paying dividends.
Recently, I’ve gotten back in touch with .Net in the form of .Net Core. I’ve been shaking off some the coding rust and building some tools to help with data handling related to the Foresight data service at Spatial Networks. It’s been fun to get my hands dirty again and also interesting to see how .Net has evolved over the past few years.
It’s been a few years since I’ve done a lot with .Net and, after spending some time in the Node ecosystem, this was my first foray into .Net Core. The application I was working on just wasn’t coming together correctly in Node, so I started prototyping out the logic flow in .Net Core, with the intent to port it back to Node when I had a good reference implementation. The more I kept using .Net, the more impressed I got, so I just kept the application there.
I started this blog because I love to write. At the time I started it, blogging was what passed for social media, but I wasn’t necessarily looking for a social experience. I just wanted to write.
I was at a point in my career where I was fairly cloistered inside the windowless rooms of the Washington, DC defense contracting industry. I went home every day without anything to show for it, having left my work behind in places few could access. Blogging became a way for me to craft the technical skills I was developing into something demonstrable, something I could point to and say “that’s what I do.”
I started programming young, around the same time I started writing for pleasure. This is probably not coincidental. Piaget would probably say that I had reached an appropriate stage of cognitive development for both skills to emerge, possibly late in the concrete operational stage or early in the formal operational stage. Whatever the explanation, they emerged at the same time for me and, consequently, both have felt to me like forms of creative expression.
It’s something of a running joke that, you hand existing code to a developer, that developer will stay up all night completely re-writing it. I wish I could say it was completely a joke but, not only have I seen it happen numerous times, I’ve done it.
Counter-intuitively, some developers find it easier to use an existing application as a storyboard for a re-write rather than simply digging into the existing code. This is because programming is not only an extremely mental activity, it is quite psychological as well. When you are asked to take over existing code, as has happened to me a few time recently, you are not only learning the code, you are are also become familiar with how the previous developer(s) approached problem solving. You must train yourself to think like the previous developer in order to understand their approach.
Lately, I’ve been working on a project that involved retrofitting authentication via client certificates, similar to CAC/PIV smart card authentication, into an existing set of Windows Communication Foundation (WCF) web services and a desktop (yes, desktop) client application that was designed to interact with them. The first part was pretty easy to figure out; the second part was less so.
The truth is that the code needed for the client application is not onerous. The trick was finding any documentation/examples that pointed the way. If I had ever doubted that desktop applications are second-class citizens (I didn’t), this task confirmed it.
If you’ve accessed a web site that required smart card or certificate authentication (which are really the same thing), the dialog above is probably very familiar to you. With a web application, the browser is the actual client, and it detects that the back-end site or service needs a certificate. The browser then prompts you to provide a certificate and, assuming you do, passes you through to the site. With a desktop application, you need to build all of that interaction in. (In case you’re wondering why all of the certificates above say “DO NOT TRUST,” it’s because I applied a filter to show only Fiddler dummy certificates for the screen shot.)
When you reach a certain stage in your career, you start fielding more and more inquiries from those younger than you about how you got started in your field. In my case, the field is GIS. The short answer, and not a particularly uncommon one, I’ve discovered, is “by accident.” I have previously documented that I landed my first job through one of my regulars at the bar I was tending at the time. I’ve also documented how I became interested in maps and programming at an early age. There are, however, a few more dots to connect.
My love of maps remained avocational and really went dormant as I got more into programming. During my middle school and high school years, I wrote BASIC code on my Commodore 64 to automate Dungeons and Dragons tasks. This was in a time before the internet was available in homes and, since we lived in a pretty rural area of Maryland, every call was long-distance. As a result, there was no way my parents would let me dial into bulletin boards. So I did it the old-fashioned way: checking out programming books from the public library. I had a few other friends who were into programming as well so we shared what we learned.
I’ve been working with a mix of technologies lately that includes Node and GeoServer. I’ve recently begun integrating the two by using Node to manipulate GeoServer’s configuration through the REST API it provides for that purpose. One task I’ve been working on automating is the registration of vector layers stored in PostGIS with GeoServer to make them available via WMS, WFS, and the various other services provided by GeoServer.
It’s been a quiet month-and-a-half here on the blog, mostly owing to an abundance of project tasks. I recently started a short-term project to help one of my Federal customers extend data source support for an application they have been developing. This customer is technically a new one but the project team is made up of government developers that I have worked with on a few other projects so there is a great deal of familiarity.
The application, which has been under development for some time, is written in .Net and make use of the open-source (MIT) GMap.NET mapping library. The application features a desktop version running in Windows and a mobile version running on Android tablets. The .Net back end works seamlessly on both through the use of Xamarin, although I have not had the chance to get my hands dirty with that yet due to limits on Xamarin licenses and available Android devices. To its credit, GMap.NET seems to work fairly well in both environments.
It’s been a pretty good week for us at Zekiah. We announced two new contractwins and I’m pleased to say that we’re not done yet. After final paperwork is done, we should be able to announce a couple more. These are the things that make small-business ownership worthwhile: doing good work, building relationships with our customers and then leveraging our track record to be able to work with new customers. Project execution and business development help us build the foundation necessary to be a good place for our employees to work and we try hard every day to make sure that we are such a place.
Over the past few weeks, I have been reading with conflicted agreement the posts of Brian Timoney and Bill Morris about the nature of geo-portals and what they should or should not be and do. I say that I am in conflicted agreement not because I take any issue with anything they have said. Their posts represent what should be considered best practices in terms of building web mapping applications. In Brian’s posts, the counter-examples he highlights represent some of the worst practices to be avoided.