Tag: Education

Choosing a First Language to Learn

My first programming experience (during the time of the dinosaurs) involved using a light panel to enter machine code into a rudimentary computer with 3 KB (yes, that’s KB) of RAM. The output was also in light form and I needed to decode the lights to determine if my code worked right. I worked with various systems in various ways over the next several years. By the time I got to college, the first language I learned there was BASIC (Beginner’s All-purpose Symbolic Instruction Code), then PC assembler, followed by Pascal. In fact, I’ve just stopped counting the number of languages I’ve learned over the years because each language has a place in my programmer’s toolbox. Of course, the question is what language you should learn first. I get asked that question quite often because there are a huge number of languages available today and no one wants to invest time in a language that’s going nowhere.

Part of the answer to the question of what to learn first is what you intend to do with the language. Each language has features that make it better at performing specific tasks. Programming languages can be split into those that are designed for a special purpose and those that are designed for a general purpose. A special purpose language, such as Structured Query Language (SQL), could be a good choice if you intend to move into database work immediately. However, for most people, a general purpose language works better because you can use it for a wider variety of tasks without bending yourself into a pretzel shape to do it.

A good place to start if you want to choose a language that’s popular enough to help you get a job afterward is the TIOBE index. It shows a listing of which languages are most popular today. As I’m writing this, Python is the most popular language on the list, but that could change tomorrow. Generally, any of the top ten languages on the list are good choices.

Of course, you want a programming language that is easy to learn. C/C++, C#, and Java are all complex languages with great flexibility. Furthermore, C/C++ and C# can help you work at a low level with the computer hardware. These languages have a steep learning curve and may not provide the best choices for a starting point. That said, if you have a line on a job that uses any of these languages, you could do worse than start here, just be prepared to burn the midnight oil learning.

The language I suggest people learn as a starting point is Python. In fact, Beginning Programming with Python For Dummies, 3rd Edition makes a point of showing you just how easy things can be. You don’t even need to invest in any special software, the book shows you how to use Google Colab so that you could conceivably learn how to program on your smartphone or TV. Others must agree with me because Python has turned into the language that the education industry turns to most often for budding programmers.

There are a lot of programming languages available today. You need to research the choice by taking into account what your personal needs are and what sort of job you want to get afterwards. You might find that something like JavaScript or Ruby will provide benefits that you can’t get with Python. Which language do you think will work best for you? Let me know your reasons at [email protected].

Python Community Support

This is an update of a post that originally appeared on October 13, 2014.

There are many issues to consider when choosing a programming language. Python is no exception. Just because I feel it’s the right tool to meet some of my needs doesn’t mean it will work well for you. That’s why the Understanding Why Python is So Cool section of Chapter 1 in Beginning Programming with Python For Dummies, 3rd Edition is so important. This section tells you why I see Python as an important programming language and why you might want to use it too. I break the problem into three parts: what Python can do for your application needs, how Python can benefit you personally, and which organizations are using Python for specific tasks. Between the three sections, you can make an intelligent decision as to whether Python will actually serve your particular needs. I really don’t want you to take my word for it—I would rather know that you selected Python based on your own research.

No matter how interesting a language is, no matter how many features it provides, and no matter how much you personally like it—you can’t typically learn a language that lacks broad community support with any ease. If no one else is using the language and contributing to it in some major way, the language will eventually die. Fortunately, Python doesn’t have this problem. Chapter 21 of my book discusses ten essential libraries for Python, none of which come with the language when you download it. In fact, the introduction to this chapter lists a number of places where you can find even more libraries to use.

The thing is that Python keeps attracting ever more attention. A recent Dev article, 10 Best Tools Python Programmers Can Learn in 2023, provides you with access to tools you really need to know about. The point about tools is that they represent an essential form of community support. As people use a language, they start to build places where others can discuss it with them. However, that’s only one form of community support. Tools represent a significant increase in support because creating, debugging, and supporting a tool requires time and effort that most developers don’t have in abundance. Someone really has to believe in a language to provide this sort of language support.

