Book Review – Understanding ECMAScript 6

Although I find the idea of a library in the palm of my hand to be very appealing, I still prefer a paper book to an electronic reader. For this reason, I recently found myself browsing the JavaScript section of a local Barnes & Noble where I discovered Understanding ECMAScript 6 by Nikolas C. Zakas. I picked it up, almost reluctantly, and headed back to a couch. I was not expecting it to be very interesting or useful, but after reading only a few pages, even my wife could tell that I was hooked. She purchased the book as a birthday gift and insisted that I not read any more until my actual birthday. After some begging, I got permission to read it early and thoroughly enjoyed every page.

To get the most out of Understanding ECMAScript 6, a good working knowledge of JavaScript is required. If you don’t have any JavaScript background, this book is not for you. Read JavaScript: The Good Parts instead. If, however, you are generally familiar with the core language concepts like object construction, this usage and behavior, functions as object, closures and prototypes, then you will have a difficult time finding a better resource for learning ES6.

This book is very thorough at 352 pages covering all of the changes from ES5 to ES6 (with the additional changes in ES7 covered in an appendix). Despite its moderate size and level of detail, it is well-organized and reads like a much smaller and lighter book. I found myself flying through the chapters even though there is nothing witty or especially engaging with respect to the writing style or content other than the introduction. This may seem like a contradiction but consider the following excerpt on destructuring.

Destructuring for Easier Data Access

Object and array literals are two of the most frequently used notations in JavaScript, and thanks to the popular JSON data format, they’ve become a particularly important part of the language. It’s quite common to define objects and arrays, and then systematically pull out relevant pieces of information from those structures. ECMAScript 6 simplifies this task by adding destructuring, which is the process of breaking a data structure down into smaller parts. This chapter shows you how to harness destructuring for both objects and arrays.

Why is Destructuring Useful?

In ECMAScript 5 and earlier, the need to fetch information from objects and arrays could lead to a lot of code that looks the same, just to get certain data into local variables. For example:

let options = {
repeat: true,
save: false
};

// extract data from the object
let repeat = options.repeat,
save = options.save;

This code extracts the values of repeat and save from the options object and stores that data in local variables with the same names. While this code looks simple, imagine if you had a large number of variables to assign; you would have to assign them all one by one. And if there was a nested data structure to traverse to find the information instead, you might have to dig through the entire structure just to find one piece of data.

That’s why ECMAScript 6 adds destructuring for both objects and arrays. When you break a data structure into smaller parts, getting the information you need out of it becomes much easier. Many languages implement destructuring with a minimal amount of syntax to make the process simpler to use. The ECMAScript 6 implementation actually makes use of syntax you’re already familiar with: the syntax for object and array literals.

Object Destructuring

Object destructuring syntax uses an object literal on the left side of an assignment operation. For example:

let node = {
type: "Identifier",
name: "foo"
};

let { type, name } = node;

console.log(type); // "Identifier"
console.log(name); // "foo"

In this code, the value of node.type is stored in a variable called type and the value of node.name is stored in a variable called name. This syntax is the same as the object literal property initializer shorthand introduced in Chapter 4. The identifiers type and name are both declarations of local variables and the properties to read the value from on the node object.

In addition to being clear and concise, this excerpt follows a pattern that is repeated methodically throughout the entire book. The pattern is as follows.

  • Summarize a challenge faced by ES5 developers.
  • Briefly describe the ES6 solution to the challenge.
  • Demonstrate the concept with a simple code example.
  • Explain the code in more detail.

After a few concepts have been introduced, this pattern becomes very familiar and the reader is able to quickly digest even the most challenging concepts. By framing every new ES6 feature in the context of a ES5 problem and then demonstrating it with code, Zakas provides an extremely efficient learning experience that engages the reader in a way that even the most entertaining of technical writers cannot. I especially enjoyed the sections on block bindings, arrow functions, classes, promises and modules and would recommend this book as the perfect companion to JavaScript: The Good Parts.

The Bitcoin Experiment

I recently became interested in Bitcoin and decided to become one of the daring entrepreneurs in the field by establishing myself as a credible merchant. After watching several documentaries on Amazon, taking some PluralSight training and reading up on various sites I bravely generated a Bitcoin address using bitaddress.org and printed it out. I was ready for a garage sale.

