Fun is Where You Find It!

There are many aspects to the self-sufficient lifestyle. One aspect is that you don’t have a lot of money for entertainment. However, if you’re self-sufficient, you quickly find that the fun aspect of entertainment has nothing to do with cost. Rebecca and I often entertain ourselves for free (or at least, next to free). So it was this past Saturday as we prepared for Easter. Every year we decorate some eggs for ourselves. Last year we used bought a glitter kit from the store, which didn’t work out as well as we would have liked (the glitter ended up on everything), but did produce a nice result. (I definitely wouldn’t mind trying it again, but would probably do things a bit differently this time.)

This year we used a Paas tie-dye kit to create some colorful eggs that are far less messy and store well too. Our total cost was about $4.00, including the eggs and we ended up with a second set of dye pellets leftover. Perhaps we’ll dye some eggs using the extra pellets during vacation this summer. The tie-dye kit was a tiny bit messy, so I wouldn’t recommend it for younger kidsat least not if you don’t want everything, including the kids, dyed spectacular colors. Here are the results we achieved:

EasterEggs

As you can see, they’re quite fancy and looked nice displayed in egg cups on the table (the holder shown in the picture was used only for drying). To get this effect, you wrap a piece of material around the egg, place the egg in a special holder, and inject colors using a syringe type device into holes in the holder. It took between 2 and 3 hours for us to complete the task. During that time we had a lot of fun and laughs, especially when a set of colors would produce unexpected results. We found that you need to leave the egg in the holder for a few minutes after injecting the colors to obtain optimal results. The bottom line is that you can have a ton of fun for nearly nothing if you try. So, how do you have fun on a budget? Let me know at John@JohnMuellerBooks.com.

 

CodeBlocks on a Macintosh – Part 2

In an earlier post I had provided what I had hoped were great instructions for getting CodeBlocks to work on a Macintosh so that you can work through the examples in C++ All-In-One Desk Reference For Dummies. The instructions do, in fact, work for most people, but they don’t work for everyone. So, part of the reason for this post is to ask for your input. If you’re a Mac user who has encountered problems getting CodeBlocks to work, but solved the issue in a way that differs from my previous post, please let me know all the details about your technique (including the symptoms and step-by-step solution) at John@JohnMuellerBooks.com.

In the meantime, I have discovered a few new pieces of information. For one thing, you can verify that you have the GNU GCC compiler installed by opening a terminal, typing gcc -v, and pressing Enter.  If GNU GCC is installed, you should see some version information along with some compiler instructions. A failure message will look something like this:

My-MacBook-Pro:~ someone$ gcc -v
-bash: gcc: command not found

