Fitzpatrick's Leap

A tool to help understand web pages

2012-01-29T19:01:00.000-08:00

With a little Ruby, a little GNU, and some reading, I built a small utility to help me understand web pages.

The utility takes the HTML, picks out the links, and draws a map of the web site. It shows which pages link to other pages. (It works only for static pages, not dynamic ones.) The result is a PostScript image with pages listed and arrows connecting the pages.

I can use this to navigate web pages and get a view from a height. I can also find 'orphan' web pages, pages that are not linked.

I used a lot of off-the-shelf components: Ruby and its built-in functions for parsing HTML, GNU sort, and GraphViz. The components do the heavy lifting, and save me a lot of time.

It was a good exercise. I learned a lot, and now I have a useful tool!

Three years

2012-01-28T12:06:00.000-08:00

It was three years ago that I started this part of my journey. I left the comfort of a secure position in a large company and struck out in search of new opportunities. At the time, I knew that it was risky, and that it was either a smart thing to do or a very foolish thing to do.

Looking back, the evidence leans towards the "smart" side. I have acquired a position with a smaller company, and the pay is a little less than before, yet I have met knew people, broadened my view of the technology world, and learned a lot about tech and myself. I am more in touch with the local technology and creative scene. I have a better appreciation for project management and corporate management. I have shed some arrogance and improved my interpersonal skills.

Looking forward, I am positioned for the coming changes in technology. Mobile computing, cloud-based processing, new languages, big data, and user experience will all change the way we build programs. The old ways of project management won't carry us through the changes. (Yet they are not obsolete. The previous techniques for project management are still useful; they are not enough on their own.)

I'm looking forward to the next chapters.

CreateBaltimore

2012-01-21T18:34:00.000-08:00

I invested time at the CreateBaltimore un-conference today. This was a meeting of folks in Baltimore who consider themselves creative, and who want to help improve the city and the state of its inhabitants. It's a good arrangement: people self-select themselves in, so the attendees are all interested in problems and solutions. (It's also a casual and not glamorous event, so there is no incentive for fame-seekers to attend.)

The conference started late, due to inclement weather, but it still allowed for a long session (from 10:00 to 17:00) for conference sessions and informal conversations. It was an excellent way to meet folks in the area, folks who want to make a change. (And a few were looking for developers!)

A group meeting about git

2012-01-11T19:47:00.000-08:00

Tonight's CALUG meeting had a presentation on 'git', the version control package. (I am starting to think of software in terms of "packages". Probably an influence of Linux.)

I like git. I find it easy to use. Yet I think it has a ways to go. A few years ago, I would have thought that git (with its GUI tools) was a sufficient product. Today, after the "tablet revolution", I feel differently.

Tablet computers have raised the bar for a typical application. Now I expect that an application installs quickly, configures itself (except for a user ID, password, and possibly an update frequency), and handles everything through a simple graphical interface. (Not the command line, and not a complicated multi-dialog interface.)

I believe that the folks working on git can improve it and make it "first class".

I will point out that other version control systems have similar challenges. Microsoft's TFS has a good user interface, but requires lots of configuration. Subversion and CVS need bolted-on graphic front ends which work -- more or less -- and they also need a lot of configuring.

Someone will figure out version control, really figure it out, and then we will have the "iPod of version control". I think that git is in the best position to achieve that goal.

Apache and PHP

2012-01-08T10:22:00.000-08:00

