Site backup and sundry…

I spent last weekend getting backup set up for the site after a scare that had me thinking I’d lost the blog side of the site. Backups now are looking good and appear to be running well. I still need to load XAMPP on my linux box and verify that I can restore the sites, but I’m pretty comfortable that will work.

I’m not sure what is on my agenda next in terms of technical projects but here’s a loosely form list in no particular order:

Continue reading Site backup and sundry…

Continuing to pull together the blog area here

I’ve been putting off fixing the ninecrows.com landing page because things have been busy. At this point I’m trying to put content up here and keep the site interesting and thus I’m looking at fixing the landing page and pulling the whole site together.

It looks as if I can use mod-rewrite to point http://ninecrows.com/ to a static page wordpress instance that then provides hand-offs to the blog areas. At the moment I have two, one for career/technical information (here) and another for all other personal items

Continue reading Continuing to pull together the blog area here

WordPress and PHP

Back in WordPress and PHP land a bit. OpenGL is fun, but I want to make this hosting/blog cleaner and something I can point people at without running then through messiness at the landing page.

I think the Jetpack plugin has resolved my immediate image display issues over on my personal blog. I still want to build more comfort level with PHP for a number or reasons and with WordPress to keep things going in the right direction here.

I’ve bought a few PHP and WordPress kindle books to cover these areas (and update my several years old volumes on my current physical bookshelf). I’ll likely drop XAMPP on my linux machine sometime soon to create a test environment for a number of things.

Continue reading WordPress and PHP

3D Rendering…

I find myself back again reading the documentation to OpenGL. There are so many cool things that can be done with this stuff. At this point it is a bit like a whole new API though as the programmable pipeline is new since last time I took a serious look. Much more capability, but in many ways a completely different way of making things happen.

The issues around gimbal lock with Euler angles and transformation matrices (which is the approach I’ve used in the past) are making me seriously look at quaternions again. They’re a bit of a strange hybrid, but it seems as if they offer a means to manage rotations that may have fewer sharp edges than what I’ve used in the past.

I think I may wind up buying the paper copy of the the OpenGL Superbible as it is likely to be more pleasant to flip around in than the kindle version I’ve been reading. Also suspecting that HLSL is important enough that the OpenGL Shading Language reference may be something I want on my bookshelf. Add in the OpenCL Programming Guide that I picked up when I was job searching (thought there might be some CT related opportunities and for projective reconstruction, OpenCL seems very interesting) and all sorts of stuff should be possible.

Writing up an updated version of my C++ coding guidelines.

I’ve written C++ and C coding guidelines for a number of teams that I’ve been part of. In general, those documents are owned by my employers at the time I created them. I’m working through a list (just getting started at the moment) of things I think should be included in current day C++ guidelines and posting them under my ‘information’ tab here on my career blog. This is a work in progress and depending on how busy I become may stall for extended periods of time…

If time permits I may also write up some commentary on java and C# (and perhaps others).

Interesting tools and libraries for Java and the JVM.

I’ve spent a few evenings rummaging around the web, looking for interesting tools and code that is either coded in java or runs on the JVM. There is a lot of material out there. I had been discussing other programming languages with a friend a little while ago and lisp was mentioned. That got me thinking (and clojure as a functional programming oriented lisp dialect particularly got my attention) so this list is currently a bit lisp heavy.

  • ANTLR is a java coded parser generator.
  • Clojure is a lisp based functional programming language that generates JVM code and can interoperate with java proper. Clojure also seems to have >ClojureScript which generates javascript code from Clojure inputs.
  • Jython is a python compiler that generates JVM code.
  • SISC is a compiler for the Scheme dialect of lisp that targets JVM code.
  • Rhino is a javascript interpreter written entirely in java that originates from the Mozilla folks.
  • JRuby implements the ruby language (which I don’t know much about, but sounds worth a look) and generates JVM code.
  • Armed Bear Common Lisp was the first common lisp implementation that I came across that runs on the JVM. There seem to be others out there, but it appears that common lisp implementations are a bit old and ragged at this point (at least the references I could find).
  • Kawa is another scheme implementation  with JVM support.
  • Groovy is in the same category for me as ruby. Sounds interesting, runs on the JVM and I don’t know much about it.

