Continuing Education

I don’t know if you’ve noticed, but I’m continually asking questions in my blog posts. In fact, you can find questions in a few of my books and more than a few readers have commented when I ask them questions as part of my correspondence with them. I often get the feeling that people think I should know everything simply because I write books of various sorts. In fact, I had to write a post not long ago entitled No, I Don’t Know Everything to address the issue. Experts become experts by asking questions and finding the answers. They remain experts by asking yet more questions and finding yet more answers. Often, these answers come from the strangest sources, which means that true experts look in every nook and cranny for answers that could easily elude someone else. Good authors snoop more than even the typical expert—yes, we’re just plain nosy. So, here I am today asking still more questions.

This year my continuing education has involved working with the latest version of the Entity Framework. The results of some of my efforts can be found in Microsoft ADO.NET Entity Framework Step by Step. You can also find some of my thoughts in the Entity Framework Development Step-by-Step category. I’ve been using some of my new found knowledge to build some applications for personal use. They may eventually appear as part of a book or on this blog (or I might simply choose to keep them to myself).

However, my main technical focus has been on browser-based application technology. I think the use of browser-based application technology will make it possible for the next revolution in computing to occur. It certainly makes it easier for a developer to create applications that run anywhere and on any device. You can find some of what I have learned in two new books HTML5 Programming with JavaScript for Dummies and CSS3 for Dummies. Of course, there are blog categories for these two books as well: HTML5 Programming with JavaScript for Dummies and Developing with CSS3 for Dummies. A current learning focus is on the SCAlable LAnguage (SCALA), which is a functional language (akin to F# and many other languages of the same type) based on Java.

Anyone who knows me very well realizes that my life doesn’t center on technology. I have a great number of other interests. When it comes to being outdoors, I’ve explored a number of new techniques this year as I planted some new trees. In fact, I’ll eventually share a technique I learned for removing small tree stumps. I needed a method for removing stumps of older fruit trees in order to plant new trees in the same location.

I’ve also shared a number of building projects with you, including the shelving in our larder and a special type of dolly you can use for moving chicken tractors safely. Self-sufficiency often involves building your own tools. In some cases, a suitable tool doesn’t exist, but more often the problem is one of cost. Buying a tool from the store or having someone else build it for you might be too expensive.

The point I’m trying to make is that life should be a continual learning process. There isn’t any way that you can learn everything there is to learn. Even the most active mind picks and chooses from the vast array of available learning materials. No matter what your interests might be, I encourage you to continue learning—to continue building your arsenal of knowledge. Let me know your thoughts on the learning process at John@JohnMuellerBooks.com.

 

The Role of APIs in Application Development

More people are coming to understand that the PC will constitute just one of several devices that users will rely upon to perform daily computing tasks in the future. Articles such as, “Life in the Post-PC Era” are appearing more and more often because the trend is clear. However, unlike many people, I don’t see the PC going away completely. There really are situations where you need to size and comfort of a larger system. I can’t imagine myself trying to write an entire book on a tablet. If I did, the resulting Repetitive Stress Injury (RSI) would be my own fault. However, the higher reliability and slow rate of technological change also means that my systems will last longer and I won’t be buying them as often. In other words, I’ll continue to use my PC every day, but people won’t be making as much money off of me as I do it. This said, a tablet will figure into my future in performing research and reading technical materials that I would have used a PC to accomplish in the past.

The nature of computing today means that any application you write will need to work on multiple platforms. Users won’t want a unique application for each platform used. Unfortunately, new platforms arrive relatively fast today, so developers of most applications need some method of keeping their applications relevant and useful. Web-based applications are perfect for this use. These applications are the reason I chose to write CSS3 for Dummies and HTML5 Programming with JavaScript For Dummies. These books represent the future of common applications—those used by users every day to perform the mundane tasks of living and business.

When reading these two books, you’ll find a strong emphasis on not reinventing the wheel. In fact, a lot of developers are now finding that their work is greatly simplified when they rely on third party Application Programming Interfaces (APIs) to perform at least some of their work. The stronger emphasis on APIs hasn’t gone unnoticed by the media either. Articles such as, “How the API Movement is Transforming the Telecom Industry” describe how APIs have become central to creating applications for specific industries. In fact, you’ll find targeted articles for API use all over the Internet because APIs have become a really big deal.

I plan to write quite a lot more about APIs because I see them as a way of standardizing application developing, creating more reliable applications, and reducing developer effort in creating the mundane parts of an application. What will eventually happen is that developers will become more creative and APIs will put the art back into the science of creating applications. However, I’d like your input too. What do you see as the role of APIs in the future? What questions do you have about them? Let me know at John@JohnMuellerBooks.com.

 

Sometimes Newer Really Isn’t Better

I normally spend a good deal of time telling readers to use the latest versions of libraries because the newer versions will have additional functionality and contain bug fixes for issues that have surfaced since the library was released. There are some situations where this tactic doesn’t work and one of them appears in Chapter 2 of HTML5 Programming with JavaScript For Dummies. The example originally displayed information about the host browser, but the property used to perform that task, browser, has been deprecated in jQuery 1.9.

The easiest way to fix this problem is to use a version of jQuery that does support this property. The change is relatively small. All you need to do is change the line that reads

to read

The change will force the application to use an older version of the jQuery library. As an alternative, you can also add a call to the jQuery migrate library so that the code looks like this:

<head>
   <title>Detect a Browser</title>
   <script
   </script>
   <script
   </script>
</head>

The jQuery site recommends using feature detection instead. Although this feature is directly supported in the latest version of jQuery, there are problems with it as well. The most important issue to consider is that the site tells you outright that the library might have certain features pulled without notice or with a long deprecation cycle, which means that you code could simply stop working at some point. It’s a poor way to detect the kind of browser that you’re using because it’s unreliable. The technique shown in Chapter 2 of the book is far more reliable at the moment.

The point of this post is that there aren’t any absolutes when it comes to coding practice. You need to know when to break the rules. Let me know if you encounter any difficulties with my solution to the problem at John@JohnMuellerBooks.com. If someone has a better jQuery-oriented solution to share, contact me because I’d love to hear about it.

 

Working with the HTML5 Canvas

HTML5 has a considerable number of new features to offer. In fact, I discuss many of the new tags that HTML5 has to offer on page 228 of HTML5 Programming with JavaScript For Dummies. In fact, my book demonstrates a number of these tags as part of showing you how to use JavaScript to create applications that run anywhere and on most devices that support HTML5.

One of the more amazing (and least talked about) features of HTML5 is the concept of a canvas that you can draw on, much as an artist uses a canvas to create interesting pictures. I encountered an article about the HTML5 canvas the other day entitled, “All About HTML5 <canvas>” by Molly Holzschlag. In this article you get a great general overview of precisely what a canvas can do for you. I think you’ll find it quite useful, especially if your artistic skills are at the same level as mine are (nearly non-existent). The <canvas> tag makes it possible to create useful graphics in a way that most developers can understand quite easily.

This is one tag that I wish I had explored more fully in my book, but picking topics carefully is part of being a good author. Instead of providing an overview like the one that Molly provided, I chose to include a more specific example that also employs the Google API. My Working with Data Using Maps post describes just one method of working with the Google APIs. Chapters 18 and 20 both discuss methods of working with the Google API and the example in Chapter 20 combines the Google API with the <canvas> to create an interesting example.

If you’re working with HTML5 for the first time, make sure you spend time working with the <canvas> tag. It makes data presentation considerably easier, even if you lack artistic skills. Let me know about the projects you’ve created using the <canvas> tag at John@JohnMuellerBooks.com.

 

More Goodies for HTML Programming with Javascript For Dummies

During the last few weeks I’ve mentioned some of the extras you can get for HTML5 Programming with JavaScript For Dummies. There are even more goodies and you can access them through the Extras page. All new Dummies books will likely include this special page where you can obtain access to the Cheat Sheet and a number of other items that will vary by book. Of course, I’ve already told you about the article on using tooltips to make your pages more accessible.

While I wrote this book, I tried to avoid too many specific references to particular products. My goal was to provide a book that anyone could use on the Mac, Linux, or Windows platforms without modification. The examples were designed to work with just about any major browser; although, I did focus on Chrome, Firefox, and Internet Explorer during testing. Even though I did follow these guideline rigorously while writing, I also used some specific tools to write my code. You can read about one of these tools in the article entitled, How to Create a New JavaScript File in Komodo Edit. Make sure you let me know whether you’d like to see more articles on this exciting editor. I’ll post them along with the other blog posts for this book.

If you have already performed some programming with JavaScript, you know that the prototype can be particularly difficult to understand. In fact, while researching this book, I noted an inordinate number of questions about this particular JavaScript element. The book does address the prototype property to some degree, but you may want a little more information. I provide it as part of the article entitled, How to Use the JavaScript Prototype Property.

Some developers make working with CSS mysterious and difficult. Fortunately, there is a way to make things simple. No, you won’t use every feature that CSS has to offer using my technique, but you’ll get an excellent start on organizing information on your site. The article entitled, How to Create Cascading Style Sheets (CSS) Simply and Easily, describes this technique in detail.

A final article for the Extras page considers the idea that many people learn by viewing what other people have done. Mimicking the actions of others is an excellent way to learn. That’s why I created Ten Really Cool Sites You Can Emulate. This is a simple list of ten sites you can use to learn by seeing what other people have done for their sites. I chose each site in the list for a specific reason and the article tells you why.

The Extras page is a good way to discover whether you’ll like my book and whether my style of writing suits your needs. I encourage you to check out the Extras page, along with the extensive list of blog posts you find here. Of course, I’m always happy to answer your questions. If you find that you need additional information before buying my book or after you start reading it, please be sure to contact me at John@JohnMuellerBooks.com.

 

Using Tooltips on a Web Page

Some developers focus on functionality, rather the usability, when designing their Web pages. The tradeoff is usually a bad one because users favor usability—they want things simple. One of the issues that I find most annoying on some sites is the lack of tooltips—little balloons that pop up and give you more information about a particular item. Adding tooltips requires little extra time, yet provides several important benefits to the end user:

  • Less experienced users obtain useful information for performing tasks such as filling out a form.
  • More experienced users obtain additional information about a given topic or the endpoint of a link.
  • Special needs users gain additional information required to make their screen readers functional.
  • Developers are reminded precisely why an object is included on the page in the first place.

In short, there are several good reasons to include tooltips. The only reason not to include them is that you feel they take too much time to add. One of the added articles for HTML5 Programming with JavaScript For Dummies is entitled, “How to Create Friendlier Pages Using Tooltips.” This free extra for your book tells you precisely how to add tooltips (it demonstrates two methods, in fact) and shows how they appear on screen. The article is provided to help you obtain a better understanding of what my book is about and also helps you discover whether you like my writing style and manner of presenting information.

If you already have my book and find that you want additional information on making your site more accessible so that everyone can use it, check out another one of my books, Accessibility for Everybody: Understanding the Section 508 Accessibility Requirements. This book contains all of the information you’ll ever need to address every accessibility issue for any kind of application you want to create.

Accessibility is becoming more and more of a concern as the world’s population ages. In fact, everyone will eventually need some type of accessibility assistance if they live long enough. If you’re a developer, adding something as simple as tooltips to your pages can make them significantly easier to use. Users should request the addition of accessibility aids when sites lack them (and vote with their pocketbook when site owners refuse to add them). Let me know your thoughts about accessibility in general and tooltips in specific at John@JohnMuellerBooks.com.

 

Where is the HTML5 Book Cheat Sheet?

A few people have now purchased HTML5 Programming with JavaScript For Dummies and one of the first questions that I’m asked is where the cheat sheet is. If you’ve purchased other Dummies books, you’ll have encountered the cheat sheet—a feature that includes quick tips for becoming productive quickly. The cheat sheet is normally printed on card stock and perforated so that you can easily remove it from the book. You place the cheat sheet where you can access it easily and provide tips for jogging your memory about content you saw in the book.

Don’t worry, the cheat sheet is still available, but now you access it online on the Dummies site. Now, before I get a bunch of e-mails yelling foul, yes there are some disadvantages to this new approach—the most noticeable of which is that you can’t remove the cheat sheet from your book and carry it around with you. I have to admit, not having the cheat sheet within easy reach wherever I am at the moment is a disadvantage. However, it used to be more of a disadvantage when I wasn’t always connected to the Internet. I thought about it recently and those occasions are rare today.

Let’s discuss the positives of an online cheat sheet. The following list provides some reasons that you’ll find the new cheat sheet really helpful (at least, these are reasons I like the new cheat sheet).

  • The new cheat sheet is available to everyone, even if you purchased an e-book version of the book.
  • I can make the cheat sheet as large as needed (within reason) to accommodate everything I think the reader might like to see (I often had to cut content from the old cheat sheets).
  • You now have access to live links as part of the cheat sheet so that all you need to do is click a link to see additional resources.
  • The new cheat sheet can’t get lost. Readers used to complain all the time that they had misplaced their cheat sheet (or someone had borrowed it).
  • The new cheat sheet won’t get worn out.

If you’re like me, you still like to have a paper copy of your cheat sheet around. To make the new cheat sheet as readable in paper form as possible, click the smallish Print link near the top of the page. You’ll see a less embellished version of the cheat sheet that will print cleanly no matter what platform you’re using. When the paper copy you have is lost, borrowed, or worn out, you can simply print a new one without having to ask anyone about it. Talk about convenient !

I’m always open to your input. What do you like or dislike about the new cheat sheet? Is there anything I can do to improve this new form of cheat sheet in the future? This is my first stab at this new format, so I really do need to know your thoughts so that I can polish my presentation to meet your needs. Let me know your thoughts at John@JohnMuellerBooks.com.

 

Considering the Increasing Need for Security

Many of the readers I work with have noted an increase in the amount of security information I provide in my books. For example, instead of being limited to a specific section of the book, books such as Microsoft ADO.NET Entity Framework Step by Step (the new name for Entity Framework Development Step by Step) and HTML5 Programming with JavaScript for Dummies provide security suggestions and solutions throughout the book. The fact of the matter is that this additional security information is necessary.

There are a number of factors that have changed the development environment and the way you design applications. The most significant of these factors is the whole Bring Your Own Device (BYOD) phenomenon. Users bring devices from home and simply expect them to work. They don’t want to hear that their favorite device, no matter how obscure or unpopular, won’t work with your application. Because these devices aren’t under the IT department’s control, are completely unsecured, and could be loaded with all sorts of nasty software, you have to assume that your application is always under attack.

Years of trying to convince users to adopt safer computing practices has also convinced me that users are completely unconcerned about security, even when a lack of security damages data. All the user knows is that the application is supposed to work whenever called upon to do so. It’s someone else’s responsibility to ensure that application data remains safe and that the application continues to function no matter how poorly treated by the user (through ignorance or irresponsible behavior is beside the point). Because of this revelation of human behavior, it has become more important to include additional security discussions in my book. If the developers and administrators are going to be held responsible for the user’s actions, at least I can try to arm them with good information.

The decentralized nature of the security information is also a change. Yes, many of my books will still include a specific security chapter. However, after getting a lot of input from readers, it has become apparent that most readers aren’t looking in the security-specific chapter for information. It’s easier and better if much of the security information appears with the programming or administration techniques that the reader is reviewing at any given time. As a consequence, some of my books will contain a great deal of security information but won’t even have a chapter devoted to security issues.

I’m constantly looking for new ways to make your reading experience better. Of course, that means getting as much input as I can from you and also discussing these issues on my blog. If you have any ideas on ways that I can better present security issues to you, let me know at John@JohnMuellerBooks.com.

 

Introducing HTML5 Programming with JavaScript For Dummies

Today marks the first day you can obtain my latest book, “HTML5 Programming with JavaScript For Dummies.” This is a really exciting book because it helps you create interesting applications using technology that works on just about every platform that exists in the world today using tools that cost little or nothing to use. Of course, these are Web-based applications—the kind that run within a browser. At one time, Web-based meant applications that provided deficient interfaces, lacked any sort of pizzazz, and just generally felt cheesy (poorly made). Today Web-based applications provide interfaces that are every bit as good as their desktop counterparts, but don’t require a special platform to work. All of the examples in the book were tested on Windows, the Mac, and Linux using several different browsers including Internet Explorer, Firefox, and Chrome. One of my beta testers even checked out a few of the examples on his smartphone and they worked just fine. (I do try to point out situations where differences between browsers or platforms will cause an application to look or act differently that what you see in the book.)

Don’t get the idea that this book is only for beginners. Even intermediate readers will be able to discover some new techniques. That said, the beginning of the book is definitely targeted toward someone who hasn’t worked with JavaScript before. Here is a list of the chapters:

 

  • Chapter 1: HTML, Say Hello to JavaScript
  • Chapter 2: Assessing Tools of the Trade
  • Chapter 3: Integrating HTML5 and JavaScript
  • Chapter 4: Embracing JavaScript Variables
  • Chapter 5: Working with Objects
  • Chapter 6: Getting to Know the Standard JavaScript Objects
  • Chapter 7: Using Functions
  • Chapter 8: Making Choices in JavaScript
  • Chapter 9: Making the Rounds with Loops
  • Chapter 10: Performing Error Handling
  • Chapter 11: Understanding the Document Object Model
  • Chapter 12: Handling Events
  • Chapter 13: Connecting with Style: JavaScript and CSS
  • Chapter 14: Enhancing HTML5 Forms with JavaScript
  • Chapter 15: Interacting with Windows
  • Chapter 16: Working with XML in JavaScript
  • Chapter 17: Cleaning up the Web with AJAX
  • Chapter 18: Making JavaScript easier with jQuery
  • Chapter 19: Using jQuery to handle AJAX
  • Chapter 20: Animating the web
  • Chapter 21: Ten Incredible HTML5 and JavaScript Examples
  • Chapter 22: Ten Thoughts About the Future of Web Development

As you can see, the later chapters in the book contain some really interesting topics you can use to create great sites. For example, you get to work with jQuery, possibly one of the best libraries available today. There is even an example that demonstrates how to work with the Google Maps API. The point is that you’ll start this book as a beginner, but you won’t stay a beginner for very long. Not only does the book use the Dummies approach to learning, but you get a lot of hands on experience through 108 programming examples.

I’d love to hear any questions you have about my new book. Let me know what you’d like to know at John@JohnMuellerBooks.com.

 

Discovering a New Way to Create JavaScript

Over time, developers will gain an entire toolbox full of different computer languages. A fully stocked toolbox is a developer’s best defense against the ever changing tide in what’s popular and what’s not in the world of application development. Recently I learned about a new computer language called TypeScript. The amazing thing about TypeScript is that it’s a true superset of JavaScript. If you know how to write JavaScript, you already know a great deal about TypeScript. In fact, I wrote an article entitled, “TypeScript: A New Direction in Browser-Based Applications” that describes some of my experiences with this new language. The short story is that TypeScript compiles into JavaScript, so you start with TypeScript and its advantages and end up with JavaScript code that is ready for use in your favorite Web application.

Of course, the biggest question people ask me is why I need to know yet another language.  After 28 years I’ve collected knowledge of more than a few computer languages—some of which turned out to be turkeys, some of which were extremely useful for a limited time, and others that I still use almost daily. Experiencing new languages and understanding how they can make developers more productive helps keep computer science alive for me. If I had stayed with the original set of languages that I learned as part of my training in college, I would not only be bored to tears, I’d be unemployed. So, if nothing else, learning about TypeScript is an adventure for me.

Adventures are better when they’re productive and interesting. TypeScript is interesting because it actually does improve on a language that’s really popular. You gain the advantages of using a compiler and static typing (amongst other things). For me, the use of the compiler is the biggest advantage because working with a compiler makes it possible to locate and fix the sort of simple errors developers make when tired. There have been more than a few times where a seemingly simple problem has kept my JavaScript application from running as it should and I later found that the problem was something that a compiler would have found in an instant.

Finding mistakes fast and easily, especially when you’re tired, is a real productivity booster. If I can code efficiently for another hour or two because I have a compiler helping me, I can produce more usable code than other developers. In the end, no one is going to care that I used a compiler to produce my JavaScript code. All that anyone is going to care about is that I produced more lines of code in a given time-frame than other developers using older techniques that don’t involve using a compiler. When you use TypeScript, you gain a productivity advantage over other developers.

TypeScript is available using the Node.js Package Manager, a Visual Studio plug-in, or by compiling the source code for your particular environment. My personal favorite is the Node.js Package Manager because it lets me work at the command prompt without having to worry about a particular IDE. I simply set up Komodo Edit to work with the new environment. Since I already use Komodo Edit to create my JavaScript applications, the environment is a good fit with TypeScript as well. There is no actual TypeScript support in Komodo Edit now, but people are talking about it. Of course, you’ll have your favorite environment and working with a new language like this always presents some challenges at first.

If you do try TypeScript out, let me know what you think of it. Do the features that TypeScript provides today make working with a new language worthwhile? Let me know your thoughts at John@JohnMuellerBooks.com. Also, keep your eyes peeled for more posts about TypeScript because this really does seem like an interesting and productive language!