Summer Vacation

I normally take vacations twice a year.  The first time is during the Christmas holiday (see Learning to Unplug). The second time is at the beginning of summer. Our Christmas holiday is definitely the more restful of the two.

Summer vacation usually means getting out into the garden every day to weed and then there are animal needs to address. We’ll process a certain amount of food during this time as well. This is the time of year when we’re starting to see the benefits of having our garden. However, there is normally so much work to do that I really do need the time off in order to help Rebecca manage it all. So, the vacation part comes from not going into the office each day to write.

It’s not as if we won’t take some time off. There will be a few days where we go fishing first and do chores later. After all, even we have to have a bit of fun . Summer is the time for picnics, so we’ll probably go for a picnic or two to one of our favorite spots. Every summer vacation we also have some activities we do, such as putting together the annual summer jigsaw puzzle. It’s a fun way to spend a bit of time when we decide it has gotten too hot outside and want to spend a little time in the coolness of the house. Of course, kicking back in my hammock under the big maple tree next to the garden Rebecca has created for me is quite nice too.

The one big thing we do every summer vacation is barbecue every day. Normally I make the meat dish every day and Rebecca makes up a vegetable to go with it. Sometimes I cook both the meat and the vegetable dish to give Rebecca a day off cooking. The smell of roasted meat is a mighty nice way to spend an evening meal. I’ll use a combination of herb seasonings from Rebecca’s garden, butter or olive oil, and selected woods to give the meat a special taste.

This summer vacation will hold something special for me. I have an abundance of construction wood this time, so I’ll probably take a bit of my time out of the office to put up new shelving in our larder. Rebecca currently lacks a good place to put empty jars without cluttering up the shelves containing food. In addition, there have been times where we had such an abundance that we had to scour locations to put it all. The new shelves will ease some congestion.

We’ll be back to work on July 17th. If you have any questions regarding my books, please be patient and I’ll answer them when I get back. In the meantime, don’t worry if your email message goes unanswered. I assure you that I’m not going to ignore you. Happy computing!

 

Thinking Through Indentation and IDE Automation

I’ve been asked a number of times about code indentation in my books by publishers, editors, and readers alike, so I thought it might be a good idea to talk about the matter in a blog post. It’s important to indent your code to help make the code more readable—to help make the flow of your code easier to see. Each indentation represents another code level. The application is at one level, classes at another, methods within the class at another, loops within a method at still another, and so on. By viewing the various levels of code within an application, you see an outline of application functionality and can better understand how each application element works. Because indentation is so important to the understanding of code, I spend considerable time working through indentation in my books so that you can better understand the examples I present.

Indentation is there for the developer to use as an aid to understanding. A few early computer languages, such as COBOL, were positional and depended on coding elements appearing in certain positions on each line. Most languages today don’t require that you use any sort of indentation. In fact, more than a few languages would let you write the entire application on a single line without any indentation at all (as long as you supplied a space between statements and expressions as needed). The compiler doesn’t care whether you indent using spaces or tabs, whether there are three or four spaces per indent, or whether you provide an indent for continued lines. The fact is that all of these characteristics are controlled by the developer to meet the developer’s needs.

Modern IDEs make it easy to indent your code as needed by performing the task automatically in some cases. For example, given an example of a Java method, you could begin by typing:

public void MyProc()
{

The moment you press Enter after the curly bracket (}), most IDEs will add an indented line and a closing curly bracket. Your cursor will end up on the indented line, ready for you to type a statement. You see something like this in your IDE:

public void MyProc()
{
 
}

The developer hasn’t done anything so far to provide indentations for the code, yet the code is already indented. Let’s say you create a variable like this:

boolean MyVar = true;

You then type a statement like this:

if (MyVar == true)

It’s at this point where some IDEs continue to provide an automatic indent and others don’t. For example, if I press Enter at the end of this line in Eclipse, the IDE automatically indents the next line for me. However, when I’m working with CodeBlocks, pressing Enter leaves the code at the same indention level as before. Neither approach is wrong or right—simply different. If I were to add a curly bracket on the next line to hold multiple lines of code within a block, CodeBlocks will already have the cursor in the right position and Eclipse will have to outdent the curly bracket to position it correctly.