I configured Apache and PHP today, and converted a web page from plain HTML to PHP format. With these changes, we can create templates for web pages and slug in the content that we want. (That's the whole point of PHP.) Separating the content from the HTML will make it easier to update the web page, since we can replace the content file and leave the HTML in place.

Changing servers at the new year

2012-01-07T09:26:00.000-08:00

I'm changing my server configuration at home. These changes will support my efforts with local organizations and their web sites.

I installed Ubuntu Linux Server on //ophelia (an old Dell Optiplex GX280). This install was quite simple, with a no-nonsense approach and few questions. I picked SSH, LAMP, NFS, Samba, and printer server options. It doesn't include NTP, so I will have add it later.

My goal is to make //ophelia my main server, hosting my "alternate home" directory and serving web pages. Certainly not the configuration that a real shop would use, but acceptable for my needs.

Refactoring for fun and profit

2012-01-03T18:52:00.000-08:00

I have been working on the "convert C++ to C#" project for several months, and this week I have achieved the "factor out code to objects" level. It has been a long, long wait, as I converted code and divided the poorly-organized C++ into better-organized (although not perfect) C# code.

Today I was ready to refactor code into smaller classes. I had the code converted to C#, and tests to ensure that refactoring would change no functionality, and I was looking at the code... and the changes just came to me. It was a no-brainer, an obvious operation. I was able to separate three sections of code into distinct classes -- but the last class needs a bit of work, given the (ugly) API that it requires. But I am even happy with that, since the API is obviously ugly and a sure sign that a better design is waiting.

Fun with HTML and JavaScript

2011-12-30T05:47:00.000-08:00

I've been working on a web site for a local charity.

The project has been mostly fun, with a small amount of hair-pulling. My forte is "traditional" non-web programs, written in Java or C# to read and write files. The web with its design and layout concepts and its HTML, CSS, and JavaScript is different. I have leveraged my collection of O'Reilly books and the web to overcome the difficulties.

My current challenge is with a specific browser layout issue: a horizontal list of compound items. Each item is an image and text description; I want a set of these across the screen with the text below its corresponding picture. Easy enough to do with a few well-designed lists, at least in some browsers. I can render the list as I want it in Chrome, in FireFox, and ReKonq. But rendering the list in IE eludes me. IE apparently sees a compound list element as a thing that needs a new line, and insists on displaying the list vertically. No combination of list tags and "display: inline" or "display: inline-block" appeases IE.

Grr. More research and experimenting is in order.

Git for version control

2011-12-26T18:11:00.000-08:00

I successfully installed and used "git" tonight. (I'm working on a set of web pages for a friend, and I need version control.)

Wow, git makes version control easy. I'm used to the old, heavyweight version control systems (PVCS, SourceSafe, TFS) which require an elaborate install and a more elaborate configuration before one can even begin to use them. I installed git in less than a minute (mostly due to the package manager in Linux) and configured it for my project in less than ten seconds (the one command is "git init" -- with no options or questions).

My old saying was "if your version control system isn't giving you heartburn, you're either doing it wrong or you don't understand version control". With git, I can discard that saying.

Arduino and Beaglebone

2011-12-14T19:50:00.000-08:00

Tonight's CALUG meeting had a presentation on the Arduino and BeagleBone processors. They are small processors that can do a fair amount of work, and they have hardware for interfacing with sensors and devices like motors and LEDs. The topic was not strictly Linux, since these processors are supported under Linux, Windows, and Mac OSX, but that didn't bother the audience. People were interested and several folks stayed for after-meeting conversations.

Success with web stuff

2011-12-11T12:42:00.001-08:00

Success this week, with web pages and web servers. I successfully composed a web page for my friend, and successfully installed the Apache web server to serve up the web page.

This is not new for me; I have installed Apache before and created web pages before. But no web site is quite like another (perhaps they are snowflakes) and this project had its interesting aspects. First, I used CSS for a lot of the formatting. (And it worked quite well.) Second, I used port forwarding to make the web site visible to my friend. (Before, I was using web pages within the intranet.)

Web "programming" -- I suppose a better term might be "composing" -- and administration is quite different from the traditional desktop programming. Yet possible, with the right resources. I used a number of resources this weekend, mostly O'Reilly books and Google.

Time constraints on user group meetings

2011-12-07T03:16:00.001-08:00

I attended the CMAP meeting last night -- and left early. This was unusual for me. I have attended CMAP meetings for somewhat more than two years, and I have consistently stayed at meetings until their ends. The last event of the meeting is a raffle of prizes.

Last night I made the decision to leave early. I had arrived slightly early to chat with people at the meeting, which for me is the most important part of the meeting. With other tasks pressing on my schedule, I had to leave before the end of the meeting.

The presentation was on Microsoft's MVC Scaffolding, a set of assistants for application development. The speaker knew his material and presented it well. I have no complaint about the material, except perhaps that it doesn't apply to my current assignment.

A step away from C# and towards the web

2011-12-03T14:43:00.001-08:00

Today I stepped away from "classic" programming in C#/.NET and moved into the world of web design.

A friend asked me to create a web page from a mock-up. A simple task, yet for me a good challenge. Web page design is quite a different mode of thought than the programming on my current assignment. (That programming is object-oriented programming with immutable objects. A step into functional programming, but still quite different from HTML.)

I used several tools for this project: Chrome; Rekonq, the Kubuntu browser; Bluefish, an HTML editor; and Heel, the Ruby-based web server for static pages. They all served well.

I was pleased with the Bluefish editor. It's quite like the old Homesite program (made by Allaire, which was bought by Macromedia) in its simplicity and hands-on approach to web page design. It understands CSS and can edit more than HTML.

I was also pleasantly surprised, and impressed, with Chrome's inspection capabilities.

The 'heel' project made viewing web pages easy. I could avoid the effort of configuring a full web server (Apache) and focus my efforts on the web page.

My success was also due to the information resources available. The web with its forums (and Google's search engine) was important, but also important were the O'Reilly books on my shelf. Web Design in a Nutshell, HTML and XHTML: The Definitive Guide, and "Cascading Style Sheets: The Definitive Guide" were all helpful.

The loss of WYSIWYG in programming languages

2011-11-28T18:20:00.001-08:00

As programming languages have evolved, we have moved from static languages to dynamic languages. These new languages offer new capabilities, but at a price. That price includes performance (perhaps not a great cost, given advances in hardware) but also the ease of understanding code.

Early programming languages of FORTRAN and COBOL were quite easy to understand. They did not allow for recursion (the early versions, at least), and offered static, up-front at compile/link time memory layout. You knew (or the linker knew) the location of every variable and every subroutine when the program was built. You knew the destination of every jump and the meaning of every statement. (Yes, COBOL had the 'ALTER' keyword, and FORTRAN had the "assigned goto", but they were proscribed in civilized shops.)

Of all languages, BASIC (prior to Visual Basic) was probably the most easily understood. It had a specific set of keywords, no pre-processor, strongly-typed variables, and no dynamic aspects.

The C language was one of the last languages in which "what you saw was what you got". A colleague referred to his "cortex compiler" when discussing the clarity of C code. One could look at source code and know the actions performed by the computer. (I am ignoring the effects of the pre-processor here. Poorly-design -- or even well-designed -- #define macros can change the normal meaning of C code and stymie all but the most careful analysis.)

Things changed with object-oriented languages. In object-oriented languages, one can look at the source code, but the action taken by the computer is not always obvious. To understand polymorphic code one must understand the inheritance hierarchy. To understand operators one must understand the class and its ancestors. Multiple inheritance (multiple implementation inheritance, as in C++) is rife with ambiguity.

(I'm ignoring LISP in this sequence. LISP, which dates back to the days of FORTRAN and COBOL, offered the same flexibility and dynamic constructs that it does today. But most programmers ignored it then, too.)

Java kept object-oriented programming but mercifully implemented multiple interface inheritance (and not multiple implementation inheritance) and eliminated the pre-processor and operator overloading, all which made it more obvious than C++.

Dynamic languages are now in the ascendant. Perl allows for lots of un-obvious constructs (some will snarkily comment that the entire language is un-obvious). Ruby lets one define or modify classes -- even the "standard" classes -- during run-time. (The shades of COBOL's 'ALTER' haunt us still.)

The trend may be towards dynamic languages, but not everything is moving in that direction. The up-and-coming functional programming languages (Haskell, Erlang) take a different approach and enforce strict definitions of functions and their results. Their syntax and organization is different from object-oriented programs, and can be difficult for those trained in O-O programming constructs. Despite the differences, I expect that these languages will, in the long run, be considered the more "obvious".

And we may, once again, have programs that are obviously understood, capable of being processed by our "cortex compilers".

Android success

2011-11-20T12:55:00.001-08:00

I successfully wrote an Android app today, and downloaded it to my tablet. It installs and runs! Woot!

OK, the app is simple -- trivial, really. It is a simple "Hello, world!" app that displays the "hello" message and the screen resolution.

I was impressed with how easy it was to test the app in the Eclipse simulator. I was also impressed with the ease of installation: on the PC copy the .apk file to the tablet and then on the tablet click on the .apk file.

Playing with X

2011-11-13T08:23:00.001-08:00

I took some time this week-end to play with X and remote access to computers.

First, I set up a virtual machine running Ubuntu Server edition 11.11. The server edition is plain Ubuntu without the Gnome front-end. It's a much better configuration for a server -- although it does require that one perform administration tasks on the command line. I had to refresh my memory of the 'apt' and 'aptitude' commands.

Second, I configured the virtual machine with a bridged network connection, so it will appear on my local network.

Then I configured Ubuntu Server to use a static IP address. That took some research (a minimal amount, thanks to Google) and some experiments (keep the "auto eth0" line in /etc/network/interfaces) and some tests with 'wget' to ensure that the configuration was correct.

Finally I installed ssh-server and 'xclock' on the Ubuntu Server and tried some connections. Connecting from a Windows PC running Xming and putty worked, and I was able to see the clock. Connecting from an Ubuntu PC failed at first; I had to use the 'ssh -X' command to connect, an 'export DISPLAY=192.168.1.102:0.0' command to identify my display, and also the 'xhosts +' command to allow connections.

I want to create an /etc/X0.hosts file; that should eliminate the need for the 'xhosts +' command. I'm not sure how I can auto-configure the DISPLAY variable... or if that is even desirable.

All in all, I feel pretty good about my accomplishments. Remote access with Linux is quite different from sharing desktops in Windows. The Linux approach has more possibilities: run X applications in my local display, share a KDE session, or share the whole desktop. Windows seems to be limited to the 'share a desktop' approach. (Can one SSH into Windows? That is, get just terminal -- a CMD.EXE terminal -- session?)

Looking at HTML5 and CSS3 with the .NET folks

2011-11-01T19:52:00.000-07:00

I attended tonight's CMAP meeting, with a presentation on HTML5, CSS3, and Javascript. The meeting was well-attended, perhaps the best attendance I have seen. Apparently lots of Microsoft tech fans are interested in the subject.

And they should be. Microsoft let the cat out of the bag earlier this year, announcing that their new development platform supported HTML5 and Javascript. (That announcement may have been premature, but the direction seems correct.)

Tonight's meeting was about HTML5 and CSS3 and Javascript, and had very little about Microsoft tools. (It was given by a Microsoft employee and evangelist, so it seems credible.) The programming paradigm of HTML5 and CSS3 is very different from the old world of WPF and XAML. It is not specific to Windows or Internet Explorer -- it is cross-platform.

Interestingly, the presenter mentioned "inkscape" as a tool for experimenting with SVG. (Apparently Microsoft has no SVG editor.)

We are in a new world, a world of multiple technologies and multiple environments. Mobile phones, tablets, desktops, and servers all interact as part of your system. This new configuration is bigger than any one company.

Local Linux, Cloud, and Virtual Machines

2011-10-23T17:36:00.000-07:00

This past week I accomplished a number of things.

I attended the local Linux user group. They are going through a transition, expanding their focus from Linux to open source. The change makes sense; when they were formed, Linux was a difficult beast and one needed a lot of technical knowledge. In today's world, the modern distros install themselves. (I recently installed Kubuntu 11.10 and the process was simple.)

The change in focus requires a new focus, and the challenge to the group is to identify it. No one is stepping forward to claim ownership, and the transition has stalled. I have considered stepping up, but I have no clear vision for the group, no "itch" that I want to "scratch". As such, I consider myself an inappropriate candidate.

The cloud computing meeting had an informative presentation on database.com, a "spin-off" of the salesforce.com folks. I chatted with a number of folks; these meetings attract people with varying degrees of experience.

The cloud computing group was in the Washington area, and it highlights the challenge of my living and working arrangements. Living in Baltimore and working in Washington leads to a long commute, even on the train. It also locks me out of a number of activities -- I arrive in Baltimore too late to participate, and I must leave too early to participate in Washington events.

As to virtual machines, I made modest progress with my local tests. I successfully connected to a virtual machine with remote access software. I had to completely disable the firewall on the host system, and the color palette leaves a bit to be desired. But it is success, and I am looking forward to tuning the arrangement, adjusting the firewall to allow access and handling the color palette. I also found instructions for creating a headless virtual machine, which makes a lot of sense for remote operation. I'll have to read up on the process; it is something more than simple.

Revisiting virtualization

2011-10-09T18:02:00.000-07:00

I dusted off some virtual machines today. They are experiments, to see how virtualization performs in different environments.

I use VMware and Oracle's Virtualbox. Both had updates; new versions of the virtual machine software.

The updates for Virtualbox ran a bit smoother than VMware. Both programs alerted me to the new version, and let me download them. Both updates were replacements and not patches. That is, both un-installed the old version and then installed the new version. And both new versions had new "inside helper" packages, utilities that install drivers inside the guest operating system to help the "outside" virtualization program.

It was the installation of helper utilities that Oracle beat VMware. With VMware, you have to run a script, answer several prompts, and let the script compile several modules for your system. (The questions have default answers, but they are sensible only to a sysadmin.) Virtualbox, on the other hand, installed the helper utilities without prompts or compiling.

For both VMware and Virtualbox, the improvements were evolutionary, not revolutionary: small improvements to the GUI, noticeable changes in support for devices.

And for VMware and Virtualbox, performance was acceptable. Virtual machines run a little slower than a "real" machine, but the difference is small.

I don't use Microsoft's Virtual PC, as it refuses to run on my hardware. My PC is a two-year-old SystemMax PC with a nice Intel processor and 4 GB RAM, but apparently it lacks something that Virtual PC needs. So I limit my tests to VMware and Virtualbox.

Sharing evil plans

2011-10-04T19:15:00.000-07:00

I attended the GBTC meeting for "Evil Plans" tonight. This was a meeting of meetings; a parliament of local groups to discuss meetings and schedules. Baltimore has enough special-interest technical groups that our schedules collide. This meeting was to introduce the groups and let them work out their scheduling conflicts. (Working out non-conflicting schedules is to every group's benefit, since other events pull people away.)

About fifty people attended, all creative in their own way. Some were hard-core programmers, others web developers, and others teachers. It was a creative mix of creative people!

Betascape

2011-09-25T18:25:00.000-07:00

I attended the Baltimore conference Betascape this Saturday. Betascape is a small conference for creative people: artists, writers, programmers, designers... you name it.

It's an informal conference; the small cons can be informal. Yet while informal, it had interesting sessions and was run efficiently.

There were lectures, conversations, workshops, and of course the "hallway track". The last is a feature at all conferences, although not all conferences recognize its importance and accommodate it. The venue for Betascape was multiple buildings, so the hallway track was actually the "sidewalk track". The weather was pleasant and chatting outside worked well.

I attended several sessions, including "How gadgets can change our culture", "Visual Design: Why It's Necessary", "Now that the internet has arrived, are writers dead?", and "What happens when everyone is a publisher?" Beyond the sessions, I contributed to a project at the con: a person is constructing a reading of a book, with people reading one sentence each. (I read sentence number 13.)

Betascape is an enjoyable conference. I had short notice of it this year and could attend only a fraction; next year I will block out the entire week-end.

2011-09-21T16:35:00.000-07:00

Today was a day of technical development.

For the past few years, I have avoided Microsoft's WPF and the associated .NET technologies. I would see presentations at user groups and read about it in magazines, but I didn't use it.

I wasn't keen on it. The more I saw of it, the less I liked it. I felt that it was cumbersome and required a lot of typing.

Today, I used it. I used WPF and XAML and a few other things. Invested the entire afternoon building a simple application for Windows. Got the application to work -- or at least perform the basics. It's not fancy, but it gets the job done.

I'm still not impressed with WPF and XAML. Oh, It's better than the previous WinForms, since it transports to web apps. And it's way better than the old MFC applications.

But it still feels clunky. I feel that I am doing too much work, writing too much code.

Perhaps the new world of HTML5 and Javascript is what I am seeking.

BaltoLUG meeting

2011-09-20T18:47:00.001-07:00

I attended the monthly meeting for BaltoLUG, the Linux User Group here in Baltimore. This was an administration meeting, since we did not have a speaker.It was a good meeting, with a lot of ideas about the direction of the group. One topic was the limitation of Linux items; our presentations tend to run with open source but not restricted to Linux.

Betascape, courtesy of Facebook

2011-09-12T13:09:00.000-07:00

Facebook earned its pay today. It notified me of the Betascape event here in Baltimore, through one of the local technology groups. Without it, I would not have known about the event.

Betascape is later this month. It runs on the same weekend as the annual book fair, which is an interesting choice. (I expect that the audience for Betascape would like to visit the book fair. But the two events are fairly close, so perhaps the thinking is that people will come and attend both.)

This will be my first Betascape (is this the first Betascape ever?) and I am looking forward to it. It seems to be a mix of crafts, technologists, and hackers (the good kind, who like to mix-and-match tech).

Thank you, Facebook groups!

Pentaho

2011-08-25T18:09:00.000-07:00

I sat in on a meeting to review the Pentaho tools. It's an impressive set of tools.

We focussed on the "Kettle" and "Spoon" tools (Pentaho uses a kitchen motif for their names). "Spoon" offers an easy-to-use interface for the configuration (it's too easy to be programming) of an ETL operation. The tools make for easy extraction, transformation, and loading (which is what ETL is all about).

Way back when, we called these tools "swabbers" (from "swap bytes A and B"). They were much simpler but did the same task: read data from a source, transform it, and send it to a destination. The Pentaho suite handles neat things like parallel threads and multiple sources and destinations and scheduled jobs.

Not a bad hour to invest.

Pair programming trade-offs

2011-08-18T20:02:00.000-07:00

I attended the local cloud computing group meeting tonight. The presentation was on pair programming, one of the elements of agile development. The concepts were familiar to me, yet I took home a few thoughts:

Pair programming requires you to work with another person: You have to put aside your ego and listen to the other person. This idea goes back to at least the 1970s; Gerald Weinberg wrote about egoless programming in his "The Psychology of Computer Programming".

Pair programming affects productivity: Managers take note, because this affects the project schedule. With pair programming, time for development increases. It takes longer to implement the same features, compared to solo programming. (But not twice as long, oddly. The initial increase is sixty percent, but drops to twenty percent as people become comfortable with working in pairs.)

While the development time increases, so does the quality. The increased quality means fewer defects and therefore less time and effort for testing. Thus, pair programming shifts the effort from testing to development, with an overall reduction in effort (and time). The project manager must weigh the benefits and costs of this trade-off.

Recruiters and user groups

2011-08-17T20:16:00.000-07:00

I chatted informally with a recruiter today. They informed that they had few openings for C++ in the area. I suspected that the demand for C++ would drop, but I thought it would be a gradual decrease, not the sharp drop we are seeing.

This evening I attended the BaltoMSDN group meeting. It was an open discussion about future technologies, with discussions on HTML5, Sharepoint, Silverlight, database administration, Gartner Group reports, and Windows Phone 7. It was a lively discussion, with lots of creative ideas. (This was a treat for me, as I can rarely attend these meetings.)

Agile Development presentation at CMAP

2011-08-08T04:49:00.000-07:00

The CMAP group had a presentation on agile development techniques. For those familiar with agile development techniques, there were no surprises.

The key ideas from the presentation:

- Software development uses the metaphors of building construction, which serve us poorly. Software development is similar to a journey of exploration, not building a well-defined thing.

- The "big design up front" approach fails not from lack of planning or poor planning skills, but from our inability to predict the future. Project plans do not account for every possible event -- and never will.

- Allow for change and respond to it

- Revise the plan as you gain information

- Build features of the system, not layers. You can build a feature in layers, but the objective is to build the feature.

- Use feedback loops to ensure that you progress towards your goals

- Agile techniques are not tied to specific development tools

I was happy to see the CMAP group (a Microsoft-centered technology group) look at agile development.

OSCON 2011

2011-08-02T20:46:00.000-07:00

I attended OSCON, the O'Reilly-run conference on open source software.

There were four "take-aways" from the conference:

Java has renewed interest, due to Oracle

Oracle purchased Sun Microsystems, and acquired Java in the process. Oracle has invested in Java, and the results show it. Java is not open source, and relations between Oracle and the open source community are uneasy, but as one person put it: "People are afraid of Oracle and its reputation of money-grubbing, hard-business operations. But it is precisely those money-grubbing, hard-business operations that allows Oracle the resources to invest in Java." Oracle has invested in Java. Recent changes to the JVM allow for dynamic languages, something that will enable open source projects.

Open source has matured to a respectable choice for development

Open source has changed its status. In the past, open source was a subversive movement, a "rebel alliance", against the empires of commercial software. That has changed. Open source is now a respected alternative for software. Its success with projects such as Apache, Linux, and Android have demonstrated that it can deliver workable solutions.

Open source is the research arm of the software industry

Open source has become the research laboratory for software. There are projects for large and small efforts, in various areas of software development. They explore new ideas and techniques, and release software quickly. Some recent accomplishments:

Scripting languages: Perl, Python, and Ruby are all open source projects. While Perl has been released slowly (version 6.0 has taken over a decade) the other languages have seen a number of revisions. The languages are capable and usable.

Future languages: There are open source implementations of a number of new languages. Some of these fall in the "functional programming" category, and offer efficiencies for cloud computing. The company that wants to get an early grasp of these languages can evaluate them today, thanks to open source.

Databases: The "NoSQL" data store concept was built in open source. This idea of a database abandons the SQL language and the relational organization of databases in exchange for performance and flexibility. NoSQL databases don't enforce a structure on the data and therefore can store varied information. They are often used for high-performance, large user base applications.

Distributed version control: Expanding version control for distributed projects, these DVCSs (distributed version control systems) allow people to work independently in distant locations. The DVCS coordinates updates from multiple people without the need for constant contact with the central database.

Open source is allowing companies to thrive in the current economic environment

Numbers can tell the story better than words. Of the two dozen exhibitor companies, over half were hiring. The hiring companies included small, obscure companies (Azur, Neustar, Percona, and Linbit) and large, well-known companies (the New York Times, O'Reilly, and Facebook). Some folks were at the conference for the express purpose of hiring -- no product demos, no sales pitches... just recruiting.

Hiring was competitive enough to spark a good-natured "recruitment war" during one of the closing sessions. Two companies (Grant Street Group and Booking.com) made multiple requests, advertising their hiring packages. Grant Street Group offered generous salaries and medical benefits; Booking.com offered to re-locate people to Amsterdam. No other companies joined the debate; perhaps they were overwhelmed by the competition.

Cloud computing group

2011-07-15T04:20:00.000-07:00

Yesterday I attended a meeting of the Capital Cloud user group. Since I arrived early, I was pressed into service as a volunteer at the check-in desk. (Sound familiar? The same thing happened at OSB back in June.)

The Capital Cloud group is a small, "young" group, and getting a good start. They have interesting presentations (last night was Hadoop) and they also have a good networking session prior to the presentation.

GnuPG and Android tablet

2011-07-13T20:26:00.000-07:00

I attended the CALUG meeting tonight, with its talk on GnuPG and public key cryptography. It was a good presentation, and the most pleasing aspect was that I knew most of the concepts. (So my studies have been successful.) I also had some nice chats with other folks there, about things technical and non.

At home, I have been playing with the Viewsonic gTablet, an Android tablet that has wifi but not cell net. It's fairly nice, but takes some time to familiarity. Viewsonic implemented Android with a slightly different design than my cell phone. I made the mistake of thinking that my cell phone was the implementation of Android, when it is an implementation. The gTablet does not use the Android market; it routes you to handango.com. (Possibly because it has no gmail.com ID.) I spent some time looking for the New York Times app until I realized that I didn't need it -- I could use the browser.

I'm beginning to like the gTablet. I've downloaded and installed the Andiko e-reader and loaded an O'Reilly book. The reader has its quirks (or maybe the .epub file has its quirks) but it is usable.

AOP and MS Azure fabric

2011-07-05T19:45:00.000-07:00

I attended the CMAP meeting tonight. I enjoyed the presentation on Aspect-Oriented Programming (AOP) and Microsoft Azure fabric. The presenter knew his material and demonstrated the need for AOP and the proper use of it. I came away with a good understanding of how MS implements AOP in .NET and some of the extra tools needed to make it happen. (Interestingly, you cannot do it with just Microsoft tools. Or so I currently believe.)

After the meeting I chatted with a few folks about programming, assignments, and non-techie stuff.

All in all, a good meeting.

Only two years behind

2011-06-28T19:39:00.000-07:00

I was going to comment that the "Square object is not a Rectangle object" problem is solved by using immutable objects, an insight I had on this evening's commute home, but others have beaten me to it. And more eloquently than I would be.

There is one here, and another one here.

On the other hand, I'm still happy that I had the insight.

Open Source Bridge 2011

2011-06-20T21:28:00.000-07:00

I'm attending the Open Source Bridge conference in Portland OR this week. I've been to this conference in the past. The conference is small and casual, with sessions on technology and also social change. The presenters and attendees are passionate about their work, and conversations are always interesting.

Windows Phone 7 demos

2011-06-08T03:12:00.000-07:00

I attended the CMAP meting last night. The presentation was on Windows Phone 7. it was a disappointment.

The WP7 platform seems powerful enough, although programming requires a lot of different concepts (GUI design, web services, .NET, C#, and Microsoft's XAML are all necessary) and a simple program is complex.

Part of my disappointment is with the demo. The presenter built a "typical" application, using the above-mentioned technologies. The process took almost an hour, and in the end the program did not work. The presenter had to display a previously built program, a trick used by cooking shows on television.

Microsoft would benefit from the concept of "Hello, World". Their demonstrations of new tech are complex and pull together multiple technologies. Good in that it shows the total power of the platform, but it misses the immediate gratification and confirmation of the new tool.

Science fiction convention

2011-05-30T18:34:00.000-07:00

I visited the local science fiction convention (Balticon) this week-end. A good decision.

The "con" was filled with science fiction enthusiasts. Many were people involved in IT; I talked with several folks about programming technology. Mind you, I made it easy to spot me as a computer geek. I wore t-shirts with computer programmer themes and carried the trusty HP-35 calculator. The shirts and calculator were conversation-starters, and I talked with people about things from FORTRAN to Python.

The con had a lot of creative and smart people. It had sessions for science fiction, hard science, culture, and writing/publishing. I looked for the sessions with the odd-sounding titles; I've found that those are the sessions with the new and different ideas.

It was good to get away from the office and talk with other people about the future of computing.

Lunch among techies

2011-05-26T19:19:00.001-07:00

I lunched with a long-former co-worker, someone from a mid-career UPS project. He was a contractor on that project while I was an employee. Now he is an employee at NCQA in Washington, and I am a contractor at a government agency. Odd how situations change!

We had a nice lunch, talking about things technical and fun. The ability to meet folks for lunches like this is one of the reasons I like this assignment.

Fun with virtual machines

2011-05-14T19:19:00.000-07:00

I spent some time with virtual machines today. It was interesting comparing the behavior of VMware's VMware Player against Oracle's Virtualbox.

I'm using VMware Player 3.1.4 and Virtualbox 4.0.6. (Microsoft's Virtual PC refuses to run on my PC. Apparently my hardware is not worthy of such a lofty program.)

I have VMware and Virtualbox running on Windows 7. I created virtual machines for Ubuntu and Kubuntu in each virtual environment, four machines in all. My experience has been good with both VMware and Virtualbox. I can install the guest operating system, configure it, get updates, and install new packages.

There are some differences between the two.

The machines under Virtualbox can use bridged networking to find my DHCP server; the machines under VMware cannot and must use NAT.

The installs for Ubuntu went well. The installs for Kubuntu were a little rougher for VMware. The VMware Tools package expects gcc and make, neither of which was installed by default. Running the Kubuntu Software Management package solved the problem easily.

Performance is acceptable but not stupendous. This is due, I am sure, to my equipment. The PC is a fairly recent one (about two years old) but it is not the datacenter-class server designed for hosting virtual machines.

Overall, I am pleased. I can work with the virtual environments, which is my goal.

IBM z/OS

2011-05-11T21:05:00.000-07:00

I attended the CALUG (Columbia Area Linux User Group) meeting tonight. The presentation was on IBM z/OS and virtual Linux machines.

It was a good presentation! A clear overview and lots of technical details. More impressive than the presentation was the set of questions asked by members of the audience. They knew their stuff, from old IBM mainframe concepts (partitions, microcode, and DASD) to the new concepts (virtual machines, Linux instances, and databases). OK, perhaps the concept of a virtual machine is not that new. But the audience was interested and inquisitive.

I left with a lot of information about z/OS and Linux. IBM has made some good choices with its technologies, and I think they are well-positioned to leverage their tech for cloud apps.

Into the cloud

2011-05-10T19:42:00.000-07:00

I am building a vision of my next set of technology. Here's what I have:

- Tablet for user interface (the "front end"), probably Android
- Cloud for data storage and processing (the "back end"), probably Amazon.com EC2

I have considered other platforms (Google App Engine, Azure) and interfaces (iPhone, Windows Phone). My picks seem the easiest for starting a new venture. In part, I follow the path of least resistance. I will say that my experience with the Android phone was an influence in my choices.

Code but no coding

2011-05-03T20:16:00.000-07:00

I attended the CMAP meeting tonight and heard a presentation on MVC 3 from Microsoft. MVC 3 is a web development thing, allowing you to build web applications. it takes advantage of .NET, HTML 5, jQuery, and a few Microsoft-specific packages. Using the packages and tools, one can assemble a slick web application quickly.

The presenter walked us through the development a calendar application. It took all of about 90 minutes.

My impression: easy to use, lots of code, but very little coding. There was code on the screen (C# and HTML) but not much in the way of creating code. The wizards did a lot of the work, and the work was mostly connecting existing pieces, not writing functions, methods, or classes.

Is this the future of coding? I guess it is, in Microsoft's view. This is coding so simple that anyone can do it -- as long as the understand the components that are available. Sixty years ago, coding was in assembly language and you had to know the processor architecture and the operating system calls. Forty years ago, coding was in a high-level language and you had to know the language and its (rather limited) library. Now you have to know the language syntax and a large collection of library classes and their methods, and most of the effort is for the libraries.

Haskell, improved

2011-04-25T19:00:00.000-07:00

I showed my Haskell program to a co-worker today. As we were looking at it, we noticed some possible improvements. (Surprising, since neither of us are Haskell programmers.)

I tried the changes this evening, and they do indeed work. We've simplified the program and made the logic clearer. I also expanded the program to handle a list of payment values, and not assume that each payment is the same value. It was quite easy to do -- much easier than similar changes to a C++ or C# program.

Haskell for real

2011-04-23T12:14:00.000-07:00

Today was the day that I wrote a 'real' -- that is a non-trivial, example-from-the-book -- program. It was an exhilarating experience.

The program (actually three functions) computes the price of a stream of payments.

I was inspired by a task at the office: review code that computes the price of the stream of payments. The code was in two forms: Java and Fortran. The code also came with the math for the calculations, and I immediately thought of functional programming.

Today I set aside some time and dug out the one book on Haskell in my library. It had enough to get me started. With the book and the math, I was on a programming adventure!

Programming in Haskell is a trip. Just as object-oriented programming was alien to my brain trained in procedural programming, functional programming is alien to my brain now trained in object-oriented programming. I struggled a bit with the syntax and with the design of the program, and emerged victorious! I had a set of functions that performed the desired calculations. (I checked them with math calculated in a spreadsheet.)

The Haskell version is shorter and cleaner than the procedural versions. (The Fortran version is obviously procedural, and the Java version makes no use of object-oriented constructs.) The procedural version uses a loop and a temporary variable that is assigned at the end of the loop so that it can be used the *next* time through the loop.

The Haskell version has no loops and no assign-at-the-end distraction. If you know the syntax, it is straightforward and easy to understand. I believe it to be less efficient than the procedural versions (efficient meaning 'less CPU time') so with Haskell I have gained programmer time at the expense of CPU time, a trade-off that I am willing to accept.

I will say that I don't fully understand the Haskell version. That is, I am not fluent in the syntax. I have internalized the syntax of Fortran, C, Java, and other languages so I can look at the code and know what it does without thinking. I am still in the "think about the code" stage with Haskell. (And that's OK. I expect a ramp-up time with a new language.)

Privacy? What privacy?

2011-04-21T19:59:00.000-07:00

The news that the iPhone was tracking your location in a "secret" file had barely broken when more news came out that Android phones are doing the same thing. And then we had the news that yes, Apple and Google are collecting this location data, and in sum, know where we are.

Some folks will cry "havoc" and let slip the dogs of war for privacy. But let's be honest: we knew that something like this was coming. We in the tech industry know that service providers (in the larger sense, from cell phone companies to banks to game vendors) collect data on customers. On-line web sites have been collecting data about customers, from their e-mail addresses to their click-through habits. And government officials have subpoenaed that information and used it for criminal prosecutions (and possibly other purposes).

The advocates of this data collection will say (or perhaps only some will say): "If you don't want your data collected, don't use a cell phone." This is similar to saying, "If you don't like the high cost of gasoline, don't drive a car -- use public transit." In this country, not driving is practical in a small subset of geography; cell phones are about to become a necessity perhaps greater than an automobile.

I'm afraid that Mark Zuckerberg of Facebook was correct. We will sell our privacy for shiny applications and the ability to look cool in front of our friends.

More cloud stuff

2011-04-21T19:53:00.000-07:00

I attended the Capital Area Cloud User Group meeting tonight. (My, that's a lot of syllables!)

This was the group's first meeting at their new location in Rosslyn. I find this location more convenient -- and more spacious. I think that it is a good change for them.

The presentation was on Salesforce.com and some recent changes that improve their web UI. I am impressed with their selection of improvements. One feature (they call it "inline editing") enables the in-form editing of fields without round-trips to the server. (So I infer that they are using AJAX and probably jQuery.) Enabling this feature is easy, much easier than anything I have seen in the Microsoft world. (Yes, you can do it with Microsoft's tech, but it ain't pretty to code.)

CloudCamp

2011-03-09T19:51:00.000-08:00

I attended the local CloudCamp un-conference tonight. It was a good con, with an opening session, some lightning talks, and un-panel, and then some un-conference sessions.

It was also well attended, with somewhat more than 200 people at the con.

The most interesting aspect of the con: no one talked about programming languages. They talked about databases (MySQL, Oracle, etc.), cloud providers (Amazon, Google, Microsoft, etc.), public and private clouds, provisioning, and big data. But not about programming languages. Nor version control, or agile development, or requirements analysis, or user interface design. As if all of these things were givens.

CMAP and Mercurial

2011-03-01T20:16:00.000-08:00

I attended the CMAP (Central Maryland Association of .NET Programmers) tonight, and heard a presentation on the 'Mercurial' distributed version control system (DVCS).

I'm glad that I went. I chatted with a bunch of folks and learned about DVCSs. (Actually, a few lights went on tonight, and I want to think a bit more about DVCSs.)

And today the US House of Representatives passed a two-week continuing resolution. The Senate will probably approve the bill, and I suspect that President Obama will sign it. Which means that we may be back to nail-biting in two weeks, on St. Patrick's Day.

Virtual machines

2011-02-21T18:07:00.001-08:00

This morning I planned to spend some time at the co-working site. After reviewing the work before me, I decided to stay at home. Some things are possible at the co-working site, and some tasks are better at the co-working site, but some are best (and some possible only) at my home systems. So pragmatism ruled!

I attempted to use Microsoft's Virtual PC. The package is interesting: it's not a Windows Application. Instead of installing as a regular application, it merges into Windows. There is no entry in the "Installed Programs" list for Virtual PC. Shades of the old "Internet Explorer is part of Windows and cannot be removed" argument.

Despite it's merging into Windows, installing the thing is not particularly easy. You have to find the download site, then specify the version of your operating system (Home, Pro, or Enterprise) and the word size (32-bit or 64-bit), and the language. And then you have to go through a little ActiveX dance to ensure your Windows is genuine. Only then can you install it. And after installation do you learn that Virtual PC is fussy about hardware and requires hardware support for virtualization. When I ran it, it did nothing but display a little dialog that says, effectively, "I won't run, because your hardware is lame". And then you learn that you cannot un-install the beast.

Oracle's Virtualbox, in contrast, was easy to install and as a bonus it actually works. While Microsoft's Virtual PC supports Windows guests and only Windows guests, Virtualbox lets you run just about anything as a guest. So my experiments with virtualization can start.

I had lunch with former co-worker Don today, at the local burrito place. It was a good lunch and we talked about several things. At the (old) office, things have changed little.

Cloud computing group

2011-02-17T20:33:00.000-08:00

I attended the Capital Cloud Computing Group meeting tonight. It was a good session, with a presentation by World Wide Technology and their "server room in a box" solution: everything you need in a shipping container. It is an interesting idea, but one that has a limited life span.

One slide showed a typical rack with blade servers, network equipment, and a NAS. When I saw the diagram, I immediately thought of the old DEC PDP-8 and PDP-12 computers. They, too, were rack-mounted hardware with CPU, storage (disk or tape), and communications equipment. Yet in ten short years, they were replaced by the modern PC.

So I'm thinking that in ten years (maybe less) we will see a cloudframe (CPUs, storage, and communications) all in a current-day PC tower. And a few years after that, it will be in an Apple Mac Mini box. Eventually it will be the size of an HP calculator.

Is that a cloud in your pocket?

Budget cuts

2011-02-15T19:33:00.001-08:00

I attended the local Linux user group meeting tonight. There was no speaker, and the meeting transformed from a regular monthly meeting into a planning session. We discussed several good ideas, from sponsors to lightning talks.

In other news, the federal budget process is beginning, and things look a bit dark for my contract. The agency will be getting a reduced budget; how much is yet to be decided. I may be considered expendable. Such is the life of a contractor!

Geek connections

2011-02-09T20:00:00.000-08:00

I attended the CALUG (Columbia Area Linux User Group meeting tonight. The presentation was on RCU (Read-Copy-Update) synchronization techniques. Quite a geeky subject, yet it spurred a good conversation.

I arrived early and chatted with a few folks. The CALUG members are a diverse crowd, and each are well-versed in their own areas.

Housekeeping

2011-02-06T20:14:00.001-08:00

In programming, one trend is the removal of "housekeeping" tasks.

The transition from assembly language to high-level languages saw the elimination of register and stack frame management. This was a big change, but not the only change in housekeeping tasks. FORTRAN and COBOL eliminated a lot of housekeeping for files.

The C programming language (and the UNIX operating system) made file operations even easier, allowing the command shell to handle files for the "stdin" and "stdout" channels.

The introduction of Java saw the elimination of memory management. Prior languages (C, C++, and Pascal) forced the programmer to allocate, track, and release memory. (The early Pascal had a very clumsy "mark and release" model.) Every language introduced after Java has included memory management.

Eliminating housekeeping tasks is usually a good thing. There are some specialized applications that require the complete control of memory allocation, file operations, and even register allocation. But these applications are few. For the mainstream, less housekeeping is better. Housekeeping distracts us from the problem at hand.

Once eliminated, we don't re-introduce housekeeping tasks. We're not going to use (with any degree of popularity) a language that requires us to track and free memory, or jump through hoops to perform file operations, or to manually specify register usage. Future languages will keep the automatic transmissions that we have built.

Which means that the hard-won skills for housekeeping in languages -- even modern languages -- has limited usefulness. Memory allocation skills in C++ were not needed in Java or C#. (It may be useful to know them, to understand the actions occurring "under the hood", but it is not necessary.)

Housekeeping skills have limited life. Skills of longer duration are of lasting value. These include algorithm design, simplification of code, understanding business requirements, communicating with team members (technical, artistic, and management members), project management, cost estimating, and problem diagnosis.

So... what kind of skills do you have?

Evening event in WAS

2011-02-04T03:19:00.000-08:00

I attended Ignite/DC last night. This was a bit of an experiment, attending an event in WAS rather than in BAL. It went well, although I had to leave early in order to catch a train home.

Living in BAL and working in WAS puts a strain on my schedule. I am reluctant to stay in WAS because of the train schedule. I am often late to events in BAL... due to the train schedule.

Driving offers little help. The time for driving is longer than the train. The train allows me to read or eat; I cannot while driving.

Wireless internet

2011-01-23T10:43:00.000-08:00

After a bit of thought, I committed to wireless internet with Clearwire. I'm pleased with the result. I have a faster internet connection and with no fuss!

Clearwire uses a network of transmitters throughout the area. Instead of running a wire to your home and supplying you with a "modem", Clearwire broadcasts the signal and supplies you with a "modem". (The modems are really routers.) The wireless router plugs in to your home network (or your sole PC) and you can start using it without any configuration. For those who are network admins, you *can* program the router for a specific subnet, for serving DHCP, and for port forwarding.

I still have the DSL internet service. I may keep it as a backup service, or I may keep it for the one client that insists on "no wireless".

Ruby at the Hive

2011-01-20T18:38:00.001-08:00

I'm working at the Baltimore Beehive tonight. This was a special night-hours session, with a bunch of people attending. The Beehive is a co-working facility, with tables, chairs, power, monitors, and network access (wi-fi and wired). And tonight they have chill/ambient music, which supports programming and design.

Most folks here (all but one) are using Apple computers. (And I am not the one! I have my old Apple MacBook.)

I'm working on the virtual microcomputer project from a while back. I call it "virtua". It's in Ruby, and it is bigger than I would like it to be. I have processors for the 8080, Z-80, 6502, 6800, and a phone one that I call a KA68. Each processor needs a definition, an assembler, and an absolute loader. And each of those needs a set of tests. It's more than I want, and I think that I can re-organize things to simplify this arrangement.

The experience of working at the Beehive is a good one. There are fewer distractions, and the chairs are better for long programming sessions.

PCs and networks

2011-01-15T18:15:00.000-08:00

I attempted to install Linux on the old IBM A20p Thinkpad today. Several times. I tried Ubuntu, Kubuntu, and SuSE. Each of them failed. During one re-start, the PC displayed the message "Extended ROM failure" with some additional diagnostics. This is bad. The extended ROM is a ROM BIOS thing, not a Linux thing or a driver thing. I'm writing the A20p off as unusable. (I'm sorry to see it go. It had a nice keyboard and a fabulous screen. Today's laptops all have the wide -- or short-height -- screens, and the older, taller displays are better for programming.)

I also visited the local store -- CyberGuys -- and checked out replacement laptops. They have a few, but all in the short-height flavor.

While there, I looked into the Clear Wireless ISP. I have been considering them as a replacement for Verizon DSL, and they seem reasonable. They offer faster speed (4-5 Mbps) at a decent price ($45/month). I checked the configuration settings for the router and it will work with my home network.

So if I start Clear, how long do I keep Verizon DSL? Should I keep it as a backup? Or for work in the office? (The office wants no wireless connection.) A little more thought is needed.

Refresh meeting

2011-01-13T18:58:00.000-08:00

I attended the Baltimore Refresh meeting this evening. This was a group of smart people, in a unique building, with an interesting topic.

The smart people were the Refresh Meetup group. They are a diverse set of folks: different ages, skill levels, and areas of interest. Some are web developers, others designers, and some teachers.

The unique building was the MICA main building, an old building from Baltimore's "Medieval period" when buildings were designed to look like old castles. Its also convenient, being close to Penn Station to allow me to attend right after work.

The topic was "web accessibility" -- making web sites that can be accessed by people with disabilities. The speaker was blind and used a laptop PC running Windows and JAWS to demonstrate well-designed and poorly designed web sites.

A better recursive mood

2011-01-13T18:33:00.000-08:00

Today I thought about my palindrome detection function, and revised it.

func bool IsPalindrome(s)

return true if s.length < 2

return false if s[0] != s[-1]

return IsPalindrome(s.substring(1, s.length - 1))

end

This version separates the "no brainer" conditions from the recursive call. It also uses tail recursion.

Thinking in a recursive mood

2011-01-12T16:56:00.000-08:00

A colleague issued me a lunch-time challenge today: Write a program to detect palindromes. After a few minutes of thought, I wrote a small program that used a single function to detect palindromes. It is a very functional-programming design, looking like this:

func bool IsPalindrome(s)

return true if (s.length < 2)

return IsPalindrome(s.substring(1, s.length - 1) if s[0] == s[-1]

return false

end

No looping! All objects are immutable!

What surprised me is that I thought of this solution quickly, and without thinking specifically about functional programming. It came to me, rather than me sitting down and deliberately looking for a function-programming solution.

Beehive for co-working

2011-01-09T16:12:00.000-08:00

The Baltimore Beehive (http://beehivebaltimore.org/) is considering night-owl hours. This solves a number of problems. I plan on attending.

In other news, I attempted to set up NFS on //ophelia, a Dell GX280 running SuSE Linux 11.0. I'm almost there -- I have the NFS daemons installed and configured, and other systems can see it, but they cannot write to the directory.

Because learning never stops

2011-01-08T17:29:00.001-08:00

I'm planning to attend four conferences this year: three for software and one for science fiction.

The software conferences are: OSCON, Open Source Bridge, and the Central PA Open Source conference. The science fiction con is BaltiCon, and it is more of a writer's convention than science fiction convention.

I've looked at the costs, and I think that I can swing all of these. Of course, I plan to use my tricks for minimizing the cost of conferences. Those tricks are:

- Plan ahead
- Register early (and get reduced, early-bird rates)
- Use 'alumni' discounts, if available (O'Reilly conferences usually offer them)
- Book travel early (and get reduced fares)
- Use public transit (to avoid car rental and parking fees)

OSCON is in July, OSB is in June, CPOSC is in October, and BaltiCon is at the end of May.

Why attend conferences? Three reasons:

- Learn new things (or at least learn that there are new things)
- Get away from the daily routine
- Meet smart, interesting people

Learning never stops. We can always learn, always do something new.

.NET meeting

2011-01-04T19:38:00.000-08:00

I attended the CMAP meeting tonight. The presentation was a group of speakers talking about tips for .NET development. The major topics were jQuery, an Extension loader for Visual Studio, and Silverlight. More interesting were the side conversations with people. One convo was about the format of XLS and XLSX files!

Fun with network shares

2011-01-03T17:43:00.000-08:00

This past week-end I had quite the fun with network shares. I configured several Linux systems to auto-mount an NFS shared directory on another PC. I configured Ubuntu Linux, Kubuntu Linux, and Xubuntu Linux. On each system, I made a mistake, and had to check my work. What was nice was that I made different mistakes on the different systems. We learn from our mistakes, so I learned a lot!

And now all three systems are working with the shared directory.

A little bit of fun

2011-01-02T13:43:00.000-08:00

For fun, I wrote a little class in C# to handle arithmetic with significant figures. This is one of my goals for the new year. (I'm already getting one of them done! Wow, I am productive!)

I used Visual Studio Express for C#, which is simpler than the full Visual Studio package yet powerful enough to handle this task. The Express edition works almost identically to the Professional edition, so I was familiar with the environment.

The solution consists of a small class to handle the arithmetic and a small program to invoke the class. I don't have any test cases; I want to create some as I am uncomfortable working without them.

But the class does what it is supposed to do. The result of 1000 (1 sig-fig) plus 20 is 1000, not 1020 as one would expect. The answer should be 1000 since you must keep the number of significant figures at 1 and not expand it. Which means that 1000 plus 200 is also 1000, and 1000 + 200 + 200 + 200 + 200 + 200 is still 1000 although 200 + 200 + 200 + 200 + 200 + 1000 results in 2000, since the '200' amounts add up to 1000 and then the second 1000 yields 2000.

Leaving the oddities of sig-fig math, and coming back to programming, it was a fun project. Now perhaps I will port the solution to a few other languages.

Looking forward

2011-01-01T09:49:00.001-08:00

As a contractor, I must serve two masters: the client of today and the client of tomorrow. I recognize that there are no guarantees for the length of any contract, and I must be prepared for a new client. That preparation includes keeping abreast of current technologies. (It also includes connections and business relationships, but that is for another time.)

The turn of the year is a good reminder to look ahead and identify technologies and skills to learn. Here's my list for 2011:

- Functional programming languages
- Dynamic programming languages
- Virtualization
- Programming for Mac OSX
- Conferences
- Cloud computing
- Fun projects that aren't necessarily client-based

First, programming languages. I'm convinced that functional programming will be the new big thing, replacing object-oriented programming. I've already started by using Haskell on my home PC. I also have a few old projects with Ruby, and I want to re-start them.

Virtualization has been a challenge for me, mostly due to hardware. My PCs are not-quite-enough to support virtualized PCs. In addition, the three virtualization engines that I attempted in the past (that was, um, two years ago) were not quite willing to work for me. Two years and several Linux upgrades later, things may be different.

I've attended conferences in the past, and I expect to attend them this year. I miss the "Software Development" conferences run by Miller-Freeman; they covered different technologies and vendors without a specific agenda. In their place, I find the open source cons educational and informative. I'm looking at OSCON, Open Source Bridge, and the Central PA Open Source Conference for this year.

Cloud computing is the up-and-coming thing, and I would like to examine cloud-based processing. Perhaps with Google's App Engine, or maybe Salesforce.com.

For the fun projects, I'm looking at a software and hardware. For the software, I'm thinking of a class to perform arithmetic operations that respect significant figures. The math for "sig figs" is almost identical to "infinite precision" math, but the rounding is different. I may create something in C++ and then port it to Java, C#, Python, or Ruby. (Or perhaps several!)

The hardware project will be an HP scanner and some OCR software. I'd like to scan some pages from old programming texts and try out the programs.

All in all, this could be a very educational year.

Haskell, the language

2010-12-20T19:47:00.001-08:00

I started getting serious about Haskell tonight. I have Graham Hutton's book "Programming In Haskell", and I installed hugs and started going through the exercises in the book. (I finished the Matlab book last week.) The installation on my Xubuntu system worked without problems (as usual) and I had fun with the first chapter.

More fun with matrices

2010-12-12T16:14:00.000-08:00

I'm more impressed with Matlab and Octave.

Octave (Matlab also) has a small language that lets one build scripts. This language has two features that give Octave (and Matlab) its advantages.

The first feature is parallel assignment. Programming languages have had serial assignment since the early days of COBOL and FORTRAN. Serial assignment moves one item in a statement, like BASIC's

LET A = B + C

It is a simple operation, easy to program and easy to understand.

Parallel assignment moves multiple items in one statement. Perl has it, and the typical example is

($a, $b) = ($b, $a);

to swap to values. The corresponding code with serial assignment is:

temp = a;
a = b;
b = temp;

Notice that one line of parallel assignment requires three lines (and an extra variable) in serial assignment.

(Actually, COBOL had a sophisticated "MOVE CORRESPONDING" operation that is rarely discussed. It moved one record to another record of a different structure, moving fields based on their names, which meant that COBOL "did the right thing", all in one line.)

The second feature is the colon operator, which generates a sequence of numbers. The expression "1:10" generates a list of numbers from 1 to 10. A variant on the syntax allows you to specify the interval size, so the expression "1:0.5:10" generates the numbers from 1 to 10 in steps of 0.5 in size.

An expression that generates a list is more powerful than one might think. After all, you can generate a sequence of numbers in a loop and every programming language has basic looping. But the expression that generates a list is a compact thing, roughly the equivalent to C's pointer arithmetic. Just as C can use pointer arithmetic for

while (*d++ = *s++);

Octave can use the colon operator for

list = 1:7:365;

for a list of numbers that might represent days in the year.

Combining parallel assignment with the colon operator provides for some powerful programming constructs. Where in other languages we would need to set up loops and control variables, in Octave we can perform a single operation:

output(10:20) = data(1:11);

This moves eleven items from 'data' into 'output'. Without parallel assignment and the list generator, we would need:

for (int i = 10; i <= 20; i++)
output(i) = data(i - 9);

Now, one might argue that the difference between these two code snippets is small, with the difference being one line of code and the latter using familiar constructs. Yet I find the Octave version much easier to read -- once I learned the 'lingo' of Octave.

And programs that are easier to read are easier to write, easier to understand, and easier to debug.

So I'm impressed with Octave.

Fun with matrices

2010-12-09T03:21:00.000-08:00

I did some work with Octave (the GNU variant of Matlab) last night. I performed one of the exercises in book "Engineering Problem Solving with Matlab". It was fun, working on a new tool and on a problem different from the normal work-day problems.

I found one difference in the book's description of Matlab and the performance of Octave, and that was in the zeros() function. This might be due to a difference between Octave and Matlab, or a difference in a later version of Octave (and a later version of Matlab), or possibly an error in the book. Solving this challenge and seeing the plot come out was the most fun of the exercise.

Calendars and dragons

2010-12-08T19:22:00.000-08:00

I attended the CALUG (Columbia Area Linux User Group) meeting tonight. We had an open conversation about calendar tools and then watched the movie "Sintel". Both were educational. The first was less about technology and more about business models and group psychology; the latter was impressive in the tech and the artistry.

Microsoft WebMatrix

2010-12-07T19:46:00.001-08:00

I attended the CMAP (Central Maryland Association of .NET Professionals) tonight. The presentation was on Microsoft's new "WebMatrix" development tool, a low-end web page/app editor/builder.

WebMatrix is pretty nice, for what it does. The description "low-end app builder" is perhaps not quite accurate, nor is "high-powered HTML editor". WebMatrix is an IDE and a set of libraries that sit on top of .NET, run under IIS, and serve dynamic web pages. You can program web pages with this funny little language (like PHP or ASP or JSP) and get results pretty quickly. I got a lot out of the presentation.

I also chatted with a bunch of folks, including my friend Ben who wants to attend ShmooCon. Apparently the tickets have already sold out, and he missed the small window.

And bonuses: I picked up a copy of a book on IronRuby (the .NET implementation from Microsoft) and a USB memory stick with Microsoft Windows Phone stuff on it.

All in all, a good evening.

Adventures with MatLab

2010-12-05T13:56:00.000-08:00

On a recent trip to the Book Thing, I found a copy of "Engineering Problem Solving with MatLab", a dual introduction to engineering problems and the MatLab software. For me, the engineering is a stroll down memory lane; MatLab is the new experience.

I installed Octave, the GNU equivalent of MatLab. Octave performed some basic functions identically to MatLab, which got me excited. I have yet to try the advanced features.

The book contains a floppy disk with programs and data (I assume) for its exercises. The Linux systems (//desdemona and //delilah) refuse to mount the disk. Perhaps it is no longer readable -- the book was published in 1993. I may have to get the data from another source.

My plan is to perform the exercises in the book. The idea excites me -- it's a fun, geeky way to learn a new language!

Edit: Apparently the exercises use very little in the way of data from the floppy disk. I had some fun this evening, entering data and displaying graphs. Whee!

Sharing is nice

2010-12-04T17:01:00.000-08:00

I did a little bit of technical work at home today: I configured a Linux system to automatically mount a share from another Linux system. It took less than 30 minutes, even with my fumbling searches for information on the web.

This change makes my home systems a little more web-like, in that the data is not stored on the local PC but on the server -- even though the server is less than four feet away.

Cloud computing user group

2010-11-18T19:39:00.000-08:00

I attended a meeting of a the Capitol Area Cloud Computing user group. The presentation was on salesforce.com, a platform for building cloud-based apps.

I was impressed with the product. It's more than a sales or CRM tool; it is an application platform that can be used for a number of things.

I was also impressed with the enthusiasm of the attendees. They were much more "into it" than last night's audience for the Windows Phone 7 meeting. They salesforce.com crowd was also more diverse, with recruiters, newbies, and experienced developers. (The Windows Phone 7 meeting had only experienced developers.)

This is a likable group, and I plan to attend future meetings. Next month will have a presentation on Amazon.com's cloud offerings.

Microsoft User Group

2010-11-17T20:17:00.000-08:00

I attended the BaltoMSDN user group meeting tonight. BaltoMSDN is a local group interested in all things Microsoft, and mostly the developer tools such as Visual Studio and .NET technologies.

Tonight's meeting morphed from a .NET meeting into a Windows Phone 7 meeting. The conversations were interesting, but as I am not a Windows Phone developer, not particularly pertinent to my work.

The meeting was held at the Baltimore Emerging Technology Center, which was part of the appeal of the meeting. They have had meetings outside of Baltimore, and I find it easier to attend meetings in the city. And the ETC is a nice space.

I had some good conversations with the folks at the meeting.

Linux is not Windows

2010-11-16T19:53:00.000-08:00

I attended the BaltoLUG Linux User Group meeting tonight. They had no speaker, but an open discussion about Linux distributions and the features that people liked or wanted in distros. It was a lively discussion with various tangent ramblings.

One idea that came out of the meeting was: Linux is not Windows. More specifically, lots of corporate support sites know how to fix problems with Windows installations and only Windows installations. They are set up with prepared scripts and Windows-specific training; they cannot handle problems for Linux systems, or Mac systems.

Using Linux, as a person, means that you are a pioneer. Linux requires a sense of rugged self-sufficiency, where you can handle just about any problem. Some corporations can handle Linux and Mac issues, but many cannot. (And expecting them to handle Linux is unrealistic, given the demographics of the market.)

Not a happy thought, but a realistic one.

Networking and co-working facility in Baltimore

2010-11-11T17:26:00.000-08:00

Today is Veteran's Day, or as some call it, Armistice Day. A holiday for the federal government, and therefore a free day for me. I did what I could with it.

I lunched with former co-workers today. Yummy burgers! And speculation on the future of tech. We all agree that Java needs a "2.0" version, something that moves Java up from its current level to compete with .NET. We consider the current Java (and its JVM and libraries) as "Java 1.0". It showed that the virtual processor was feasible, and usable, and even profitable. Microsoft .NET is a competent product and Sun (now Oracle) must step up and improve Java to match .NET.

I also visited the Baltimore Beehive, a co-working location. For a modest fee, one gains access to the facility, which is a large room with tables, chairs, monitors, power, and network access. I see several advantages to working in the Beehive over working at home: fewer distractions, better furniture, a collection of books, and interaction with other folks at the facility.

Stevens in Washington DC

2010-11-09T19:43:00.001-08:00

I attended a gathering at Stevens tonight. Not in Hoboken, but in Washington.

The gathering was to recognize the role Stevens has played and continues to play in educating and supporting veterans. The crowd was a good size, with perhaps 30 alumni attending (and possibly that many staff).

Stevens in Washington is not a full stand-alone campus. It is space in the Ronald Reagan building. They have one classroom and some offices. This is the new "urban school" model, which uses office space but doesn't require the acres of greensward for frisbee games. For graduate programs, I think this model makes sense.

I chatted with a bunch of folks, including my old class-mate Bill Accardi.

An orchestra in a box, and smart people

2010-11-04T20:48:00.000-07:00

I attended a meeting at Loyola College this evening. I had heard about it through a random e-mail, and had it scheduled on my calendar.

The presentation was on "Simfonia", a PC-based music synthesizer. It's an impressive package, given the challenges of creating music that sounds real. It can synthesize music for many different instruments, and the authors are working on the problem of "liveness" to music. (They know the desired effect and the problems, but the solutions are difficult.)

The meeting was a pleasant experience. The folks were *smart*. Within five minutes, we talked about synthesizing music, the Turing Test, and rounding issues. It's nice to chat with knowledgeable people!

Professional meeting, Microsoft, and networking

2010-11-03T03:19:00.000-07:00

I attended the CMAP meeting last night. I chatted with some folks before the meeting started, and listened to the presentation on Microsoft's "Entity Framework 4". (The previous version was Entity Framework 1"; Microsoft changed to version 4 to match the version number of C# and .NET Framework.

The presentation went at a slow pace, and gave me some time to think about the Baltimore Beehive, the local co-working location. If I get the opportunity to work there (say, one day every other week) I would need a PC. My trusty IBM ThinkPad just died, so it won't be that one. I could replace is, or I could use the Apple MacBook. Or, I could get a tablet, although I think a computer with a keyboard would be better for coding.

A day at the Beehive would also give me the opportunity to network with other folks, perhaps at lunchtime meetings.

Two more steps towards functional programming

2010-10-27T18:05:00.000-07:00

I took two steps towards functional programming today.

First, I read a bit of "Pearls of Functional Algorithm Design", a book of essays on functional programming and modelled after Jon Bentley's "Programming Pearls" book. "PFAD" is written with examples in Haskell, and I have enough knowledge to follow the text but not enough for full comprehension. I'm not worried; my early experiences with object-oriented programming were similar. I plan to read up on Haskell a bit more, continue reading the text, and if I can find the time write some examples in Haskell myself.

Second, I continued my re-design of a program at the office, converting it to a modest form of functional programming. A very modest form. I call it "constructor programming", and attempt to push all code (well, all non-trivial code) into the constructor for objects. Using this techniques, I can use plain object-oriented languages (like C++ and C#) yet still get a feel for functional programming. (Or what I currently thing of as functional programming.)

The re-design work was helpful. It forced me to think about the classes and the true problem. I ended with a cleaner design, or so I like to think -- I have no measurements for complexity. (Come to think of it, I do have a utility to measure class interface complexity, and perhaps I should use that to measure my progress.)

I'm happy with the direction the code is taking. The code is clean and easy to understand. I think we could explain it to the business users and they would understand it. This is a big win, as the current system is quite opaque.

Inching towards functional programming

2010-10-20T18:59:00.001-07:00

My recent work has been in object-oriented programming, but I'm interested in functional programming. I've read about it, talked with people about it, and I think it has a lot of promise. But working on it is tricky. The "regular work" during the day is in object-oriented programming, due to the tools, existing code, and talent of the rest of the team.

Despite the limitations, I can take some aspects of functional programming and use them in plain object-oriented code. Today I worked on the aspect of immutable objects. I've been designing (and re-designing) some classes, and I have been designing them to use immutable objects. The exercise has been enlightening, and I have gotten a better design out of it too.

So my recent efforts have been, effectively, to gradually transition from object-oriented programming to functional programming.

I followed a similar strategy when I moved from procedural to object-oriented programming. At the time, I was working in C. The client's shop was heavily regulated (by internal folks, not the government) and the corporate standards group strictly controlled the software installed on their PCs. (They still strictly govern software.) This was also prior to the great revolution of the internet, the web, and the open source movement. Acquiring software was harder (and more expensive) in those days.

I started my move from procedural code to object-oriented code by doing three things: reading about it, attending conferences, and programming in the style of object-oriented programming with the tools we were allowed to use. I didn't create anything as elaborate as the cfront compiler. Instead, I designed function calls that worked like object-oriented code. I called it "thing-oriented programming", and it was somewhere in between procedural programming and true object-oriented programming. Like today's efforts, it was enlightening and gave me better designs.

I'm excited about the future of functional programming. And with the internet and open source efforts, I should be able to try some real functional languages at home. The biggest challenge there will be time.

With vim

2010-10-19T20:09:00.000-07:00

Attended the monthly BaltoLUG meeting tonight. It was easy; the new location is downtown, about ten blocks away.

The meeting was held at the Baltimore Node, a hacker space. This was my first visit. The space is a large workroom with various bits of electronics on tables, stored in bins, and tacked onto the walls. Not elegant but very practical.

The presentation was on VIM, the improved VI editor that is shipped with just about every distro of Linux. It's a powerful editor, and reminds me of TECO on the DECsystem-10. It can handle regular expressions and it has a macro-programming tool.

Hardware fun

2010-10-18T18:36:00.000-07:00

I did some hardware work tonight.

I replaced a failing DVD reader on //ophelia (a Dell GX280 that was gifted to me). It came with a CD reader, and I had installed an old used DVD reader. That reader worked for a while, but recently failed. The failure was physical; there was something preventing the drive tray from opening.

A quick stop by the Radio Shack web page got a new DVD reader on its way to me. (Although there was only the one selection for internal DVD readers. I suspect that DVD readers will soon disappear, replaced by USB drives and network connections.)

With the new DVD reader installed, I was able to upgrade the operating system to SuSE 11.3. The upgrade went smoothly, and I like the look of the new KDE desktop.

Open source in Pennsylvania

2010-10-17T13:18:00.000-07:00

This Saturday I attended CPOSC, the Central Pennsylvania Open Source Conference.

CPOSC is different from most conferences. It's small, with a maximum of 150 attendees. It's run by volunteers. It lacks the pizazz and glitz of the big conferences. It focusses on open source software, avoiding proprietary and commercial solutions.

Despite the unusual approach, it has interesting sessions and good speakers, on par with those at the larger conferences. I attended several sessions and they were just as good as sessions at the Microsoft or O'Reilly conferences.

The sessions I attended included:

- A review of Java, the Tomcat web server, and the Eclipse IDE and how they work together.
- "One-line" programs that do useful things in Perl
- Javasript and how it can be used effectively
- A review of the latest version of Wordpress, which is growing from a blogging framework into a content management system.
- A summary of new features in Rails version 3
- Writing internet applications in Python using the "Twisted" framework. This framework is much easier than the Java RMI or the Microsoft .NET solutions for internet client/server applications.
- A list of collaboration tools for organizing and managing projects with distributed teams

The schedule is too fast to learn any topic in depth. Sessions run for fifty minutes, which is too short to discuss deep technical issues. Effective participants use the sessions as highlights for solutions, noting promising ideas and investigating them later.

CPOSC is targeted to practitioners. The speakers and attendees are practitioners, and can interact and share knowledge. It is a conference run by geeks for geeks. Managers (non-geek managers) may not want to attend, but they should consider sending their teams.

This was the third CPOSC; a fourth is planned for sometime late in 2011. I'm already pencilling it onto my schedule.

Meetings and tech - single packet authentication

2010-10-13T18:49:00.000-07:00

I attended the CALUG (Columbia Area Linux Users Group) meeting tonight. The presentation was on Single Packet Authentication (SPA), a successor to port-knocking for granting access to selected users and hiding open ports from other users.

A somewhat scary aspect of the meeting was the fact that I could keep up with the discussion. I'm not much of a network geek (programming is my thing) yet at this meeting I quickly understood the concepts of port-knocking and SPA. Some folks knew it better than I, yet a bunch of folks asked questions that I felt I could answer. So I must be learning something about network configurations!

Thinking before acting

2010-10-12T18:43:00.000-07:00

I've been working on a prototype of the next version of a finance model for the office. The old model is in C++ and the new model will be in C# or Java.

The prototype has advanced to the point that we need unit tests and system tests. We've been building system tests as we built the prototype, so they are in place. We now have a need for unit tests, or more specifically, class-specific tests. We need these tests to exercise features of classes before they are integrated into the system.

Our framework (a home-grown thing) is capable of such tests, and we can add them with a little effort. The unit tests will give us finer resolution on changes and faster feedback on changes. We're keeping the system tests; they exercise specific business cases and connect us to the users.

2010-10-11T17:34:00.000-07:00

At the last CMAP meeting, I picked up a DVD with Microsoft's Visual Studio on it. The DVD has a timed edition, good for 90 days.

So far, I haven't installed it.

I will install it; I want to set up a time to use it. This week is busy for me. Installing the software now would simply mean throwing away one or two precious weeks of available time. Better to wait for a better schedule.

I'm thinking that this is not good for Microsoft. If you want people to try software, you want them to install the software and try it, not delay and worry about maximizing the demo time. Any time that is spent not running the software is... well, not running the software.

Getting back to me...

Perhaps I will install it next week. My week-days are busy, and the long commute takes a good chunk out of the day. Week-ends are better for experiments. This Saturday I will be out of town, attending the Central Pennsylvania Open Source Conference, so Sunday is the earliest day that makes sense.

The .NET meeting gives me a book on... Ruby

2010-10-05T19:26:00.000-07:00

I attended the CMAP (Central Maryland Association of .NET Professionals) tonight. The presentation was on jQuery, which isn't a .NET technology nor even a Microsoft thing. And while I didn't win anything during the raffle I did pick up Thomas and Hunt's "Programming Ruby" (also not a .NET or Microsoft thing).

I did talk we a few other folks. My friend Ben is considering a position in Washington, but is not happy with the commute. (And it *is* a long commute.)

To list on the resume or not

2010-10-01T19:03:00.000-07:00

I've been working with Microsoft VBA for Excel. The biggest benefit of this experience has been to refresh myself on the reasons for leaving VBA and using other languages. VBA is this horrid mutation of Visual Basic that loosens data typing, while retaining the frustrating VB6 editor that tries to be smart about syntax. The run-time engine has vague messages that amount to liitle more than "something went wrong".

The question before me is: do I add VBA to my resume? On the positive side, it shows that I have experience with different languages and platforms. On the negative side, someone might actually want me to work on VBA applications.

So perhaps I will, with the condition that jobs that ask for VBA skills get the "special" hourly rate.

Ignite Baltimore

2010-09-30T20:29:00.001-07:00

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.

Book fair and lunch

2010-09-26T13:42:00.001-07:00

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!

Linux and LISP

2010-09-21T19:48:00.000-07:00

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.)

Subversion

2010-09-18T12:21:00.000-07:00

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.

Experiments with C# and .NET

2010-09-15T18:36:00.000-07:00

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.)

A short lunch to discuss business

2010-09-14T16:23:00.000-07:00

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.

Another geek meeting

2010-09-08T19:46:00.000-07:00

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.

Local group, global software from Microsoft

2010-09-07T19:25:00.001-07:00

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".

Books on tech

2010-08-29T12:43:00.000-07:00

A visit to the Book Thing yielded some interesting books. (The Book Thing gives away books, mostly used books from different vintages. You can find them here: http://www.bookthing.org)

I came home with a several recent books and a couple of "early vintage" books. The recent ones include:

"Mac OS X Hacks"
"Python Cookbook"
"lex and yacc"
"Practical C++ Programming"

These are all from O'Reilly, the well-known and well-respected publisher.

The early vintage books (from the pre-PC era, in my mind) include:

"The Joy of Minis and Micros" by Stein and Shapiro
"Human Performance Engineering" by Robert W. Bailey
"Programming Business Computers" by McCracken, Weiss, and Lee

"Joy" and "HPE" are from 1981 and 1982, so possibly not strictly from the pre-IBM PC era, but neither talk about IBM PCs, MS-DOS, Windows, or the internet. Indeed, "HPE" is more about psychology than technology.

"Programming Business Computers" is a very nice text and I picked it up after I saw the name "McCracken" on the spine. I have a few books by him on Fortran and I find his books both informative and readable. (More readable than many of the O'Reilly books.) I guess that is known as star power -- I picked up the book because of the author, not the content. (I find the content informative, although a bit dated. Yet I enjoy the reading of the book. Reading tech books as literature?)

Networking

2010-08-25T19:23:00.000-07:00

I attended the "Innovate Baltimore" social this evening. It was held at Red Maple, a bar/club that is within walking distance of my apartment. (How could I not attend?)

The event saw a fair number of people (perhaps fifty?) from various tech areas of Baltimore. There were graphics designers, startup entrepreneurs, and even folks providing a physics engine for game deverlopers. I talked with a number of folks (no, not all fifty of them) and even some folks from UPS.

It's nice to see these events here in Baltimore. We need a group to pull together the startups and small technical companies.

Less is more

2010-08-20T20:48:00.000-07:00

I accomplished a lot today, although the numbers would indicate otherwise. In truth, it really depends on the numbers you choose to examine.

I made some code changes that fixed some defects. The number of changes and the number of lines of code changed were small. I changed perhaps thirty lines of code across five modules. A manager using lines-of-code or lines-of-code-changed metrics would say that I did very little this day.

The number of defects fixed was small. You could say that it was really only one defect, which expressed itself in several scenarios. So the number-of-defects metric also indicates that I did very little today.

Yet my changes transformed the program from not-useful to useful. The defects prevented us from using the program -- the calculations were wrong -- and my changes fixed the defect. So the metric of "can we use it" went from "no" to "yes", which means a lot to people.

It's not how many lines of code one writes, its which lines of code.