Gant Software Systems

Blog Posts

Epidemic of Crappy Tech

It’s been a while since I’ve posted. I’ve been working on my side project Agulus, my upcoming book Developer Career Book, my podcast Complete Developer Podcast, helping run Code Newbie Nashville, as well as a full time job and having a family. I’ve been doing a lot of writing of late, but not very much online.

As I’ve been trying to juggle all these things, technology has simply not been helping any more. In the past couple months, I’ve had the following experiences:

No More Hack Attempts

There are a lot of upsides to wordpress. It’s not terribly difficult to set up, relatively straightforward to administrate, and makes a lot of website use cases pretty simple. This is why I initially used the tool, as I just wanted to get started without too much ceremony. However, after a few years of using the tool, I started having a lot of issues. For one, Wordpress has got some significant security issues, as well as a large number of automated attacks on the platform. Nearly every day, I got at least half a dozen messages where particular IP addresses were being blocked for repeated unsuccessful login attempts. In addition, I had to spend a fair bit of time trying to tune my website to sort out performance issues, a number of which were actually the result of interaction with the MySql database server. Finally, I had frequently wanted to experiment with different ways to lay out the website, but it wasn’t as straightforward as I liked due to the complexity of the tool.

Announcing The Complete Developer Podcast

I’ve been away from the blog for a bit. Life got really busy back in July and I finally realized I was a bit over-committed and had to scale back for a bit. During the down time, I’ve been re-evaluating my business and trying to determine what things I want to continue doing. Blogging is definitely one of the things I plan to continue, but I needed to get some other things handled. I’ve thinking a lot about the direction in which I want to take my career as well, and I realized I was doing a lot of stuff that really isn’t what I want to do. However, that thought process also revealed a number of things that I DO want to do that will help my career go in the correct direction.

Stopping Hate On Forums

After the shooting that happened last week and the subsequent revelation that online forums may have contributed to that bowl-cut-weirdo’s radicalization and subsequent rampage, several people I know have approached me to ask what website owners with discussion boards could have done that could have prevented radicalization. There are some options, but I’ll warn you, most of them are pretty terrible and have a tendency to be easily circumvented (or to backfire spectacularly). The architecture of the internet is intended to be able to route around damage (it was designed to assist with communications after one or more nuclear strikes, after all), and censorship mimics damage in an architectural sense. So, most fixes are not particularly useful, although there are some options.

Managing Large T4-Based Code Generation Projects

This past weekend, I spent a great deal of time reworking some parts of our data access layer for Agulus that have been problematic in the past, mostly by trying to get rid of places where we are using ExecuteScalar and places where we are are working with DataTables, as both places are very sensitive to changes in the underlying database schema and the errors don’t surface until runtime, which really stinks. I managed to figure out how to get all the metadata I needed to replace this functionality (some things could be easier….) and proceeded to start editing my templates to achieve this goal. As I did so, I started reflecting on how much I’ve learned, mostly the hard way, about how to manage larger sets of T4 templates while keeping things maintainable. I’ve not seen a lot of guidance floating around on how to deal well with this stuff, so here’s a list of a few things I’ve figured out (so far). Most of the guidance below sounds very much like the guidance you’d expect to see when building something using ASP.NET MVC, which if you think about it, makes a lot of sense since both share many similar concerns. None of these are earth-shattering, but people tend to forget that code that generates code should be maintained at the same quality level as code that is actually being shipped.

Introducing Agulus

I apologize for missing the last couple of weeks of blog posts, but I’ve been extraordinarily busy with product development on my side project. I thought I’d take a little bit of time to show off what I’ve been working on with my friend Matt Sanford.

A Tale Of Two Framework Approaches

I’ve been slowly building a new version of this website, to replace wordpress (and its attendant problems and constant updates) with something a little lighter that I control more tightly (I’m not just rolling my own blog engine, but a platform for several other things I have planned). As I’ve done so, I’ve been rethinking a lot of my approaches to software development for personal projects (corporate projects are a different matter and under different constraints). Given the ever-accelerating rate at which frameworks change, especially client-side javascript frameworks, I’ve had to more carefully assess the risk of major breaking changes and attempt to mitigate those as I switch things over. I’m currently building a fairly lightweight blog editor that allows me to create new blogposts using markdown and publish the rendered HTML in the actual blog itself. None of it is rocket science, but there are a lot of little things to think through. Perhaps one of the biggest things I’ve noticed is how different frameworks deal with extensibility versus ease of initial setup. I’m going to use javascript frameworks as an example of the sort of design decisions I’m dealing with, because it often seems to be the worst offender for me, although it’s likely that much of the difficulty I have on occasion will go away once I’m a little closer to a decade of solid javascript usage (I really only started using javascript heavily in the early days of jquery, although I used it under duress all the way back). While I was originally a fan of larger, more comprehensive systems, such as AngularJS because they handled much of the internals of the front end of the application, I’ve since started to move away from such systems precisely because they attempt to handle the internals of so much of the front end all in one place.

Databases And The Microservice Model

I’ve been on a bit of kick lately, rethinking how I build applications, particularly with the aim of reducing complexity. One thing that has been readily apparent (even in the bad old days when we called it service oriented architecture) is how breaking a system into small, discrete pieces that do a single thing well makes it much easier to maintain and reason about code. This approach works really well for scaling, deployment, and for quickly being able to build out a piece of functionality without entangling it with other systems. The model works really well for the way I typically think about code in general these days. Breaking the system into smaller pieces also allows me to optimize my technology choices for the problem I’m trying to solve at a much more granular level, which often makes things simpler (in practice, I still typically stick with just c# code, but the ability to throw node, ruby, or python into the mix can be handy at times).

Ready, Fire, Aim!

We live in a pretty amazing world. Right now, I have on my desk several devices with which I can communicate with people nearly anywhere on the globe. I use one of those devices every day for several hours at a time, both for communication with others and to create things. The money I earn doing that is automatically put into my checking account, and I can spend it on groceries with a little plastic card that I carry in my wallet. I can even order food online and have it delivered directly to my house, for a very modest charge, that is nearly always a better choice (price-wise, not nutrition-wise) than driving down the street to get the food (at least for pizza, grocery delivery isn’t quite here yet, but will be). I could, right now (well, if I had renewed my passport) be in India, Iceland, or Argentina within a day. In short, we live in truly amazing times and are capable of things our ancestors would have never dreamed of.

The Words You Use

I’ve been noticing something in my network of friends and family of late. Really, it’s been there all along, but I suppose it started really jumping out at me a few months ago. Like most things that really jump out at me, I notice it more when other people do the same crap I do, so this is not presented as an indictment of them. I’ve noticed a remarkable difference between people who really excel at moving their lives forward and reaching their goals and those who trudge along more slowly, or fail altogether. While lots of things can impede success, from dumb luck, to bad timing, to rashness, or lack of skills, one thing I consistently see out of people who aren’t doing well when they should be (ie., in the absence of those other things) is that a large number of them seem to describe their situations, both to others and themselves, in terms of their own powerlessness.