Manning’s ‘MongoDB in Action’ has been updated for version 3.0 – #programming #bookreview

MongoDB in Action, Second Edition

Covers MongoDB version 3.0

Kyle Banker

Manning, paperback

Yes, this updated edition of MongoDB in Action is aimed at software developers. However, the book wisely does not ignore those of us who are more casual users of MongoDB.

Indeed, this is a fine how-to book for MongoDB newcomers and casual users, too, particularly if you are patient and willing to read through an introductory chapter focusing on “MongoDB’s history, design goals, and application use cases.”

Many people, of course, just want to jump straight into downloading the software, running it, and playing with it for a while before getting down to any serious stuff such as application use cases. So this book’s Appendix A is the place to go first, so you can get MongoDB onto your Linux, Mac, or Windows computer.  Then, after MongoDB is installed, you can jump back to Chapter 2 to start learning how to use the JavaScript shell.

After that, things quickly  start getting more “practical.” For example, Chapter 3 introduces “Writing programs using MongoDB.” Here, Ruby is employed to work with the MongoDB API. But the author notes: “MongoDB, Inc. provides officially supported, Apache-licensed MongoDB drivers for all of the most popular programming languages. The driver examples in the book use Ruby, but the principles we’ll illustrate are universal and easily transferable to other drivers. Throughout the book we’ll illustrate most commands with the JavaScript shell, but examples of using MongoDB from within an application will be in Ruby.”

I won’t try to sum up everything in this well-written, 13-chapter book. I have used older, 2.X versions of MongoDB in MEAN stack applications. And, separately, I have worked a bit with Ruby and MongoDB. But in each case, I haven’t needed to learn all that much about MongoDB itself, mainly just ensure that it is storing data that can be accessed in the right place and updated, saved or deleted as needed. So this book, written for 3.0.X (and earlier and later) MongoDB releases is an eye-opener for me and one that I will keep around for reference and more learning now that I have upgraded to 3.2.

Part 1 of MongoDB in Action, 2nd edition “provides a broad, practical introduction to MongoDB.” Part 2 delivers “a deep exploration of MongoDB’s document data model.” Part 3, meanwhile, examines MongoDB “from the database administrator’s perspective. This means we’ll cover all the things you need to know about performance, deployments, fault tolerance, and scalability.”

The book’s author knows that readers with some MongoDB experience will not read the book straight through. Instead, they will tackle chapters in many different orders and will even skip some chapters. And this is okay. MongoDB in Action: Second Edition is a book many of us will be happy to have handy whenever we need to get a better grip on some new aspect of working with this very popular open-source document database.

One cautionary note: The author points out that “as of MongoDB v3.0, 32-bit binaries will no longer be supported.” Of course, some 3.X 32-bit binaries are still out there, and you can install them. But you will get a lot of warning messages from MongoDB. So, download a 64-bit binary if your system will support it.

Si Dunn

Attack of the Killer Parentheses: ‘Clojure in Action, 2nd Edition’ – #bookreview

Clojure in Action, 2nd Edition

Amit Rathore and Francis Avila

Manning – paperback

Clojure seems to be afflicted with a measles-like outbreak of parentheses, and it generally just looks strange to many software developers. And there’s a good reason for that, as this book’s two author point out in their recently released second edition.

“Clojure’s syntax is derived from its Lisp roots: lots of parentheses. It’s alien to most developers with experience in languages with Algol-inspired syntax like C, C++, Java, Python, Ruby, Perl, and so on.”

But Clojure also is an intriguing and powerful choice for many software development projects, Amit Rathore and Francis Avila insist. Clojure is “a functional Lisp on the JVM” (the Java Virtual Machine), and: “It is impossible to separate the Lisp, functional programming, and JVM features of Clojure. At every step they play on each other and tell a compelling software development story….”

I have been tinkering with Clojure on the side, at random spare moments, for more than two years, using a disorganized approach of looking at web postings, building and modifying simple projects that others have posted, and sometimes looking at Clojure how-to books as time permits.

From my perspective, Clojure in Action, 2nd Edition fills a beginner’s need for a friendly, well-organized approach to learning the language and putting it to work effectively. Developers already working with Clojure can benefit from having this book, too, as a handy reference. It covers a lot of ground, using reasonably short paragraphs and offers many short code examples to illustrate its key points.