Let’s say that this if statement has just one line of code following it, so I don’t use a curly bracket. When working with Eclipse, the cursor is already at the correct position and I simply type the next statement. However, when working with CodeBlocks, I must now press Tab in order to indent the line of code to show that this line (and only this line) is associated with the if statement. In this case, the example simply outputs a statement telling the value of MyVar like this.

System.out.println("MyVar == true");

Pressing Enter automatically outdents the line when using Eclipse because the next statement is automatically at the same level as the if statement. However, when working with CodeBlocks, I must press the Backspace to outdent the line manually. The resulting method could end up looking like this:

void MyProc()
{
    boolean MyVar = true;
    if (MyVar == true)
        System.out.println("MyVar == true");
     
}

Of course, a good developer will add some comments to this code as a reminder of what task the code performs and why the developer chose this particular technique to perform the task. The point of this post is that indentation is an essential part of working with most languages in order to make the resulting application easier to understand.

A final thought on IDEs is that most of them make it possible to configure the editor to indent or not indent to meet the requirements of your organization or personal tasks. IDEs commonly allow the use of tabs or spaces for indents (spaces are better when you want to write documentation). You can also choose the right amount of indentation (three spaces is optimal for books where space is limited). Let me know your thoughts on indentation and how you use it at John@JohnMuellerBooks.com.

 

Sunday Surprise!

Most people view a self-sufficient lifestyle as an experiment in boredom. It’s possible to think that the only entertainment one gets is watching the grass grow. That’s really about as far from the truth as you can get. We’ve had all sorts of excitement over the years. This past Sunday was no different. We were just about ready to head out the door for church when the post office called. Let’s just say that I thought it was a prank at first. I’ve never heard of the post office calling anyone on a Sunday.

Our laying hens and second batch of meat chickens were supposed to arrive Monday morning in Reedsburg—the small city about ten miles from us. The post office was calling to let us know that the chicks had actually arrived in Portage (52 miles away) on Sunday and that we needed to pick them up before noon. So, it was off with the Sunday attire and on with the regular clothes. We piled into the car, found a place to stuff some breakfast down our throats, and then drove to Portage as fast as country roads would allow (and believe me, there is no 65 on a country road—it’s 55 on a good day).

On the way home we stopped at a Kwik Trip to buy some Gatorade for the chicks. Then we rushed home, set the brooder box up for chicks, and started showing the chicks how to drink the first time.

There is a misconception that all chicks are bits of yellow fluff. Chicks actually come in a range of colors. The meat chickens are certainly yellow, as are our Delaware laying hens, but the Ameraucana and Buff Orpington chicks look much different.

SundaySurprise01

The Ameraucana chicks are actually quite pretty with all of the shades of brown they possess. These chicks have a beautiful dark streak down their backs. The Buff Orpington chicks are almost an orange color. Think of it as a lovely brownish orange, rather than a pumpkin color.

Each of these layers will provide different sized eggs and have different characteristics. For example, the Delaware chickens will lay a moderate number of jumbo brown eggs quite well all winter long. The Buff Orpingtons will produce a larger number of large brown eggs, but produce a bit better during the summer months. Ameraucana hens produce copious quantities of the most beautiful medium eggs you’ve ever seen. The colors range from buff, to blue, to blue-green. All three types of chicken are bred for cooler climates and won’t require any weird drugs to keep them alive. More importantly, because they’ll all be free range chickens, we’ll get superior eggs from them.

Farm life does come with a wealth of surprises. This Sunday was just a reminder to be ready for anything. Let me know about your latest life surprise at John@JohnMuellerBooks.com.

 

Debugging As an Educational Tool

