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.

 

Selecting a Programming Language Version

Because I have worked with so many programming languages and reported on them in my blog, I get a lot of e-mails from people who wish to know which language they should use. It’s a hard question because I don’t really have inside information about the project, their skills, their organization, or the resources at their disposal. Usually I provide some helpful guidelines and hope that the sender has enough information to make a good selection. Of course, I’ve also discussed the benefits of various programming languages in this blog and direct people here as well. The next question people ask is which version of the language to use.

Choosing the right programming language version is important because a mistake could actually cause a project to fail. I was asked the question often enough that I decided to write an article recently entitled, How to Choose the Right Programming Language Version for Your Needs. This article helps you understand the various issues surrounding programming language version selection. As with choosing a programming language, I can’t actually tell you which version to choose and for the same reasons I can’t select a language for you. At issue are things like your own personal preferences. In many cases, the language version you choose depends as much on how you feel about a specific version as what the version has to offer you as a developer.

An interesting outcome of programming language selection requirements is that I have one book, Beginning Programming with Python For Dummies that uses Python 3.3 and another book, Python for Data Science for Dummies that uses Python 2.7. Of course, I’ve had books that cover two different versions of a language before, so there is nothing too odd about the version differences until you consider the fact that Python for Data Science for Dummies is the newer of the two books. The reasons for my selections appear in Where is Python 3?. The point is that even book authors need to made version choices at times and they’re almost never easy.

Precisely how do you choose language versions in your organization? Do these criterion differ from techniques you use for you own choices (if so how)? Let me know your thoughts on selecting a programming language version at John@JohnMuellerBooks.com.

 

Programming Your Way

I’ve been working with Python for a while now. In fact, I’ve worked on three books on the topic: Beginning Programming with Python For Dummies, Professional IronPython, and Python for Data Science for Dummies. Of the languages I’ve used, Python actually comes the closest to meeting most of the programming needs I have (and a lot of other developers agree). It’s not a perfect language—no language can quite fulfill that role because of all the complexities of creating applications and the needs developers have. However, if any language comes close, it’s Python.

There are a number of reasons why I believe Python is a great language, but the issue I’d like to discuss today is the fact that you can actually use four completely different programming styles with Python. Care to guess what they are? In order to find out for sure, you’ll need to read Embracing the Four Python Programming Styles. Before I encountered Python, I never dreamed that a language could be quite so flexible. In fact, the single word description of Python is flexible.

Realistically, every language has potential issues and Python has them as well. For example, Python can run a bit slow, so I probably wouldn’t choose it to perform low level tasks on a specific system. It also lacks the User Interface (UI) functionality offered by other languages. Yes, there are a huge number of add-on libraries you can use, but nothing quite matches the drag and drop functionality provided by languages such as C#.

However, negative points aside, there aren’t any other languages that I know of that allow you so much flexibility in programming your way. You have four different styles to choose from. In fact, you can mix and match styles as needed within a single application. The ability to mix and match styles means that you can program in the way that feels most comfortable to you and that’s a huge advantage. Let me know what you think about Python’s ability to work with different programming styles 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.

 

Using My Coding Books Effectively

A lot of people ask me how to use my books to learn a coding technique quickly.  I recently wrote two articles for New Relic that help explain the techniques for choosing a technical book and the best way to get precisely the book you want. These articles are important to you, the reader, because I want to be sure that you’ll always like the books you purchase, no matter who wrote them. More importantly, these articles help you get a good start with my coding books because you start with a book that contains something you really do need.

Of course, there is more to the process than simply getting the right book. When you already have some experience with the language and techniques for using it, you can simply look up the appropriate example in the book and use it as a learning aid. However, the vast majority of the people asking this question have absolutely no experience with the language or the techniques for using it. Some people have never written an application or worked with code at all. In this case, there really aren’t any shortcuts. Learning something really does mean spending the time to take the small steps required to obtain the skills required. Someday, there may be a technology that will simply pour the knowledge into your head, but that technology doesn’t exist today.

Even reading a book cover-to-cover won’t help you succeed. My own personal experiences tell me that I need to use multiple strategies to ensure I actually understand a new programming technique and I’ve been doing this for a long time (well over 30 years). Just reading my books won’t make you a coder, you must work harder than that. Here is a quick overview of some techniques that I use when I need to discover a new way of working with code or to learn an entirely new technology (the articles will provide you with more detail):

  • Read the text carefully.
  • Work through the examples in the book.
  • Download the code examples and run them in the IDE.
  • Write the code examples by hand and execute them.
  • Work through the examples line-by-line using the debugger (see Debugging as An Educational Tool).
  • Talk to the author of the book about specific examples.
  • Modify the examples to obtain different effects or to expand them in specific ways.
  • Use the coding technique in an existing application.
  • Talk to other developers about the coding technique.
  • Research different versions of the coding technique online.
  • View a video of someone using the technique to perform specific tasks.

