An Issue with Cloud Computing

The world is heading toward cloud computing at a frantic pace. However, the question is whether cloud computing is ready for the world to rely on it. I keep hearing about major outages of line of business applications. This is not good. Businesses need to be able to rely on these applications in order to complete their daily operations. However, when they aren’t functioning properly, it can cause big problems for the business. Of course, some businesses do reach out to IT companies in Melbourne, or somewhere closer to their office, for help with these sorts of problems. That usually helps businesses to continue working with few problems, ensuring that they can get their work done. However, for businesses without IT support, this can cause huge issues. For example, Visual Studio Online recently suffered a major outage. If you’re a developer, the last thing you want to hear is that you can’t access the application you use to create new applications. Just think about the implications about such a scenario for a while and all kinds of negative images come to mind.

What really gets to me is that Microsoft did manage to get Visual Studio Online fixed in about five hours and it identified a potential source for the problem, but it still doesn’t know the cause. Not knowing the cause means that the problem can easily happen again. The loss of income to companies that rely on Visual Studio Online could be huge.

However, the basic problems with cloud computing aren’t just limited to application availability. The biggest problem is saving data to the cloud in the first place. Application development is tricky at best. You absolutely don’t want to give your trade secrets away to other companies and losing data is too terrible to even consider. There is also the connection to consider-whether your users will be slowed down by inefficient communications. Cloud-based applications can also change at a moment’s notice and it’s even possible that a company could simply orphan the product, making it completely unavailable. Losing access to your application in the middle of a development cycle would mean starting from scratch-can your organization really afford it?
Don’t get me wrong. Online computing has a lot of advantages and there are times when using a cloud application works just fine. In fact, I use a cloud application to write my blog each week. However, I also save a copy of the posts to local storage because I simply don’t trust anyone else to make my backups for me. One of my non-business e-mails is also a cloud application. I don’t make a copy of the data in this case because losing it wouldn’t cause any hardship. The point is that I think through the ramifications of using cloud computing carefully and make informed choices-something every organization needs to do.

sd-wan to disconnect from my network. Your business simply has too much riding on the applications you use to have to worry about whether the application will even be available then next time you need it.

I’m sure that some people will write to let me know that their cloud application has never failed tns-serif; font-size: 14px;”>Will cloud computing ever be ready for prime time? I’ve had a number of readers ask that question. I’m sure that cloud computing will continue to improve. There may come a time when you can trust it hem, to which I would add, “yet”. Desktop applications fail too, but with a desktop application, you’re in control. You have a copy of the software locally and you don’t have to worry about the software becoming unavailable or being changed at precisely the wrong time (adding code breaking functionality). Let me know your view of cloud computing 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.

 

Rod Stephens’ Visual Basic Programming 24-Hour Trainer

Learning a new skill, such as programminglearning it quickly and easily, is much harder than it sounds, but “Rod Stephens’ Visual Basic 24-Hour Trainer” makes the task considerably easier. The book begins with possibly the best Introduction I’ve ever seen. The author tells you precisely how to use his book to learn how to code in Visual Basic in a short interval. Additionally, he makes it clear what the book won’t tell you. This is most definitely a book for the rank beginnersomeone who has never written code before and the author makes it clear that better educated developers need not apply. (More advanced readers will benefit more from another of Rod’s books, “Visual Basic 2010 Programmer’s Reference“.)

The chapters tell you how to perform most basic tasks associated with desktop applications. You won’t find any Web development techniques in this book, but the author makes that clear in the Introduction. The reason for focusing on the desktop is that it provides a controlled environment that works anywhereno Internet connection required, no special setup needed. All you need is your system and Visual Basic.

The first chapter is the usual description of how to get Visual Basic installed on your system. Rod discusses a few different options and doesn’t wimp out by covering only Visual Basic 2010 Express Edition like many beginner books do. Because of the target audience for this book, Visual Basic 2010 Express Edition works fine.

The book takes the usual college approach of starting with a basic application, working through variables and structures, and then moving toward more complex application types. You learn all of the basics of working with classes, printing documents, working with the clipboard, and other usual fare for a book of this type. Rod does provide a couple of nice perks such as working with LINQ and databases using the entity framework. The goal is to learn how to use Visual Basic at a basic level, so these exercises will serve the reader well. Someone looking to start by creating a relatively complex example almost immediately will be disappointed. I know that some readers look for this approach now and Rod’s book definitely won’t serve their needs; this book is more traditional (and proven) in its approach.

Each of the chapters provides several methods to learn the material. You can read about the technique, try it yourself on your machine, work through exercises, and even watch a video. Most readers will find a technique that works well for them. Rod suggests using some or ideally all of the techniques to obtain a better learning experience.

The videos are a nice touch and Rod does them well. The longest video I watched came in at 17 minutes, the shortest at 4 minutes. He has a nice speaking voice and an easy manner of approaching the topic. The reader should definitely feel at ease during the presentation. Rod doesn’t resort to humor to cover up a lack of depth in his book. It’s not that he’s incredibly serioushe’s simply straightforward and businesslike in his approach.

Will you actually get through this book in 24 hours as the title says? I doubt it. I tried out a number of the chapters and found that I averaged about an hour in doing them fully (including the exercises) at a rapid pace. There are 39 chapters in the book for a total of 39 hours of training as a minimum. Even if you attack the book at a rabbit-like pace and skip some of the features, you still won’t get through it in 24 hours and manage to gain anything worthwhile. I’d suggest setting aside at least 40 hours of focused time to get through this tome.

The bottom line is that this is a great book for the rank novice to learn a new skill and discover the joys of programming. It’s not the sort of book that anyone who has written code before will want and it’s also not the sort of book that the impatient reader will find helpful. Rod has done a marvelous job of presenting a complex topic in a manner that will help most people get up to speed working with Visual Basic in a short time.