Author: John

John Mueller is a freelance author and technical editor. He has writing in his blood, having produced 123 books and over 600 articles to date. The topics range from networking to artificial intelligence and from database management to heads-down programming. Some of his current offerings include topics on machine learning, AI, Python programming, Android programming, and C++ programming. His technical editing skills have helped over more than 70 authors refine the content of their manuscripts. John also provides a wealth of other services, such as writing certification exams, performing technical edits, and writing articles to custom specifications. You can reach John on the Internet at [email protected].

Passing By Value Versus By Reference

A number of readers have written me about the examples that use pointers in the book. One of the most common questions comes from the example on page 149 of C++ All-In-One Desk Reference For Dummies. In this example, the application contains a function that accepts an argument by reference. The use of a reference seems to have many people confused and this post will hopefully clear the issue up.

The first thing you need to understand is that there isn’t any magic going on here. The process for working with functions remains constant in C++. When you call any function with an argument, the application creates memory to hold the argument. The memory is local to that function. When the function ends, the memory is released. What the memory holds, now that changes.

Think of the memory as a box. This box has an address that points to it. When you work with a pointer, you’re working with the address. On the other hand, when you work with the value, you’re working with the content pointed to by the pointer, or the contents of the box. Whether the box the function receives contains a pointer or the value depends on how you write the function and what you pass to it from the caller.

Now, let’s look at an example so that you can better understand what’s going on. This example will do the same thing to the number each time, but using different techniques: by value, using a pointer, and by reference.

#include <iostream>

using namespace std;

void MessMeUpA(int myparam)

{

myparam = myparam * 2 + 10;

}

void MessMeUpB(int* myparam)

{

// Obtain the current value.

int currentValue = *myparam;

// Perform the required math.

currentValue = currentValue * 2 + 10;

// Save the result.

*myparam = currentValue;

}

void MessMeUpC(int &myparam)

{

myparam = myparam * 2 + 10;

}

int main()

{

// Call by value.

int mynumber = 30;

MessMeUpA(mynumber);

cout << "By Value: " << mynumber << endl;

// Call using a pointer.

mynumber = 30;

MessMeUpB(&mynumber);

cout << "By Pointer: " << mynumber << endl;

// Call using a reference.

mynumber = 30;

MessMeUpC(mynumber);

cout << "By Reference: " << mynumber << endl;

return 0;

}

You may notice that part of this example comes directly from page 149. If you run this example, you’ll see this output:

When you pass the data by value, you’re passing the information, not a pointer to the information. As a result, MessMeUpA() receives a value of 30. It doesn’t receive a pointer to the initial variable, nor does it obtain a reference to the initial variable. As a result, when the application performs the calculation, the result is thrown away.

When the application calls MessMeUpB(), it provides a pointer to the variable. However, the pointer isn’t a value. As a result, you move the value pointed to by the pointer into a local variable, perform the required math, and then move the value back into the original pointer. As a consequence, the original value is altered to 70.

Finally, when the application calls MessMeUpC(), the function obtains a reference to the original memory location. When the function performs the math, it’s actually using the original value as pointed to by the reference, which means that this is a kind of pointer, just not passed from the caller. The changes made in MessMeUpC() are reflected in the original value because you’re using a pointer to that value and not a copy of the value in local memory.

I highly recommend that anyone trying to understand how code works use the debugger to trace through that code. It’s instructive to look at each of the functions to see how they look. Place a breakpoint in each of the functions and then start the debugger. Open the Watches window, if necessary, by choosing Debug | Debugging Windows | Watches. Here is the view of the Watches window when calling MessMeUpA().

What you see here is a function argument—an integer that contains the value of 30. Now, let’s look at MessMeUpB().

In this case, you see a local variable, currentValue, that contains the updated value and a pointer to the variable used by the caller in myparam. The pointer gives you access to the value held by the caller and allows you to change it. Finally, let’s look at MessMeUpC().

Look at the function argument, myparam. The debugger is giving you a valuable insight here. See the address provided with the variable? Match that address to the pointer provided to MessMeUpB() and you’ll see that they’re the same. The reference is simply another sort of pointer, but one that gives you direct access to the memory without having to go through the extra steps required by pointers. The debugger even shows you that the current value of that memory is 30 (the math hasn’t been performed as of yet).

