‘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

 

 

 

Advertisements

D3.js in Action: A good book packed with data visualization how-to info – #javascript #programming

D3.js in Action

Elijah Meeks

Manning – paperback

 

The D3.js library is very powerful, and it is full of useful choices and possibilities. But, you should not try to tackle Elijah Meeks’s new book if you are a JavaScript newcomer and not also comfortable with HTML, CSS and JSON.

It likewise helps to understand how CSVs (Comma Separated Values) can be used. And you should know how to set up and run local web servers on your computer. Prior knowledge of D3.js and SVG (Scalable Vector Graphics) is not necessary, however.

Some reviewers have remarked on the amount of how-to and technical information packed into DS3.js in Action. It is indeed impressive. And, yes, it really can seem like concepts, details and examples are being squirted at you from a fire hose, particularly if you are attempting to race through the text. As Elijah Meeks writes, “[T]he focus of this book is on a more exhaustive explanation of key principles of the library.”

So plan to take your time. Tackle D3.js in small bites, using the d3js.org website and this text. I am pretty new to learning data visualization, and I definitely had never heard of visualizations such as Voronoi diagrams, nor tools such as TopoJSON, until I started working my way through this book. And those are just a few of the available possibilities.

I have not yet tried all of the code examples. But the ones I have tested have worked very well, and they have gotten me thinking about how I can adapt them to use in some of my work.

I am a bit disappointed that the book takes 40 pages to get to the requisite “Hello, world” examples. And once you arrive, the explanations likely will seem a bit murky and incomplete to some readers.

However, that is a minor complaint. D3.js in Action will get frequent use as I dig deeper into data visualization. D3.js and Elijah Meeks’s new book are keepers for the long-term in the big world of JavaScript.

Si Dunn

jQUERY UI IN ACTION: A smooth guide to getting, learning and using plugins supported by the jQuery Foundation – #bookreview

jQuery UI in Action

TJ VanToll

 (Manning – paperback)

 

TJ VanToll had two straightforward goals in mind when he decided to write this nicely prepared book: “I wanted to write about how to use the jQuery UI components in real-world usage scenarios and applications. I also wanted to tackle the tough questions for jQuery UI users. [Such as] Why should you use the jQuery UI datepicker instead of the native date picker included in HTML5? How do you use jQuery UI on mobile devices, especially in low bandwidth situations?”

According to the jQuery Foundation, “jQuery is a fast, small, and feature-rich JavaScript library. It makes things like HTML document traversal and manipulation, event handling, animation, and Ajax much simpler with an easy-to-use API that works across a multitude of browsers. With a combination of versatility and extensibility, jQuery has changed the way that millions of people write JavaScript.”

The problem with popularity, of course, is that jQuery became widely employed soon after it was introduced in 2006. Users quickly created a flood of jQuery plugins that, Van Toll writes, “had inconsistent APIs, and often had little or no documentation. Because of these problems, the jQuery team wanted to provide an official set of plugins in a centralized location. In September 2007 they created a new library with these plugins—jQuery UI.”

He adds: “From a high level, jQuery UI was, and still is, a collection of plugins and utilities that build on jQuery. But dig deeper and you find a set of consistent, well-documented, themeable building blocks to help you create everything from small websites to highly complex web applications. Unlike jQuery plugins, the plugins and utilities in jQuery UI are supported by the jQuery Foundation. You can count on them to be officially supported and maintained throughout the life of your application.”

Well-written and well-illustrated, jQuery UI in Action reflects VanToll’s knowledge and experience as a professional web developer and member of the core jQuery UI team.

The book is structured into three parts, encompassing 12 chapters. And it assumes readers have at least basic experience with JavaScript, CSS, and jQuery.

Part One’s chapters introduce jQuery UI and “the ins and outs of widgets…the core building blocks of jQuery UI.”

Part Two’s chapters offer “a comprehensive look at the components of jQuery UI: twelve jQuery UI widgets (chapters 3–4), five jQuery
UI interactions (chapter 5), numerous jQuery UI effects (chapter 6), and the jQuery UI CSS framework (chapter 7).” VanToll explains how each component works and shows how to apply the knowledge to real-world applications. The example projects include: building complex webforms with jQueryUI; using layout and utility widgets; adding interaction to interfaces; and using built-in and customized themes to provide “a consistent look to all widgets.”

Part Three focuses on “Customization and advanced usage.” Here, VanToll explores such topics as using the widget factory to create custom widgets, preparing applications for production, and building a flight-search application “at real-world scale.” In the final chapter, he takes us under jQuery’s hood “to dig into a series of utilities, methods, and properties intended for more advanced usage of the library.”

