Discerning Where the Internet of Things (IoT) Really Fits

A number of people have written to ask me about the Internet of Things (IoT) and where it really fits into the technology picture. The current problem with this technology is that it’s so new that people really don’t know where it fits. As with most new technologies, you can find all sorts of uses that simply don’t fit. These uses will eventually die because there isn’t any pressing need to have them. I write about these sorts of uses in the article, What The Internet of Things Is Not. Of course, it’s possible to avoid this particular phase of a technology by asking a simple question, “Is there a pressing need that this solution answers?” Where there is no need, there is also no solution required.

The question I addressed in, What is the Internet of Things? remains. The technology elements are there to create some phenomenal solutions to pressing problems. That’s why I was interested to see a recent ComputerWorld article that describes industrial uses for IoT. No, it’s not as sexy as using IoT to monitor your microwave popcorn so it gets done, but not too done. However, these are the sorts of applications that keep a technology around and also help improve it. The industrial setting will present legitimate questions for IoT to answer. Interestingly enough, you’ll likely benefit from these sorts of industrial uses by not seeing them. That’s right! By making industrial processes more reliable and predictable, they begin to disappear from view. All you really see is the cost savings when it comes to buying products and services.

The IoT is here to stay, that much is certain. However, every year will see major changes to IoT until the technology becomes more stable. At that point, the true killer applications for the technology will begin to appear and everyone will begin seeing the true potential for this technology. For now, what you see is interesting applications—some will survive, many won’t. Let me know your thoughts about IoT at John@JohnMuellerBooks.com.

 

Understanding the Effects of Net Neutrality on Web Programmers

There has been a lot of hubbub about net neutrality. I even saw not one, but two articles about the topic in my local newspaper the other day. Of course the discussion has been going on for a while now and will continue to go on—eventually ending up in the courts. My initial interest in the topic is different from almost every other account you read. While everyone else seems to be concerned about how fast their app will run, I’m more concerned about getting new applications out and allowing them to run correctly on a wide range of systems.

Both HTML5 Programming with JavaScript for Dummies and CSS3 for Dummies speak to the need of performance testing. Neither book covers the topic in detail or uses exotic techniques, but it’s an issue every good programming book should cover. Of course, I had no idea at the time I wrote these books that something like net neutrality would become fact. The developer now has something new to worry about. Given that no one else is talking much about developer needs, I decided to write Considering Net Neutrality and API Access. The article considers just how developers are affected by net neutrality.

If net neutrality remains the law of the land, developers of all types will eventually have to rethink strategies for accessing data online as a minimum. However, the effects will manifest themselves in even more ways. For example, consider how net neutrality could affect specialty groups such as data scientists. It will also affect people in situations they never expected. For example, what happens when net neutrality assures equal access speeds for the x-ray needed to save your life and that online game the kid is playing next to you? Will people die in order to assure precisely equal access. So far, I haven’t found anyone talking about these issues. There just seems to be this nebulous idea of what net neutrality might mean.

My thought is that we need a clearer definition of precisely what the FCC means by equal access. It’s also important to define exceptions to the rule, such as medical needs or real time applications, such as self-driving cars. The rules need to spell out what fair really means. As things sit right now, I have to wonder whether net neutrality will end up being another potentially good idea gone really bad because of a lack of planning and foresight. What are your ideas about net neutrality? Let me know at John@JohnMuellerBooks.com.

 

API Security and the Developer

As our world becomes ever more interconnected, developers rely more and more on code and data sources outside of the environment in which the application runs. Using external code and data sources has a considerable number of advantages, not the least of which is keeping application development on schedule and within budget. However, working with APIs, whether local or on someone else’s system, means performing additional levels of testing. It isn’t enough to know that the application works as planned when used in the way you originally envisioned it being used. That’s why I wrote API Security Testing: Think Like a Bad Guy. This article helps you understand the sorts of attacks you might encounter when working with a third party API or allowing others to use your API.