A function argument is simply a box that holds either a value or a pointer. Whether that pointer is an actual pointer or a reference depends on how you write you code. That’s the point of the example. Pointers don’t have to be mysterious or hard—they’re simply an address for an area of memory (a box if you will) that holds a specific value. Please let me know if you have any questions about this issue at [email protected].

Profession Versus Job

I often find inspiration for posts in places that you wouldn’t think to look. Today’s post comes courtesy of Bill Bridges from his Green Market Press blog. The post in question is the Taipei Journal entry for today—there are many of these journal entries, all entertaining and educational about the human condition. Bill is a professional journalist and a good friend who has often inspired me to excel with his seemingly simple posts. The reason that today’s post struck a chord with me is that it answers part of the question of how to become a programmer. My initial post discussed the mechanics, the precursors that someone might pursue to become a programmer, but that post didn’t answer the question of how to make programming a profession.

Today’s journal entry answers the question of profession versus job rather succinctly. Susan writes an article that constantly mentions “the French system of government” without ever explaining what the term means. Bill asks her about it and her response is, “I did sort of wonder about that.” Susan has a job, Bill has a profession. Education, no matter how complete, is only a precursor to a profession. In order to turn a job into a profession, one must also become involved, learn to think for oneself, and have a desire to excel. An aspiring programmer must have integrity as well and be willing to devote long hours toward the goal of delivering the best possible code. Mind you, the code a particular individual delivers is unlikely to be perfect and it’s always possibly that someone else will write better code—I’m talking here about excellence within the individual’s ability to deliver it.

Anyone can perform a job. Only a few people have a profession. However, I’m not talking about a particular sort of profession. When Rebecca and I lived in San Diego, we’d go to a particular restaurant (the name escapes me at the moment, but the restaurant is no longer there anyway). There was a man named Kevin there who waited tables—it was his profession. You could see it in the way he performed the tasks of his trade—with enthusiasm, vigor, and more than a little subtle humor. You felt honored to be served by him and the lines were often long with people who specifically asked for him. Application development is a trade that requires no small amount of education, but I’ve seen more than a few people obtain the required skills by simply reading a book. The difference between a job and a profession remains the same—the professional takes responsibility for successful completion of the task and delights in seeing the task well-done.

While my previous post described a job, this one describes a profession. Many people have questioned why America has been losing it’s place in many different technology areas. First of all, I submit that statistics lie and often tell the story that they’re designed to tell. Don’t believe the lies that you read—think for yourself. Americans still have what it takes to create some of the most amazing technologies ever and I’ve discussed more than a few of these technologies in previous posts. If America has truly lost its edge, then where do these technologies come from? Second, far too many Americans are focused on getting a job, rather than a profession. When you view America of the past, you discover that we have had an array of professionals that delivered new technology is all sorts of ways—many never thought about before.

The bottom line is that you need to consider what sort of programmer you’re going to be as part of your journey. Education isn’t enough. If you really want to become a good programmer, then you must be willing to do what it takes to become a professional. As a professional, you’ll have a higher quality of life, discover the benefits of job satisfaction, and contribute to society in ways that you can scarcely imagine. So what do you have—a job or a profession? Let me know your thoughts at [email protected].

Review of ADO.NET 4 Step by Step

Microsoft has created a plethora of database technologies over the years. The managed form of ActiveX Data Objects (ADO) is just another in a long series of ways to access data from within an application. Because some older technologies, such as Open DataBase Connectivity (ODBC), are so entrenched, there isn’t any way that a single book can tell you everything there is to know about working with databases from a Microsoft perspective. When you add in all of the potential database products (SQL Server, MySQL, AskSAM, Oracle, DB2, and many, many others), the task becomes impossible. So, when I reviewed this book (supplied to me by the publisher), I didn’t consider completeness from the perspective of providing a single source solution to database management. In fact, given 25 years of experience, I feel that such a book is impossible to write—at least as a single useable volume. When shopping for a database management book, be sure you look for a book that covers both the required access technology (such as ODBC, ADO, or ADO.NET) and the database manager (such as SQL Server or MySQL) that you need for your project.

Tim Patrick has written ADO.NET 4 Step by Step with ADO.NET and SQL Server in mind. In fact, the book is incredibly focused and I applaud the author’s single minded devotion to this combination of technology and product. Other database books I’ve read just don’t seem to get the idea that watering down the message won’t work. While it might be possible to include multiple products in a book, trying to cover multiple technologies seldom works because there is too much to discuss and, even if the author successfully writes about each technology in an unbiased way, the reader tends to become confused. So the first thing you must know about this book is that it’s strictly about ADO.NET and SQL Server—try another book if you need any other combination.

