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.
Continue reading “Catching Up with Microsoft”
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.
Continue reading “Looking Ahead”
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.
Continue reading “Other People’s Code”
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.)
Continue reading “Client Certificates In a Desktop Application”
TL;DR: This post is long and there is no summary.
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.
Continue reading “My Path to GIS”
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.
Continue reading “Working with Node and the GeoServer REST Configuration API”
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.
Continue reading “Data, Apps, and Maps”