Knowing the sources and types of potential threats can help you create better debugging processes for your organization. In reality, most security breaches today point to a lack of proper testing and an inability to debug applications because the inner workings of that application are poorly understood by those who maintain them. Blaming the user for interacting with an application incorrectly, hackers for exploiting API weaknesses, or third parties for improperly testing their APIs are simply excuses. Unfortunately, no one is interested in hearing excuses when an application opens a door to user data of various types.

It was serendipity that I was asked to review the recent Snapchat debacle and write an article about it. My editorial appears as Security Lessons Courtesy of Snapchat. The problems with Snapchat are significant and they could have been avoided with proper testing procedures, QA, and debugging techniques.This vendor is doing precisely all the wrong things—I truly couldn’t have asked for a better example to illustrate the issues that can occur when APIs aren’t tested correctly and fully. The results of the security breach are truly devastating from a certain perspective. As far as I know, no one had their identity stolen, but many people have lost their dignity and privacy as a result of the security breach. Certainly, someone will try to extort money from those who have been compromised. After all, you really don’t want your significant other, your boss, or your associates to see that inappropriate picture.

The need to test APIs carefully, fully, and without preconceived notions of how the user will interact with the API is essential. Until APIs become more secure and developers begin to take security seriously, you can expect a continuous stream of security breaches to appear in both the trade press and national media. The disturbing trend is that vendors now tend to blame users, but this really is a dead end. The best advice I can provide to software developers is to assume the user will always attempt to use your application incorrectly, no matter how much training the user receives.

Of course, it isn’t just APIs that require vigorous testing, but applications as a whole. However, errors in APIs tend to be worse because a single API can see use in a number of applications. So, a single error in the API is spread far wider than a similar error in an application. Let me know your thoughts on API security testing at John@JohnMuellerBooks.com.

Using Hypermedia to Your Advantage

Many developers are familiar with the task of making a request to a server and receiving a response. We’ve been performing the same task since before the PC even appeared on the scene. So, it’s hard to imagine that anything new has come up. Hypermedia is that new thing, but before we go to far, let me fill in a few details.

When working on the Web, these requests normally go through a Web service that relies on a technology such as SOAP or REST. The essential idea is always the same—send a request, receive a response to that request (even when the response is an error). Of course, the Web adds it’s own wrinkles to the process. For example, most Web services rely on text-based data transfers, rather than the binary transfers used in the past.

The problem with this request/response scenario is that it assumes that the Application Programming Interface (API) used to make the transfer of information happen is well-documented by the provider and also well-understood by the developer. Unfortunately, documentation is often poor and understanding is even poorer. Wouldn’t it be nice if along with the response to a request, a developer also received a list of things that the result allows. Hypermedia performs precisely that task. When you make a request to a service that provides hypermedia support, not only do you get the information you requested, but you also get a list of things you can do with that information.

Hypermedia has just started picking up steam in the last year, so it doesn’t appear in any of my current books (you can bet it will in the future). However, I recently wrote an article about it entitled, Working with Hypermedia APIs. The article provides you with a good overview of what hypermedia APIs can do for you, why they’re an important new way of working with services, and what you can expect from them. Still, hypermedia APIs are in their infancy and I’ll eventually need to provide additional information about them.

Precisely what I do depends on your response to the article and to this post. For example, it may eventually be a good idea to get into the design criteria for hypermedia APIs. On the other hand, it may be better to start with existing hypermedia API services so that you can better see how they work. I’d like to hear from you about your interest level in the topic so that I know how to proceed. Make sure you write me about hypermedia APIs at John@JohnMuellerBooks.com or provide a comment to this blog post.

 

WebM Replacing the Animated GIF?

There is always some new technology out there trying to replace the reigning king (or queen). The Graphic Interchange Format (GIF) has a colorful history, but is mainly used today for animated GIFs—those short sequences of animation that you see spread throughout the Internet (and many intranets as well). In fact, you can find animated GIF generators, free animated GIF libraries, and tools for working with animated GIFs by the score. It’s hard to believe that anyone has found uses for even a small portion of the resources out there.