One of the questions I get asked quite often is how I learn new programming techniques. After all, I work with a broad range of languages and IDEs in my pursuit of new programming environments. Let’s face it—I like to play with code. For me, it’s not really a job to write application code. I like to see how different things work and what’s possible with a given language. In order to accomplish my goals, however, I need to learn techniques quickly. The debugger is my secret to learning how to code quickly and easily. In fact, I’ve written an article on the topic, “Improve Your Coding Skill by Listening to the Debugger.” You also see this technique emphasized in a number of my books, especially LINQ for Dummies and Start Here! Learn Microsoft Visual C# 2010 Programming.

The main reason that I use the debugger as an educational tool is that I can see the code in action. It’s possible to see how the code actually works, rather than envision what the code is supposed to do. The difference is important. For me, seeing the code actually work demonstrates that the theory behind the code is sound. Many theories sound good until you actually try to use them—using the debugger proves the theory as you work through the code.

From a personal perspective, the biggest hindrance that I face in using the debugger as an educational tool is the lack of good comments. In fact, comments are such a problem that I write about them in Creating Useful Comments. When the code lacks comments, I need to look up the calls myself and then determine how the developer is using them. It’s time consuming and a somewhat painful way to learn at times because I can see the code work, but I don’t know how it works or why the developer chose a particular approach. Even worse is when the code contains misleading comments. Worse still are comments that are outright incorrect because they reflect a previous state of the code or the developer didn’t actually understand why a technique works (the sheer dumb luck approach to coding).

Make sure you check out my article on the topic and get back to me about it. I’d like to hear your views on using the debugger as an educational aid. For that matter, I’d like to hear your viewpoint on debuggers as a class of application. Do you feel they need work or are debuggers as useful as they need to be? You may even feel that debuggers have become encumbered by way too many features. Whatever your viewpoint, let me know at John@JohnMuellerBooks.com.

 

Software Quality Connection is Moving

A lot of you know that I write articles for Software Quality Connection (SQC) from time-to-time. In fact, you can find the newer articles listed in the Articles category of this blog. All of the existing articles and any new articles I write will still be available for your viewing pleasure. However, they’ll be moving to a new location, SmartBear blog. You can read about this update in the Software Quality Connection – Now Part of the SmartBear blog post. Make sure you subscribe to either the RSS feed or e-mail messages so that you get all of the amazing posts from this organization.

Of course, I’m concerned that you’re able to continue to read my articles. If you experience any problems, whatsoever, accessing one of my articles, please let me know. I’ll do my best to clear things up. For example, my most recent SQC article, “How to Inherit Somebody Else’s Code” now appears at http://blog.smartbear.com/software-quality/bid/167035/.

My future articles will appear on the new site. I’ll let you know as they get published so you can take a look and provide your usual feedback to me. Let me know if you have any questions about the new setup at John@JohnMuellerBooks.com.

 

Exploring the TimeCheck Application (Part 6)

Last week, we examined the last major user interface issue for this application, adding accessibility features so that someone using a keyboard could access all of the options simply by pressing Tab. I received some good feedback on that post. It’s important to me that applications work as well as possible for everyone. This week’s post will start to examine the underlying application source code—starting with the database used to manage the user time entries.

This application will have more database information than either of the two series presented so far (Exploring the GrabAPicture Application and Exploring the TypingBuddy Application). In fact, there are a number of different databases you need to consider before writing even a single line of code. Here are the basics—upcoming posts will examine each database in detail.

 

  • User Settings: Each user will have individual settings that are stored on the local system. For example, a user can choose to select a default project and a default task, making it easy to log into and out of the system each day. The local user settings also contain a pointer to the network drive used to store the group settings and also to store the user’s time entries. The time entries are actually the most important part of the application because they track the user’s daily activities.
  • Group Settings: The group settings control features that affect the group as a whole are are only accessible by the administrator for editing purposes. For example, you use these settings to control whether the group can use custom tasks or custom projects as part of a log entry. If not, the group is required to select one of the default projects and/or tasks. These settings appear in a central location on the network drive. In order to provide default projects and tasks for users, these settings control two sub-databases:
    • Default Projects: This is a list of the default projects that a user can select from.
    • Default Tasks: This is a list of the default tasks that the user can perform on a given project.
  • Individual Time Entries: Every time entry consists of a time, the project selected, and the task performed on that project. Every login and log out sequence comes as a pair of time entries. The first entry logs the user into the project to perform a given task, while the second entry logs the user out of the project. Each user has a single log file based on his or her name.