This is the second Step by Step book that I’ve reviewed (see Review of HTML5 Step by Step for details of the other review). As with that other book, this book is heavy on hands on involvement and light on theory, which is just fine because many people learn better using hands on tasks. However, database management is a more complex task than creating a Web page because you have data integrity rules and other issues to consider that simply don’t come into play when working with a Web site. (To be fair, Chapter 12 does discuss data integrity, but mainly from a hands on perspective—you end up understanding how, but not what, why, or when.) I mention this because the hands on approach in this book does help you create applications fast, but it doesn’t provide you with everything you need to know to create good applications. For example, the discussion of ADO.NET components consumes a scant two pages. Database normalization is covered in a two paragraph sidebar in Chapter 2. The author is cramming a huge amount of theory in an incredibly small space and glossing over a lot of details. I would have liked to have seen some notes, tips, or sidebars with online resources as a minimum so the reader could fill in the missing theoretical details later.

The best part about this book is the activity. I was able to create a basic application in less than an hour—far faster than any other book I can remember using, even my own books. By the time you reach the end of Chapter 1 (about 15 pages), you’ve already learned how to create a connection to your data. Chapter 2 has you creating tables using several different techniques.

I loved the quick references at the end of each chapter. They act as a quick method of ensuring you got all of the details out of each chapter. If you read the entire chapter, you can go back to the quick reference later as a reminder of the things you learned.

Patrick provides a relatively good discussion of every aspect of managing the database and the information it contains using both C# and Visual Basic examples. Support for both languages is a good addition to the book. In addition, the support isn’t sporadic as it is in many books that favor one language or the other—you’ll find most information discussed equally in both languages so neither language feels like a second class citizen.

Chapter 8 does discuss external connectivity, but it feels like Patrick is discussing the topic from the perspective of the developer who normally uses ADO.NET exclusively, which is absolutely correct for this book. You’ll discover how to interact with OLE DB and ODBC data sources. Unfortunately, as with many other areas of the book, the author digs right into using the connections without providing any theory whatsoever. This is another area where it would have been nice to have resources provided so that the confused reader could learn more. Still, everything works as promised, so there is something to be said for that. Many readers don’t want to know how it works, they simply want to know how to do something black box style and this chapter fits in perfectly with that mindset.

For me, the highlight of the book was Chapter 16. In this chapter, the author cuts through all of the usual garbage associated with objects and shows the bare essentials to use technologies such as LINQ. This is possibly the shortest, yet best conceived, coverage of the topic that I’ve seen anywhere. Again, you’ll find yourself lacking theoretical details, but the how discussed in an elegant way that will enable most readers to make use of these newer technologies in an incredibly short time. In fact, Part IV of the book goes on to cover LINQ in detail. I’m convinced that LINQ will eventually become the data query technique of choice because it’s relatively easy to understand, requires little code, and generally produces optimized results with little effort on the part of the developer. Obviously, the author agrees with me on this matter.

Overall, ADO.NET 4 Step by Step is a fantastic book for teaching you the “how” of database management using SQL Server and ADO.NET. In fact, you’ll learn how to perform many tasks that other tomes simply leave out. However, if you want to know why you’re doing something, when to do it, or understand the theory behind a task, you’ll need another book. I recommend this book to anyone who wants to get started quickly. You can always obtain a theoretical book to fill the gaps in your knowledge and you experience programming scenarios you don’t understand. The best addition the author could make to a next edition is some online sources to help the confused reader. Writing a database management book is tough, but it’s important to recognize that there are limits to what you can do and provide the reader with help in overcoming those limitations.

More on CFL Usage

Readers came back with a few questions about CFLs after reading my CFLs for Free post. The one thing I want to get across clearly is that the article is emphasizing that you can buy new CFLs using the savings from previous purchases. You need to make the investment in the first CFL to get started and then use the savings from that investment to buy future CFLs. No one is going to mysteriously pay you to buy CFLs, but if you buy smart, you can indeed get future CFLs for free after making the initial purchase. Eventually, you’ll pay off the initial purchase using the savings as well.

