Fun with HTML and JavaScript

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.