There’s much more out there and I’ll probably wind up wandering through it as time passes. I’ve grabbed snapshots of these projects to mess with. Depending on time and momentum I’m likely to poke at Clojure and perhaps a bit at some of the other lisp dialects. I haven’t messed with lisp in a long time (and most of what I have done was gnu emacs lisp) but it seems as if a few interesting things are going on there. A functional programming environment that can be used in conjunction with other methodologies is also very interesting. I can’t see doing a majority of the things I do in functional land, but having the option of doing tasks that are well suited to that approach using a functional environment is quite interesting.

Still coming up to speed on the Java front…

I’ve been doing quite a bit of reading and some talking to folks who know the language and environment. I come into this process having a decent, abstract knowledge of the java language itself and some basic idea of how the runtime library is laid out. I started with very limited practical experience writing java code but lots of experience building large, threaded and distributed systems with C++ and C.

So far the books I’ve run through (or am in the process of reading) are

  • Effective Java, Second Edition was another paper purchase. The C++ volumes in this series Effective C++, Third Edition and More Effective C++ provide excellent examples of how to make the best use of the C++ language. The java volume appears to provide good advice in the same vein but with a java focus. I have found it challenging at times to find books like these that provide advice that is useful to the experienced practitioner. Most programming books out there cover language basics and how to get things working. These volumes take that to the next level with advice about how to get the best results and warnings about subtle issues that aren’t immediately obvious.
  • Java Concurrency, Second Edition I bought in paper form. It appears to give very good coverage to java’s concurrency and locking facilities.Reading this got me looking deeper into threading and interrupt exceptions and places where these were perhaps questionable. Dive further into Apache’s CloseQuietly and its possible interactions with (windows of vulnerability in) thread interruption and I wound up in I/O land.
  • Java I/O is the book I’m currently reading. This covers the basics of the core java I/O library and then gives reasonable (if a bit superficial in places) coverage of the new I/O classes that were added later in java’s life.I got started down this road when I realized that baseline java I/O seemed to have serious limitations when used in blocking mode in threaded servers (and it appears that in java, just about everything needs to be moderately threaded). This lead me to NIO as the focal point for dealing with such things and various digression into jvm exception handling and error management.
  • Java NIO which is on my reading list and seems to go into more depth on the new I/O classes in java. It appears that any attempt to build scalable, interruptible server I/O code in java needs to take these facilities into account.Currently I haven’t started reading this one as I’m working through the second edition of Java I/O which covers NIO functionality, but in limited depth. In particular it looks as if it skips over the SSLEngine class that allows NIO sockets to implement SLL and TLS encryption.

Starting at Kiva Soon, setting up Linux to experiment with…

I’ll be starting work as Kiva Systems this coming Monday. Looking forward to getting deep into complex technical problems again and back into development work.

It was sad wrapping up my last day at GE/Oni, but I think the time had come and as endings go this wasn’t a terribly bad one. It seems that pretty much everyone  I know of who was actively looking has found something and the rest are settling in to other priorities for the summer. We’re still waiting for the final pay-out, but that was clearly noted as taking on the order of a month.

I’ve set up a spare machine here to run CentOs (Red Hat Enterprise Linux fork that is free) and started reading some Linux admin stuff. Most of the development processes seem to have remained mostly unchanged since I last touched Linux. Admin processes have changed (the yum package manager) and various things are now interesting that were not back then (http servers, MySQL, etc.).

I picked up an SSD for my main desktop machine (Win 8.1 box) and took some time to get the OS transferred. It was a bit frustrating as the differences were sufficient that neither drive cloning tool I had would handle it. I finally succeeded using a disaster recovery backup (command line version worked nicely) and then did a ‘recovery’ onto the new SSD.

I’ve still got more reading and learning to do on the Java front, but I expect that will be ongoing for the forseeable future as there is much to learn.