A number of people asked about the startup surge (also known as inrush current). The startup surge is something that occurs when you first apply power to the light. This surge is extra electricity that’s required to get the bulb started. The amount of power the bulb requires decreases as it gets to operating temperature, which isn’t very long in most cases. Of course, some people are worried about this electricity surge as some people often think they are experiencing a power surge. Luckily, these two things are quite different. If a homeowner did experience a power surge, it would be worth them contacting a company like Safe and Sound Electric to install some surge protection to prevent this happening again. However, this bulb requires that extra surge, so don’t be concerned if you notice a quick surge. I’ve read a number of conflicting opinions about the startup surge of CFLs. My take on everything I’ve read is that the startup surge will vary by bulb vendor and type of light. A tube light has a smaller startup surge for a significantly smaller time than the twisted bulbs. Vendors who meet Energy Star requirements tend to produce bulbs that have a smaller startup surge than the less expensive bulbs.

A few readers also asked about long term efficiency of CFLs. From personal experience Rebecca and I have found that CFLs do provide an efficiency advantage if you use them for one long interval, rather than several short intervals. In other words, if you burn the light for four hours solid instead of two, two hour intervals, you’ll gain an efficiency advantage. In addition, turning the light on and off reduces its life expectancy.

Efficient energy use is why Rebecca and I tune our work schedule to follow the sun. We get up at 5:30 am (sometimes a bit earlier) during the summer months to make maximum use of the daylight hours, but we get up at 7:00 am during the winter months to ensure we won’t have to turn the lights on in the morning. The actual difference between summer and winter work times is 2½ hours due to the effect of daylight saving time. We do work later into the evening during the winter months to make up for the later start time, so everything evens out. Using this approach has had both health and monetary benefits, but we also understand that it’s not a solution that most people can use.

There are a lot of myths, misconceptions, and outright controversies about CFLs online. In addition, I’m finding that people have individual experiences based on how they use lighting in their home. However, after researching this topic intensively, I’m finding that the following tips about CFLs seem to be true for just about everyone:

Buying CFLs with the Energy Star label tends to pay dividends in reduced operating costs and longer life, but you must weigh these benefits against the increased initial cost. In general, buying Energy Star products save you money.
If you must use a CFL in a socket controlled by a dimmer, buy a CFL designed for that purpose. Using a standard CFL in a dimmer-controlled socket greatly reduces bulb life and could damage the dimmer.
CFLs require more air to work properly. They’re more heat sensitive, so putting one in a can or recessed fixture will result in a reduced life expectancy. The exception is that there are CFLs specially designed to work in recessed fixtures, but you’ll also pay a premium price for them.
CFLs also don’t like
damp or wet conditions. If you need to use a CFL in a damp or wet
condition, make sure you get one rated for that purpose.
Standard CFLs don’t work well in fixtures that vibrate, such as the lighting kits for fans. If you want to use a CFL with a fan or other fixture that will vibrate, you need to get a CFL designed for the purpose. (I finally gave up using a CFL in my garage door opener light socket because even the CFLs designed for use in vibration don’t last long in that particular application.)
Excessive on and off cycles in a given day will most definitely reduce the life expectancy of your CFL. I researched this one a lot and didn’t get a definitive answer for you. The most common guidelines say that you should strive to keep on/off cycles below 20 for any given CFL during one day. It’s commonly said that CFLs have a life expectancy of 7,000 on/off cycles if you observe the 20 on/off cycle per day limit. The source of problems in this case is the electronic ballast that CFLs use, which aren’t designed for heavy on/off cycles.
Faulty wiring affects CFLs considerably more than incandescent bulbs. If your wiring is such that it causes flickers or flashing with an incandescent bulb, it might be a cause for concern and you should probably look to get more info from an emergency electrician. Your CFL also won’t last very long in this instance. Even if you can’t see the flickering, small dips in power can cause early CFL failure. If you find that your bulbs aren’t lasting very long, have the power checked and bring in an electrical repair company similar to https://electricalsynergies.com/ to fix it. Faulty wiring also affects the cost savings from a CFL in a big way because the bulb never quite gets to its operating range.
Line noise will also affect CFLs. For example, if you have a heavy duty motor (such as a refrigerator) on the same line as a CFL, the drop in line current when the motor starts can affect the life expectancy of the CFL. Line noise will also affect the cost savings you see from a CFL because the bulb isn’t operating properly.