The fact is that Python has become a “must learn” language. It has great community support, provides a broad range of functionality through libraries and tools, and is fully supported by the academic community. Even though other languages have had these advantages and eventually failed, the chances are far less likely that Python will experience problems. In fact, many rankings sites show Python as being the most popular language out there right now.

Community support is an essential determinant of programming language popularity. How do you rank Python in your toolbox and why? Let me know at [email protected]. Tell me about your favorite Python library or tool and how you use it as well. (No vendor emails please, I want to hear from developers who are actually using products.) I’m interested in discovering just what makes some languages so incredibly popular (Python being one of the most popular).

Facing the Blank Page

Most writers face writer’s block at some point. You have a blank page that’s waiting for you to fill it and you have a vague notion of what you want to say, but the text simply doesn’t come out right. So, you write, and write some more, and write still more, and hours later you still have a blank page. Yes, you’ve written many words during that time—all of them good words—just not the right words.

Every piece of writing I do starts with an outline. Even my articles start with an outline. Creating outlines help you focus your thoughts. More importantly, they help you to see how your thoughts will flow from one idea to the next. Sometimes, if you’re honest with yourself, you’ll discover that you really don’t have anything more than a vague idea that will never become an article, white paper, book, or some other piece of writing. Of course, that’s really the reason for this exercise—to see if you have enough information to even begin writing. If you don’t have enough information, then you need to research your topic more. Research can take all sorts of forms that include everyone from reading other texts on the topic, to doing interviews, to playing. That’s right, even playing is an essential part of the writer’s toolbox, but this is a kind of practical play that has specific goals.

Once you do have an outline and you’re certain that the outline will work, you need to mark it up. My outlines often contain links to resources that I want to emphasize while I write (or at least use as sources of inspiration). A lot of writers take this approach because again, it helps focus your thoughts. However, an outline should also contain other kinds of information. For example, if a particular section is supposed to elicit a particular emotion, then make sure you document it. You should also include information from your proposal (book goals) and your reader profile (who will read a particular section) in the outline. Your marked up outline will help you understand just what it is that you really want to write. In reading your outline, you can start to see holes in the coverage, logic errors, and ideas that simply don’t fit.

Moving your outline entries to the blank page will help you start the writing process. Convert the entries to headings and subheadings. Ensure that the presentation of the headings and subheadings is consistent with the piece as a whole. Unfortunately, you can still end up with writer’s block. Yes, now you have some good words on the page, but no real content. An outline is simply a synopsis of your ideas in a formalized presentation after all.

Write the introduction and the summary to the piece next. The introduction is an advertisement designed to entice the reader into moving forward. However, it also acts as a starting point. The summary doesn’t just summarize the material in the piece—it provides the reader with direction on what to do next. People should view a good summary as a call to action. By creating the introduction and the summary, you create the starting and ending points for your piece—the content starts to become a matter of drawing a line between the two from a writing perspective.

At this point, you have enough material that you could possibly ask for help. Try reading your piece to someone else. Reading material aloud uses a different part of the brain than reading the same material silently. Discussing the material with someone else places a different emphasis on the material. The other party can sometimes provide good suggestions. You may not use the suggestions directly, but listening carefully can often present you with creative ideas that you wouldn’t have considered otherwise.

It’s important not to overwork the piece. Sometimes you need to do something else for a while. Yes, you always want to spend time in research and thinking your piece through, some writing is often done in the subconscious. Fill your head up with as many creative ideas, fascinating thoughts, and facts that you can, and then do something that actually will take your conscious mind off the topic. You might watch a television show or movie, go for a while. have coffee with a friend, take a nap, or do any of a number of other things. The important thing is to forget about the book for a while. Often, you’ll find that the now semi-blank page doesn’t present a problem when you return. Let me hear about your ideas for dealing with the blank page at [email protected].

 

Selecting a Computer Book

