If you’ve read some of my more recent posts, I’ve been playing with Cucumber for use in my upcoming Testing for Developers course. I want the students to be exposed to lots of tools and that means that we have a need for lots of different languages, especially some of the dynamic languages, on the system. While Microsoft makes developing software for Windows relatively easy, it’s not my favorite platform for doing anything outside of the Microsoft ecosystem. I understand that and I’m not complaining. In the words of Bill Belichick, “it is what it is.” So, I do almost all of my development on my Macbook. It’s fast and it’s pretty much Linux (the key words here are pretty much).

If you stick to just Java, C, or C++ it turns out that almost any platform works as well as the other. I mean, if you load MinGW onto a Windows system you have the ability to develop from the C family. Add Eclipse and you’ve got a pretty portable IDE. But, when you start to look out from these languages, things get really murky.

A Concrete Example

Let’s look at a real example of what I’m getting at, setting up Cucumber for the class. We’ll start by just considering my Mac setup. Cucumber is written in Ruby and works really well if you have simple scenarios that you use to exercise some simple Ruby code. By simple Ruby code I mean code that has no GUI, database, Internet, or other features. In other words, code that’s probably not very useful for a real application.

As I went through the examples in The Cucumber Book, I began to need additional components like Sinatra, Capybara, and a many others that I have no experience with. Well, how do you get all of this to work? Do they all really work together seamlessly? Maybe, if you have the right versions and the right versions of Ruby and other gems that you have.

It turns out that I had four versions of Ruby on my system. I had ruby 1.8.7, 1.9.1, 1.9.2, and MacRuby. What’s worse is that I didn’t realize it. Some of them were installed in a standard location (whatever that means). If I reordered the sequence of directories in my PATH, I got a different version of Ruby. I needed some consistency. I was using Ruby 1.9.1 and things were going along fairly well when I needed to get the service_manager gem. I installed is using the standard “gem install” approach. Then, when I tried to use it, there was a problem with readline.

After several hours of searching the Web, tweeting to a few friends, posting on stackoverflow, and The Cucumber Book forum, I got an answer that let me get past this. But things had deteriorated to the point that I had no idea what was installed, where. I had used bundler for some things, gem for others, and done some downloading packages, source code that I built, and other ways of getting the software on my system. I also tried rvm, but frankly by this time I wasn’t sure what I was doing and the documentation wasn’t very helpful. Do you need to be using bash? How do you get it working with other shells? I was sitting on a software stack that was about to come crashing down. I could feel it in my bones.

Rewind

I decided to remove everything Ruby on my system and start over. Okay, that was another few hours, making sure that I copied everything I removed just in case I really messed it up. I finally was ready to start over. Thanks to Matt Wynne, one of the authors of The Cucumber  Book, I ended up using rvm, the Gemfile from the latest version of the installation appendix in the book, and I got the right version of Ruby installed along with the gems and packages I needed. Now, this wasn’t perfect, but it was manageable. Some of the documentation was a little bit off and I had to get on the rvm IRC channel to ask for help, but I did it.

Enter the Virtual Machine

Well, this was great. I now had a consistent installation on my Mac. Most of my students don’t use Mac. Some use Windows, some use Linux. Since they’re computer science students—advanced undergraduates and graduate students—I’m safe assuming that they know their way around Linux. If I could get the software configured on a Linux virtual machine, I could just give the students the VM image. Then I could either add new software for other topics I expect to cover in the course or simply create a different VM image.

I’ve been using VirtualBox for some time now in order to try out different versions of Linux, running Windows on my Mac, and so on. It’s free, runs on any x86 architecture, and just seems to work pretty well. So, that was the plan. I created the VM, loading on the latest Ubuntu Linux, made sure that had some basic software like Java and a few other components. Then I went through my checklist of how to get the right Ruby and Cucumber installed and in less than a half hour I had it running. Take a snapshot so that if I try to extend the image and mess it up I can back up. Voilà, the students can work without having to lose sleep over getting their system set up. There are other things they’ll lose sleep over that are much more important.