These databases are all implemented using XML files, as with the previous series examples, because none of them require true relational capabilities. The reports gather information from the various time logs to create an overview of how the individual or the organization as a whole is using the computer.

As part of figuring the databases out, you also need to consider the data storage requirements. Some of the data need not appear on the network drive. In fact, it has to appear on the local drive or the application won’t be able to find the network data location. Other data appears on the network to provide centralized access to it. Here are the storage locations used for the data in this application.

 

  • C:\Users\<User Name>\AppData\Roaming: Contains the user’s settings and the pointer to the network drive location.
  • \\<Server Name>\<Share Name>\TimeCheck\GroupData: Contains the group settings. Only the administrator can read and write this folder. Regular users can only read this folder.
  • \\<Server Name>\<Share Name>\TimeCheck\<Year>\LogFiles: Contains the individual log files. Administrators can read and write any file. However, regular users can only read and write a specific log file.

I had considered using separate files for each project, but this seems unnecessarily cumbersome. Obviously, you may prefer a different log file and folder setup than the one used in the example. The example is extensible so you can modify the locations as needed for your organization. The reason for using a year folder is to make it easier to archive a specific year’s entries when they’re no longer needed.

Now that you have a better idea of how the databases are arranged, we’ll begin looking at the code used to implement them starting with the next post. I’m going to be out of the office until July 17th, so we’ll talk about the next post in this series on the Friday that follows (July 20th). Until that time, please let me know if you have any questions about the databases or where they’re stored at John@JohnMuellerBooks.com. You can see the next post in this series at Exploring the TimeCheck Application (Part 7).

 

Weeds, Weeds, and More Weeds!

I must have struck a chord with a few people on Monday (see Real World Global Warming). My inbox has received more than a few notes about weeds. Apparently, Wisconsin isn’t the only place that has been hit hard with them. I’ve received e-mail from a number of locations in the Midwest and a couple of places in areas like Texas. They do seem to be a problem this year. I think that weeds from prehistoric times have taken a sudden urge to sprout.

As I mentioned in my post, we’ve taken a new approach to weeding this year. The weeds are so bad that we’re weeding and immediately mulching. Otherwise, within a couple days time, it seems as if the weeds are coming right back. So far, the mulching technique seems to be working. The areas that we’ve managed to eradicate weeds from are staying weed free with the mulch in place. I can only hope the mulch lasts through the summer.

I’ve noticed a difference in the weeds this year too. We’re having more problems with quack grass than normal. Quack grass is especially troublesome because normal pulling does little to remove it. In fact, if you use normal pulling techniques (or worse yet, cultivate with a rototiller), you only help spread the quack grass. The major problem with quack grass is that it can grow through anything. We actually had it grow right through our potatoes and you’ll often see the stuff growing up through even tiny cracks in concrete and asphalt.

I’ve seen any number of sites recommend using roundup on quack grass. Don’t do it! You’ll only succeed in damaging your soil and other plants. In order to get rid of this pest without damaging other plants in the garden, you must loosen the soil completely and remove the long runner rhizomes.  The grass invades from the grassy areas surrounding the garden, so you should work from the inner part of your garden, outward. I’ve removed rhizomes four and five feet (yes, that’s feet) in length. When done carefully, you can remove enough of the quack grass to keep it controlled. I have never managed to eradicate quack grass from our garden, but I do control it well enough that it’s not much of a problem after the initial weeding. Even one rhizome nodule left in place is enough for the plant to start all over again.

I use a combination cultivator/mattock to remove our quack grass, especially considering the hard baked clay soil this year. This isn’t a genteel weeding device. Use the cultivator part to carefully break up the soil by going straight down on the edge of the quack grass that points away from the edge of the garden. Raise the tool up slowly and carefully. You’ll normally find the quack grass rhizomes on top of the cultivator tines. Keep working to remove as much of the rhizome as possible in one piece to ensure you get it all. Use the mattock end as needed to break up the soil or to sever the rhizomes when you get to the edge of the grass.

