Flying home from California

Heading for home after a few days in California for my daughter’s wedding. Going to try to keep up with the C# sandbox projects and fit in a bit of playing with Kotlin and the intellij idea IDE.  I’m thinking that Kotlin looks like a less constrained Java and there is so much JVM code out there that it could be an interesting option in my kit of tools.

Also looking as if I should get my PHP back in shape as this hosting runs PHP and I’d like to do a little single page application game work. As that will need a back end I will need some restful PHP code for persistence and some rules engine logic.

Warming up to auto-completion IDEs

I’ve spent a good chunk of my career using emacs as my primary means of generating code. I’d hop over to other platforms (Visual Studio, Eclipse, IntelliJ IDEA) for debugging or an occasional search for something.

I’ve been doing a lot of C# work in the most recent project I was software lead on and I’m finding myself shifting over to Visual Studio for the speed with which it allows work to progress.

I’m expecting to play with Idea and Eclipse a bit more in the near future as I am playing with Javascript, Java and Kotlin on the side at the moment.

It does seem that the ‘hard’ documentation is less complete or available these days than it used to be. I’m guessing that this is a direct result of the rise of very capable code completion and related helper tools.

A C# implementation of ‘which’

The ‘which’ tool from unix had long been a small but useful part of my command line toolbox. For years now I’ve used the cygwin implementation when I needed to find out where the executable I was running lived.

The cygwin implementation isn’t ideal for use on windows as cygwin has its own approach to drive letters and simulates a unix style environment.

I’ve been working with C# quite a bit lately (and rather enjoying working with the language) and decided to put together some tools in C# that would streamline things.

I had a few hours between things over the last few days and put together the initial form of a more windows-y which written in C#. The current, partial version is on my github as C9Which.

I expect this to acquire more commmand line switches to control its behavior and a bit more polish in terms of what it looks for.

Currently it takes the full name of the file and returns all hits on the path in order with the first item being the one that would run if you typed the name on the command line. It also gripes about folders that are present in the path that don’t correspond to actual folders in the filesystem.

I expect to keep these features but likely hide them behind command line switches. I’m looking at command line switch processing library code out there and there seems to be a somewhat standard library shared by Microsoft called CommmandLineUtils  that looks promising. I’ll likely try using that one and see where it gets me.

Machine Learning and Feature Extraction

I’ve been doing a bit of reading on machine learning lately as the field shows great potential for making a range of hard things easier.

One thing I have noticed pretty consistently in the books I’ve been going through is that they address the recognizer and statistical side of things in great detail but pass by the feature extraction side rather quickly.

It seems as if this approach misses some of the most challenging aspects involved in making a useful machine learning system. Given a blob of raw data, the identification and extraction of features that are suitable for processing by the ML system on the back end is non-trivial. Most of the sorts of data that I’d find interesting to process fall into this category.

Perhaps I’m missing something here, but it does not appear to me that feeding the entire photograph or audio stream to the machine learning algorithm is the intended approach. I’ll keep reading and sandboxing things (no real sandbox activity on this front yet as other priorities are ahead of ML in my queue). Hoping that I’ve missed something and this is less challenging that it appears from my current perspective.

C# this weekend…appdomains and runtime loading of assemblies

I’ve used runtime loaded DLLs as plug-ins in native code for a long time. I’m now looking at some work that would benefit from C# based plug-ins…ideally ones that can be unloaded as needed.

By default, in C#, assemblies are largely ‘load only’ and cannot be unloaded from a process. AppDomains allow one process to be partitioned in a way that acts a little like process boundaries.

I’m going to put together some sandbox code to gain familiarity with this mechanism. I’ll post the samples on my github account as I go.

If the weekend goes smoothly I may also build out some more of the code needed to manage file archiving and duplicate removal that I’ve been planning on implementing for some time. I’m starting in on some of the C++/CLI code needed to provide access to the native APIs that return unique volume and file ID information. Most of these are not currently exposed in the CLR world and this information is very useful if you’re trying to manage files and filesystems.

I just noticed that google has stopped selling tablets

I’ve gotten great value out of the several android tablets I’ve had. They’re relatively reasonably priced, have long battery life, are lightweight and pretty capable.

They get used for reading technical books, checking things on the web and social media and remoting into my bigger systems if I’m elsewhere in the house. Continue reading I just noticed that google has stopped selling tablets

Finished my quick read of ‘Learning JavaScript’

Came across a few items I had not seen before. WeakMap and the Map and Set types in ES6 look useful. I think I had seen the map, reduce and filter methods on array but had not really considered their usefulness.

There were probably a bunch of other minor items that I picked up along the way. All in all, worth the small investment of time. I learned a few things and can feel more comfortable that there aren’t core concepts that I’ve missed by jumping into the middle up front.

One day soon I’ll likely read through the ES6 standard document. Ultimately that is the only way to hit all of the high points (missing details of products specific quirks, but then that is what the other books can do).

What I really need to do now is put together a small node based sandbox project with a web UI on the front end…