Nicolas Bevacqua

author
+ Follow
since Apr 08, 2015
Merit badge: grant badges
For More
Cows and Likes
Cows
Total received
5
In last 30 days
0
Total given
0
Likes
Total received
7
Received in last 30 days
0
Total given
0
Given in last 30 days
0
Forums and Threads
Scavenger Hunt
expand Ranch Hand Scavenger Hunt
expand Greenhorn Scavenger Hunt

Recent posts by Nicolas Bevacqua

The book takes a more functional approach. It's typically uncommon to see strictly object-oriented JavaScript, as a lot of people even regard it as bad practice (because prototypical inheritance is easy to get wrong)
Thanks for having me, everyone!
As I mention somewhere in the introduction of the book, the book aims to bring concepts we already encrusted in our skulls with back-end languages (c#, java, etc) but which we rarely apply to JavaScript (namely, carefully putting together an effective build process).

The first part of the book is the most unique one, as it explains how to put together those processes for JavaScript, as well as the kind of tasks we'll need to be doing to ensure code quality while being able to keep your continuous development cycles short.
The Build First philosophy is mostly outlined in Chapter 1. The idea is that in most other languages you already have a compiler that does the "spell checking" for you, but in JavaScript you don't. The book encourages you to mitigate the bad parts of not having a compiler by setting up a minimal build process as soon as you possibly can, with a linting task that will do this spell checking for you. Then as your project matures and your requirements change, your build processes should mature with it. The idea there is that it shouldn't become an issue when you need to deploy to production and suddenly you encounter all of these things that you need to do to optimize the performance of your application, only to find out that you can't do that effectively because it wasn't baked into your application design in the first place. This is why the book recommends to follow a "Build First" approach.
Yes. It's really hard to stay up to date with the latest technologies of the web. Even if you go by standards alone. There's so many of them being worked on that you can hardly get a grasp on all of them (Audio, WebRTC, WebWorker, ServiceWorker, Promises, async/await, Generators, Syntax, Web Components, responsive images, etc) the list seems endless.
The book addresses this issue by not fixating in any one particular tool or technology but instead discussing the underlying design issues. If you have a solid understanding of what it takes to design a robust application, it won't matter how much technology you throw at it, because it'll all be properly encapsulated in tiny reusable modules
The focus is on the client-side mostly because I didn't want to focus on Node.js which is not necessarily all people use for their back-end. Instead I focused on what everyone does, which is client-side JavaScript. Most of the advice can be applied to both sides of the stack, though.
Hello!
The book covers writing small modules of code and mastering asynchronous flows in JavaScript. You'll learn about well known and established patterns like using closures, as well as unreleased JavaScript APIs from ES6 like generators.
I do talk about specific frameworks. In the first part of the book, focused mostly on automating build and deployment processes, I use Grunt as the build tool of choice, although I try not to focus too heavily on Grunt as a tool, but just a means to an end. In fact, I dedicated an entire appendix to pointing out that Grunt is just a tool and that there are many more available (Gulp, Broccoli, npm run, to name a few).

The MVC chapter covers Backbone (an MVC framework) and Rendr (a library that enables you to do server-side rendering with Backbone)
The testing chapter covers Tape which is a tiny test runner.
A few more libraries are covered as well

Please take a look at the code samples to get a better idea of the kind of code that I talk about.
modules: https://github.com/buildfirst/buildfirst/tree/master/ch05
async: https://github.com/buildfirst/buildfirst/tree/master/ch06
The book has a part focused on automating your processes and a part focused on code quality. If you already know JavaScript then you won't have any trouble picking up the examples. While aimed at intermediate, as you mentioned, the book strives to explain most concepts and not leave much for granted
The book is comprised on two parts. The first part talks about processes: builds, continuous integration, deployments. The second part talks about JavaScript code quality, helping you to improve on your JS skills with concerns such as modularity (writing small pieces of code), taming asynchronous JavaScript (callbacks, promises, generators, etc), use an MVC framework (Backbone is used for the examples) to further separate the concerns in your application.

I'd recommend JavaScript: The Good Parts if you've never read anything about JavaScript, it's a great place to start. My book has more of a focus on process automation and code quality than on the language itself.
My recommendation regarding Single Page Applications (SPA) is to try and not break the web. That is to say, try and use a client-side framework that enables you to do server-side rendering (React, Backbone, Taunus, Angular 2.0 when it comes out, Ember is working on it), so that you don't degrade performance or accessibility. If you want to develop a single page application, don't just go with jQuery. Take the structured approach. Learn one of the big frameworks (Angular React Backbone Ember), or develop one of your own (like I did with Taunus), which I believe to be equally important as "learning" one of the existing frameworks, because you'll get a much better idea of why you need them and how they work.

Obfuscation through oscurity is a moot point. It only provides you, the developer, with a false sense of security. It won't do anything to dampen the efforts of bad people to figure out your code. Just don't put any sensitive data (e.g API keys) in your client-side code, and repeat all validation server-side for redundancy (because the client can remove the JavaScript validation on the client side)
TDD is mentioned in Chapter 8, which talks about all kinds of testing: unit tests, integration tests, visual tests, performance tests, etc. You can get a glimpse by visiting the online source code repository on GitHub, here: https://github.com/buildfirst/buildfirst/tree/master/ch08

The book does not encourage TDD. Most books which discuss testing do recommend TDD on some level, but I wanted the reader to focus on the testing parts, and not the "testing first" aspect. If the reader is new to testing, that's hard enough as it is, they can always discover TDD further down the road.