Some readers have pointed out that CFLs are overrated. I’m not quite sure how to respond to this question other than to say that there isn’t any free lunch. Just about every solution we now have for fixing the planet’s carbon problem is flawed. Even if we were to all go back to burning candles, there would be problems. However, I did spend some time online looking for something a bit less hysterical and a little more scientific than something that says CFLs and other modern technologies are bad. You should embrace CFLs and other good for the planet technologies with open eyes. The best post I found on these issues is one entitled, “Directory:Compact Fluorescent Lighting (CFL) Downsides.” If someone else has a non-hysterical source of additional information, I’d be happy to address it in another post.

I’d welcome verifiable tips from other people. I verified each of these tips against three sources (including government sites when available). That doesn’t mean that every tip will work for you personally, but most people find that these tips work for them. Let me know about any additional thoughts you have about CFLs at [email protected]

Review of Real Steel

Real Steel (starring Hugh Jackman and Evangeline Lilly) is a combination of two movie types I really like—science fiction and boxing. The synopsis of the movie sounds unique and in many respects, the movie is unique. However, once you see the movie, the first thing that comes to mind is that it’s faintly reminiscent of the Rocky movies. The movie is actually loosely based on a The Twilight Zone episode entitled, “Steel” (1963) penned by Richard Matheson (1956). Being a fan of the old television series (still being shown in some locations), I can see a faint resemblance to the way the show would have been put together, but don’t expect to see Rod Serling appear on screen.

Let’s get the required glitz review out of the way. The graphics in this movie are nothing less than spectacular in the fact that they look completely normal. There is a certain amount of flashing lights, explosions, and the like, but for the most part, this movie could happen in your neighborhood today. It’s this lack of over-stimulation that draws you into the movie. You find yourself believing that someone you know could be boxing robots. Whoever put the graphics together and came up with the creative ideas for this movie is amazing. I had expected eye popping effects and instead got normal, which actually suits this movie quite well.

The value of this movie is in the plot. Emotions run high because the plot is quite good and well acted. You find yourself wanting to cheer, cry, and yell all in a matter of minutes. Charlie Kelton (Jackman) ends up taking care of his little boy, Max (Dakota Goyo), after literally ignoring him all of his life and then selling him to his sister-in-law. Max is understandably upset at first, but then something happens—he gets interested in his own robot boxer. Even though Charlie is a complete loser on his own, when coupled with Max he becomes a winner. I don’t want to ruin the plot of this extraordinary film, but you can imagine what happens next.

Most of the performances in this movie are a little over the top, but well acted. The only actor that didn’t quite do the job was Evangeline Lilly (Bailey Tallet in the film). I found her performance a bit weak. It was almost as if she was overawed by Jackman. She did play an important part, but the performance could have been better—more believable. It wasn’t until the end of the movie that I felt a bit for her character, but by that time I was almost too busy cheering Charlie and Max to really notice. It was a case of too little, too late.

If you like science fiction, boxing, or simply a well-acted emotional movie, you’ll like Real Steel. It has few warts and a lot to recommend it. I just hope that they don’t ruin this movie by coming out with a sequel.

Security Implications of the AT Command

I read the security post provided by Roger Grimes with interest this morning because I’ve always felt that the Task Scheduler is just another entry point for viruses and the like on any system. As he mentions, it’s an avenue that many administrators fail to check because they don’t really think about it. As Roger points out, there are three ways to add new entries, but this post focuses on the oldest of the three, the AT command.

Before you can interact with the Task Scheduler, you must have its service started. This is a given on Vista and Windows 7, where Windows relies heavily on the Task Scheduler. However, you’ll want to read my Interacting with the Task Scheduler Service for details about this service. It’s important to have the service setup correctly in order to work with it error free.

The AT command is the oldest way of working with the Task Scheduler. At one time you could access it from the command prompt even if you weren’t an administrator. This meant that any virus or other piece of nasty software could cause woe without notice on your part. However, if you try to use the AT command at a normal command prompt in Windows 7, you’ll receive an Access Denied error message, which is at least a start in the right direction.

To use the AT command to create a new entry, you must provide a time and command as a minimum. For example, if you type AT 15:00 “Dir C:\” and press Enter, you’ll create a new task that starts at 3:00 pm on the current day. You’ll receive a numeric identifier for the task. The entry also shows up in the Task Scheduler console (found in the Administrative Tools folder of the Control Panel) as At plus the identifier, such as At1 as shown here.