Web Media (WebM) is a technology that is designed to work like an animated GIF, but provide significantly more functionality. It’s an open source project that will supposedly replace the aging animated GIF at some point. A recent articled entitled, “GIF is Dead; Long Live WebM” explains the technical details of why this file format is so superior and why developers desperately need to embrace it. (Read “What Is WebM, and Can It Dethrone the GIF?” if you want a simpler explanation.) After reviewing everything I can online, I have to agree that WebM does, in fact, have a lot to offer. Most importantly, it can support longer animation sequences. The additional colors it supports are nice to have, but it’s the long animation sequences that will ultimately sell this technology to those who need it.

Unfortunately, WebM also has a lot of hype surrounding it. Advocates would have you believe that wholesale replacement of animated GIFs is imminent. The animated GIF won’t be going anywhere anytime soon. In fact, here are some reasons that animated GIFs will stick around for at least next several years:

  • Not every browser supports WebM natively. Only newer versions of Mozilla Firefox, Opera, and Google Chrome support it. Even though Chrome is currently the most used browser out there, it doesn’t quite have enough market share to fully control the market (not that market share alone is a good reason to adopt any technology).
  • There is a huge base of site that already use animated GIFs to good effect and it’s doubtful that the developers of those sites will make a change without a really good reason for doing so.
  • Animated GIFs enjoy a huge support base in free predefined graphics, free tools, and free support. There isn’t a strong monetary need for a new technology.
  • WebM is viewed as more complicated to embed in a Web page.
  • The tools for working with WebM aren’t nearly as easy to use as those that developers can use with animated GIFs.

The question of whether WebM will eventually replace the animated GIF isn’t answerable at this point. The technology is too new, not enough browsers support it, and the tools required to work with it still need a lot of polishing. Until WebM builds enough of a presence online and a backlog of free graphics for developers to use, you can be sure that developers will stick with what they know.

Upgrades really are nice. New technology can provide developers with useful advantages over what has come before. However, without a compelling reason to use WebM, you can be sure adoption will be slow. Without major improvements in support and reduction in complexity, developers will be reticent to make the move and WebM could end up being just one more good idea that didn’t quite make it. Tell me your thoughts about WebM at John@JohnMuellerBooks.com.

 

Saving Development Time Using CSS Templates and Boilerplate

Recently I created a post entitled, Differentiating Between CSS Boilerplate, Template, and Frameworks that defines the differences between these technologies. However, I stopped short of making any product recommendations. A few of you have asked about the products I’ve tried and liked. So, I put some suggestions together in a recent article, 5 Truly Effective CSS Boilerplates and Frameworks. Mind you, there are scores of such products available on the market. This article represents the cream of the crop from my perspective based on those products I’ve actually tried and found to work well in my particular circumstances.

There are many criteria for choosing a development product and you probably have specific needs that you must address. For example, you might have specific packages that an solution must work with because these other packages form the basis of a mission critical applications. Only you know what these criteria are and it pays to write them down before you look for any third party product. However, there are some questions that you can ask yourself before you begin the search.

 

  • Will the product actually save me time?
  • Can I create a unique look using it?
  • Is the product simple to use based on my experience level?
  • Does the product come with good documentation?
  • How much community support can I expect to obtain with this product?
  • Does the vendor clearly state which packages this product will work with?
  • Has anyone investigated, validated, and qualified the vendor’s claims?


These questions will definitely get you started in the right direction, no matter what your other needs might be. Learning to identify products that meet your specific needs is important because no one can perform that particular part of the software development process for you. Yes, you can hire a consultant to guide you in your efforts, but when all is said and done, you need to make certain decisions regarding the products you use, especially when it comes to intangibles such as appeal and usefulness in making a statement your organization can live with.