Readers contact me on a regular basis about selecting a computer book. I often think they want a precise recommendation from me (and some do ask me to provide a specific recommendation). However, I can’t choose a book for you or any other reader for a number of reasons. Most important of all, I don’t know how you learn. There are other issues too. For example, I can’t always guess from the e-mail precisely how you intend to use the book or what sort of information you need from it. In short, my best guess probably won’t be good enough.

Originally, I tried to handle the situation by providing a blog post entitled, “Techniques for Choosing a Technical Book.” The blog post worked well for a while, but it still doesn’t really answer reader needs. For example, readers would often act oddly if I didn’t recommend one of my own books, even though I knew from the reader query that my book would only solve part of their need and there was a better option out there. (Part of creating a book proposal is to look at the competition in depth and determine how your book will fill a niche that the competition doesn’t. I try to be honest with readers in this regard so that when they do buy a book, they’re happy with the purchase.) With this in mind, I wrote a series of three articles that examines the whole question of selecting a computer book in significantly more detail:

The goal of these three articles is to provide you with the best possible information about selecting and using a computer book. The thing I’ve noticed most often when I receive complaint e-mails is that even when a reader does select a truly usable computer book, sometimes they don’t get the most out of it. A purchase is only as good as the value you receive from it. These articles are designed to increase your satisfaction by helping you use the books more effectively.

Choosing and then using a computer book effectively will help you gain new marketable skills and insights into the computer industry. Overall, it’s my goal to help you earn more money or live a better life when I write a computer book. In other words, my goal is to help you gain something of value—something that you can later say improved your life in some way. Of course, I’m always refining my skills and choosing new techniques based on reader needs at any given time. That’s why I always want to hear from you at [email protected].

 

Review of Mastering VBA

A lot of people have asked about the next book to read after reading VBA for Dummies. Yes, the current 5th edition of VBA for Dummies still works fine as a starting point, even with issues such as dealing with the Ribbon to consider. In fact, you can find some great updates to VBA for Dummies on my blog. However, the fact of the matter is that readers have been asking for more, which is where Mastering VBA by Richard Mansfield comes into play. This is the next book you should get if you want to move on from what VBA for Dummies shows you to writing applications with greater functionality. For example, a lot of you have requested more information about creating forms and Chapters 13 through 15 will help you in this regard. Richard has done an outstanding job of moving you to the next step of creating the complex forms required for robust applications.

Another common request that Mastering VBA addresses is the need for security. While VBA for Dummies helps you understand the need for basic security, Mastering VBA takes the process several steps further and could help prevent breaches given the modern computing environment (one that didn’t exist when I wrote VBA for Dummies). Chapter 18 begins the process by emphasizing the need to build well-behaved code. After all, if your code doesn’t behave, there isn’t any set of security measures that will protect it from harm. Chapter 19 goes on to help you understand the essentials of good security, especially with all the modern threats that cause problems for developers today.

At 924 pages (versus 412 for VBA for Dummies), Richard is also able cover some topics in detail that would have been nice to have in my own book. Readers have complained about having to go online to view object model details for the various Office applications in my book. Mastering VBA provides coverage of the object model as part of the book so you can work through it without having to go anywhere else. It’s a convenience issue—readers really shouldn’t have to look for essentials like the object model online, but every author has to face space limitations when putting a book together. The object model material is spread out across the book, but there really isn’t any way to organize it so that it all appears together. This is one time when you’ll need to actually use the table of contents and index to find the material you need.

As with all the books in the Mastering series, this one has questions at the end of each chapter. These questions are designed to help you master the skills learned in the chapter. You find the answers for each of the questions in the back of the book. This makes Mastering VBA an excellent option for the classroom. More importantly, it gives you another way to learn the material in the book. The longer I write books, the more I come to realize that one or two methods of learning simply won’t do the job. This book usually provides three or four ways to learn each task, which means that you have a higher probability of actually mastering the material (as defined by the title).