Clojure in Action, 2nd Edition “assumes no prior experience with Lisp or with any functional programming language,” the authors emphasize. “It starts out with the absolute basics and slowly layers on the different features of the language in  a way to make it all fit together in an intuitive way. It takes a first-principles approach to all the topics, first explaining why something needs to be done a certain way, and only then talking about the Clojure way.”

Clojure is not a language for absolute beginners. The authors assume “you’re familiar with an OO [object-oriented] language like Java, C++, Ruby, or Python, but no background in Java, Lisp, or Clojure is required.” They also assume you have downloaded Clojure and gotten it working on your PC. You can read more about Clojure and download it here.

This expanded 2nd edition states that it covers the “new” features of Clojure 1.6. Of course, Clojure already is up to 1.8, but I have tried many of the code examples at various points in the book and have not encountered problems while running 1.8.

Si Dunn

Getting started with 3D printing? Consider these two new Maker Media books – #bookreview

Many people who want to jump into 3D printing have almost no idea what they actually want to make. Or, they may have projects in mind that far exceed their abilities to fabricate as beginners.

If 3D printing is on your mind (or arriving soon in some shipping boxes and downloads), here are two new books to consider: 3D Printing Projects and 3D CAD with Autodesk 123D.

3D Printing Projects

Toys, Tools, and Contraptions to Print and Build Yourself

Brook Drumm & James Floyd Kelly, with John Baichtal, Rick Winscot, Brian Roe, John Edgar Park, Steven Bolin,
Nick Ernst, and Caleb Cotter

(Maker Media, paperback)

Maker Media’s 3D Printing Projects is written by a team of professionals who have 3D printing newcomers in mind, at first. But their book also includes several more challenging projects that require Arduino or Raspberry Pi boards, motors, servos, or video cameras and other devices. Importantly, all of the projects are designed to be fabricated with small, desktop 3D printers.

The book starts by showing how to fabricate a simple gooseneck lamp that uses an LED light powered by a 9-volt “wall wart.” From there, the projects increase in complexity, to fabricated devices such as a two-axis camera gimbal and a flower-care robot that monitors soil moisture and adds water when the soil gets dry. Numerous photographs, illustrations and how-to steps are provided.

This well-written book shows that much can be done, even at the hobby level, with just a few custom 3D printed parts and some electronics.

 

3D CAD with Autodesk 123D

Design for 3D Printing, Laser Cutting, and Personal Fabrication

Jesse Harrington Au & Emily Gertz

(Maker Media, paperback)

The first steps to 3D printing include “learning how to design for three dimensions using a computer” and having an idea “where to start,” the authors of this useful book point out.

“Many makers who are accustomed to creating by hand view CAD [computer-aided design] software suspiciously. They may worry that digital design will lack soul, or be perceived as cheating. Neither is true,” Jesse Harrington Au and Emily Gertz insist. “A good CAD program can be just that: an aid in realizing your vision for your project.”

Autodesk 123D is one of several popular “parametric design” software packages on the market. The authors note: “The term parametric refers to the use of design parameters, such as measurements, to construct and control the 3D model. This means you will first create a sketch that has measurements attached to it. Those measurements will be used to construct your solid model using different features such as extrude, revolve, or loft.

“This being said, 123D is also capable of ‘tinkering’: using loosely based measurements while fleshing out the look and feel of your design. The power of this is that it allows you to tweak your model during the design process based on actual measurements.”

The book shows how to navigate CAD programs, and it covers how to work with the cloud-based Autodesk 123D “family of programs that allow you to share models between the different apps.”

3D CAD with Autodesk 123D is richly illustrated and well written, with much of the how-to text contained in short paragraphs that offer clear steps.

Si Dunn

 

 

 

 

Go in Action – A comprehensive overview, from ‘Hello, Go’ to ‘Testing & Benchmarking’ – #programming #bookreview

Go in Action

William Kennedy, with Brian Ketelsen and Erik St. Martin

Manning – paperback

The authors of Go in Action assume that you are a working developer who is proficient with some other language, such as Java, Ruby, Python, C# or C++.

However, their book is written well, has good illustrations and offers small to moderate-sized code examples. So, someone who is less than a “working developer” also can pick up this work and use it to get a good start on mastering Go.