If you work with jQuery or are ready to start using it, take a good look at jQuery UI, as well. As this book promises, “You’re only one tag away from richer user interfaces….” That tag is pretty simple: <script src=”jquery-ui.js”> — but a lot can happen once you include it.

TJ VanToll’s new book should be your go-to guide for getting, learning and putting jQuery UI into action.

Si Dunn

 

 

 

 

 

http://amzn.to/1r1VwUI

 

You’ll master jQuery UI’s five main interactions—draggable, droppable, resizable, selectable, and sortable—and learn UI techniques that work across all devices.

Grails in Action, 2nd Edition – A (mostly) winning how-to guide to use with a winning web app framework – #programming #bookreview

 

Grails in Action, Second Edition

Glen Smith and Peter Ledbrook

(Manning – paperback)

Grails finishes at or very near the top in almost any smackdown of full-stack web application frameworks that run on the Java Virtual Machine (JVM). And this recently updated Grails in Action how-to book is mostly a clear winner, too.

According to the Grails.org website, open-source Grails “takes advantage of the Groovy programming language and convention over configuration to provide a productive and streamlined development experience.”

Grails likewise is a world that “moves very quickly,” the authors of Grails in Action, Second Edition emphasize. “There have been substantial changes in Grails in the time it took us to develop Grails in Action, Second Edition. Even moving from Grails 2.2 to 2.3 caused us to make significant changes! Although the book targets Grails 2.3, a new version of Grails (2.4) is already available. Fortunately, everything in here is still valid for the new version.”

In the first chapter, the authors try to move very quickly through the process of getting a Grails application up, running, tested and deployed. But in taking this “Grails in a hurry” approach, they race a bit too quickly and unclearly through the installation instructions, in my opinion. (My Linux and Windows installations did not work correctly at first, and I had to seek out  information on how to sort them out.)

And, in the portion of the chapter where you are told how to get the random-quote database set up and working, it is not always clear which file you are supposed to modify and in which subdirectory. I already had a little bit of experience with Groovy, so that portion went smoothly. But the Grails database steps could have been explained and illustrated more clearly. It took me several tries to finally get the “Quote of the Day” database working and posting random quotes.

The authors take a four-part approach to explaining Grails and its underlying Groovy programming language:

  • Part 1: Introducing Grails – You are shown how to get a nicely formatted Quote of the Day (QOTD) application up and running, while also learning how to work with Groovy.
  • Part 2: Core Grails – You get a “more thorough exploration of the three core parts of the Grails ecosystem: models,
    controllers, and views.” Includes such topics as: domain modeling; query mechanisms; how to query a database in Grails without using SQL; Grails’ web-oriented features; Grails Service objects; Grails’ tags for user interface construction; and Grails support for Ajax.
  • Part 3: Everyday Grails – The focus here is on “building all the necessary pieces of a real-world application.” The chapters cover tests, plug-ins, security in Grails and working with RESTful APIs. The chapters also cover (1) Grails single-page web apps using the Angular.js framework, and (2) Spring integration in Grails.
  • Part 4: Advanced Grails – These chapters zero in on “performance tuning, legacy integration, database transactions, custom build processes, and even how to develop and publish your own plugins.”

Aside from a few small omissions of how-to information, I am happy to have the wide-ranging contents of this book. And I am certainly pleased with what I can now do with Grails and Groovy, after reading Grails in Action, Second Edition.

 —Si Dunn

 

 

Ember.js in Action – An ambitious overview, with glitches – #programming #bookreview

Ember.js in Action

Joachim Haagen Skeie

(Manning – paperback)

 

The Ember.js JavaScript framework has “a steep learning curve,” Joachim Haagen Skeie cautions readers repeatedly in his new book.

Indeed, Ember does. I’ve watched that learning curve confuse and frustrate several experienced JavaScript and Ruby on Rails developers. And I’ve banged my own (thick) skull against the Ember.js framework several times while (1) trying to learn it from an assortment of books and websites, including emberjs.com, and (2) building a few basic apps.

Skeie’s new book is an ambitious overview of software that bills itself as “a framework for creating ambitious web applications.” And Skeie ambitiously does not start out with a lame “Hello, World!” example. Right in Chapter 1, you dive into building a real-world application for creating, editing, posting and deleting notes. ” The source code for the Notes application weighs in at about 200 lines of code and 130 lines of CSS, including the templates and JavaScript source code,” Skeie points out. “You should be able to develop and run this application on any Windows-, Mac-, or Linux-based platform using only a text editor.”

I got  the Notes app to (mostly) run on a Windows machine and a Linux machine. But I can’t get it to save the contents of notes, even though I downloaded the book’s code samples, and my code seems to match what the author highlights in his book. (Still trying to sort out the problem. Perhaps something is wrong in my setups?)