The VM approach, and the ability to snapshot and branch off of different snapshots makes life so much easier for me as a teacher and it will save the students a tremendous amount of time. I’m sure some of the uber-geeks in the class will set up the software on their systems because that’s in their DNA. However, for those who really want to concentrate on the course topics, they can now do that without the hassle of being a system administrator. I will definitely use this approach more in future courses.

This is an ambitious undertaking. I had heard about Cucumber when I looked at RSpec several months ago. RSpec was a bit too limited for what I wanted. Then I got a copy of The Cucumber Book by Matt Wynne and Aslak Hellesøy, published by The Pragmatic Bookshelf. After reading most of the book and a few weeks of playing around with Cucumber, I’m hooked. Cucumber takes the place of several tools I was thinking about introducing to my class, and allows me to into depth in several areas, using a single platform. If you’re thinking about learning Cucumber, or want to learn something about it, get this book.

The style of the book is great. It’s easy to read and describes how to use Cucumber in several bite-sized pieces. Some readers  may even find that the pieces are nibble-sized and want bigger bites. I urge you to avoid this. Install the software and go through each exercise in the steps described, even though you know what you might need to do in the next few steps. This will help you develop your intellectual muscle memory for using Cucumber. Take time to taste each bite, no matter how small it may be, because there is some new spice that was added that might be subtle if you skip over the step.

The first part of the book, chapters 1-6, introduces you to Cucumber fundamentals. Actually, this part does a little more. It teaches you something about BDD as well. If you’re really not interested in learning about BDD, you can skim chapters five and six, but I would not recommend skipping them. By the end of the first section I was able to do some useful things with Cucumber and used it to demonstrate requirement specification to my current undergraduate software engineering class.

The second part of the book, chapters 7-10, are chapters you need to read and work through if you want to become competent with Cucumber. Again, some of the discussions seemed too small to me, but after reflecting upon what I learned, I think the level is just right. Some of what you learn in this part of the book is how to work with some other tools to use databases and Web pages in your testing.

The third part of the book is one that does not have to be read in any special order, or even at all. But, if you really want to understand how to use Cucumber to define and (acceptance) test Web applications (written in Rails or otherwise) and other types of applications, you need to have these chapters available. So, skim them at least and then refer to them as necessary.

Is there a downside to this book? Well, not to the book itself. The fact is that Cucumber, like many other open source projects works in a specific inter-dependent ecosystem. Setting up Cucumber and its dependents and other pieces you might want like Sinatra, Capybara, etc. can be frustrating; especially if you want to do this on multiple platforms. If you’re not a Ruby expert, you may run into problems and will need to do some searching for answers or post to the forum for the book at the Pragmatic Bookshelf. But don’t let this scare you away. Cucumber is a good tool to learn. Whether you use it regularly or only for special occasions or specific projects, you will think a little bit differently about how you build software.

But then I thought, “am I missing out on something?” Sometimes I think it’s good to just learn a different way of doing things for the fun (or frustration of it). So today I decided to become a little bit better at bash. Now, like any of the shells, the man page for bash is pretty daunting. But all I wanted to do was set up an account on a clean Ubuntu Linux system that I’m preparing for use in a testing course next term. I’m creating a VirtualBox machine image so that all of the students will have the same environment for doing their work. If you haven’t tried VirtualBox, I highly recommend it as a choice for virtualization. I’ve used it hosted on Mac, Windows, and Linux and it works just fine.

So, after I created the VM for Ubuntu I wanted to have some of the things that are familiar to me when I use tcsh as my shell available in bash. Mainly I wanted a prompt that shows something like “gpollice [n]: “, where n is simply the current command in the command history. I also wanted to have some simple shortcuts that I alias, such as ls as a rename for ls -CF and ll for ls -l.

In tcsh, these are simple aliases that look like this in my .tcshrc file:

alias ll ls -l
alias ls ls -CF

The conversion to bash is simple. bash assumes that you want to put your aliases together and the default .bashrc file includes a file called .bash_aliases where you can put all of your aliases. The two aliases above convert directly with the addition of an equal sign separating the alias name and its contents. The aliases I have in .bash_aliases are:

alias g='grep -i'
alias ls='ls -CF'
alias ll='ls -l'
alias la='ls -A'
alias up='cd ..;pwd'

I was pretty confident that the conversion would be pretty easy. I next wanted to get the prompt configured and finding the place in .bashrc was pretty easy. But, I wasn’t sure how I was going to get the history count. In tcsh, I do it this way:

set prompt = "`whoami` [\!]: "

In my .bashrc file I simply inserted the line:

PS1 = "`whoami` [\!]: "

It was just a matter of finding out what I had to change, and it was PS1, instead of prompt.

Now for the hard part. There is a set of aliases that I’ve used since 1986 that I got from Bill McKeeman at the Wang Institute of Graduate Studies. It’s a neat way of bookmarking directories and getting back to them quickly. In tcsh, it’s a set of aliases that look like this:

alias listwork	'ls -al ~/.wrk* | fgrep '.wrk' | sed "s/^.*.\.wrk\.//"'
alias rmwork	'rm -f ~/.wrk."\!*"'
alias setwork	'rm -f ~/.wrk."\!*"; ln -s "`pwd -P`" ~/.wrk."\!*"'
alias work	'cd ~/.wrk."\!*";echo "pwd: `pwd -P`";cd `pwd -P`;ls;'

This simply creates soft links to the directories in my home directory that are prefixed with “.wrk.” It’s an elegant way to do quick navigation. I would be lost without this. Since everything came along pretty easily thus far I was hopeful that I’d have my bash environment set up pretty quickly. WRONG! I spent the afternoon tracking down how to actually get it done. In the process, I learned about shell functions in bash and found that they really are nice and simplify a lot of things. I suspect I’ll now go crazy and put a ton of these into my environment;mdash&but that’s for another time.

Without going into details, the solution to this was to add these lines to my .bash_aliases file.

setwork () { rm -f ~/.wrk.$1; ln -s "`pwd -P`" ~/.wrk.$1; }
listwork () { ls -al ~/.wrk* | fgrep '.wrk' | sed "s/^.*.\.wrk\.//"; }
rmwork () { rm -f ~/.wrk.$1; }
work () { cd ~/.wrk.$1; cd `pwd -P`; echo "pwd: `pwd -P`"; ls; }

The thing to remember is that when you want arguments to shell commands, you can’t use an alias. You need to use a function. But functions are not hard to learn. Once I found the right information it took just a few minutes.

I might become a bash user after all. At least this old duck can still learn new tricks.

I’m glad that I came across this post though. It made me think hard about what he’s saying. I have found that over the years, I agree with Kent much more than I disagree with him. I remember being on a panel at conference back around 2002 on XP, Agility, and process in general and it seemed that Kent and I were on the same side, even though I was there officially representing Rational and the Rational Unified Process team.

The other panelists, all Agile consultants, were promoting dogmatic adherence to all of the XP practices. They indicated that they forced all team members to do all of the practices all of the time when they were engaged to help teams us XP. Well, if you look at XP, that’s what you’re supposed to do. But, that doesn’t always work. You need to use some common sense.

Kent and I were suggesting that the specific set of practices and how dogmatic their application should be appropriate, not just a blind application from a book or some other source. In short, it would be better for the team to succeed by adopting a handful of practices and using them in a way that suited the team than it would be for them to turn all the XP practice dials up to 10 and fail.

During the Q&A period, Mary Poppendieck made the comment that except for Kent and I, the other panelists sounded like the process police. I found this quite funny. A significant part of the Agile movement, besides trying to discover better ways of delivering software, was to combat RUP and other process products that were deemed to be too restrictive and dogmatic (they also had a significant portion of the market). Getting into the Agile camp allowed consultants who worked individually or in fairly small companies gain traction in places where they might not otherwise have been able to compete. Certainly large companies were reluctant to get away from the IBM Rational security blanket. They may not always succeed, but they followed the conventional wisdom of “you can’t go wrong with IBM.”