If you want to list the jobs created by the AT command, you type AT and press Enter. The AT command only lists those jobs that it creates—you won’t see any jobs created using other Task Scheduler techniques.

Likewise, to delete jobs using the AT command, you provide the identifier you received when you created the job along with the /Delete command line switch. For example, if the identifier for the task you created earlier in this post is 1, then you’d type AT 1 /Delete and press Enter. In this case, the AT command doesn’t provide any output. In order to verify that the job is actually gone, you must type AT and press Enter. Here’s what the command output from this session looks like.

The true power of AT lies in remote access. For example, if you have an Administrator command line open, have a server named WinServer on your network, and possess administrator privileges on that server, you can type AT \\WinServer 15:00 “Dir C:\” and press Enter to create a command that starts at 3:00 p.m. (local time) on WinServer. It’s important to realize that the command will execute when it’s 3:00 p.m. on the server, not 3:00 p.m. on your system. You can likewise list and delete remote entries using the same commands you’d use for local entries. Again, the Task Scheduler console will display these entries, but only on the host machine (so you’d need to access that system remotely to see it from your local computer).

Windows 7 does make it harder to use the AT command, but not impossible. If an outsider should gain access to an account with administrator privileges, it wouldn’t take long for a virus to add all sorts of nasty commands to every machine on the network. As Roger comments in his post, administrators need to exercise vigilance in order to catch potential security issues such as this one. Let me know if you have any questions at [email protected].

Cutting Up a Chicken

When you raise your own chickens, you eventually end up with a lot of whole chickens in your freezer and will need to cut at least a few of them up for use. Most people are used to seeing chickens already cut up for use in the store. If you do get a whole chicken, it’s usually with the idea that you’re going to roast it whole. In many cases, people don’t know where to begin cutting a chicken up for use because the butcher has done it for them for so many years. Following the chickens you find in the store as an example won’t work very well either because they’re cut up using a meat saw (think of a band saw specifically designed for cutting meat). Unless you also have a meat saw, you probably won’t be able to follow the butcher’s example. This post describes how to cut up a chicken using nothing more than a standard utility knife.

I recommend using a 6-inch knife with a fairly stiff blade. A boning knife will be too flexible and something small, such as a pairing knife, won’t give you enough leverage. Don’t use a knife with a serrated edge—the serrations will make for a poor cut and you won’t be able to split the breastbone with such a knife. The knife you use should be sharp—the sharper the better. A dull knife is dangerous to use.

Start with the wings. Your cut should begin behind the joint area. When you lift the wing up, you’ll actually see a bit of the flesh come up with it. Start your cut immediately behind this fleshy area and angle toward the joint as shown here.

Cutting the wings in this way has the advantage of making them a bit meatier. After you cut off both wings, it’s time to cut off the combination of the leg and thigh. Start by lifting the thigh and cutting toward the joint from the front of the chicken as shown here.

Once you get to the joint from the front, you’ll need to cut to the joint from the back as well. When this cut is finished, you’ll be able to rotate the leg/thigh combination downward and see the joint pop from the socket as shown here.

You can finish the cut at this point. Remove both leg/thigh combinations using the same approach. Now you can separate the leg from the thigh. There is a natural division between the leg and the thigh. If you look carefully, you can actually see where the two separate because the meat goes in two directions. Look carefully at the following picture and you’ll see that the line shows this separation.

Cut straight down through this point and you’ll find, with practice, that the knife will neatly separate the meat at the joint. At this point, you’ve cut off the wings, legs, and thighs. It’s time to remove the lower back (the part with the tail).

Look inside your chicken. You’ll see that there is a fleshy part between the rib cage and the lower back. The fleshy part extends on both sides of the chicken. You’ll cut through this fleshy part to separate the lower back starting midway at the opening as shown here.

Cut through the fleshy part. You should then be able to flex the lower back and see the backbone separate from the rib cage as shown here.

You can then cut through the spinal cord to separate the lower back from the rib cage. Cut straight down.

The hardest cut to make is to separate the two breast halves. However, like many things in life, there is a trick to it. Look at the center of the breastbone and you’ll see a line runs through it. Now, look at the first complete rib and trace it around to where it meets with the breastbone. You’ll see a second line of a sort that forms a cross as shown here.

