Examining the Calculator in Windows 7 (Part 2)

A while back, over two years ago in fact, I uploaded a post entitled, “Examining the Calculator in Windows 7.” Since that time, a number of people have asked about the other features that the new calculator includes. Yes, there are these rather significant problems that Microsoft has introduced, but there are some good things about the new calculator as well.

The good thing appears on the View menu. When you click this menu, you see options at the bottom of the list that provide access to the special features as shown here.

The View menu includes options for unit conversion, date conversion, and worksheets.
The Windows 7 Calculator View Menu

The Unit Conversion and Date Conversion options are the most useful. However, the worksheets can prove helpful when you need them. Of the new features, I personally use Unit Conversion the most and many people likely will. After all, it’s not often you need to figure out a new mortgage, vehicle lease amount, or the fuel economy of your vehicle (and if you do such work for a living, you’ll have something better than the Windows Calculator to use). To see what this option provides, click Unit Conversion. You see a new interface like the one shown here:

The Unit Conversion display makes it possible to convert from one unit of measure to another.
Calculator Unit Conversion Display

You start using this feature by selecting the type of unit you want to convert. As you can see from this list, the kinds of conversions you can perform are extensive:

Select a conversion type to determine what options are offered in the From and To fields.
The Calculator Supports a Healthy List of Conversion Types

The option you select determines the content of the From and To fields. For example, if you want to convert from kilometers to miles, you select the Length option. After you select the type of unit, type a value in the From field and select the From field unit of measure. Select the To field unit of measure last. Here is what happens when you convert 15 kilometers to miles:

The output shows that converting 15 kilometers to miles equals 9.32056788356001 miles.
Converting Kilometers to Miles

I’ve found use for most of the entries in the types list at one time or another. Every one of them works quite well and you’ll be happy they’re available when you need them. The Data Calculation option can be similarly useful if you work with dates relatively often, as I do. However, I can’t see many people needing to figure out the number of days between two dates on a regular basic. Even so, this feature is probably used more often than any of the worksheets.

The ability to perform conversions of various kinds and to access the worksheets that Windows 7 Calculator provides isn’t enough to change my opinion. The implementation of the Calculator is extremely flawed and I stick by my review in the first posting. However, you do have the right to know there are some positives, which is the point of this post. Let me know your thoughts about Calculator now that you have a better view of it at John@JohnMuellerBooks.com.


Review of Visual Basic 2012 Programmer’s Reference

As you might expect, Visual Basic 2012 Programmer’s Reference is a heavy tome at 798 pages. Of course, those pages could be filled with fluff, but that isn’t the case with this book. Rod Stephens does a great job of covering a wide variety of topics that anyone who wants to know how to write Visual Basic applications will need to know. The book starts with the assumption that you have never worked with Visual Studio before. Actually, it’s a good start for some developers who have been coding a while because they are self-taught and really haven’t explored everything Visual Studio has to offer.

The first part of the book discusses using the tools of the trade—a topic that most books seem to miss for whatever reason. I’m not talking a quick overview either. Rod provides six full chapters, 77 pages, worth of material on how to use the Visual Studio IDE for various kinds of application development including both Windows Forms and Windows Presentation Foundation (WPF). This may not seem very important at first, but quite a few readers of my books have problems with the IDE they’re using and even more have no idea that the IDE supports certain functionality. In short, many developers don’t have a firm grasp of the tool that they’re using to write code, so they can’t perform their best work. However, if you’re already completely familiar with the IDE, it’s probably a good idea to skip this part of the book because it is quite detailed. Missing from this part of the book is material on working with Metro applications. In fact, that material doesn’t appear until Chapter 21, so this really isn’t a strong Windows 8 offering from a building Metro applications perspective.

The second part of the book is entitled, “Getting Started,” which I view as a misnomer. Yes, you’re getting started writing code, but anyone who skips the first part really hasn’t gotten a good start. This part of the book introduces the reader to controls, forms, and other objects used to create applications. There are six chapters of this sort of material. Again, you can’t expect to create great applications if you don’t know what objects are already available to you. Developers who don’t really know what objects are available will tend to reinvent the wheel or assume that the language isn’t capable of performing a specific task. Rod does an outstanding job of making the reader aware of what is available and how to use it effectively. There are 100 pages worth of extremely useful material of this sort.