In addition to these questions, you need to also ask yourself organization-specific questions such as the need to have access to a Content Delivery Network (CDN). Some organizations prefer to host third party software on their own server (which requires a download), but other organizations prefer to use a CDN that makes it possible to access the product from a remote server. There are advantages and disadvantages to each approach.

What sorts of questions do you ask yourself when looking for a third party product to save development time? The kinds of questions you ask is important and I’d love to know more about the processes that take place in other organizations. Let me know your thoughts at John@JohnMuellerBooks.com.

 

Extending the Horizons of Computer Technology

OK, I’ll admit it—at one time I was a hardware guy. I still enjoy working with hardware from time-to-time and it’s my love of hardware that helps me see the almost infinite possibilities for extending computer technology to do all sorts of things that we can’t even envision right now. The fact that computers are simply devices for performing calculations really, really fast doesn’t actually matter. The sources of data input do matter, however. As computer technology has progressed, the number of sensor sources available to perform data input have soared. It’s the reason I recently wrote an article entitled, Tools to Help You Write Apps That Use Sensors.

The sensors you can connect to a computer today can do just about any task imaginable. You can detect everything from solar flares to microscopic animals. Sensors can hear specific sounds (such as breaking glass) and detect ranges of light that humans can’t even see. You can rely on sensors to monitor temperature extremes or the amount of liquid flowing in a pipe. In short, if you need to determine when a particular real world event has occurred, there is probably a sensor to do the job for you.

Unfortunately, working with sensors can also be difficult. You don’t just simply plug a sensor into your computer and see it work. The computer needs drivers and other software to interact with the sensor and interpret the data they provide. Given that most developer have better things to do with their time than write arcane driver code, obtaining the right tool for the job is absolutely essential. My article points out some tricks of the trade for making sensors a lot easier to deal with so that you can focus on writing applications that dazzle users, rather than write drivers they’ll never see.

As computer technology advances, the inputs and outputs that computers can handle will continue to increase. Sensors provide inputs, but the outputs will become quite interesting in the future as well. For example, sensors in your smartphone could detect that you’re having a heart attack and automatically call for help. For that matter, the smartphone might even be programmed to help in some significant way. It’s hard to know precisely how technology will change in the future because it has changed so much in just the last few years.

What sorts of sensors have you seen at work in today’s world? Do you commonly write applications that use uncommon sensor capabilities? Let me know about your user of sensors at John@JohnMuellerBooks.com. I’d really be interested to know how many people are interested in these sorts of technologies so that I know whether you’d like to see future blog posts on the topic.

 

Keeping Your CSS Clean

It happens to everyone. Even with the best intentions, your code can become messy and unmanageable. When that code is compiled into an executable, the compiler can perform some level of cleanup and optimization for you. However, when you’re working with a text-based technology, such as Cascading Style Sheets (CSS), the accumulated grime ends up slowing your application measurably, which serves to frustrate users. Frustrated users click the next link in line, rather than deal with an application that doesn’t work as they think it should. It doesn’t take long to figure out that you really must keep your CSS clean if you plan to keep your users happy (and using your application).

Manually cleaning your code is a possibility, as is keeping your code clean in the first place. Both solutions can work when you’re a lone developer or possibly working as part of a small team. The problem begins when you’re part of a larger team and there are any number of people working on the code at the same time. As the size of the team increases, so does the potential for gunky code that affects application speed, reliability, and security negatively. In order to clean code in a team environment, you really do need some level of automation, which is why I wrote Five Free Tools to Clean Up Your CSS. This article provides good advice on which tools will help you get the most out of your application.

The cleaner you keep your code, the faster the application will run and the less likely it is to have reliability and security problems. Of course, there are many other quality issues you must consider as part of browser-based application development. Messy CSS does cause woe for a lot of developers, but it isn’t the only source of problems. I’ll cover some of these other issues in future posts. What I’d like to hear now is what you consider the worst offenders when it comes to application speed, reliability, and security problems. Let me know about your main source of worry at John@JohnMuellerBooks.com.

 