Put the tip of the knife through this point and you’ll find that the breastbone cracks easily. Now, draw the knife down much as you would with a paper cutter. You’ll find that the knife easily slices through the majority of the breastbone and the cartridge as shown here.

After you make this cut, move your knife higher up. Don’t put it through the hole where the neck is, but do place it higher into the cavity. Use the point to finish breaking the breastbone apart. At this point, you should also be able to break the wishbone in half. Now you can separate the two halves of the breast like this because there is cartilage separating the breast from the upper back.

Cut the cartilage holding the upper back to the breast halves. You’ll reach another joint after you cut the ribs. Separate the joint and the cut through it as shown here.

You should now have ten pieces of chicken as shown here:

These pieces are: left and right wing, left and right leg, left and right thigh, lower back, upper back, and left and right breast. Although this combination doesn’t look quite like the chicken you get in the store, it’s the most effective means of cutting a chicken up using just a utility knife. In addition, using this approach makes more of the pieces a usable size. Let me know if you have any questions at [email protected].

Creating Raw Juice for Wine Making

Earlier this year I created a series of posts about making wine using the cubicontainer technique that relies on a single container, rather than using two containers for primary and secondary fermentation. This approach requires that you use juice, and not raw fruit/vegetables, as the source for the wine. Most people think that you can make juice only from a raw source, such as crushing grapes. However, wine makers know that you can use both raw and cooked juice. This post shows how to work with raw juice—pears in this case. If you haven’t read the wine making series of posts, you can find them at:

When working with any fruit for raw juice, you need to pick the fruit at the peak of ripeness. In the case of pears, this means smelling the fruit for the distinctive pear odor. The fruit should still be firm, but crush easily in the hand. Taste the fruit and you should smell a strong pear odor, along with a high sugar content. Check the inside for an off white appearance. If the fruit seems starchy, the inside has yellowed or browned a bit, or seems mushy to the touch, it’s overripe and won’t make good wine. Likewise, if the fruit is still greenish in color, seems a bit too firm, or lacks the strong pear odor, it isn’t ripe enough. Every fruit has its peak time for picking that typically last one or two days. That’s right—you must check the fruit absolutely every day or you’ll miss the perfect time to pick it.

In order to create the juice, you begin by running the raw pears through a Victorio Strainer. You need to be absolutely certain that the pears are ready for use in wine. Pears that aren’t ripe could damage your strainer. Normally, the juice turns a bit brown as you strain it due to oxidation and the presence of bacteria. In this case, you’ll prevent that from occurring by adding a campden tablet to the output of the Victorio Strainer and stirring the juice from time-to-time as you strain the juice. The result should be a slightly greenish yellow juice as shown here.

However, this juice isn’t ready for wine making yet. It still contains a substantial amount of pulp. You need to make at least 2 quarts of strained pear juice to obtain 1 quart of juice ready for wine making. The next step is to place a jelly bag over a 1 quart measuring cup like this:

Pour as much of the strained juice into the jelly bag as possible. Now you’ll squeeze the bag to separate the pulp from the juice like this:

Once you have a quart of juice, you can use it immediately to make wine or freeze it for later use. A quart of pear juice will make one gallon of wine using the wine making techniques I discussed earlier. If you decide to freeze the juice, make absolutely certain that you mark it for wine use only because the juice already has the campden tablet in it.

This same technique works fine for any fruit that gets soft enough when ripe to put through the Victorio Strainer. For example, it works great with berries. However, I haven’t ever gotten this technique to work properly with apples—most apples are still too crisp when picked to get through the Victorio Strainer successfully. Apple wine requires the use of a cider press or the cooked juice method. Other fruits, such as rhubarb, require the cooked juice method. You can use this technique for some vegetables as well. This is the technique I use to make tomato wine. If you want to work with a harder vegetable, such as beets, then you need to use the cooked juice method. (I’ll describe the cooked juice method in a future post.) Let me know if you have any questions about this technique at [email protected].

Exercising Personal Privacy

In my post, “Is Privacy a Right?,” I tell developers that they really need to consider the right of the user to a certain amount of privacy. Books such as C# Design and Development will need to include sections on privacy as part of any update. In fact, privacy is a topic not covered to any extent in any development book on my shelf. The few mentions of privacy appear in older books I’ve written, along with a few moldy references to old books by other authors. If you really want to get a modern treatment of privacy as a question of what the individual requires, you need to look at a non-development book such as “Alone Together: Why We Expect More from Technology and Less from Each Other.” Unfortunately, this book discusses social ramifications—not the techniques a developer uses to ensure privacy. Of course, no matter what the developer does, the user can always thwart any effort to provide privacy, which is the topic of this post.