Unfortunately, the local garage sale community was not so intrepid and declined to spend even a single Satoshi on my junk. In fact, they did not even bother to spend single US cent either. I did, however, manage to spend approximately $3.00 USD worth of BTC performing a test transfer of $1.00 USD worth of BTC to my own Bitcoin address. Excellent! If only I had some venture capital to fund my mostly certain meteoric growth. Oh wait, look! The sidebar now contains a QR encoded Bitcoin address and so does the featured image for this post! How convenient! Feel free to support us with your Bitcoin donations!

All joking aside, Bitcoin and it’s underlying technologies are very interesting and promise to transform the current financial landscape. Stay tuned for a follow up post where I will explain the basic concepts of Bitcoin, the technologies involved and how they work at a high level, and why Bitcoin is something worth understanding.

Book Review – JavaScript: The Good Parts

Last summer I decided to take a more serious look at JavaScript in preparation for some work involving AngularJS. At the time, I regarded JavaScript as a poorly designed language used only by developers with no better option, but the undeniable rise of Node, NPM, Angular and so many other successful JavaScript frameworks had forced me to second guess my assumptions. Reluctantly, I decided to see what the JavaScript hype was all about.

Many years ago, as an intern programmer/analyst, I had read and enjoyed JavaScript: The Definitive Guide and initially planned to read it again to get back up to speed. I was not overly enthusiastic about it’s 1096 page and so was pleasantly surprised to discover that the most highly recommended book on the subject was JavaScript: The Good Parts by Douglas Crockford.

At only 176 pages, it would be easy to conclude that JavaScript: The Good Parts could not possibly do justice to a topic as mature and widespread as JavaScript; yet it does. Crockford explains it best in the very first section of the book.

“In JavaScript, there is a beautiful, elegant, highly expressive language that is buried under a steaming pile of good intentions and blunders. The best nature of JavaScript is so effectively hidden that for many years the prevailing opinion of JavaScript was that it was an unsightly, incompetent toy. My intention here is to expose the goodness in JavaScript, an outstanding, dynamic programming language. JavaScript is a block of marble, and I chip away the features that are not beautiful until the language’s true nature reveals itself. I believe that the elegant subset I carved out is vastly superior to the language as a whole, being more reliable, readable, and maintainable.”

This resonated with my own experience of the language. By eliminating the complexity of the “bad parts”, Crockford is able to present JavaScript in a way that allows the reader to quickly understand how to use the language effectively. No time is spent explaining the awful parts of JavaScript, except how to avoid them and why. Moreover, no time is spent discussing specific libraries or frameworks. Even the DOM is not addressed any more than what is absolutely necessary. This may leave some readers with unanswered questions, but Crockford is laser focused on the language itself and the book is better for it.

Although truly a masterpiece, my only humble criticism is that some of the explanations are arguably too terse and some of the code examples are more advanced than they need to be to illustrate the topic at hand. Do not expect multiple explanations for a single concept or any repetition at all. Expect a terse, no frills, right to the point, explanation with code samples heavily laced with functional-style programming. If that suites you (and it should), then you will enjoy this book.

In the terse spirit of the book, below are outlines of the good, awful, and bad parts, according to Crockford. Notice the proportions.

Good Parts

  • Functions as first class objects
  • Dynamic objects with prototypal inheritance
  • Object literals and array literals.

Awful parts

  • Global variables
  • Scope
  • Semicolon insertion
  • Reserved words
  • Unicode
  • typeof
  • parseInt
  • Floating Point
  • NaN
  • Phony Arrays
  • Falsy Values
  • hasOwnProperty
  • Object

Bad parts

  • ==
  • with Statement
  • eval
  • continue Statement
  • switch Fall Through
  • Block-less Statements
  • Bitwise Operators
  • The function Statement Versus the function Expresssion
  • Typed Wrappers
  • new
  • void

If you work with JavaScript in any capacity, I highly recommend reading this book!

Angular 2 and Plunker

I put together this plunk for a presentation I will be giving about Angular 2 at work. After working with server-side frameworks for so long, the flexibility and power of a client-side framework is truly amazing. It’s hard to believe that it is possible to code up a fully functional Angular application inside a webpage and then embed that application into another website. The web world has truly changed a lot in the last few years and significantly for the better! I only hope the enterprise world can keep up.

.NET Core Bootstrap Script for Linux