So, here we are more than ten years after the Agile Manifesto was signed. Are things different? Well, yes and no. Certainly we have added many new tools to our software engineering toolbox. We look at software development differently in certain areas. We are tend not to inflict heavyweight methods when lighter ones will do. In fact, we are probably guilty of erring to the opposite end of the spectrum now and not formalizing things when we probably should. After all, we don’t want people to think that we’re not Agile!

One might argue that many of the changes we’ve seen would have occurred naturally, without the Agile movement. But, however the changes have come about, I think we have a better set of tools—intellectual and otherwise—to use in our craft. What I don’t think has changed to a large extent is the ability for software developers and managers to use common sense when deciding how to work. They still want someone to tell them what to do and how to do it.

At the end of the 1990s, the RUP was sold as a process framework that you could customize to your team, the type of project you had, and the overall organization. Customers who did were usually quite successful. Those who thought they had to do everything in the several thousand pages of advice in the RUP had some spectacular failures. Of course Rational, and later IBM, was happy to send consultants to your company to help you figure out the right configuration. That is, someone would tell you what to do, how, and when.

Today, Agile consultants come and help you adopt Scrum (certified Scrum Masters), or XP, or Lean, or Kanban, or … . It doesn’t matter what. We don’t want to think and reason about what’s best for us and our project teams. We want someone to tell us. Perhaps we think it will allow us to avoid taking responsibility for the outcome of our projects; never mind that a cornerstone of Agility, or any reasonable methodology, is reflection by the team and adjusting the process. That seems like too much (non-productive) work. We can hire someone to tell us what to think and how to do our jobs. After all, they’re the experts, the consultants who have the experience.

So, we’re right back where we were ten or twenty years ago. We let people tell us what’s good for us. We don’t think. We let others do that for us. We’re always riding the crest of the next wave, be it XP, Scrum, Lean, or whatever. If we’re current, we must be doing the right thing. That may be true only if the current thing actually applies to what you’re doing. In 1999, Alistair Cockburn talked about Methodology per Project. I think this essay went unnoticed at the time. That’s a pity. I think there are some real nuggets in what he talks about. Of course he’s a consultant trying to convince you that his Crystal family of processes are right for you. Simply put, every project and project team is different. We don’t manufacture software, because each program is different. If we write the exact same code multiple times then we’re idiots. Ours is a craft. We produce one-of-a-kind products. If our products are one-of-a-kind, then maybe the way we produce them should be as well. That’s the key.

If we don’t start smartening up, we’re going to be in the same place ten years from now. Oh, there will be new methods and tools, but we won’t really know how to use them. We’ll hire someone to tell us what to use and how to use it. Same old, same old. Unless we start thinking for ourselves, reflecting upon our experiences, and taking our own destiny in our hands, we’re doomed as a profession. As the world’s appetite for software increases, we’re going to sit back and hope someone can show us how to do better.

When students get out of my software engineering course is that they are able to evaluate tools and methods and pick the right ones for their projects without someone else telling them what to do.

I do a little searching on the Web and find several references to American Family Counseling. Some point to social counseling services in California, others point to various social service centers, and one points to a marking Family Credit Counseling, which seems legitimate. I also find references to Robo calls from American Family Counseling that indicate there is clearly something shady about this specific call. I chalk it up to a probable scam, but one that shouldn’t occur again since I actually called them out on it.

A few weeks later we get another call from the same organization. Again I press ‘ 1′ and get a human. This time I tell the person at the other end that we are on the no call list and ask why they’re calling us. All I get are comments telling me that this is an important service about our credit card. I tell them I don’t want to be called anymore. However, by this time they have already hung up the phone.

At the end of August we received yet another call from them. You can guess the sequence of events that occurred. This time I filed a complaint on the no call list site. We also contacted the federal trade commission where the person my wife talked to took all the information and gave us a case number. They also suggested that we contact the state attorney general. So my wife spent the next hour trying to get someone in the right place at the state attorney general’s office who would take the information and perhaps act upon it. It seems pretty clear that this is either a phishing operation or, at the very least, a shady organization trying to drum up business. Well at the state attorney general’s office the best they could do was to send out a form for us to fill out. My wife did this and sent it back in.