Avoiding Graphical Pokes in the Eye

There are times when you can truly say that something isn’t better than a poke in the eye. Using too many of the wrong sort of graphics on a website is one of those times. Some sites use graphics in such a way that it really does feel like a poke in the eye after a while. You end up with sore, tired eyes after viewing the site for only a few minutes. Sites like this is of the reasons I wrote Zapping Graphics that Dazzle Too Much. The article helps you avoid the sorts of graphics that actually make your site a place not to visit. More importantly, the article provides you with specific techniques for creating truly amazing graphics that dazzle in the right way.

Graphical pokes in the eye are bad for the user, but they’re also bad for you because they give users a good reason to avoid your site. Users get to the point of wanting to receive a service or buy products at any other site they can find online. After a while, your site just sits there being viewed by the few people who stumble upon it after clicking a link in a search engine. If things get bad enough, even search engines will place your site so far down the list that no one will find it.

The fact is that there isn’t really a good reason to have unacceptable graphics on any site. There are resources online (see my article for details) to help you create better graphics, even if you can’t rely on a graphic designer. However, if you’re betting the business on the viability and acceptability of your site, then the cost of a graphic designer is probably a lot cheaper than the cost of failure. An essential truth for anyone creating a website today, especially one that sells a product or service, is that the next site is only a click away. Business owners have always had to keep track of the competition, but doing so is even more critical now because a competitor can easily outclass you with just the right presentation.

Don’t get the idea that great graphics are only useful to businesses either. Creating applications today usually means working within a Web-based environment now. In order to create an application that employees or other users will actually enjoy means developing and using engaging graphics in the right way. Applications, even great applications, can fail miserably when users refuse to employ them to perform useful work. When that happens, you could find yourself out of a job.

Most developers really don’t have a lot of graphic design experience. The few who do are in high demand. Building some graphic design skills will make it easier to find employment in today’s competitive environment. Your applications and websites will be successful because they attract the right kind of attention. Let me know your thoughts about the role of graphics in the business environment today at John@JohnMuellerBooks.com.

 

Finding Math Libraries for Your Next JavaScript Project

Finding precisely the JavaScript math library you need can be difficult. In both HTML5 Programming with JavaScript for Dummies and CSS3 for Dummies I define a need to perform math tasks accurately. Both books provide some workarounds for the inaccuracies inherent in performing floating point math. It’s important to remember that some numbers can’t be represented properly in the decimal system used by humans, that there are other numbers the computer can’t represent accurately in decimal, and that there are also error present in converting decimal numbers to binary and vice versa. In short, there are a number of levels at which math errors can occur. Yes, it’s true that the math errors are small, but they become a concern when performing large calculations, some of which can’t suffer any level of error (such as plotting a course to Mars).

The problem is so significant in some cases, that trying to work around the issues becomes an application development task in its own right. It’s for that reason that I started looking for math libraries to perform certain tasks. After all, it’s a lot easier to let someone else do the heavy lifting when it comes to a complex calculation. You can read about the results of some of this research in my article entitled, “Four Serious Math Libraries for JavaScript.” The article not only details the source of many of these errors in great detail, but reviews four libraries you can use to solve them.

The important takeaway I got from the research is that, like many programming tasks, there is no one library that does it all. Each library had something to recommend it. However, each library was sufficiently robust that you shouldn’t need to combine them to create your application. The point is to choose the one library that best meets your needs.

I’m actually looking into a number of library types for use in JavaScript programming. The advantage of JavaScript is that it does provide incredibly strong community support in the form of libraries that you simply use as needed. What sorts of issues do you encounter when writing applications using JavaScript. Let me know what kinds of libraries that you’re having a hard time finding at John@JohnMuellerBooks.com. I’d be more than happy to perform the research for library types that receive enough reader support and report my findings to you.