A quick script to bootstrap a dotnet core development environment for Linux Mint 18 / Ubuntu 16.04. Installs the following components.

  • .NET Core 1.1
  • Visual Studio Code with C#
  • Node.js and NPM
  • Yeoman

Usage

1
curl -s https://gist.githubusercontent.com/tschoonover/274627440d11ff32c2cd91a9d16a4974/raw/b86a6dfb39a06e49882ce8f6c698993cf8b993fd/bootstrap-dotnet | sudo bash -s

Make Baymax software for PC

Everyone who has seen the movie Big Hero 6 will be familiar with the name Baymax. In the movie, Baymax was Personal Healthcare Companion Robot created by Tadashi Hamada to scan everyone and work as a robotic nurse. When I first saw the movie I loved the way Baymax greeted the Hero Hamada when he first turns it on. That made me decide to make software for PC that greets us whenever we turn on our computer. You can make your own Baymax using the following commands before we go on with the coding you need to have drag and drop one tool called Timer on our main screen like Pic 1.1

1

Pic 1.1

When you click on Timer you can see one Properties Box on Bottom Right corner. Next you need to change the default Properties of Timer as shown below:

5

Now we can move to the Coding part but first, we need to add some Reference to our Project. For that go to “Project” and Click on “Add Reference” and search for “System.Speech” and you need to select these Reference.

Next Below

using System.Windows.Forms;

you need to add these extra namespace like the following

 

using System.Speech.Recognition;

using System.Speech.Synthesis;

using System.IO;

using System.Globalization;

using System.Threading;

using System.Xml.Linq;

using System.Xml;

using System.Web;

Next Below

 

public partial class Form1 : Form