The Go language, developed at Google, “has concurrency built in.” Also: “Go uses interfaces as the building blocks of code reuse.” And it has “a powerful standard library,” Kennedy, Ketelsen and St. Martin point out. (They are well-known figures in the Go community.)

Some readers likely will mixed feelings about using the online Go Playground rather than downloading and installing the software. But the book’s three authors emphasize: “Go developers use the Playground to share code, ideas, test theories, and debug their code, as you soon will too.”

They add: “Without installing Go on your computer, you can use almost all that Go provides right from your web browser.”

The major topics covered in the book include Go’s language syntax, type system, concurrency, channels, and testing, among others. If you want a clear, concise and reasonably comprehensive overview of Go, consider Go in Action, from the get-go.

Si Dunn

 

 

Ionic in Action – A solid guide to building hybrid mobile apps with Ionic and AngularJS – #programming #bookreview

Ionic in Action

Hybrid Mobile Apps with Ionic and AngularJS

Jeremy Wilken

(Manning, paperback)

Ionic in Action is a very good introduction to the Ionic framework, which the author describes as “a combination of tools and utilities….” These tools and utilities enable developers “to quickly build hybrid mobile apps using the same technology used to build websites and web applications, primarily HTML, CSS (Cascading Style Sheets) and JavaScript.” Using Ionic, you build “hybrid mobile apps,” which employ a browser window to display the user interface.

Ionic in Action shows how build three different mobile web apps. And, while working on those apps, you encounter virtually every feature that Ionic offers. I recently started learning Ionic, so I am pleased with how this book is organized and impressed that it has some important blessings from Adam Bradley, a co-creator of the Ionic framework.

Ionic is built on top of AngularJS, and it interacts with Cordova. The author of Ionic in Action, Jeremy Wilken, promises that being familiar with AngularJS is “helpful but not required.” However, as someone who has wrestled with AngularJS (and been slammed to the scope mat more than once), I am pleased that this book includes a chapter titled “What you need to know about AngularJS.” And, as in the rest of the book, you learn by doing, not just by reading explanations and looking at illustrations.

In the Angular chapter, you build a basic web application using AngularJS. Of course, one chapter does not take the place of a good AngularJS tutorial. But it provides a useful starting point.

Whether you are working to become a mobile app developer or seeking to improve and widen some existing skills, this is a good book both to learn from and keep handy in your reference library.

Si Dunn

‘Meteor in Action’: A good how-to guide for learning a popular JavaScript framework – #programming #bookreview

 

Meteor in Action

Stephan Hochhaus and Manuel Schoebel

Manning – paperback

I have worked with several JavaScript frameworks, and Meteor has become a favorite, mainly because it is closely related to the MEAN stack family and plays well with MongoDB and Node.js.

As the Meteor in Action authors note: “Meteor runs on top of Node.js and moves the application logic to the browser, which is often referred to as single-page applications. The same language is used across the entire stack, which makes Meteor an isomorphic platform. As a result, the same JavaScript code can be used on the server, the client, and even in the database.”

Meteor is versatile and easy to use, particularly for simple applications. But, like any other JS framework, it does have a learning curve. And there are some inherent weaknesses, as well as strengths, that must be considered when deciding if Meteor is the right choice for a particular project.

Meteor in Action can give you a good grounding in Meteor’s basics, plus solid momentum along the path toward Meteor mastery. The book begins with a polished and not-too-lengthy overview of Meteor’s Open Source framework. Then it shows how to build a small, reactive game application. From there, the major topics include: templates; data; fully reactive editing; users, authentications, and permissions; exchanging data; routing; the package system; advanced server methods; building and debugging; and going into production.

Another reviewer has stated that parts of this book may be outdated soon, because some of the technology associated with Meteor is changing fast. But not every work site immediately will keep up with the latest and “greatest” changes to Meteor software, of course. And, you may encounter applications needing support that are still running earlier releases of Meteor.

This  is a worthy and valuable book for anyone just starting to learn Meteor. And it likewise can be helpful to Meteor users who want better understanding of the framework, how it is put together, and how it can be used effectively in large applications. The two authors of this book have been working with Meteor since the framework’s “infancy” in 2011.

Si Dunn

 

 

 

Groovy in Action, Second Edition – A hefty how-to guide newly updated for Groovy 2.4 – #programming #bookreview

Groovy in Action, Second Edition

Dierik König and Paul King, with Guillaume Laforge, Hamlet D’Arcy,
Cédric Champeau, Eric Pragt and Jon Skeet