For all of you who have been asking for the next book after VBA for Dummies, Mastering VBA is the one that gets my recommendation. Until I actually have time to write a book that specifically addresses the concerns in the reader e-mails I’ve received, this book is your best option. No, it doesn’t address every e-mail request that I’ve received, especially with regard to form creation, but it does answer a considerable number of them. Of course, I’ll look forward to your continued interest in my book and I hope you keep those e-mails coming my way!

 

Review of Essential Algorithms

Working in computer science means knowing how to work with computer languages, but it also means knowing how to use math to obtain the results you want. Some math is relatively straightforward, but some becomes so complicated that you really do need some type of process or procedure for working with it. Essential Algorithms by Rod Stephens, “defines steps for performing a task in a certain way.” The first chapter begins by defining what an algorithm is and moves on from there to show you how they can help improve your ability to write complex applications.

The examples are written in a pseudocode that the author explains in Chapter 1. In fact, the explanation is accompanied by some examples of how to turn the pseudocode into an actual programming language. I’m almost positive some readers will take exception to the use of pseudocode because it doesn’t relate the example in their specific programming language, which would make implementation of the code as easy as possible for the reader. In this case, the use of pseudocode is impossible to avoid because the book would be far less useful without it.

This text could easily be used in a college. Each chapter ends with exercises that help the reader understand the concepts better (or at least determine whether any of the material actually sunk in). The answers to the examples appear in an appendix at the end of the book. However, in a college setting it might be possible to create a student version of the book without the appendix and a teacher version that includes the answers. The author also uses many of the same examples that I used when I was a student in college, but with an emphasis on diagrams to pictorially show how the examples work. The addition of graphics makes the examples considerably easier to understand.

The early chapters discuss specific kinds of algorithms that are used in every programming language that exists. For example, the author tackles the topic of randomizing data and ensuring that the randomizing process is fair. Of course, getting truly random data on a computer is impossible, but it’s possible to create random sequences of such complexity that the average human would never notice they aren’t random. This book discusses the topic at a length that I wish the text I had used in college would have provided.

Don’t get the idea that Essential Algorithms is light on the computer science aspects of using algorithms. For example, you’ll find coverage of all the basic structures used by most languages: linked lists, arrays, stacks, and queues. I could have wished for coverage of dequeues because many languages modify dequeues to create stacks and queues. Understanding how this essential structure works would have been great.

There are separate chapters for sorting and searching. These two tasks are performed so often by applications that an in depth knowledge really is a necessity for any computer scientist. All the common sorts are covered in sufficient detail that the reader should understand them with relative ease: insertion, selection, bubble, heap, quick, and merge. In addition, you find the counting and bucket sorts (two types of sorts that are completely missing my my college text—I took the time to check). The list of searches are likewise complete: linear, binary, and interpolation.

The opening chapters are finished with chapters on hash tables and recursion. I thought the chapter on hash tables was a bit light and their use as dictionaries in languages such as Python is only mentioned in passing. The chapter on recursion was far better done. I found the material on the various kinds of curves: Koch, Hilbert, and Sierpinski, exceptional.

The middle of the book (starting with Chapter 10) is taken up with trees, networks, and strings. There should be enough material here for anyone who really wants to learn the information. The author seems to hit his stride in these chapters—they’re both interesting and well written.

The end of the book starts with cryptography in Chapter 16. It’s the part of the book that just about anyone will find helpful and it’s also the part that separates this book from being a mere college text and more of a reference book. The chapter on complexity theory is exceptionally nice. Even if you’re already an expert in other areas of this book, it’s likely that you’ll find some new ideas in this part of the book—enough ideas to make it well worth the purchase price.

Overall, Essential Algorithms is the text I wish I had when studying the topic in college and it’ll make a fine addition to my bookshelf. I’ll likely use it as a reference book when trying to understand how various programming languages are implementing a practical need, such as determining how to work with structures such as stacks. I don’t delve deeply into security issues very often, but I’m sure that material will see use as well. There are some holes in the book, but I wouldn’t consider them deal killers and could provide great fodder for the author in the form of articles and blog posts. This is a great book and one that you need on your shelf.

 