Two days ago we get another call from American Family Counseling—this time, from a cell phone number. The sequences of the same and I pressed  ’1′.  Again, when I press for information, the person hung up. My wife then called the Federal Trade Commission and a very nice woman  took down the new phone number and added it to the case. Whether anything will be done is anyone’s guess. At the attorney general’s office it was even worse.  We were told that if we wanted to add information to the previous report that they would mail another for for us to fill out. (If the computer system is that poor, they’ve got some real problems.) They said it sounded like a scam that was going around and they were just telling people not to press any buttons.

Isn’t it nice to see how well oiled the government runs?

To my surprise, this book turned out to be a delight. This book doesn’t serve you the full language in a multi-course meal. Instead, it lays out the small tapas and lets you sample just enough to let you see if you like the taste. And, if you do, it gives you enough to keep you going until you order the full meal from another book, course, or combination of sources. What’s even more interesting is how Tate has selected tasty languages that each tantalize different parts of your intellectual pallet.

There are no common, “fast food” languages like C, Basic, or even Java here. Instead Tate offers avant-garde  languages that are gaining traction—or being rediscovered because they offer new paradigms or efficiences that we need for future applications and computing systems. His choices are Ruby, Io, Prolog, Scala, Erlang, Closure, and Haskell. Few people will know enough about all of these, and even if you do know something about all of them, the chances are that you’ll gain some additional insights.

Tate helps the reader approach each language by framing it with several questions that one should ask when learning any new language. These questions are:

• What is the typing model?
• What is the programming model?
• How will you interact with it?
• What are the decision constructs and core data structures?
• What are the core features that make the language unique?

I recently used the chapter on Ruby to introduce the language to high school students. It worked wonderfully. When they were done, several of them decided to use Ruby for their project and did some very nice work in the span of about five days.

The book can be read comfortably in a weekend, but that’s like going to a wine tasting and chugging down everything in sight. Take your time with these languages. Use the seven weeks, or at least a few. Taste deeply and then decide which ones you want to learn more about. It will be a fun ride, and certainly worth your time.

So, to me, the release of the new volume is a really big thing—a really big nostalgic thing. I wonder how many of the current generation of software developers are excited, or even care about this release. There is no doubt that the number of people involved in computing has increased dramatically. Many of these people are programmers and not computer scientists or mathematicians. I don’t say this to belittle them. What they do is an honorable, important job. Decades ago, the state of computing was such that you really needed to be much more knowledgeable about math and the inner workings of computers than you do today if you wanted to write a program. Clearly, this is a good thing because the world’s appetite for software seems to be insatiable and we need to have as many people as possible preparing the dishes for the ravenous beast.

How many of this generation of software developers are able to, or even care to mine the depths of the works of people like Knuth to find the gems there that are hidden from mere mortals? I have the utmost respect for many of today’s technology heroes, but to paraphrase Sen. Lloyd Bentsen, “I knew Knuth, and these are not Knuth.”

Perhaps there is too much for any one person to know about computing today. That’s been true for decades, but Donald Knuth knows as much about the core concepts than anyone I can think of. I hope that we will see a renewal of interest in Knuth’s works with the publication of volume 4A of TAOCP and that it will inspire students as it did me and many of my friends.

What other people and classics are we missing today? I’d like to compile a list of those which inspired people and stand head and shoulders above others in their field.

Many years ago, and I do mean many, I decided to become a Certified Data Processor. The CDP is a certificate that was issued by the Institute for Certification of Computing Professionals. The ICCP still has a presence and offers updated certification. Even when I was a consultant I never placed CDP at the end of my name. I don’t know whether it was important or not. To me it was like any other exam, such as the SAT or GRE, that I looked at as an intellectual challenge without very much use, except to get me accepted into a school I wanted to. I’m not sure it really said anything about whether I was qualified. The ICCP has newer certifications, but these are approximately equivalent to the ones in effect when I took the exam. In fact they indicate that “holders of the previous certifications qualify for the current certifications.” Does this mean that knowing how to draw a flowchart indicates that I can create a UML diagram? So what.

The ACM and IEEE have been working on certification programs for quite a while. IEEE offers exams that, when passed, enable professionals to claim certification. And yet, this has not caught on. Why not?

Last week in a department meeting we had a brief exchange about certification. There are certainly different viewpoints among faculty members. When we consider macro software engineering which involves very large projects, often involving hardware systems, the set of skills seems to change more slowly than those required to be a competent micro software engineer. Heck, the projects often take years to get to release. The macro software engineer will typically spend more time on project management of the whole system, scheduling, validation, verification, process, and so on. These are certainly necessary and valuable skills. But does one need certification? And, if they do, does this have anything to do with the software developer trying to build a particular module?

At the micro level things change much more rapidly. New languages, new technology, and new practices that enable one to deal with changing environment pop up regularly. Should we have certification specialized for web developers, embedded software developers, IT applications, and so on? If so, where do we draw the lines, and can we keep up with all of the advances?

When I was at Rational the RUP was a framework that we felt described the process of building software. Those companies that succeeded using RUP were those who understood that the framework needed to be specialized and customized. Those who attempted to apply all the practices and advice in the 3000 or so Web pages were doomed to fail. The fact is, that one size does not fit all. We must consider the context—project, people, environment—in order to be successful in a software development project.

There’s another, more practical reason why certification will not work. There is just too much software that needs to be created and not enough people to do the work. Will the lack of certification really cause a company to not hire someone who can get the job done?

So, if not certification, then what?

Portfolios can correlate to competence

A few years ago Pete McBreen penned his book, Software Craftsmanship. If you haven’t read the book you should. McBreen likens software developers to craftsmen of previous centuries. We learn through a series of apprenticeships. Just as someone who wanted to be a jeweler would sign on with a master jeweler as an apprentice, new software developers begin their career by learning from master software developers. The apprentice jeweler might spend years to become a master jeweler, he might just as well have become an apprentice for different master jewelers, and become a journeyman. So too, one software developer might become a master and specialize in one type of software development, while another might become competent in several areas and become a modern day journeymen.

With this model in mind, I believe there is a better way of determining who can build the next generation of our software. If you are looking for jewelry, a piece of art, a house, or any number of things that require customization in craftsmanship, you don’t look for certification. What you do is look for a person with a portfolio that indicates she is capable of producing the type of artifact you desire. The same approach can be used to find software developers.

I encourage my students to begin putting their portfolio together early in their academic careers. As they proceed through the university they should add to the portfolio so that when they graduate they have something to show prospective employers about what they can do by  showing what they have done. Then, as they advance in their careers they can add to this portfolio and decide whether they want to be a master of a small set of skills or a generalist. There are some—but few—who can be masters of everything.

This approach, in my opinion, makes much more sense than looking for certification. Certification simply means—in the way it has been and is being implemented—that the person has learned how to pass one or more tests. The portfolio lets you see a body of work and will often show how the person has advanced. This let you fine people who not only have a set of skills, but more importantly showed that they can learn and apply those skills.

Isn’t this what we really want from our software developers?

I’ve learned a bit more about the Arduino in the last couple of weeks, since my last Arduino post. Most of the information has been about using Eclipse and the Arduino Uno. The basic project I completed last time was the simple blinking example on the Decimilia board. This is an ATmega168 processor and runs just fine. However, when you go to Eclipse, you need to make sure that you set the clock frequency to 16000000 and not 1000000 as in some of the documents. Other than that, everything works just great.

Enter the Uno

The Arduino Uno is the latest version of the Arduino. I ordered a starter kit from Amazon. It was a duemilanove kit, but shipped with the Uno. It has the ATmega328p processor. It worked just fine with the Arduino IDE, but when I tried to duplicate the steps to get it working with Eclipse, I failed miserably. It’s taken a while to track things down, but I think I’ve got it pretty much sorted out now.Here are some of the things that I’ve found helpful.

1. When you set up the AVRDude configuration for the Uno, the baudrate should be 115200 instead of 57600 as some of the documents indicate. This will get rid of the annoying “stk500_recv(): programmer is not responding” message when AVRDude runs.
2. In order to see what’s going on with the Arduino IDE, you can modify the preferences.txt file to add some verbose options. The file is in the Library/Arduino directory under my home directory on the Mac. A couple of the useful things I’ve found are adding the following lines:
   • upload.verbose displays the command line used for invoking AVRDude.
   • build.verbose=true displays the output of the build process.
3. I’ve copied the Uno core.a library created by the Arduino IDE and am going to just use it rather than trying to create an Eclipse project for building such a library like I did for the Diecimilia. This will reduce the number of things I have to work with and it is the preferred way of getting the library according to the installation. One of the problems is finding the library on the system on the Mac. The location of the libraries is specified for other platforms in the Eclipse installation instructions from the Arduino playground. It took a little while, but after putting in the “build.verbose” file in the Arduino IDE’s preferences.txt file, I found the directory. It was in /var/folders/7A/… . Not the most obvious place. I moved this into my a lib/arduino directory in my home directory.

After all of this, I still am not getting the program to execute. It compiles, loads, but does not run on the Uno.

Finally: Success

So, it was back to the drawing board. I went back and recreated a separate project for the Uno core library. Then I compiled that and created a new project for the Uno blink program, and it worked. It’s still not the easiest thing to make sure you get all of the settings correct, but it is nice to see the light blink.

Next, I think I’ll work on building the project in a more simple environment, like a text editor, command line compilation, and make.

First, it’s probably worth recording the settings I’ve got on the two projects.

Uno Core Library Project

I simply copied all of the sources from the …/cores/arduino directory to the top level of this project. I deleted the main.cpp as the Eclipse installation directions said. Next, I followed the directions from the Eclipse installation page exactly. The relevant preferences settings for the project are:

• AVR>Target Hardware: ATmega328p, 16000000 MHz.
• C/C++ Build>Seettings: no debugging information, and optimize for size on both compilers (C and C++). Also, the other optimization flags for the C++ compiler are”-ffunction-sections -fdata-sections -Wl,–gc-sections”.

I have both the debugging and release configurations set for this, but it only needs release. We’re not really worrying about debug configurations at all here.

The Uno Blink Project

Again I followed the instructions in the Eclipse installation directions. There was one thing not covered which got the library included in the linking. Here are my settings:

• AVR>AVRDude: Uno programmer configuration. No switches set under Advanced tab.
• AVR>Target Hardware: same as above.
• C/C++ Build>Settings
  • Additional Tools in Toolchain: Generate Hex Files for Flash Memory and Print Size are checked.
  • AVR Compiler>Directories: “${workspace_loc:/UnoCore}”, where UnoCore is the name of my Uno core library project.
  • For both compilers (C and C++), no debugging and size optimizations.
  • AVR C++ Compiler>Directories: same as for the AVR Compiler.
  • AVR C++ Compiler>Optimization: -ffunction-sections -fdata-sections -Wl,–gc-sections
  • AVR C++ Linker>Libraries: Libraries (top): UnoCore, which is the name of my library for the Uno core. Libraries Path (bottom): “${workspace_loc:/UnoCore/Release}”.

This post is the first document that I’m actually writing with my voice. The accuracy is, to me, uncanny. There’ve been very few errors in (except for the word errors that I just had to try several times to get right). But this is just with the basic training of my voice. I can go back later a innd train it in a more advanced way so that even “errors” will be no problem.

I’m hoping that this will give me the ability to write better by not editing as I write. When I type documents, especially for books and articles, I tend to edit as I write. Almost every book or article on writing says that editing as you write is a bad practice. If I can break myself of that habit I should be able to express my thoughts better and then go back and edit the document for correctness and clarity.

My hope is that this will help me get back to writing my software engineering book and maybe even finish it this summer. It’s only been 2+ years that I’ve been working on the book and I’m still only a chapter 5. Part of the problem is that I simply take too long to get something on paper and then have to go back and review the things I’ve written every time I try and start again. Perhaps this will get me into  a regular routine to keep current on my writing.

Whatever, there is no doubt in my mind that the technology used in Dragon  Dictate is quite advanced. Right now, after a short trial, I would heartily recommend anyone use, or at least try, Dragon Dictate or the Windows version of the Dragon product.

I’ll keep you posted.