Manning – paperback

Groovy in Action, Second Edition, is not light reading. Indeed, the printed book weighs nearly three and a half pounds and has 880 pages. But it is great reading for anyone who wants to learn, or get better at, the increasingly popular Groovy scripting language that works very smoothly with Java. Indeed, Java’s creator, James Gosling, has hailed Groovy’s “smooth and efficient” integration with Java and called Groovy “an effective implementation language in its own right.” He also has praised the Groovy in Action book as “a clear and detailed exposition of what is groovy about Groovy.”

The Second Edition‘s two main authors and five assisting authors are members of the Groovy core team. And their book spent a lot of time being reviewed and tested by readers in the Manning Early Access Program (MEAP) before it was formally released. So it likely has a better preparation record than many programming books currently on the market.

Groovy in Action‘s front flap indicates that the book covers Groovy 2.4. Groovy recently was up to version 2.4.3, but the programming language has maintained a good track record for supporting backward compatibility. Indeed, I tested random selections of the book’s code samples using version 2.2.0 and its Groovy Console, and programs compiled and ran without problem.

However, if you own the first edition of Groovy in Action, you likely will want to upgrade to the new book. It is, the authors state, “a full rewrite,” with several new chapters, plus  “a few hundred additional pages of genuinely new content.” (And yes, I am upgrading my Groovy installation from 2.2.0 to 2.4.3.)

Despite its heft, the book is nicely structured and easily approached. And its many code examples are mercifully compact, for the most part, and available online, if you prefer. (I actually enjoy keying reasonably short code examples into the Groovy Console.)

The 20 chapters are organized into three major parts:

  • The Groovy Language
  • Around the Groovy Library
  • Applied Groovy

“The Groovy Language” introduces the reader to the language’s basics: its “syntax, grammar, and typical idioms,” plus how to use dynamically typed Groovy as a static language, if desired. The “Around the Groovy Library” reference section focuses on such topics as working with builders and the Groovy Development Kit (GDK), as well as Groovy’s support for database programming and the handling of JSON and XML. And “Applied Groovy” looks at “typical uses cases for Groovy,” including “a thorough exposition of how to use Groovy for test automation,” how to put Groovy to work on multi-core machines in concurrent programming situations, and “using Groovy for domain specific languages.”

In short, there is no shortage of useful content in Groovy in Action, Second Edition.

Si Dunn

——————–
Get Groovy in Action, Second Edition here, at no extra cost.
——————–

BIG DATA: A well-written look at principles & best practices of scalable real-time data systems – #bookreview

 

 

Big Data

Principles and best practices of scalable real-time data systems

Nathan Marz, with James Warren

Manning – paperback

Get this book, whether you are new to working with Big Data or now an old hand at dealing with Big Data’s seemingly never-ending (and steadily expanding) complexities.

You may not agree with all that the authors offer or contend in this well-written “theory” text. But Nathan Marz’s Lambda Architecture is well worth serious consideration, especially if you are now trying to come up with more reliable and more efficient approaches to processing and mining Big Data. The writers’ explanations of some of the power, problems, and possibilities of Big Data are among the clearest and best I have read.

“More than 30,000 gigabytes of data are generated every second, and the rate of data creation is only accelerating,” Marz and Warren point out.

Thus, previous “solutions” for working with Big Data are now getting overwhelmed, not only by the sheer volume of information pouring in but by greater system complexities and failures of overworked hardware that now plague many outmoded systems.

The authors have structured their book to show “how to approach building a solution to any Big Data problem. The principles you’ll learn hold true regardless of the tooling in the current landscape, and you can use these principles to rigorously choose what tools are appropriate for your application.” In other words, they write, you will “learn how to fish, not just how to use a particular fishing rod.”

Marz’s Lambda Architecture also is at the heart of Big Data, the book. It is, the two authors explain, “an architecture that takes advantage of clustered hardware along with new tools designed specifically to capture and analyze web-scale data. It describes a scalable, easy-to-understand approach to Big Data systems that can be built and run by a small team.”

The Lambda Architecture has three layers: the batch layer, the serving layer, and the speed layer.