I find it amazing that people willingly give up their privacy for apparently little or no reason. I read John Dvorak’s post, “I’m Not Home Right Now. Please Come In.” with great interest this morning (after having read the news report that he discusses). The idea that a husband would be able to check up on his cheating wife through an iPhone application is amazing to me. The private detective industry should take note that they’ve been replaced by a phone. It won’t be long before someone comes up with an application to surreptitiously take pictures of the dupe who loads one or more of these applications on their cellphone.

After thinking about this issue for a long time, I’ve come to the conclusion that some people have watched one too many episodes of CSI (and shows of that ilk). There is a sense that someone is going to reach out and grab each of us, and that our cellphones are the only way anyone will find us again. It’s also human nature not to be left out. If people don’t know where we are, we might miss out on something that we think is important at the time, but turns out not to be much of an issue at all in hindsight. I’m sure that little Jerry can find his sock just fine without dad’s intervention over the telephone (a little self-sufficiency does everyone good). The announcement that Maggie has a new tooth can easily wait until mom gets home from the store.

There should be alarm bells going off in the minds of every person who currently owns a cellphone, OnStar, or any other tracking technology. Do you really want someone to follow absolutely every move you make in the interest of providing some uncertain sense of security? Privacy, once lost, is incredibly hard to regain. People should learn how to disconnect in comfort, keep their privacy intact, and discover the wonderful world of being alone every once in a while. I think you’ll find that you’re a lot less stressed once you get used to it. Consider Remembering to Rest as not just beneficial to yourself, but those around you.

Most of all, it’s time that people learn to demand privacy from their technology. Whoever created the new tracking application in the iPhone wasn’t thinking and people should disable it sooner than later. It’s not necessary for vendors to track your every move online. No one gains anything by knowing you’ve gone to the store to buy this week’s groceries. All of the applications that are tracking you are stealing your privacy and making you a target for all of the things you fear most. Don’t give criminals (or marketers) an edge. What is your privacy worth to you? Let me know at [email protected].

Celebrating with Birthday Butter

Rebecca grows quite a few herbs. In fact, the majority of herbs used in our house come from Rebecca’s garden and not from the store. People have asked us in the past how to use these herbs. Of course, there are the mundane uses of savory herbs (such as sage) in meat dishes and sweet herbs (such as mint) in cakes and cookies. However, if you’re really interested in shaking things up, you mix the herbs in new and interesting combinations. That’s what I decided to do in making birthday butter.

Birthday butter was actually created for Rebecca’s birthday. I used it for her breakfast. I spread the birthday butter on a bagel, but it tastes just fine on toast, crumpets, English muffins, or any other sort of bread. In this case, I filled the holes in the center of the bagel halves with cherry tomatoes to dress it up a bit. The result is an interesting mix of savory and sweet that is a delight to the palette. Here’s the birthday butter recipe:

1/2 cup	Butter, Smart Balance, or Margarine
2 tsp	Sugar or Splenda
2 tsp	Rubbed Sage
1 tsp	Mint Leaves
1 tsp	Lemon Juice

Cream the butter in a bowl. Place the remaining ingredients in the bowl. Mix together until blended. The lemon juice will have a tendency to separate from the rest of the mixture, so remixing is needed if you store the unused portion.

I found that butter works far better for this recipe than margarine does. We’ve actually tried something new, Smart Balance Buttery Sticks with Omega 3 Fatty Acids. This product is half butter and half margarine. It cooks extremely well and tastes much like butter does. However, it significantly reduces the amount of cholesterol you receive and the Omega 3 fatty acids are actually good for you. I’m not sure how this recipe would work using other alternative sweeteners, but the results with Splenda are quite good.

The kind of mint you use has a big impact on the taste of birthday butter. Try various mint varieties out to see for yourself. The original version uses spearmint, but peppermint or even wintergreen would probably work just fine. For something unusual, try orange or lime mint.

The best way to get the ingredients to mix properly is to use a mixer. However, I’ve been able to get them to mix just fine using a fork. The point is, this butter blend has a wonderful taste and is a great way to start the day. How do you use your herbs? Let me know at [email protected].

S	M	T	W	T	F	S
					1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30