I’ve have a little time between gigs to put a some focus on my web site in the last few of weeks. One of the things I tend to do normally is to spawn a lot of small projects to learn or build something I’m interested in. This comes naturally and, almost regardless of other commitments, I usually find time to code something that keeps me engaged. This lets me ramp up quickly on a technology I might not already know or prefect my understanding on technologies I do.

I’ve been working heavily with TypeScript over the last couple of years on the client side and spent a lot of time in the last year investing in ramping up my React skills in parallel. If you’re not familiar with React, you owe it to yourself to check it out. It’s a very reasonable response to a key problem that plagues MVC (and all of it’s variations). As applications grow, models and components in MVC tend to start to cross-link and because they are usually based heavily on observers, it becomes impossible to track all the triggers for change and their execution order, leading to difficult to diagnose concurrency problems that don’t appear as readily in React because it enforces patterns that stop it from happening.

A Collection of Projects

I have a plethora of small projects that started out as learning exercises but some of them have become more involved. In fact, to some degree I’ve developed a fair number of small infrastructure-related JavaScript libraries as I build up my own collection of tools and projects. I feel like it’s time to package some of these, write about them and publish them somewhere. It seems reasonable to do this on my web site, which is finally in a workable state for blogging and larger integration projects. I’m going to start slowly. Hopefully, this will have value to others and you’ll be willing to posts links on your own web sites or post them in social media and help me start driving traffic here.

For those who don’t know me, I’ve written a lot in the past, primarily in the Java and XML domains, for the Java Developer’s Journal, and later for Fawcette publications like Java Pro Magazine, XML Magazine and Enterprise Magazine, as well as online for IBM on DeveloperWorks. I haven’t found the time to resume any of those activities, which I was able to focus on much more when I was primarily playing management roles. It was a way to ensure my programming skills were still being exercised. Since them, I’ve taken more hands-on roles.

Tools, Frameworks and Libraries

I’m hesitant to put an outline together since it may be subject to change and intent doesn’t always align with either the ability to or the timely delivery of what may sound like promises. But I do need to do some planning, so I’ll just update this post as the plan evolves. Here’s a list of obvious information that needs to be written up, based on my existing projects:

  • Up and Running with TypeScript and VSCode
  • Bits and Bytes (as set of bit manipulation utilities)
  • Making Noise (Random, Perlin and other noise utility code)
  • Flexible Interpolation (a comprehensive tween collection)
  • Your Favorite Colors (RGB, HSV, HSB, Conversions code)
  • Canvas Geometry (a set of HTML5 Canvas rendering objects)
  • Image Kernels (a collection of image-convolution code)
  • Higher Dimensions (Scalar, Vector, Matrix and Tensor code)
  • Neural Networks (includes deep-learning code)
  • Up and running with React and web Packaging
  • Boots on the Web (React wrappers for Bootstrap)

In each of these cases, the source is written in TypeScript and compiled to JavaScript. In my view, TypeScript adds just enough structure to JavaScript to ensure we get many of the benefits of type-safety (fewer bugs surfacing at run time at a much higher cost of repair) as well as a specification that tracks the ES standard tracks and lets you use most of those features in a backward-compatible manner, even in browsers that are not currently compliant. The commitment that TypeScript has to evolving ES standards ensures that it will be ahead of the curve no matter the feature set, with only a few capabilities (such as async and generators) depending on lower-level implementations.