I hate writing mixed reviews. It takes enormous effort and thought to create and finish a book. And I have been looking and hoping for a solid how-to text on Ember. For me, however, this book has two key downsides. First, the code examples are written for Ember.js 1.0.0, and as this review is being written, Ember.js 1.5.1 is the latest release (with 1.6 in beta). Second, the book’s opening chapter is very difficult for beginners to follow.

Some other reviewers also have noticed problems with the book’s example code –which, for me, forms the heart of a good how-to book. And they have taken issue with how the code is presented in the text.

Still, there is much to like here, especially if you are experienced in JavaScript and in model-view-controller (MVC) frameworks and have been curious about Ember.js.

I am fairly new to Ember, so some of the chapters most helpful to me have included using Handlebars js, testing Ember.js applications and creating custom Ember.js components–areas not given much notice in the other Ember books I have read.

If you are new to JavaScript and to frameworks, do not attempt to dive into Ember.js in Action as your first Ember exposure. Start with the Ember.js website and some simpler books first. Then, consider this book.

Hopefully, in the next edition, the all-important opening chapter will be reworked, and the code examples will be presented in a clearer and more complete fashion.

Si Dunn

 

Learning Dart – A solid guide to basic development using Google’s Dart #programming language – #bookreview

Learning Dart

Learn how to program applications with Dart 1.0, a language specifically designed to produce better-structured, high performance applications 

Ivo Balbaert and Dzenan Ridjanovic

(Packt – Kindle, paperback)

 

The programming language Dart was introduced in late 2011 by Google as a potential replacement for aging JavaScript. But JavaScript, of course, has continued to spread all over the Internet and planet since it first appeared in 1995.

Not surprisingly, Google found itself getting some pushback from software developers and others who have a lot of time, education, sweat and money invested into creating, supporting and modernizing files that have .js extensions.

Dart today is billed as “a new platform for scalable web app engineering.” It is a long way from replacing JavaScript. Indeed, it compiles to JavaScript.

At the same time,  Dart is a good and powerful Open Source language. And, while it is not yet seen on most lists of top languages to know, it is gaining momentum and followers in the software world.

“Dart looks instantly familiar to the majority of today’s programmers coming from a Java, C#, or JavaScript/ActionScript background; you will feel at ease with Dart,” write the authors of Learning Dart.

“However, this does not mean it [Dart] is only a copy of what already exists; it takes the best features of the statically typed ‘Java-C#’ world and combines these with features more commonly found in dynamic languages such as JavaScript, Python, and Ruby. On the nimble, dynamic side[,] Dart allows rapid prototyping, evolving into a more structured development familiar to business app developers when application requirements become more complex.”

In their recent book,  Balbaert and Ridjanovic note this about Dart: “Its main emphasis lies on building complex (if necessary), high-performance, and scalable-rich client apps for the modern web.”

Likewise, they point out that  “Dart can also run independently on servers. Because Dart clients and servers can communicate through web sockets (a persistent connection that allows both parties to start sending data at any time), it is in fact an end-to-end solution. It is perfect on the frontend for developing web components with all the necessary application logic, nicely integrated with HTML5 and the browser document model (DOM).

“On the backend server side, it can be used to develop web services, for example, to access databases, or cloud solutions in Google App Engine or other cloud infrastructures. Moreover, it is ready to be used in the multicore world (remember, even your cell phone is multicore nowadays) because a Dart program can divide its work amongst any number of separate processes, called isolates, an actor-based concurrency model as in Erlang.”

Their well-written book, from Packt Publishing, delivers a structured and nicely paced overview of how to use the Dart programming language. The book is suited for inexperienced developers and experienced developers alike who are curious about, or ready to dig into, Dart .

The intended audience, the authors state, includes “…web application programmers, game developers, and other software engineers. Because of its dual focus (Dart and HTML5), the book can appeal to both web developers who want to learn a modern way of developing web applications, and to developers who seek guidance on how to use HTML5.”

Indeed, in the first chapter, you get more than the obligatory “Hello, World!” program. You also learn how to use the Eclipse-based Dart Editor to create some simple command-line and web applications.

From there, the 12-chapter work focuses on topics and software examples that range from variables, classes and libraries, to combining HTML forms with Dart, building games with HTML5 and Dart, developing business apps with Polymer web components, using Dart with MVC web and UI frameworks, working with local data and client-server communications, and creating data-driven web applications using Dart and MySQL or MongoDB.

I have tested some of the book’s code examples both on Linux and Windows machines and have enjoyed working with the Dart Editor. However, I did find a couple of code typos in the print version while hand-typing some of the shorter examples. The better choice is to download and use the book’s code examples found on the Packt website.

One other matter that some new Dartisans may encounter: Norton 360 antivirus software currently tends to throw dart.exe into quarantine on Windows machines–and that stops Dart cold. There is a fairly simple way to retrieve the file from quarantine and tell Norton 360 to let it run. However, check the Dart community page on Google+ for info on that and some other approaches to avoiding the problem.

Learning Dart was published soon after Dart 1.0 was released, and Dart has continued to evolve fairly quickly. (Its stable version was 1.4.3 at the time this was written.) So there will be some small differences in screen displays and other matters.

If you want to learn Dart and get up to speed for using it in application development, Learning Dart can be your handy and solid how-to guide.

Si Dunn

 ***

Ready to get Learning Dart? Click here: Kindlepaperback

Play for Java – Good intro to the Play 2 Java web framework – #programming #bookreview

Play for Java

Nicolas Leroux and Sietse de Kaper

(Manning, paperback)

 

“There are,” co-author Nicolas Leroux writes, ” many Java web frameworks, but most of them have a key flaw: they try to hide the web behind an abstraction layer, rather than embracing it. That is the most important difference between Play and most other Java web frameworks (Servlets, we’re looking at you!).”

His writing partner, Sietse de Kaper,  adds: “Play ‘gets it.’ For ‘it,’ in this case, a lot of things can be substituted. Play ‘gets’ HTTP and the web in general, how developing web application works, what makes a nice and clean API, and more. This was clear from the early Play 1 beta versions, and that’s why we’ve used it on many projects since 1.0 came out. It didn’t disappoint. Now, with Play 2, Play continues to improve web development for the Java platform.”

Their new book from Manning is nicely written, adequately illustrated and structured properly to help newcomers get started with Play and with basic web application development. Play for Java also can help experienced web app developers quickly get up to speed quickly with this powerful development platform.

You start by creating and modifying the ubiquitous “Hello world!” application. Then you spend the remaining chapters developing, expanding and enhancing a warehouse management application, one designed to meet specific requirements within a made-up company. “Enterprise applications usually live inside the IT department and are usually hosted within the organization,” Leroux and de Kaper explain. Indeed, businesses may have several or many enterprise applications serving specific purposes, and those apps often do not communicate with each other.

As both writers note: “Web developers are used to interacting with their applications through the browser. With Play, you can also use the console to interact with your web application’s development environment and build system. This is important for both quick experiments and automating things.”

The web app framework Play is, indeed, fun to play with–and work with. For example, it is very good at showing you exactly (ona browser screen) where you have made a keystroke mistake or other blunder in your code. And the words  “Compilation error” on the screen display can’t be missed. Indeed, they can be read from across a room. (Fortunately, in my office, so no one sees them but me.)

If you decide to download Play and give it a try, be sure you (1) have Java installed correctly and (2) know how to set PATHs correctly on your Windows, Linux, or Mac machine. (I had a lingering Java glitch in one of my machines, and I nearly flung a Windows 7 PC into a wall in frustration. But I finally found the problem and fixed it, and Play immediately popped to life as shown in the book. Meanwhile, Play installed smoothly on a Windows 8.1 machine and an ex-XP PC now running Ubuntu.) 

The authors show how to use Play with three IDEs: Eclipse, NetBeans and IntelliJ. Or, if you prefer, you can stick with the Play console and a text editor such as Notepad++ (my current favorite). And they repeatedly emphasize that (1) you should not worry that their Java framework called Play actually is written in Scala and (2) you will encounter some bits of Scala while working with template files.

“Any template language has structures you need to know to build your templates, and Scala templates are no different,” they explain. “Once you know what you have to do to, for example, iterate over a collection or insert a variable value somewhere, you know all you have to know to use that feature. You don’t have to think of it as Scala if you don’t want to. Think of it as another template language.” (Actually, Scala is not scary at all once you’ve spent a little time with it or taken an online class.)

Play supports the optional use of some compiled assets, and “[o]ut of the box, Play 2 comes with support for LESS, CoffeeScript, and Google’s Closure compiler,” the co-authors note.

According to Playframework.org, Play is built on Akka and offers “a lightweight, stateless, web-friendly architecture.” It also offers built-in testing tools and speedy “hit refresh” workflow capabilities.

Whether you are an experienced web app developer, a newcomer, a student or a hobbyist programmer, it can be serious fun to work with–or play with–Play. And Nicolas Leroux’s and Sietse de Kaper’s Play for Java can be exactly the well-tuned guide you need to learn Play 2.

 — Si Dunn