Not surprisingly, the book likewise is divided into three parts, each focusing on one of the layers:

  • In Part 1, chapters 4 through 9 deal with various aspects of the batch layer, such as building a batch layer from end to end and implementing an example batch layer.
  • Part 2 has two chapters that zero in on the serving layer. “The serving layer consists of databases that index and serve the results of the batch layer,” the writers explain. “Part 2 is short because databases that don’t require random writes are extraordinarily simple.”
  • In Part 3, chapters 12 through 17 explore and explain the Lambda Architecture’s speed layer, which “compensates for the high latency of the batch layer to enable up-to-date results for queries.”

Marz and Warren contend that “[t]he benefits of data systems built using the Lambda Architecture go beyond just scaling. Because your system will be able to handle much larger amounts of data, you’ll be able to collect even more data and get more value out of it. Increasing the amount and types of data you store will lead to more opportunities to mine your data, produce analytics, and build new applications.”

This book requires no previous experience with large-scale data analysis, nor with NoSQL tools. However, it helps to be somewhat familiar with traditional databases. Nathan Marz is the creator of Apache Storm and originator of the Lambda Architecture. James Warren is an analytics architect with a background in machine learning and scientific computing.

If you think the Big Data world already is too much with us, just stick around a while. Soon, it may involve almost every aspect of our lives.

Si Dunn

Programming for Musicians and Digital Artists: Creating Music with ChucK – #music #programming #bookreview

 

 

Programming for Musicians and Digital Artists

Creating Music with ChucK

Ajay Kapur, Perry Cook, Spencer Salazar and Ge Wang

Manning – paperback

Manning’s Programming for Musicians and Digital Artists is enjoyable, informative reading, particularly if you like music and programming and are motivated to combine them in some way.

The book offers plenty of clear how-to content for those who want to take their first deep dives into the techniques needed to make, modify and perform music using computers.

Indeed, this excellent guide can help take you from generating  “Hello, World” and “Twinkle, Twinkle, Little Star” to linking up with MIDI devices and creating sophisticated music and sounds that can be used in live performances and elsewhere.

Don’t be scared by the word “Programming” in the title. Yes, it can help–but it is not required–to have a little bit of programming experience. As you start working with the audio-centric programming language ChucK, you will simply type a few brief lines of code or paste them from downloaded files into a simple on-screen tool known as the “miniAudicle.” With this tool, you can then make changes and hear the results “instantly without interrupting other sounds being synthesized and heard,” the authors point out. You also can save your files, load different files and do other tasks quickly.

The free, open-source ChucK programming language, the authors’ emphasize, “is designed specifically for real-time sound synthesis and music creation.” Their book provides numerous short code examples to tinker with, as well as a few basic physics, math and music pointers that illustrate features and help support the authors’ descriptions.

Note: If your goal is to sit down at a keyboard and immediately start creating digital music, you may want to skip this book and look for other options. The authors concede that “many artists are happy with over-the-counter software systems and controllers for real-time performance work. And there are many who only want to use computers to produce static final products in the form of .wav/.mp3 files, CDs or collections of songs, sound tracks for videos, and more. A large number of those artists are happy to learn and use the packages and tools from commercial or free sources.

“But there are many, and we’re betting you’re one, who want more,” they add. “Maybe you’re coming to this book with a big idea (or many big ideas) and want the tools to help you realize it/them. Maybe you’re looking to shift directions in your art making. Or perhaps you already know how to program in a language such as Java, but you find it doesn’t do what you want.”

ChucK gives you “greater under-the-hood access” than some of the other popular music/sound languages and systems, such as Csound, SuperCollider, JSyn, Max/MSP and PD (Pure Data). And Chuck, the authors note, “is generally more succinct, requiring much less code (lines of typed text) than these other languages in order to accomplish a particular task.”

You learn how to work with many different tools, ranging from oscillators, to filters, to delay generators, reverberators and other audio effects, and MIDI (even without a MIDI interface and cable). You also learn how to generate the sounds of several different musical instruments.

ChucK has a key emphasis on ease of controlling time: for example, how long a tone or sounds occurs, how often it occurs within a set time period, and how long are the silences between tones or sounds.

I have not yet tried all of the code examples in the book, but the ones I have tried in several chapters have worked very well on a Windows laptop and are easily modified and tested in real time using the miniAudicle. (The book also shows how to install ChucK on Mac OS X and Ubuntu Linux systems).