Is quack grass bad? Not really! It’s a good plant for controlling erosion. You can’t ask for a better grass to hold a hillside in place. It’s also the best grass I’ve found for the areas where we run our chicken tractors. The chickens can’t seem to kill the stuff off. They will kill absolutely everything else off at some point, but the quack grass keeps coming back. The quack grass also provides good nutrition for our chickens and rabbits. So, it’s not a bad plant—it’s just not wanted in the garden.

We’ve also been seeing more pigweed and lambsquarters this year. Both are easily pulled, however, even in the dried out soil we’re currently dealing with. I wasn’t surprised to learn that both of these plants have different names in other areas of the world, so I provided links to them. Finally, our dandelions are growing profusely everywhere. All of these plants are theoretically edible (especially the dandelions) if you can find a clean source of them. I’m contemplating making the dandelions pay the ultimate price for invading our garden—consumption in a salad. The leaves also taste quite nice boiled with a bit of lemon and olive oil. However, for now, we’re just weeding furiously to get the garden in shape and aren’t taking a lot of time to separate the plants. The chickens and rabbits, however, are in seventh heaven.

What sorts of weeds are you having to control this year? Do you think we’ll eventually get some rain? Let me know at John@JohnMuellerBooks.com.

 

Review of The Art of Readable Code

I encounter a lot of unreadable code because I work through a lot of code I download from the Internet for learning purposes and rework code from failed projects. So, it was with great interest that I opened The Art of Readable Code by Dustin Boswell and Trevor Foucher. After reading this relatively short book, I’m convinced it should be picked up as a college text. If developers would follow even half the advice in the book, many of the truly weird errors in code today would simply disappear because developers wouldn’t end up overwriting the good parts of other developer’s code due to a lack of understanding it.

The authors rely heavily on humor to make good points about writing code that is easy to read by others. The cartoons are engaging and fun. I wouldn’t necessarily call them funny—some of the jokes are tongue-in-cheek and others are a bit dry, but they’re all in good taste and make important points. As for the good points in the book, I don’t think I’ve ever seen anyone suggest that a developer actually turn to a thesaurus to find a better name for a variable, but the authors make this point on page 9. The point is made in a humorous way—not as a command as I’ve seen some authors do. I did laugh relatively often. For example, “The Ultra Hard Metal Nail Smashing Rod” reference on page 13 gave me quite a laugh. You’ll need to see the reference for yourself to understand it.

You’ll want to pay attention to the frequent Advice blocks in this book. In fact, if you’re short on time, skim the book looking for these blocks (and the Key Idea blocks I describe in the next paragraph) and you’ll improve your coding technique significantly. Some of the advice is obvious to a veteran programmer. For example, on page 25 the authors advise putting max_ or min_ in front of programming elements that describe some sort of limit. (If only novice programmers would follow that simple advice.) I only wish that the Advice blocks appeared with greater regularity later in the book. I would have welcomed advice from the authors on some of the more complex topics.

The Key Idea block is another useful addition in the book. For example, on page 122 you find the authors advocating that you create code that only performs one task at a time. Even though this idea seems quite obvious, you’ve probably seen code that is trying to do too much and ends up not doing anything well. The authors back up their Key Ideas with good coding examples (some relatively complex). Unlike the Advice block, the Key Idea block does appear with good consistency throughout the book and the authors have used it quite well.

The section on Eliminating Variables that starts on page 94 was especially useful for me. I often create intermediate variables while writing an application to aid in debugging it. The authors provide techniques that greatly simplify code without making it much more difficult to debug later. Even so, sometimes you really do need that intermediate variable for a while. The point is that you should simplify your code as it nears production to reduce complexity, provide fewer failure points, and improve performance.