Review of Math for the Zombie Apocalypse

Making learning fun is something every author struggles with and few authors achieve. Math for the Zombie Apocalypse is one of the few books out there that actually make a mundane topic like mathematics fun. The essential content of this book is the same as the content for any beginning math book you have ever read. There is no way to get around the requirement of having to learn addition, subtraction, multiplication, and division. However, this book accomplishes its task with panache.

The reader is instantly engaged in a favorite topic of children today, avoiding zombies. Of course, it’s one thing to say that you want to avoid zombies, but it’s quite another to actually accomplish the task. Throughout the book, the reader is asked how he or she would prove their mettle against hoards of zombies roaming the land. The answer is to use math to figure out how to stay alive while less skilled acquaintances become zombies themselves.

Of course, the book is meant entirely in fun. The humor is grand and of the sort that children will enjoy immensely. However, the result of reading the book is that a child sees a useful purpose in learning math—even though this purpose is quite fictional in nature. Most math books out there are dry, humorless tomes filled with mind numbing repetition that will lull the most stalwart child to sleep. There is no reason that a child can’t learn new skills in a fun-filled environment. Before the reader realizes it, he or she has learned new and useful skills.

Fortunately, this isn’t the only book the author intends to write. You’ll want to wait to see the new additions to the for the Apocalypse series, but for now, make sure you check out Math for the Zombie Apocalypse, especially if you have a child that is having a hard time learning the basics. This is the sort of book that I wish had been available when I was growing up and one that I hope others see as being a valuable way to get kids interested in an essential topic. The press, teachers, parents, and even a few students complain about the low scores children achieve in basic math today, but this book does something about the problem.

 

Review of MCSD Certification Toolkit (Exam 70-483): Programming in C#

You’re really excited about becoming a Microsoft Certified Solutions Developer (MCSD)! How do you proceed to make your venture a success? Having been through several certifications myself, I understand the importance of having a great certification guide to help you overcome some of the less intuitive parts of the examination process. Tiberiu Covaci, Gerry O’Brien, Rod Stephens, and Vincent Varallo have provided such a guide with MCSD Certification Toolkit (Exam 70-483): Programming in C#. Anyone planning to take exam 70-483 will benefit from this book because it presents the exam topics in a highly organized manner. You can also look at checking out the microsoft exam dumps on sites like Exam Topics to see how this can further help you out.

Let me get one of the gripes out about the book before I discuss all of the good material though. It seems as if every certification guide I’ve ever looked at includes topics such as, “Why Get Certified?” The problem with these topics is that they waste space and bore the reader. The reader already knows why certification is important, so there is no need to discuss the topic, plus if they need help with the 70-480 certification exam, as well as others, they can look towards websites such as itexams.com for the necessary help. The reasons for getting certified vary, of course, but the vast majority of people can sum it up in one word, money. Certification will open a door to a better job, help the candidate keep an existing job, or move the candidate one step further up the corporate ladder. The topic is unimportant because the only thing the reader wants to know is how to ace the exam (or at least get a passing score). I feel strongly that the authors could have used the space spent in preaching to the choir to provide additional helps and aids. If your tolerance for less useful material is low, then you’ll want to skip directly to page 11 of the book and start reading “How to Study for the Exam Using This Book.”

After you get past Chapter 1, the rest of the book starts to take on a predictable pattern. You read the theory behind each of the topics that the exam will test. Code Labs give you hands on experience putting the theory into practice. My favorite sections are the Real-World Case Scenario, which helps you understand how the theory is actually used to write an application that could exist in the real world. A problem with many certification guides is that they pursue a purely academic course-this book avoids that particular problem and gives you practical knowledge as well.

Each chapter ends with a Chapter Test Questions section that contains a few questions you can use to check what you have absorbed. The questions will typically be useful for one or two uses, so you need to ensure you read the chapter and go through the exercises before you attempt to try the test questions. Otherwise, you won’t really know whether you have absorbed the material. Personally, I found the number of questions a bit small. The authors could have beefed up this section to provide the reader with a better idea of how the exam will appear. Having this type of valuable insight into how the exam will be laid out and what type of questions they may ask you, could help you to achieve a higher score. It may also be worth having a look at something similar to these mb-300 exam questions, (if this is the certification you’re taking), in order for you to see how the material you’re reading can be incorporated within the exam. At least this way you will have a better idea about what the questions will be like, so you’re better prepared.

The Cheat Sheet and Review of Key Terms sections provide an outstanding method for refreshing your memory the day before the exam. One of the mistakes I (and probably many others) made in preparing for a certification exam is to study too hard the night before. If you don’t know the material the night before, you most definitely won’t pass the exam because these exams are designed to thwart people who cram. A reminder, an overview of what you should know, is really all you need the night before. Relaxing and getting the rest you need are essential.

I wasn’t quite sure about the Additional Reading and Resources section found in each chapter. This section is helpful, but only if you’re using the book as a reference after the exam, rather than as a means for preparing for the exam. The authors could have possibly skipped this section in favor of providing more questions or other kinds of hands on learning activities (one of my favorite CNE books used puzzles as a learning aid). Then again, having the book as a reference after the example will likely prove useful too-just don’t cloud your mind with too many competing sources of information before the exam. The trick is to keep your mind clear and focused on your objective (passing the exam).

Overall, the text is written in a clear manner and you’ll find that the authors carefully lead you from one topic to the next. Developers who are already familiar with C# application development may find the book a bit boring because it really does cover all the details. The book is more designed for someone who hasn’t programmed using C# in the past. In fact, the authors recommend that more advanced readers simply skim the book and look for areas of weakness, which seems to be a winning strategy.

Of course, the big question is whether a book is worth the price you pay for it. In this case, you’re getting a bargain. The book is well written and will serve the needs of anyone who needs to take the 70-483 exam. Certification usually brings some significant benefit, so anything you spend on materials today will reap financial rewards in the future. Getting a book is also a lot less expensive than taking a course. Using this book will save you money in the long run.

A New Emphasis On Libraries

I’ve been talking with a friend about libraries recently. He had noted that the only people he had seen using libraries lately were older; that children had no desire whatsoever to even enter a library. Of course, this bodes ill for the institution because the youth of today will be the supporters of libraries tomorrow. However, his observations don’t match my own. Our local libraries seem to be packed with children. In fact, I saw three children standing outside our local library the other day while waiting for the doors to open. The difference in these two observations has me quite curious.

The way in which people use libraries has always interested me because these public warehouses of knowledge are essential to a functioning society. People require some method of accessing exotic or expensive texts—especially people who have limited means. The way in which libraries present information to the public will change in the future, but I have no doubt they will remain. In fact, I’ve touched on this topic before in my “Future of Libraries?” post. Before a future kind of library can take shape, however, the children of today must be engaged in the materials that a library can provide and see these materials as useful.

The two of us are still discussing the topic of libraries because the differences in our observations provide good fodder for discourse on the topic. My thought is that the differences in our observations could come from a number of sources:

 

  • A difference in the community (small town versus large city)
  • Differences in the society (such as, beach community versus Midwest farming community)
  • Times of observation
  • Motivation level of the librarians manning the library
  • Perceived value of the library’s content


Our local library is blessed with a great librarian and strong support from volunteers who truly care that we have a library. For example, we actually host events at our library to get people engaged and to enter the building so they can see what the library has to offer. The state has also been running ads to help support the local libraries and those ads may be boosting the number of people the library sees. Whatever the difference, I’m truly happy to see children waiting for the doors to open at our community library.

Of course, I always want to hear your opinion. What level of participation do you see at your local library? Who goes there and what seems to interest them most? What do you see as factors that affect participation in your local library? Let me know your thoughts at [email protected]

 

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.