{”

 

Copy the following codes:

 

Random rnd = new Random();
SpeechSynthesizer Baymax = new SpeechSynthesizer();
SpeechRecognitionEngine reg = new SpeechRecognitionEngine();
private DateTime timenow;
String userName = Environment.UserName;”

 

Next Below

 

public Form1()

{

InitializeComponent();”

 

 

Copy the following codes:

 

“timenow = DateTime.Now;

if (timenow.Hour >= 1 && timenow.Hour < 5)

{ Baymax.Speak(“Goodmorning, Its currently ” + timenow.GetDateTimeFormats(‘t’)[0] + “. I think you should sleep now, it’s too early. Wish you have a good sleep” + userName); }

if (timenow.Hour >= 5 && timenow.Hour < 9)

{ Baymax.Speak(“Goodmorning, Its currently ” + timenow.GetDateTimeFormats(‘t’)[0] + “. I think you have slept peacefully. have a nice day” +userName ); }

if (timenow.Hour >= 9 && timenow.Hour < 12)

{ Baymax.Speak(“Goodmorning, Its currently ” + timenow.GetDateTimeFormats(‘t’)[0] + “. how’s the day going ” + userName); }

if (timenow.Hour >= 12 && timenow.Hour < 18)

{ Baymax.Speak(“Good afternoon, Its currently ” + timenow.GetDateTimeFormats(‘t’)[0] + “. It is good to see you again ” + userName); }

if (timenow.Hour >= 18 && timenow.Hour < 24)

{ Baymax.Speak(“Good evening, Its currently ” + timenow.GetDateTimeFormats(‘t’)[0] + “. It is good to see you back ” + userName); }”

 

Now we are going to use the Timer we dragged from the Toolbox for that we are going to create a new string to check the date and time from our PC, as shown below:

 

public string time()

{

              DateTime timenow = DateTime.Now;

              string o = timenow.GetDateTimeFormats(‘t’)[0];

              return o;

}”

 

Now we are going to our last step, that is to give coding to our “ShutdownTimer” for that double click the Timer we made. When you click on Timer it leads you to the coding page as default the coding will be like this:

 

private void ShutdownTimer_Tick(object sender, EventArgs e)

{

                      #Paste your code here

}”

 

And paste the following code:

 

“ShutdownTimer.Enabled = true;

Close();”

 

Now you are ready to use your Baymax Startup software, you can test your software by pressing “F5”. Before you press “F5” make sure that you have closed every curly braces { }.

If you have any problem with your coding just leave a message 😉

You can download Baymax Code from the link below : https://github.com/stark25795/Baymax_Startup

You can download “How to make Baymax” PDF from the link below : https://drive.google.com/file/d/0BzQ8yfuAE9O1dkVLdFdhLS1JZlk/view?usp=sharing.

Installing Kivy on Windows

I found this really cool cross-platform toolkit for making GUIs from Python! It’s named Kivy. It’s available on Windows, Linux and Mac. (In case you’re not a developer, this is very cool!) The official installation instructions are here: https://kivy.org/docs/installation/installation-windows.html

However, I got an error when it tried to install gstreamer. I had to install that separately. What I did was download the wheel (.whl) file and install it first. After I did that, the rest of install worked fine. You can download the wheel file from here:
https://www.googledrive.com/host/0B1_HB9J8mZepNzZ5aW91Q0tJU2s/kivy.deps.gstreamer-0.1.5-cp27-none-win_amd64.whl

Open a command prompt/shell (of your choice), change to the directory where you downloaded the file and run:

pip install kivy.deps.gstreamer-0.1.5-cp27-none-win_amd64.whl

Note that I got an HTTP 502 error (yes, 502, or “temporary error”) for a while this morning, but then it worked. However, if that file does not exist (an HTTP 404 error), please check this page and download the appropriate file for your version of Windows and Python:
https://kivy.org/downloads/packages/simple/kivy-deps-gstreamer/

Finally, proceed with running everything from the official instructions. (Or everything that failed on you, if you’re sure what that was.)

Happy GUI development! 🙂

The Pajama Coder

My apprentice hard at work in her pajamas!  =)

Book Review – Object Oriented Software Construction Second Edition

Object Oriented Software Construction Second Edition by Bertrand Meyer

I discovered this book in 2007 while searching for references on the subject of object oriented programming. Although I knew the basics at the time and had been coding in OO languages for several years, I felt that I was doing it poorly and wanted to take my understanding to the next level. It did not take much time to realize that OOSC2 was generally regarded as one of the best, if not the BEST, book on the topic and so I happily spent an outrageous $78 for a new edition. That was exactly 9 years ago today and the book now sells for $120 brand new.

When it arrived I promptly read the first page, browsed through the chapters and set it aside with the sincere intention of reading it cover to cover “when I had more time.” Months passed, then years. I read many other books and continued to program in OO, but I could not seem to muster the motivation to tackle those 1200+ pages. One day I took a new job and brought this book to the office. One of the senior architects walked by and commented, “that’s one of the best books I’ve ever read.” I knew then that it was time. I cleared my schedule and over the course of many months, inched my way through it cover to cover.

Looking back, I would not recommend this book to anyone wishing to learn or improve their understanding of object oriented programming. Instead, I would recommend Head First Object-Oriented Analysis and Design. Although OOSC2 does explain all of the essential OO concepts in great detail, it reads like an academic thesis full of proofs and theorems. This is because at the time of the writing, OO was a somewhat controversial approach to software development. Meyer’s primary intention was not to make OO understandable, but to prove that OO as an end-to-end software development method was superior to all of the existing alternatives. To this end, many of the explanations and ideas are accompanied by mathematical proofs and notations which, while necessary to the progression of his arguments, only serve to frustrate those seeking to understand OO as quickly and plainly as possible.

Despite the fact that OOSC2 is not, in my opinion, the best book to learn or understand OO (although some would disagree), it is without a doubt one of the most important and influential works in the history of software engineering. As such, I recommend it highly to any person serious about software development. It is a challenging read that will add depth to your view of the craft and force you to grapple with concepts that are often taken for granted in today’s world of pervasive OO such as the superiority of single inheritance, the importance of designing by contract, the value of assertions, type checking and constrained genericity.

I thoroughly enjoyed the journey that is OOSC2 and hope you have the chance to as well!

Useful OpenSSL Commands

As a software developer, especially when working with security or web-based technologies, one is often required to deal with X.509 certificates. Although it is increasingly easy to obtain a certificate issued by a trusted certificate authority, understanding how to create and use them yourself is invaluable. Below is a list of the OpenSSL commands that have been the most useful to me.

Create a new RSA key:

openssl genrsa -out key_filename.key 2048

The genrsa command generates an random RSA private key consisting of two prime numbers. The size of the key in bits is determined by the last argument (2048 above). Larger values are more secure, but use more resources. NIST estimates that key sizes of 2048 bytes will be secure until 2030. Currently it is possible to crack a key of size 1024 in approximately 100 hours.

Create self-signed X.509 certificate:

openssl req \
    -x509 \
    -sha256 \
    -days 9999 \
    -newkey rsa:2048 \
    -keyout key_filename.key \
    -nodes \
    -out ca_filename.cer

The req command with option -x509 generates a self signed X.509 certificate which can be used for testing or as the root certificate of a certificate authority. Certificates generated in this manner are very useful for development but have limited use in production environments. A common use of self signed certificates is to enable HTTPS on a local or non-production web server.

When used in this manner, the req command will prompt for information to be included in the resulting certificate. When prompted for Common Name, provide the fully qualified domain name to be secured (ex. www.google.com). It is also possible to create a wildcard certificate which can be used to secure unlimited sub-domains by using the * character in place of a concrete sub-domain (ex. *.google.com). Note that to secure multiple domains with the same certificate (ex. www.google.com, www.google.org, www.google.net) the Subject Alternate Name (SAN) extention must be used instead. Using the SAN extension is discussed in the example for the x509 command below.

The -days option determines the number of days (relative to the current date) that the certificate will be valid. The -newkey option generates a new CSR and private key using the specified algorithm. If the -keyout option is used the generated key will be output to the specified file. Option -nodes (no DES) indicates that they generated key should be stored without encryption and can be omitted if you wish to protect the key with a pass phrase.

The -sha256 option indicates that the SHA256 hashing algorithm should be used to generate the message digest when digitally signing the certificate. Note that SHA256 is currently the default and this option can usually be omitted. It is important to use a secure digest algorithm because certificates signed with an insecure message digest such as SHA1 generate warnings in some browsers resulting in sites that clients will not consider trustworthy.

Create certificate signing request:

openssl req \
    -new \
    -sha256 \
    -key key_filename.key \
    -out request_filename.csr

The req command with option -new generates a new certificate signing request containing the information needed by a certificate authority to create a new X.509 certificate. This command prompts for the same certificate information as the example above.

The -key option specifies the key file to use. It is also common to generate a new key as part of this command by using for example -newkey rsa:2048 -keyout key_filename.key -nodes instead of -key key_filename.key. This technique eliminates the need for the use of genrsa as shown in the first example above.

Sign CSR to create new X.509 certificate:

openssl x509 \
    -req \
    -sha256 \
    -days 9999 \
    -in request_filename.csr \
    -CA ca_filename.cer \
    -CAkey key_filename.key \
    -CAcreateserial \
    -out certificate_filename.cer

The x509 command with option -req is used to create an X.509 certificate from a certificate signing request. The -CA option specifies the certificate of the signing Certificate Authority and the -CAkey option specifies the private key to use for the digital signature of the resulting certificate. The -CAcreateserial option indicates that a new serial number file should be created if needed and that the serial number of the resulting certificate should be read from this file.

To create a certificate with the Subject Alternate Names extension, add the options -extensions v3_req -extfile san.cnf as shown below.

openssl x509 \
    -req \
    -sha256 \
    -days 9999 \
    -in request_filename.csr \
    -CA ca_filename.cer \
    -CAkey key_filename.key \
    -CAcreateserial \
    -out certificate_filename.cer \
    -extensions v3_req \
    -extfile san.cnf

The file specified by -extfile is used to define the domain names to be secured by the certificate and should be in the following format.

[v3_req]
subjectAltName = @alt_names
[alt_names]
DNS.1 = your.domain.name
DNS.2 = another.domain
...
DNS.x = last.domain.name

For more information about creating certificates with the SAN extension see http://techbrahmana.blogspot.com/2013/10/creating-wildcard-self-signed.html.

Combine X.509 certificate and key into PKCS12 encoding:

openssl pkcs12 \
    -export \
    -out pkcs12_filename.pfx \
    -inkey key_filename.key \
    -in certificate_filename.cer

The pkcs12 command with the -export option can be used to combine a key and certificate into a single file in PKCS12 format secured by a pass phrase. This is useful when working with Microsoft systems where PKCS12 is commonly used. Note that the file extension used for PKCS12 is typically .pfx on Microsoft systems and .p12 on Linux systems.

Return top

Info

Section9 is a computer club based out of the Springfield Missouri area. For more information, please see the About Us page or follow us on Facebook.
 
%d bloggers like this: