Thursday, September 30, 2010

Ignite Baltimore

I attended the Ignite Baltimore presentations tonight. (Finally!) They were quite good, and my friend Heather H. gave a presentation! I also chatted with a few folks and re-connected with Peter from the old Java user Group days.

Sunday, September 26, 2010

Book fair and lunch

I attended the local book fair this week-end. This is an annual street fair, with booksellers, authors hawking books, writers organizations, the local library, local museums, authors reading their books, some stages with musicians, and a set of food carts (complete with unhealthy food). The weather was warm and sunny and the fair was well-attended. I bumped into one person with a "I see dead code" T-shirt. We chatted briefly.

Today I lunched with a former co-worker. We talked about a number of things from technology to politics. We both agree that the economy is improving, albeit slowly. We also discussed offshore IT contract work, and can see some benefits and some costs. The costs seem to be harder to measure, so the easy-to-measure lower salaries tend to outweigh the decline in quality. Savvy development managers will see the problems and get a full understanding; inexperienced managers will miss the problems and eventually wonder at the later production problems and customer incidents. A bleak scenario indeed!


Tuesday, September 21, 2010

Linux and LISP

I attended a meeting of BaltoLUG tonight. They are the Baltimore area Linux User Group. The presentation was on LISP.

I like the BaltoLUG meetings. The conversations take unusual turns and go to unexpected places. Beyond the basic LISP talk, we discussed the FORTH language, the Python language, Peter Norvig and Google, tail recursion, and possible meeting places. Our next meeting will be at the Baltimore Node hackerspace. (A location much more convenient for me.)


Saturday, September 18, 2010

Subversion

I set up a Subversion server this week. This was an experiment at home to review the steps (and effort) for Subversion. We may be using Subversion in the office, and familiarity with it will help me in my job.

The installation and configuration went well. Much better than the first time, which was over a year ago. Perhaps I am more comfortable with the concepts of client and server, perhaps it was just plain remembering what I did last time. I did consult my notes, and record my steps.


Wednesday, September 15, 2010

Experiments with C# and .NET

I've been working with C# and .NET this week. The project is a conversion of the current C++ software to C# and the .NET framework. The first step is a prototype to prove that basic functionality is possible. (And so far, it is.)

I'm actually happy to be working with C#. It's an easier language (and environment) than Visual Studio's C++ side, with better auto-completion and better debugging options. Microsoft has done a good job with C++, but a more complete job with C#.

I won't compare C# to Java, as I have not used Java or Eclipse for quite some time. (Note to self: try out the latest Eclipse.) Comparing C# to C++ finds me at least fifty percent more effective with the former. While C#/.NET is a verbose and long-name environment, Visual Studio helps with most of it. (Although sometimes the auto-completions guesses wrong, which is frustrating.)


Tuesday, September 14, 2010

A short lunch to discuss business

I had lunch with Eric from Apptis today. Eric is the account executive for my contract. (After almost a year, we finally meet!) We had a good conversation about the state of the contract, its renewal, and some organizational changes. In sum: nothing that affects me, and it looks like we will have a contract for another 12 months. (Woo-hoo!)

One item he mentioned was Ruby on Rails, which is missing from my skill set. I have wanted to get invovled with RoR for some time; today's conversation gives me another push. The question is: how to fit it into my schedule? Evenings? Week-ends? It will have to be one of the two.


Wednesday, September 8, 2010

Another geek meeting

I attended the CALUG meeting tonight. It made an interesting contrast to the CMAP meeting of last night. The CMAP meetings are a bit more organized (structured) and presentations are a bit more formal. CALUG tends towards the informal end of the spectrum.

CMAP and CALUG both offer attendees free pizza and soda. I find CALUG's pizza a bit more digestible, but that may simply be due to different vendors. (CMAP uses Papa John and CALUG uses a local shop.)

I find the folks at CALUG more approachable. It's easier to start conversations. The conversations are generally deeper and more meaningful. Folks at CALUG focus on the art of programming (or sysadmin-ing, or management) and folks at CMAP focus more on careers. Well, the 'P' in CMAP stands for 'professionals' so perhaps a professional is one who keeps his career in mind.

The CALUG meeting had a presentation on GNU Screens and Byobu. GNU Screens lets you multiplex a terminal session, and byobu lets you manage the configuration. A "repeat" talk, but still interesting.

More interesting were the side conversations. One with a Tenable employee about talent, management, and angry drivers. We also chatted about Agile Development techniques and their advantages over "Big Design Up Front". Another conversation was with some DP veterans (I say "DP" because in their day that's what it was called) about the Ada programming language, DVD players, lucky finds, and early personal computers such as the Commodore PET and the Radio Shack TRS-80 model I.


Tuesday, September 7, 2010

Local group, global software from Microsoft

I attended a meeting of CMAP (Central Maryland .NET Professionals) tonight. They had a presentation on Microsoft's Managed Extensibility Framework (MEF).

First impressions are that MEF isn't fully baked. It's a collection of add-in classes to C# (not sure that it works with any other .NET language) that lets you build components and connect to them at run-time. In many ways, it is like the concept of a DLL for the initial version of Windows.

Like any technology, it has its upsides and downsides. First the downs:

MEF imposes a fair amount of work on the user; it bleeds into your application, requiring you to code a bit of plumbing. It allows you to mix the plumbing and your business logic; there is nothing to help you separate them. It relies on attributes, those square-bracketed phrases which pollute your code. The code you add is verbose, with long namespace names and long class names.

On the upside, it lets you build applications that bind to objects at runtime. Nifty, yet I'm not sure that this is such a good thing. It seems to have the same problems as the early implementation of DLLs. They, too, let your application bind to objects at runtime. But the incompatibilities between versions lead to many broken applications and the eventual coining of the phrase "DLL hell".