If you don’t have the GNU GCC installed, there seems to be all sorts of conflicting information online on how to resolve the problem. Most of the advice suggests a rather lengthy download and installation process because apparently GNU GCC isn’t shipped with all versions of the Mac (I’m of the opinion right now that it definitely didn’t ship with any Mac OS X version prior to 10.4, which is why the download at http://www.codeblocks.org/downloads/5 won’t work in this instance and doing things like resetting the compiler will also result in failure.)

One of the best pieces of advice I can offer is to check the CodeBlocks Wiki for Mac-specific information. The current advice is to download the Xcode developer tools from http://developer.apple.com/technologies/tools/, which apparently is a large downloadin excess of 4 GBso be prepared to do something else while you wait. I found similar advice on sites such as Tech-Recipes and the nixCraft forum. If you have a better solution, please let me know and I’ll be all too happy to share it here on my blog.

As a final note, if someone could let me know the actual installation directory for GNU GCC on the Mac, I’d really appreciate it. I understand that the installation directory is probably /usr/bin/gcc, but I’d like to be sure.

 

Using a Horizontal Web Site Layout

A friend recently wrote to me regarding an issue with Web site layout. Of course, I’ve dealt with Web design issues in a number of my booksmost notably C# Design and Development and Accessibility for Everybody: Understanding the Section 508 Accessibility Requirements. If you look at most Web sites today, they all have three serious problems:

 

  • The line length is too longforcing the eye to work extra hard to read the material because the eye loses track of the line and actually making it tiresome to review the material.
  • The page contains too much material, which makes it tiresome for anyone working with a screen reader to listen to all the material before finding the one bit of information actually required from the site.
  • The use of vertical scrolling is contrary to the historical use of horizontal scrolling. If you look at how people worked with scrolling in ages past, it was always horizontal, making it easier to read the material.

She even sent me two articles that describe the problem in greater detail. The first article is entitled, “Are Horizontal Website Layouts the Wave of the Future?” and points out that research shows that most people don’t even read the excess material on a Web site. If nothing else, the strong research showing that my efforts are being wasted would tend to make me rethink my design. The second article is entitled, “Horizontalism and Readability” and it places more emphasis on the historical approach to horizontal layout, rather than focus on modern research. I tend to prefer tested approaches to presenting information when I can get them (new ideas are fine for someone else to test).

Of course, a Web site is not the same as printed material. Trying to equate the two could very well be a mistake. Here is my take on how the mediums differ:

 

  • The method of presentation differs. You’re not relying on paper, you’re using a video screen of some sort and that does make a difference in how the reader perceives the material.
  • The environment differs. I don’t usually sit in my easy chair next to the fire when I read materials online. I’m normally in my office in a formal work environment.
  • The approach to reading differs. My paper reading environment is relaxed and long term. It’s nothing for me to spend an entire day reading a good book. My online reading is more like a sprintI find what I need quickly and never read for more than a half hour at a time.
  • The technology differs. When I read a book, I get print in one size. So, if the print is less than appealing or causes eye fatigue, I’m just stuck with it. My browser allows me to change the font size a Web site uses so I can make the print eye friendly. In fact, I can even use a CSS file to change the typeface and other features for some Web sites.

The obvious question now is whether the two environments differ enough that considerations normally made for paper don’t apply to Web sites. My thought is that creating Web sites with smaller amounts of material, eye friendly design, and shorter columns are all great ideas, but I’m not completely sold on the idea of horizontal scrolling. What is your take on this idea. Let me know at John@JohnMuellerBooks.com.

Simulating Users with the RunAs Command

One of the problems with writing applications, administering any network, or understanding system issues is to ensure that you see things from the user’s perspective. It doesn’t matter what your forte might be (programmer, administrator, DBA, manager, or the like), getting the user view of things is essential or your efforts are doomed to failure. Of course, this means seeing what the user sees. Anyone can run an application at the administrator level with good success, but the user level is another story because the user might not have access to resources or rights to perform tasks correctly.

Most knowledgeable users know that you can simulate an administrator by right clicking the application and choosing Run As Administrator from the context menu. In fact, if you Shift+Right Click the application, you’ll see an entry for Run As A Different User on the context menu that allows you to start the application as any user on the system. However, the GUI has limitations, including an inability to use this approach for batch testing of an application. In addition, this approach uses the RunAs command defaults, such as loading the user’s profile, which could cause the application to react differently than it does on the user’s system because it can’t find the resources it needs on your system.

A more practical approach is to use the RunAs command directly to get the job done. You can see some basic coverage of this command on page 480 of Windows Command-Line Administration Instant Reference. To gain a basic appreciation of how the user views things, simply type RunAs /User:UserName Command and press Enter (where UserName is the user’s fully qualified logon name including domain and Command is the command you wish to test). For example, if you want to see how Notepad works for user John, you’d type RunAs /User:John Notepad and press Enter. At this point, the RunAs command will ask for the user’s password. You’ll need to ask the user to enter it for you, but at that point, you can work with the application precisely as the user works with it.

Of course, many commands require that you provide command line arguments. In order to use command line arguments, you must enclose the entire command in double quotes. For example, if you want to open a file named Output.TXT located in the C:\MyDocs folder using Notepad and see it in precisely the same way that the user sees it, you’d type RunAs /User:John “Notepad C:\MyDocs\Output.TXT” and press Enter.

In some cases, you need to test the application using the users credentials, but find that the user’s profile gets in the way. The user’s system probably isn’t set up the same as your system, so you need your profile so that the system can find things on your machine and not on the user’s machine. In this case, you add the /NoProfile command line switch to use your profile. It’s a good idea to try the command with the user’s profile first, just to get things as close as you can to what the user sees. The default is to load the user’s profile, so you don’t have to do anything special to obtain this effect.

An entire group of users might experience a problem with an application. In this case, you don’t necessarily want to test with a particular user’s account, but with a specific trust level. You can see the trust levels setup on your system by typing RunAs /ShowTrustLevels and pressing Enter. To run an application using a trust level, use the /TrustLevel command line switch. For example, to open Output.TXT as a basic user, you’d type RunAs /TrustLevel:0x20000 “Notepad C:\MyDocs\Output.TXT” and press Enter. The basic trust levels are:

 

  • 0x40000 – System
  • 0x30000 – Administrator
  • 0x20000 – Basic User
  • 0x10000 – Untrusted User

Many people are experiencing problems using the /ShowTrustLevels and /TrustLevel command line switches with newer versions of Windows such as Vista and Windows 7. The consensus seems to be that Microsoft has changed things with the introduction of UAC and that you’ll need to work with the new Elevation Power Toys to get the job done. I’d be interested in hearing about people’s experiences. Contact me at John@JohnMuellerBooks.com.


A Quick Method for Adding Custom Ribbon Elements

Everyone knows that the days of the CommandBar are gone. Sure, you can still use the CommandBar in your VBA applications, but the result is less than spectacular. All of the entries end up on the Add-Ins tab of the Ribbon. Consequently, even though the code in Listing 12-2 of VBA for Dummies still works just fine, you end up with this addition to the Add-ins tab as a result.

ProgrammingRibbon01

Even the icon is correct from the listing, so the code does indeed work, but it isn’t as nice as it could be. Of course, you could create a true Ribbon addition for your VBA application. Starting on page 266 you discover the incredibly convoluted and horribly difficult technique to add a real addition to the Ribbon in Office 2007. The results really are quite nice and you obtain the full functionality that the Ribbon provides. However, unless you have a lot of time to spend working through these steps, you’ll quickly learn to dread the entire process.

Fortunately, Office 2010 offers a middle ground approach. The results really are Ribbon-specific and you do have some flexibility in how the buttons appear, but there are still a few limitations. Let’s look at what you need to do to obtain this middle ground result. The first phase is to create the buttons you want to use with the application and export them to a file so you can modify their appearance. Uses these steps to accomplish this task.

  1. Create your macros as normal. The example uses these two very simple macros.
    Sub SayHello1()
        MsgBox "Saying Hello From SayHello1"
    End Sub
     
    Sub SayHello2()
        MsgBox "Saying Hello From SayHello2."
    End Sub
  2. Attach the macros to buttons using the technique shown in my “VBA in Office 2010” post. The example uses the setup shown here:
    ProgrammingRibbon02
  3. Check your results. You’ll likely see something like this where the buttons are all large and not very attractively set up:
    ProgrammingRibbon03
  4. Choose File > Options to display the Options dialog box. Select the Customize Ribbon option so that you can see the Ribbon configuration again.
  5. Choose Import/Export to display the import and export options. Select Export All Customizations to display a File Save dialog box where you can save the customizations to disk.
  6. Type a name for the file, such as MyCustomization.exportedUI and click Save. At this point, you have an XML file containing your customizations.

Open the file using an XML editor or even Notepad. Any text editor will do fine. For the example, I’m using Notepad to make things a bit clearer. What you’ll see inside is going to be messy because Office won’t add any carriage returns or white space to make the text easier to read. Adding these features won’t invalidate the file. Here’s the result from the example:

ProgrammingRibbon04

Most of this code isn’t important to the example, but it’s all functional. Let’s say you want to use icons that aren’t supported directly in the Options dialog box and you also want to use medium sized icons. You can make both changes quite easily now. First change the <group> element to allow custom sizing by changing the autoScale property to read autoScale=”false”. Second, change the <mso:button> elements to look like this:

<mso:button idQ="x1:Book1_SayHello1_0_16A6B4C"
            label="Say Hello 1"
            imageMso="AnimationAudio"
            onAction="SayHello1"
            size="medium"
            visible="true"/>
<mso:button idQ="x1:Book1_SayHello2_1_16A6B4C"
            label="Say Hello 2"
            imageMso="WorkflowPending"
            onAction="SayHello2"
            size="medium"
            visible="true"/>


Notice that the buttons are now medium sized and are using icons that aren’t normally supported by the Excel Options dialog box. To see the results of these changes, reopen the Customize Ribbon folder of the Excel Options dialog box. Choose the Import Customization File option of the Import/Export drop down. Excel will ask whether you’re sure that you want to replace the existing Ribbon and Quick Access Toolbar customizations. Click Yes and you’ll see the changes added to your Ribbon. Close the Excel Options dialog box and you’ll see something like this:

ProgrammingRibbon05

Notice that the buttons now use different icons and they’re arranged differently. You can use this approach to create a customized look to this much simpler approach for dealing with the Ribbon. Make sure you get the Office 2010 Icon Gallery or the Office 2007 Icon Gallery to obtain usable icon names to use for your applications.

Of course, there are always limitations. So far I haven’t figured out how to use other kinds of controls. For example, I can display a toggle button just fine by changing the <mso:button> element to an <mso:toggleButton> element, but the resulting control isn’t functional. With any luck, I’ll eventually figure out techniques for working around these issues, but this post is a good start. Let me know if you try this technique out and what additions you can figure out for it at John@JohnMuellerBooks.com. You can download the example files, if desired, to see how things work.

Easter Bunnies

Spring heralds many things at our homestead. Of course, you’ve already seen the flowers, Early Spring – The Garden and Orchard, and budding trees. Today’s post is about our Easter bunnies. Because they require so little space, we raise rabbits. Each spring the does are bred and usually have their babies around spring. The gestation period for a rabbit is between 28 and 35 days, with 31 days being the average. We’ve found that our rabbits will often time the birth for a warmer dayjust how they know is a mystery to us, but the weatherman could probably take a few clues from them. The first clue we have that the does are about to have babies is that the does start pulling hair and fluffing it up in their nest box like this:

Rabbit01

The doe usually has her babies within 24 hours of pulling her hair, but I’ve seen it take a little longer. We normally watch the nest box carefully after the hair pulling to try to determine when the babies are born. We’re extremely careful not to disturb the babies at all for several days after the birth. After that, we gently pull away a little of the hair using a stick (human scent will keep the mother from taking care of her babies). Here are the two day old babies of Rocky Raccoon (she has raccoon markings on her face):

Rabbit02

These babies were quite active and healthy, so they were a little hard to catch with the camera, but you can see them under all that hair. We were quite careful not to touch them or anything in the nest box. Afterward, we carefully covered them back up because they can take a chill pretty easily at this point.

Whether we get a look at all depends on mother bunny. If she looks at all concerned, we leave the babies completely alone. Some mothers will thump to show their displeasure at our peeping. Normally, they’ll let us take a look a bit later, usually within a few days. Happy Easter from the farm!

 

Inheriting Someone Else’s Code

In my book, “C# Design and Development,” I propose a lot of management techniques that could apply to any language. In fact, I’ve used the techniques in this book successfully for years with Visual Basic, C#, IronPython, C++, and PHP, among many others. The idea behind the concepts in this book is to create code that performs well from the outset and is easy to maintain when changes are required. In today’s environment, you can count on changes at some point. There are many reasons to expect changes:

 

  • The business is bought by someone else and the code must be integrated into a new system.
  • A change in some other component necessitates a change in the application (such as the changes in Vista and Windows 7 security).
  • The business has grown and now needs new features to support its customers.
  • Modifications in the law mean changes to the way the application interacts with data.
  • Technology changes in such a way that the application no longer works properly.

In fact, the reasons for change are endless. I could probably continue writing reasons for change for hours and not cover even a small number of them. The point is that applications will change at some pointit’s simply a matter of time.

If you’ve written code for any time at all, you know that feeling in the pit of your stomach when you discover the perfectly lucid comments you wrote at the time you created the application are no long lucid now. Worse still, the documentation you put together doesn’t tell you what you did and why. Still, after a few hours of looking at your comments and documentation, you can usually begin to fit the pieces together of an application you created because you can recreate the thought patterns you had when you designed and wrote it in the first place.

However, what happens when you’re part of a team or you’re working on an application that someone else designed? Now there isn’t any way to “get back into the groove” of what you did in the past. The thought processes are foreign, so the comments and documentation have to be as comprehensive as possible. Even with great comments and documentation, it’s going to take a while to get up and running with the code.

The longer it takes you to recreate the ideas that went into creating the code, the longer the project update languishes and the more extreme management’s position becomes. The only thing that management knows is that your application (the one you inherited from someone else) is costing the business money. Not only is there a cost associated with the update, but the delay costs the organization money too. Users who have to fight with an outdated application are always unhappy and aren’t productive. So, what techniques can you use to become productive as quickly as possible? That’s what I’d like to know as well. Obviously, reading the documentation and comments are two pieces to the puzzle, but what other techniques do you use?

I’m currently putting an article together that discusses this topic in detail and I’d like to hear about your techniques. If you’ve ever been frustrated by someone else’s code, write me at John@JohnMuellerBooks.com. I’ll let you know when the article is published on Software Quality Connection

 

Dune

Dune is an amazing read that’s hard to strictly categorize. Most people say that it’s a science fiction book, which I guess it is to a certain extent. After all, it does take place in the future when mankind has moved out into the solar system and colonized many worlds. The book takes place so far into the future that all knowledge of man’s origins has faded into obscurity. There are certain technology elements to the book, but you won’t find robots, space battles, or anything of that sort. In fact, the author deliberately downplays technology and offers technology run amok as a reason for man’s venture into an almost anti-technology society.

In some respects, Dune is a fantasy. You’ll find mention of the strange spice melange which imparts almost magical characteristics to those who indulge in it (and almost everyone in the book does to some extent with differing effects). The backdrop for the book reads somewhat like a Gothic novel with kings and queens. The main character is a duke seeking to repair an incredible wrong done against his family. The book is also filled with the mythical creature, a sand worm that’s so large that people can ride it. Dune is a desert planet and it invokes a somewhat romantic view of the difficulty of living in such an environment.

However, in its innermost being, Dune is a book about political intrigue and the author, Frank Herbert, does an amazing job of creating a twisted plot. Because this book is a bit complex, some people will find it hard to read. Still, once you get into the meat of the book, you’ll find that it keeps your interest. Dune is for someone who likes almost Machiavellian complexity and doesn’t particularly relish a book with little substancemere mind candy.

The book has a strong cult following and you’ll find many follow on editions for it. In fact, two movies have come out about Dune in the past. The first is a shorter version (a little over 2 hours for the original theatrical offering) that stars Kyle MacLachlan, Virginia Madsen, Francesca Annis, Leonardo Cimino, and Brad Dourif. This version also includes Patrick Stewart before he became famous as the captain of the Enterprise in Star Trek. The second is a longer 265 minute version that stars William Hurt, Alec Newman, Giancarlo Giannini, Uwe Ochsenknecht, and Saskia Reeves.

Both theatrical versions of Dune diverge from the original book plot in a significant waythe book doesn’t spend much time discussing the action in battles, while the movies seem to focus on it to an extent. In fact, Frank Herbert is apt to simply say that the battle occurred and that a certain party won. Consequently, the movies and the book both have something to offer and are different presentations of the same plot. I enjoy all three and plan to review the movies at some point.

Dune is the sort of book to get if you want to become totally immersed and forget your cares for a while. The writing is good and you won’t find yourself distracted by inelegant prose. When you’re done, you’ll definitely find yourself wishing for more (and fortunately, there is more to be had in tomes such as Children of Dune).

 

Using the PTVS for a WPF Project

As with Silverlight, there is no mention of theWindows Presentation Foundation (WPF) in my book, “Professional IronPython.” The WPF is supposed to help solve some display problems for application developers and allow better use of modern graphics processors. Microsoft has provided a significant amount of information about the WPF that I won’t be discussing in this post. Whether you find WPF helpful or not depends on the kind of applications you create. I’m sure that WPF will find use in game applications, widgets of various sorts, mini-applications, and a host of other uses, but I’m not sure just what it adds to the common business application, such as a data entry application. Still, WPF is an exciting new technology that you should investigate.

As with the Silverlight project in my previous post, you need to have the PTVS installed on your system to work through this example. To begin this example,
you start Visual Studio as normal and choose File | New to create a new
project. The New Project dialog box should contain an entry for a Wpf Application template as shown here. If you don’t see
this template, then you probably don’t have IronPython 2.7 installed on
your system and can use the instructions found in the IronPython 2.7 and PTVS blog entry to install it.

WPF01

The example will accept the default name for the project. Of course, you can use any name that you’d like. Click OK. You’ll see a new WPF application. However, for some odd reason, the eXtensible Application Markup Language (XAML) (pronounced zammel) file doesn’t always open, so you’ll have to open it manually. At this point, you’ll see a project similar to the one shown here.

WPF02

The top half of the designer shows what the page will look like, while the bottom half shows the associated XML. As you add controls to the form and configure them, you’ll see the changes in the XML, making it easy to code changes to the controls when necessary. Of course, you can choose to display just the Design window or just the XAML window if desired. Depending on the amount of screen real estate at your disposal, collapsing one of the panes by clicking Collapse Pane at the right side of the window, may be a good idea.

One of the advantages of using WPF is that you have immediate access to the Ribbon without having to employ any odd programming techniques. You just drag and drop the Ribbon controls from the Toolbox as you would any other control. Here’s a subset of the default set of WPF controls you can access from IronPython.

WPF03
As you can see, the set of controls is rich and you do have access to others, so WPF may be the way to go for IronPython developers who need maximum control access.

The example isn’t going to do anything fancy. I’ve added two Button controls to the form. Here is how I set the various properties using XAML:

<Window
   Title="WpfApplication1" Height="300" Width="300">
   <Grid>
      <Button Content="Click Me"
              Height="23"
              HorizontalAlignment="Left"
              Margin="191,12,0,0"
              VerticalAlignment="Top"
              Width="75"
              Uid="btnDisplay"
              Click="btnMessage_Click" />
      <Button Content="Cancel"
              Height="23"
              HorizontalAlignment="Left"
              Margin="191,41,0,0"
              VerticalAlignment="Top"
              Width="75"
              Uid="btnCancel"
              Click="btnCancel_Click" />
   </Grid>
</Window>

The first button displays a simple message box, while the second ends the application. Each Button control is assigned basic visual properties, a name, and an event handler for its Click() event. One thing I dislike about working with WPF is that the Properties window doesn’t display any quick help for the various properties. You need to know what each property does or look it up, which is really inconvenient.

The code behind for this example relatively simple. As previously mentioned, the first control displays a message, while the second closes the application as shown here:

import wpf
 
from System.Windows import Application, Window, MessageBox
 
class MyWindow(Window):
    def __init__(self):
        wpf.LoadComponent(self, 'WpfApplication1.xaml')
     
    def btnCancel_Click(self, sender, e):
         
        # End the application.
        MyWindow.Close(self)
     
    def btnMessage_Click(self, sender, e):
         
        # Display the message on screen.
        MessageBox.Show("Hello")
     
if __name__ == '__main__':
    Application().Run(MyWindow())

Much of this code is automatically generated for you. In order to use the MessageBox class, you must add it to the import statement as shown in the code. The code begins with the initialization, which simply loads the components from WpfApplication1.xaml.

The btnCancel_Click() event handler relies on the MyWindow object’s Close() method. Make sure you pass a copy of self as part of the call.

The btnMessage_Click() event handler makes a call to the MessageBox.Show() method with a simple text message. You’ll see the dialog box appear as expected.

From what I can see, the WPF support for IronPython in PTVS is on par with WPF support for any other .NET language. It has the same limitations and benefits as any WPF application will have. So, what do you think of the new WPF project support provided by PTVS? Let me know at John@JohnMuellerBooks.com.

 

Making Soap for Easter

Most of my crafting has a practical aspect to it. Such is the case with soap making. I make the soap because I use it. However, the soap I make has a certain artistic aspect to it and I also give it as gifts to friends and family I know will appreciate it. So there is more to soap making for me than simply an exercise in creating something to wash with.

I make glycerin soap and get many of my supplies from SoapCrafters. Rebecca grows all of the herbs I use in my soap, including the German chamomile, which can be quite expensive when purchased in the store. Given the season of the year, my soap making efforts this past weekend focused on spring and Easter. Here are some lovely springtime soaps with a lilac (top) and baby powder (bottom) scent:

Soap01

Both soaps use the same mold, an assortment of daffodils. I’ve used a special soap glitter to give them a bit of glitz. I found that this particular mold produces easily held soap, but children sometimes find it a bit large. Making the soap easy to use has been a quest of time (along with all of the other accessibility topics I tend to work through). Because of this, I also make egg-shaped and completely spherical soaps like these that are easier for smaller hands to use:

Soap02

The soap on the left is a lovely coconut smell, while the one on the right is another baby power scent. Of course, kids love shapes too, so I was extremely pleased when my wife found a jello mold that had pleasing kid-friendly shapes. These soaps are in a wonderful Creamsicle scent that kids really love (think orange/vanilla).

Soap03

A few of our friends raise sheep. What would be better than a sheep shaped soap (try saying that three times fast)? SoapCrafters had this wonderful sheep and I couldn’t resist buying it:

Soap04

This one also uses the coconut scent that seems to be a favorite with guys and gals alike. It smells quite clean and it’s refreshingnot heavy at all. A few people will receive a three soap medley of lemon, orange, and coconut soaps as shown here:

Soap05

So, what are your favorite shapes and scents? Let me know at John@JohnMuellerBooks.com. In the meantime, I’ll continue crafting and letting you see the results !