Thus far, I have encountered only one typo in the printed book’s code examples. In Listing 1.8, “Playing notes with integer values,” there is a mistake in the line that is supposed to multiply the frequency of a tone pitch by 2. However, the line is printed “1 *=> myPitch;” — which simply repeats previous pitch. Changing the line to “2 *=> myPitch;” fixes the problem and takes only a couple of seconds to implement in the miniAudicle.

Si Dunn

 

JavaScript Application Design: A book you likely need if you are working with, or still learning, JavaScript – #programming #bookreview

JavaScript Application Design

A Build First Approach

Nicolas Bevacqua

Manning – paperback

 

I didn’t know how much I needed this book until I started reading it and exploring its code examples.

Many of us who have worked with JavaScript started our connections to the language in very haphazard fashions. We learned some of it on the job, under deadline pressure to fix or update somebody else’s code. Or we took an introductory class or two and then started picking up whatever else we could on the fly, including the bad habits of others around us who seemed to know a bit more about JavaScript than we knew at the moment.

Unfortunately, JavaScript is a big, messy programming language, and it offers numerous opportunities to crash and burn if you really don’t know what you are doing.

In his new book, JavaScript Application Design, Nicolas Bevacqua makes a compelling case for using “the Build First philosophy of designing for clean, well-structured, and testable applications before you write a single line of code.”

He writes: “You’ll learn about process automation, which will mitigate the odds of human error…. Build First is the foundation that will empower you to design clean, well-structured, and testable applications, which are easy to maintain and refactor. Those are the two fundamental aspects of Build First: process automation and design.”

In his well-written text, he argues: “Front-end development requires as much dedication to architecture planning and design as back-end development does. Long gone are the days when we’d copy a few snippets of code off the internet, paste them in our page, and call it a day. Mashing together JavaScript code as an afterthought no longer holds up to modern standards. JavaScript is now front and center.”

He continues: “We have many frameworks and libraries to choose from, which can help you organize your code by allowing you to write small components rather than a monolithic application. Maintainability isn’t something you can tack onto a code base whenever you’d like; it’s something you have to build into the application, and the philosophy under which the application is designed, from the beginning. Writing an application that isn’t designed to be maintainable translates into stacking feature after feature in an ever-so-slightly tilting Jenga tower.”

Bevacqua divides his nine-chapter book into just two parts: build processes and managing complexity. Here is how the chapters are organized:

  • PART 1: BUILD PROCESSES
    1 – Introduction to Build First
    2 – Composing build tasks and flows
    3 – Mastering environments and the development workflow
    4 – Release, deployment, and monitoring
  • PART 2: MANAGING COMPLEXITY
  • 5 – Embracing modularity and dependency management
    6 – Understanding asynchronous flow control methods in JavaScript
    7 – Leveraging the Model-View-Controller
    8 – Testing JavaScript components
    9 – REST API design and layered service architectures

Bevaqua notes that “Linting is often referred to as the first test you should set up when writing JavaScript. Where linters fail, unit tests come in.” He strongly pushes testing and automation right from the start.

Linting soon leads to Grunt, which Bevaqua uses as a task runner and key build tool (with selected modules) in this book. “Grunt is a tool that allows you to write, configure, and automate tasks–such as minifying a JavaScript file or compiling a LESS style sheet–for your application,” he states. (It also works well on Windows machines, which I find handy.)

Grunt leads to running a bit of Node.js on the command line. And if you’ve never worked with Node.js, Bevacqua takes the reader smoothly through the process of installing it and using it in linting exercises. Indeed, he devotes an entire appendix (B) to installing and running Grunt and picking the right plugins for the right tasks and targets.

One of the best parts of this book, to me, is how the author uses short code examples to introduce a concept, and  then builds upon the examples with helpful descriptions and more short but expanded code samples.

Nicolas Bevacqua offers his readers plenty of helpful how-to and why information. Using his book, I have begun applying the Build First approach to some new projects and learning to how test and automate more of my work. I feel as if I now have a good shot at getting a lot better at JavaScript.

There is one small but important glitch to note: At two points in my preview copy of the book from Manning, Bevacqua shows what he calls a simple way to create bare-minimum JSON manifest files. For example, echo “{}” > package.json. Creating a blank, starting-point manifest file did not work this way for me. Instead, I had to use echo {“name: ” “project-name”} > package.json. The empty package.json issue apparently is somehow related to certain versions of Node’s npm.

Si Dunn