As with any book you buy, this one does forward the author’s agenda. If you follow all of the advice in the book, your programming style will closely reflect the style that the authors use. Anyone who has written a lot of code knows that there are many perfectly acceptable styles of coding. The point is to make your code readable so that someone coming behind you can pick up on your style and quickly discover how your code works. For example, I still prefer to use a form of Hungarian Notation for my applications. Because I apply the notation consistently, my code is readable, but many developers feel that the notation is outmoded. Whether you use Hungarian Notation or not is not the point, the readability of your code is. The authors express their view of Hungarian Notation on page 17—as with many other parts of this book, they take a firm middle ground approach that should serve the reader well.

There is a lot to like about this book. As I said at the beginning of the review, colleges would do well to incorporate it into their curriculum. The authors do press their style of coding strongly at times, but I imagine that if I were writing this book I would do the same things, so I can hardly fault them on this point. The content is a bit simplistic for the veteran programmer at the beginning, so you might want to start around Chapter 7. Overall, I think this is a good and much needed book.

Updates in the .NET Framework 4.5

I try hard to follow the latest developments in all of the technologies that interest me. Since my range of interests is large, sometimes it proves nearly impossible to track it all. So, like you, I rely on summaries of information at times. I’ve been working with Visual Studio 2012 quite a lot lately. Not only is it the tool of choice for other authors and the tool I’ll use to write books myself, but I also need to verify that the source code for my currently supported books still works. The new features in the associated .NET Framework 4.5 are of great interest to me, so I checked out an article about it entitled, “What’s New in the .NET 4.5 Base Class Library” by Immo Landwerth.

There are a lot of welcome updates. For example, asynchronous programming won’t be as difficult in the future because Microsoft has taken measures to simplify things. You can read the article yourself to see how much better the new technique is. I’m sure that many developers will welcome the change because it will make it possible for developers to create asynchronous routines with greater ease, which should make applications considerably more responsive. Given that one of the five tenets of Metro programming is to be fast and fluid, it doesn’t surprise me that .NET 4.5 contains this sort of change. I worked through the example and even tried a few of my own and the new asynchronous support works great! However, I have to wonder what the cost of this new support is. It isn’t often that you get simplicity without the loss of flexibility. As I explore this new feature, I’ll let you know if I do come up with reasons to use the old approach (as nice as the new approach is).

The new ZIP file support strikes me as something Microsoft added because everyone else already has it. Microsoft was late to the party with this one. However, the new support is quite welcome because ZIP files have proven to be a problem in the past. Not many applications can get by without this particular archive today. What I had hoped would happen is that Microsoft would build an extensible archive support feature that would support ZIP files, but would also make it incredibly easy to add support for other archive file types, such as JAR and TAR. Unfortunately, it looks like we’ll see one new archive file format supported at a time.

I’ll need to play with the read-only collections to determine how I’ll use them. Right now, it appears that this new feature will see limited use in my applications (if I use it at all). The first two improvements mentioned in this post have a definite use in my applications and I’m welcoming them with open arms. What I’d like to hear from you is how you’d use this new feature. Let me know what you think about it at John@JohnMuellerBooks.com.

Articles are problematic at times because the author often doesn’t have sufficient space to cover all of the details. I know that I’ve encountered this issue myself. The editor assigning the article might not have sufficient grasp of the material to make a good decision about it either. I wish that this article had been split into several parts because the author lists a number of miscellaneous improvements at the end of the article. If you read the article, make sure you check this list carefully because some of the improvements, such as Console.IsInputRedirected, Console.IsOutputRedirected, and Console.IsErrorRedirected properties, are quite interesting. I write a lot of console applications and utility application that provide a console interface. Having these properties available will make it possible for me to code applications that are more responsive to user needs.

I’ve noticed that Microsoft didn’t provide a full number update to the revision number in this case and the minor upgrade number is warranted. There are some nice changes to the .NET Framework 4.5, but nothing so exciting that you should rush out right now and start implementing it in your applications. It would be wise to carefully add this update to your applications to determine when it provides a true advantage and when there is potentially a loss of functionality or flexibility that makes the update a bad idea.

 

Real World Global Warming

Every time I hear someone talk about global warming, they discuss the issue in terms that have no real meaning to me. Yes, I understand that the average temperature is going to increase as a result of global warming and that I’ll see weather pattern changes. However, what does it really mean to me? Why should I care? I don’t mean to appear uncaring, but prognostications of impending doom are better served with a dose of reality.

I’ve already discussed one direct result of global warming—the USDA has defined new hardiness zones as described in my Contemplating the Hardiness Zone Changes post. However, even this direct result of global warming doesn’t say much to me. It’s not an indicator that I see every day—something I can point to and say that it’s the result of putting too many of the wrong chemicals into the air.

However, this spring is providing something in the way of a wake up call to me personally. Spring came early this year; very early. Odd spring weather is nothing new to Wisconsin—we get odd weather every year. In fact, it’s the variety and uncertainty of weather that attracts me to Wisconsin. However, no one can remember a spring coming this early. Our spring has also been quite hot and dry. As a result, vegetables that normally do quite well in our garden, such as broccoli, are doing poorly.

In fact, all of our brassicas are doing poorly. I should have planted the brassicas earlier this year to accommodate the warm spring, but I didn’t. Local wisdom says not to plant too much, especially not tender plants, until Mother’s Day, which was simply too late this year. After talking to a number of other people, I find that I’m not the only one who planted too late. Everyone is complaining about how their broccoli has bolted without growing a head. Yes, you can pick the pieces and use them, but what you get is more like a second crop, rather than that perfect first crop in the form of a head.

The weeds, however, are doing marvelously. Rebecca and I can hardly keep up with them. We’re grabbing bushels of weeds from the garden at a time when we’re normally looking at light weeds and are able to mulch to keep them controlled. This year, we’re battling the weeds with vigor and mulching as soon as we get a patch freed from their grasp. However, I’m thinking that the late summer weeds we normally get poking up through the mulch are going to appear by mid-summer this year, long before we’re ready to harvest some of the end of season offerings (assuming they grow at all).

Fortunately, the news isn’t all bad.  We’ve just had the best asparagus season ever. Not only have we had spears vigorously poking their heads above ground, but the spears are thicker and more tender than usual. Rebecca has quite a few meals worth of asparagus already frozen because we can’t even contemplate eating it all without making ourselves sick. So, we’ve learned that asparagus loves exceptionally warm springs, but brassicas  don’t.

We’ve also had a pleasant surprise in the form of cantaloupes. Normally we have a hard time growing them, but we try anyway. The other day I noted that our cantaloupes are already flowering. They also appear quite vigorous this year, so I anticipate getting a lot of a cherished fruit that I often have to buy at the store as a “nicety” instead of picking it from my garden. This change in garden does lend credence to my number one rule of planting a wide variety of items to see what works and what doesn’t in a given year. Next year may very well prove to be the year the brassicas fight back, but this year I’m expecting a lot of broccoli soup.

I had mentioned in a previous post that our trees have also been affected by the spring weather. It turns out that our tree fruit harvest is just about ruined due to the odd weather because our trees simply aren’t used to it. We had thought we might get an exceptionally good berry harvest (the bushes are certainly full enough), but the exceptionally dry weather has already caused the black caps (a kind of raspberry) and the blueberries to fail.  On the other hand, the grapes apparently love our spring and are putting out more than I’ve ever seen them put out.  We can still hope that the blackberry and gooseberry harvests will be good too. The point is to look for the good and bad in the situation (as I described in my Every Year is a Good and a Bad Year post).

When you hear people discuss global warming in the news, it really doesn’t hit home. A degree or two temperature rise doesn’t quite make an impact. Even seeing the loss of ice at the poles doesn’t really hit the nail on the head like seeing your gardening conditions change so significantly that you never imagined they’d be the way they are now. Most scientists now accept global warming as a reality, but they continue to spout facts and figures that most of us can’t begin to relate to. What does global warming mean to you? How have you been affected by it? Let me know at John@JohnMuellerBooks.com.