Chapter 13 should have begun a new part. Rod leaves controls, forms, and other objects in this chapter to begin working with applications. It’s one of the few organizational errors in the book, but one that is easily forgiven. The next six chapters, 160 pages worth, discuss basic programming topics such as variable data types and the use of programming structures. Chapter 18 provides an excellent discourse on error handling and will be one of the chapters that even experienced developers will want to read.

Chapters 19 and 20 provide extremely basic, but thorough coverage of database topics. This is not a book about database development. Rather, it exposes you to the topic of database development and you’ll need to obtain another book on the topic to finish your education. This said, what this book is really doing is helping you understand database development at an extremely basic level so that the second book you get, the one specifically about database development, will make sense.

Chapter 21 (which is only 12 pages), likewise, is an extremely basic view of Metro development. Again, this isn’t a Windows 8 book and it doesn’t appear that the author ever intended it to fulfill that role. What Chapter 21 does is introduce you to Metro in a basic way so that you can go on to work with a Windows 8-specific book and make sense of the material it contains. That said, I did notice that Chapter 21 does miss out on a few fundamentals, such as obtaining a license for developing apps. Rod doesn’t appear to mention that the target application will only work when running Windows 8 either (at least, I wasn’t able to get it to run on Windows 7).

Starting with Part III, you learn about Object-Oriented Programming (OOP) techniques in detail. Chapter 22 is a must read chapter because it provides the theory that many books on the market lack. It describes what OOP is all about. It’s tough to understand coding examples when you don’t understand the basis for those examples and Rod fills all of the gaps for you. In the chapters that follow, Rod leads the reader through basic class development, structures, and namespaces. The book then continues with some specifies on collection classes and generics. Again, all of this material is designed around a person who really doesn’t know anything about Visual Basic, so Rod takes time to explain the details not found in other books.

Part IV of the book fills out some basic information needed to create standard desktop applications, such as printing in Chapter 27 and the use of configuration information in Chapter 28. The use of streams and filesystem objects come next in Chapters 29 and 30 respectively. The book closes out with an enormous array of appendices (22 of them) that contain all sorts of useful reference information. After you’ve gone through the book, the example applications and this reference material continue to provide you with long term value.

Overall, this is the book that you want when learning Visual Basic. It provides the details needed to write robust applications quickly. However, getting this information is like getting any other sort of education—it takes time and you must work through the examples. This isn’t a quick reference book, nor is it going to provide you with details about specific technologies such as database development or writing Metro apps. Where the book does touch on specifics, it covers those specifics at a basic level with an emphasis on helping people understand the underlying technology. If you’re looking for a book that provides quick answers, a cookbook approach to solving problems, or detailed information about specific technologies, you really do need to look elsewhere. On the other hand, if you’re tired of being confused by online examples and tutorials that don’t really teach you anything, then this is the book you want.


Adding a Web Reference in Visual Studio 2010 (Part 2)

Some time ago I provided some step-by-step instructions for creating both a Web Reference and a Service Reference in Visual Studio 2010 in the Adding a Web Reference in Visual Studio 2010 post. In addition, the post explains the difference between the two to make it easier to understand when to use one over the other. The post has proven popular and a number of people have commented on it.

There are a number of questions about the post though and I wanted to answer them in this follow up post. The biggest question is where the WeatherSoapClient class comes from. The WeatherServiceClient() part of the code comes from the way in which Visual Studio interacts with the WSDL. If you look at:


you find that the WSDL doesn’t contain the word Client either. The WeatherServiceClient class is generated by Visual Studio in response to the WSDL it finds on that site.


Another complaint about that original post is that it relies on C#. Just to make things different, this post uses Visual Basic instead. Creating the Service Reference works precisely the same as it does with C#.

To see how this works, go ahead and create a Service Reference as specified in the original post. When you get done creating just the Service Reference, choose View | Class View in Visual Studio. You’ll see a new Class View window open up. Now, drill down into your project. If you create your example using Visual Basic, you’ll see something very similar to this:


(The C# view of the dialog box is almost precisely the same.) What you’re seeing here is the result of creating the WeatherService Service Reference. I didn’t do anything else at all to this project. Highlighted in the upper window is the WeatherSoapClient referenced in my article. In the lower window you see the methods associated with that class.

Once you get done, you can recreate the example in Visual Basic. Just add two textboxes (txtCity and txtWeather) and one button (btnTest) to your application. Create an event handler for btnTest. Here’s the code you need to make it work:

Private Sub btnTest_Click(sender As System.Object, _
                          e As System.EventArgs) _
                       Handles btnTest.Click
   ' Create an instance of the Web service.
   Dim Client As WeatherService.WeatherSoapClient = _
      New WeatherService.WeatherSoapClient()
   ' Query the weather information.
   Dim Output = From ThisData _
      In Client.GetWeather(txtCity.Text) _
      Select ThisData
   ' Clear the current information and
   ' output the new information.
   txtWeather.Text = ""
   For Each Letter In Output
      txtWeather.Text = txtWeather.Text + Letter
End Sub

As you can see, the code is similar to the C# version I provided in the previous post. The point is that you really do need to use the Class View at times to determine how to interact with a Web service after you create either a Web Reference or a Service Reference. My book, LINQ for Dummies, provides a lot more in the way of helpful information on using Web services effectively for queries. If you want a simpler view of Web services using the C# language, check out C# Design and Development instead. Now you know that the names used by other authors don’t come out of thin air either, even though it might seem that way at times. Please let me know if you have any other questions about this example at John@JohnMuellerBooks.com.


Entity Framework Programmer Beta Readers Needed

Next week I’ll begin work on my 91st book, “Entity Framework Development Step-by-Step.” This technology is really exciting. Microsoft keeps improving the Entity Framework support and Entity Framework 5 is no exception. Just in case you haven’t seen it, Microsoft recently released the Entity Framework 5 release candidate through NuGet. You can read about the updated technology on the ADO.NET blog.


The Entity Framework is an ADO.NET technology that maps a database and its underlying structures to objects that a developer can easily access within application code. Before the Entity Framework, a developer needed to write code that directly accessed to the database, which caused considerable problems every time the database received an update. The Entity Framework helps shield applications from underlying changes in a database. You can read about the Entity Framework in more detail in the Entity Framework Overview provided by Microsoft. Microsoft also provides a support center that offers some basic Entity Framework learning tools.

The Entity Framework is amazing technology because it greatly reduces the work you need to do and even automates many of the processes used to interact with databases. My book will make performing tasks even easier. As you go through the book, you’ll see how to perform many Entity Framework-related tasks using step-by-step procedures. There won’t be any guesswork on your part. As a beta reader, you’ll be able to provide me input on when these procedures work, and when I need to work on them some more to help prevent Errors in Writing.

You may have an Entity Framework book on your bookshelf already. However, if that book is on an older version of the Entity Framework, you really do need to know about the new features that the Entity Framework provides. In addition, my book will highlight these five essential topics:


  • Choosing the right workflow: The main reason this topic is important is that the Entity Framework actually supports several different workflows and they’re all useful in different ways and for different projects.

  • Using LINQ to interact with the Entity Framework: LINQ presents the fastest, most efficient, and least troublesome way to perform basic tasks with the Entity Framework. Of course, this book also discusses more complex methods, but making things simple is essential for the overburdened developer today.

  • Working with Table-Valued Functions: This is a new major feature in the Entity Framework 5 that developers have been requesting for years.

  • Complete application health checking: Because you likely work in an enterprise environment, simply discussing exception handling isn’t enough. You also need to know how to deal with other application health issues, such as what to do when an application has concurrency issues or how to address speed problems. An entire part of the book is devoted to the topic of application health because more organizations than ever are paying close attention to this topic now (as evidenced by the large number of books and articles being created on the topic of Application Performance Monitoring, or APM).

  • Entity customization: Yes, Entity Framework automation is quite good and gets better with every release, but as with any other form of automation, it has limits. Automation can only address those issues that the creator of the automation originally envisioned for it. Developers have a habit of coming up with situations that the automation can’t handle, so that’s why the last part of the book discusses this issue to some degree. I’m not going to delve into this topic so deeply that you feel overwhelmed, so my treatment of the topic is unique in that it gives you a useful set of skills without burdening you with topics so complex that the information becomes buried in jargon.

As I said, I’m really excited about this book and would love to have you read it as I write it. Your input is essential to me. Let me know if you’d like to be a beta reader for this book at John@JohnMuellerBooks.com.


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.


An Update on Microsoft’s New Casablanca Release

A little over a month ago I wrote a post entitled, “Microsoft’s New Casablanca Release” about Microsoft’s newest Casablanca product. Niklas Gustafsson, a member of the Microsoft Visual C++ Team was kind enough to contact me and answer a few questions about this release. I decided that you also need to know the answers to these questions so that you can make an intelligent decision about Casablanca. As a quick recap, Casablanca is a new product that lets C++ developers interact with the cloud using REST.

The first thing Niklas pointed out is that Casablanca isn’t precisely a product—it’s what is termed as an incubation effort, something to see what is possible and will work. Casablanca is early in its life cycle and doesn’t provide either the quality or maturity that a released product would provide. to me, this means that you need to be careful using Casablanca. For the time being, it’s probably an interesting technology to play with, but you probably shouldn’t employ it in your production application because it will change quite a lot.

Even though I use C++ for utilities and low level program (as described in C++ All-In-One Desk Reference For Dummies), Niklas pointed out that many organizations use C++ for larger, line of business applications. In many cases, the reason for using a language like C++ for this purpose is that the organization has already made an investment in C++, so the language is familiar and the organization already has the required resources. I still can’t imagine creating a large scale user application using C++, but I’m also not the one trying to forge ahead in a large organization. It seems to me that using other languages would be simpler and less error prone, but I’m well-versed in using a number of languages, so I have the option of using the best tool for a specific task. In fact, Niklas summarized C++ usage for larger applications in the following points:


  • Raw performance
  • Portability
  • It’s what they know

To make his point clearer, Niklas provided me with a link to a whitepaper entitled “C++ and Cloud Computing” that makes a number of points clear. I encourage you to download this whitepaper and give it a read before you make any decisions regarding C++ and the cloud. It certainly helped me envision how someone might use Casablanca a bit better. For example, even a low-level application could need access to an online storage provider in order to access the information it needs. I also hadn’t considered some special areas of program, such as gaming, when I wrote my original post—I was thinking more along the lines of what a business developer would need.

With regard to my question about using REST, rather than SOAP, Niklas pointed out that REST currently enjoys far wider support than SOAP and that it’s simpler to implement. If Casablanca becomes a success, SOAP support could follow. So, at least the team is thinking about SOAP as a future addition.

It’s also important to remember that many organizations are only starting to think about cloud computing, so technologies such as Casablanca are still well ahead of the curve. Sometimes in reading the technical articles online, you get the idea that cloud computing is already well entrenched in the enterprise. The truth is that many enterprises are only now experimenting with the cloud and some will never use the cloud due to regulatory or other concerns.

I was really happy that Niklas took time out to contact me regarding Casablanca. I’ll be taking another look at this technology as the Visual C++ Team works on it and will likely provide you with an update sometime in the future. In the meantime, let me know how your organization is working in the cloud today at John@JohnMuellerBooks.com.


Visual Studio 11 Updates

Microsoft plans to release the next update for Windows 8 during the first week in June. Most developers are also looking forward to an update of Visual Studio 11 about the same time. Visual Studio 11 contains a number of modest, but important, feature updates. As a result, I’ve been reading everything I can find on these new features and doing a little testing myself. So far, I haven’t seen much mention of the new debugging features or the new/updated tools provided with the new release. These changes are important nonetheless.

Of course, the most important of these updates is the ability to create Metro applications. Visual Studio 11 provides a complete set of templates you can use to create Metro applications using a combination of HTML5 and JavaScript. From the confusing assortment of posts that I’ve read, I’m not really clear as to whether the main download site provides you with a copy of Visual Studio 11 that includes full support for developing Metro applications. It turns out that you need the SDK in order to build these applications. In order to play with Metro applications, I downloaded the Visual Studio 11 beta from the Metro-style applications site, which definitely includes the SDK. This download only installs on a Windows 8 system. The Metro-style applications site also includes a number of other helpful downloads.

The feature that seems to be garnering the most attention though is the appearance of the new IDE. Many developers find the new IDE incredibly depressing to use. According to a number of sources, the beta team has heard the pleas of testers and decided to do something about it. Essentially, the changes are limited to a difference in colors. The updated IDE will be lighter gray and use some brighter colors in the icons. Of course, having a tool that’s fun, or at least interesting, to use is a requirement. No one wants to work with a depressingly dark gray tool all day. Still, I have to wonder why this particular feature is receiving so much press.

Of the features I’ve tried so far, I’m finding the C++ language additions the most tempting. For example, the IDE now makes it a lot easier to see various C++ elements through the use of color coding. A feature called Reference Highlighting is also interesting because it makes it easy to move between instances of a keyword within a source code file with greater ease. There is also built-in support now for the C++ 11 specification version of the Standard Template Library (STL). If you want, you can even build Metro-style applications using C++. The IDE also makes it a whole lot easier to work with code snippets. These new additions do make the IDE faster and more efficient, but also add complexity. Readers of C++ All-In-One Desk Reference For Dummies will be happy to know that I’ll continue using the GNU C++ compiler for the reasons stated in my Choosing the GNU C++ Compiler post.

Because I know I’ll eventually need to provide some level of Metro application support, I have been playing around with the Metro functionality. As part of my reading, I checked out the information on the Metro-Style Design Applications site. From a developer perspective, there are some pros and cons about these new requirements. For example, some developers see them as actually limiting application functionality and making applications less useful. I’m sure that what will happen is that developers will find new ways of adding functionality to applications that fit within the Microsoft guidelines and still offer a great application experience. Undoubtedly, Microsoft will also be tweaking those Metro design documents.

Have you done anything with Visual Studio 11? If so, let me know about the features you like best and which features you wish Microsoft would change. One of the most important questions for me is whether you see yourself using Visual Studio 11 for serious application development anytime soon. Knowing these answers will help me create better blog posts for you in the future. Contact me at John@JohnMuellerBooks.com.


Microsoft’s New Casablanca Release

When I wrote C++ All-In-One Desk Reference For Dummies, I provided the reader with a view of C++ as a low-level language. It’s true that most developers use C++ to create command line utilities, drivers, embedded systems, libraries, and even operating systems. While I might use C++ to create a database engine, I probably wouldn’t use it to create a database application. I’d probably lean toward some combination of a procedural language such as C# or Visual Basic and a declarative language such as SQL or LINQ for the purpose. I’ve written database applications using PHP, Java, and a host of other languages, but never in C++ because C++ isn’t the optimal tool for the job. Many developers have written about the strength of C++ being the flexibility it provides to perform amazing tasks. So, I was a bit surprised to learn that Microsoft has delivered a new product codenamed Casablanca that lets C++ developers interact with the cloud using REST.

In reading the blog post announcing Casablanca, I detect a lack of direction. I understand that C++ currently lacks library support for any sort of Web service access without buying a separate third party product. However, that’s all that the blog post tells me. It doesn’t provide me with any ideas of how Microsoft sees the developer using this library. Given that some people do write C++ applications, I imagine that Microsoft envisions developers creating full-fledged applications with their product, but the intent is a mystery (and will remain so until someone at Microsoft speaks up). The last paragraph of the blog post says it all, ‘We would love to know whether you’re interested in using C++ to consume and implement cloud services, and if so, what kind of support you want in order to do so, whether “Casablanca” is on the right track, and how you’d like to see it evolve.’ Apparently, Microsoft is hoping that the development community will come up with some ideas on using this product.

Casablanca also comes with some significant restrictions. The most important of these restrictions is the platforms that support it:


  • Windows Vista
  • Windows 7
  • Windows 8

This means you can’t use Casablanca to create a library for all of those Windows XP users on your network. It doesn’t surprise me that Microsoft would place these platform limits on the product, but I’m wondering just how many developers will be able to use Casablanca in today’s enterprise environment for a product application. The fact that Microsoft’s Casablanca site heavily promotes its use with Azure leaves no doubt that this product is designed for the enterprise (or at least, a larger business).

Another strange limitation is that the product only supports REST. At one time, Microsoft was promoting SOAP and many Web services still rely on this protocol. In fact, it’s actually easier to create a connection to a SOAP Web service in Visual Studio than it is to create a REST connection. I’m sure that Microsoft will address this limitation at some point, but for now, this remains a problem for developers.

Casablanca does come with the usual Microsoft bells and whistles. If you buy the latest version of Visual Studio, you’ll obtain a complete set of templates that will make coding access to a REST Web service easier. I’m sure that there are developers who are working with just the supported platforms, work with Azure, and have the most recent version of Visual Studio who will absolutely love this product, but I have to wonder how many developers outside this small core group will be able to use Casablanca to do something productive.

Normally, I try to find something positive to say about new product releases, but this one has me scratching my head. I’ve downloaded Casablanca and plan to play with it some more. If there are some truly dazzling features, I’ll post an updated blog entry later. In the meantime, I’d like to hear your input. Is Casablanca an amazing new product that C++ developers must have? If so, how do you plan to use it? Let me know at John@JohnMuellerBooks.com.


Web Service Examples in Books

A number of my books include Web service examples. It’s hard to write a book about any sort of development today and not include one or two Web service examples in it. In fact, some of my books, such as Start Here! Learn Microsoft Visual C# 2010 Programming contain a number of these examples. The reason is simple. Online services provide access to a wealth of information and can also reduce the programming burden on developers. Learning to use Web services provides a significant competitive advantage, so I need to discuss them in my books.

Creating a useful and interesting Web service example in a book is a lot harder than you might think. It’s not as if my book is for a particular kind of reader or someone who is looking for a specific type of information. In addition, I need to consider the overall learning experience that the reader will receive from the example. With these criteria in mind, I ask myself the following questions when choosing a Web service for a book.


  • Is the service free?
  • Is it general enough to be appealing to my reader?
  • Will the service be around tomorrow so that the reader doesn’t find a blank site?
  • Does the service include a well-designed API that will make it easy for my reader to learn?
  • Will the service be easy enough to use that the examples won’t become too complex?

There are often other questions I must ask, but you get the general idea from these questions. It isn’t simply a matter of choosing something, anything, online. Even though I’m particular about which Web service I choose, readers often encounter problems. Just this past week at least one reader complained about the REST example in Chapter 6 of Start Here! Learn Microsoft Visual C# 2010. It was a frustrating problem to troubleshoot because the example continued to work just fine for me. However, here are some things to consider when working through the Web service examples in one of my books:


  • Use the book’s source code, rather than type the source in yourself.
  • Look on my blog for updates for your book that show how to use any Web service updates.
  • Check your Internet connection to ensure it’s active.
  • Verify that the Web service is actually functional (and try back a few times, just in case).
  • Contact the Web service owner with questions you have about it.
  • Contact me at John@JohnMuellerBooks.com about example code that you simply can’t get to work.

I want you to have a great experience using my books. When I do encounter a Web service that has changed or is no longer in service (it does happen), I’ll try to update my example code so you can continue using the book, as long as the book is still supported (please check the unsupported book list on my Web site).


Visual Studio 11 and Windows 8

The trade press is beginning to talk about Visual Studio 11 quite a bit more often now, even though the release of the initial beta won’t even happen today (coincident with the consumer release of Windows 8). The word on the streets is that you won’t see anything too exciting or unexpected in Visual Studio 11. Yes, Microsoft is making the usual laundry list of changes, but there isn’t anything that you wouldn’t expect them to add. Here’s a quick overview of the changes that I’ve been able to glean from the various articles I’ve read:


  • HTML5 and JavaScript support
  • Touch application support
  • Agile application development
  • Cloud application development
  • .NET Framework 4.5 support
  • Metro interface designers
  • Devops integration (a tool designed to make it easier for administrators and developers to communicate)
  • IntelliTrace updates that make it possible to trace activity in operational applications
  • Asynchronous programming updates
  • Parallel program development
  • Improved SharePoint support

In other words, Visual Studio 11 is targeting Windows 8 and Windows Azure development. Along with these changes, there are rumors that Microsoft will simplify the IDE to make it easier to use. I just hope that they don’t bury functionality in places where you can’t find it. The Ribbon interface that Microsoft is so fond of adding to other applications does just that—making them a nightmare for power users to use, while simultaneously reducing the learning curve for the novice (the bad and the good that comes with any change).

There isn’t any mention of one of my pet peeves with Visual Studio 10, it’s voracious appetite for system resources and an unflinching desire to freeze the system. The current version of Visual Studio tends to require me to reboot my system at least once during any programming session.

Also missing from the laundry list is any mention of Silverlight, which makes me wonder whether Microsoft is putting this technology out to pasture. In addition, there was nary a mention anywhere of updated Windows Phone support. You’d think that Microsoft would be providing some updated support for Windows Phone development considering that many developers will need to support the mobile device. More and more users are augmenting their desktop systems (or replacing them entirely) with mobile devices, so Microsoft had better get on the ball.

Everything I’m reading focuses on Microsoft’s two main languages C# and Visual Basic. For example, I haven’t seen anything about F#, which appears in the current product. Of course, IronPython was orphaned quite some time ago, but the IronPython community remains alive and well (see my IronPython 2.7.1 Update post for details). This lack of information makes me wonder about the future of Microsoft’s other languages (including C++).

Of course, the updates in Visual Studio 11 and the .NET Framework 4.5 will affect applications of all sorts. During the upcoming months I’ll try to test all of the application examples in my books to determine whether there are any issues you need to know about. In the meantime, please continue to use the supported versions of Visual Studio when working through the examples in my books to ensure you have the best learning experience possible. Contact me with any concerns or observations you have about Visual Studio 11 at John@JohnMuellerBooks.com.