There are other methods you can use to work with my books, but this list represents the most common techniques I use. Yes, it’s a relatively long list and they all require some amount of effort on my part to perform. It isn’t possible to learn a new technique without putting in the time required to learn it. In a day of instant gratification, knowledge still requires time to obtain. The wisdom to use the knowledge appropriately, takes even longer. I truly wish there were an easier way to help you get the knowledge needed, but there simply isn’t.

Of course, I’m always here to help you with my books. When you have a book-specific question, I want to hear about it because I want you to have the best possible experience using my books. In addition, unless you tell me that something isn’t working for you, I’ll never know and I won’t be able to discuss solutions for the issue as part of blog post or e-mail resolution.

What methods do you use to make the knowledge you obtain from books work better? The question of how people learn takes up a considerable part of my time, so this is an important question for my future books and making them better. Let me know your thoughts about the question at John@JohnMuellerBooks.com. The same e-mail address also works for your book-specific questions.

 

Getting Python to Go Faster

No one likes a slow application. So, it doesn’t surprise me that readers of Professional IronPython and Beginning Programming with Python For Dummies have asked me to provide them with some tips for making their applications faster. I imagine that I’ll eventually start receiving the same request from Python for Data Science for Dummies readers as well. With this in mind, I’ve written an article for New Relic entitled 6 Python Performance Tips, that will help you create significantly faster applications.

Python is a great language because you can use it in so many ways to meet so many different needs. It runs well on most platforms. It wouldn’t surprise me to find that Python eventually replaces a lot of the other languages that are currently in use. The medical and scientific communities have certainly taken a strong notice of Python and now I’m using it to work through Data Science problems. In short, Python really is a cool language as long as you do the right things to make it fast.

Obviously, my article only has six top tips and you should expect to see some additional tips uploaded to my blog from time-to-time. I also want to hear about your tips. Make sure you write me about them at John@JohnMuellerBooks.com. Be sure to tell me which version of Python you’re using and the environment in which you’re using it when you write. Don’t limit your tips to those related to speed either. I really want to hear about your security and reliability tips too.

As with all my books, I provide great support for all of my Python books. I really do want you to have a great learning experience and that means having a great environment in which to learn. Please don’t write me about your personal coding project, but I definitely want to hear about any book-specific problems you have.

 

 

The Importance of Finding Work

Readers sometimes show patterns in the questions they ask and, in some cases, the pattern shows across a number of my books. When I started to note that readers were interested in discovering just how to earn a living once they have developed a new skill and that they were interested in me providing that information, I started adding a new section to many of my books, such as MATLAB for Dummies, that describes what sort of industries could use the skills the reader has learned. However, I don’t want anyone to be bored to tears either, so I made a point of listing interesting vocations. It’s my feeling that readers want to be engaged in their work. Of course, jobs with less pizzazz are always available and you might have to accept one of them—at least in the short term.

I didn’t provide such a listing for Java eLearning Kit for Dummies. My thought was that Java jobs are so plentiful that readers could probably find a job they liked without too much trouble. However, even with this book, I’ve received more than a few queries about the issue. That’s why I wrote 10 Surprisingly Interesting Ways to Earn a Living Using Java recently for New Relic. As with all my other job listings, this article focuses on jobs that could be really interesting and most definitely rewarding. Of course, not every job is for every person out there—you need to read the article to find the kind of job you like best.

One reader actually did ask why I focused my efforts on interesting (or at least, unusual) jobs. It all comes down to my personal vision of work. I get up every morning with all kinds of cool ideas to try for my books. I actually like opening my office door, starting up my systems, and getting down to writing. For me, work is an enjoyable experience—so much so, that I often forget that it’s work. I’d like other people to have that experience—to have the joy of enjoying their work so much that they really hate to leave at the end of the day.

Of course, there are other languages out there and I have other books that lack lists of jobs. If you find that one of my books is lacking this sort of information, and you really would like me to research the kinds of jobs that are available, let me know at John@JohnMuellerBooks.com. I’d like to hear which book should receive a listing of associated jobs next. In the meantime, be sure to enjoy the Java job listing. You might see your dream job listed, you know, the one you didn’t think existed.

 

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.

 

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.