March 2019 archive

Mar 29 2019

Book review: justinguitar.com Intermediate Method by Justin Sandercoe

intermediate_courseIt is possibly inevitable that my guitar playing has leaked into my book reviewing, or that time I should have spent practicing has gone into reading books, or buying gadgets. So far I have been well-behaved on the guitar buying front, my guitar count is still at one.

However, I have bought a Boss Katana 50 amplifier which counts as saving money since it simulates other amplifiers! As well as 5 amplifier models it allows for 3 effects to be chained together to such as reverb, chorus and overdrive. Justinguitar.com has a whole section on the amplifier (link), this includes downloadable settings which if you’re playing correctly will give you the same tone as Justin and the original track. Any differences in sound will be down to your skill.

But back to the next book, justinguitar.com Intermediate Method by Justin Sandercoe is the follow up to the Beginner’s Course I reviewed previously. I reviewed the Beginner’s Method when I’d worked most of my way through it, this one I’m reviewing after just reading it and trying out a few of the new things.

The Intermediate Course contains five stages in contrast to the nine in the beginners stage, it finishes with a section on different improvisation styles including jazz and fingerstyle playing. The stages tend to develop ideas in previous stages rather than each stage representing a new area. Four months after I started playing it is probably a bit soon for me to be working seriously on this course, although I have a good memory for chord shapes and the minor pentatonic scale my playing is really slow which I think will only be fixed by practice. I could do with learning some more songs too. Justin pitches this very much as an optional course, the Beginner’ Course should leave you competent to play a wide range of tunes.

Barre chords were introduced towards the end of the Beginner’s Course, in this course they are expanded and developed further — indeed barre chords are the main chord work of the book. The beginner’s course just looked at the Major E-shape barre-chord, here we meet the variants of the E-shape (minor, dominant 7th and minor 7th), as well as other shapes (the A-shape and the diminished/half-diminished). One of my achievements playing guitar is a fairly good barre –gained by practicing bits of Creep by Radiohead excessively – it isn’t yet entirely useful since I can’t change very quickly.There are still some of the one minute chord change exercises which I found really useful in the beginner course.  

A new feature of this course is an introduction to standard musical notation. TAB notation works very well for guitarists since it tells you where to put your fingers but it doesn’t provide a visible sign of the rise and fall of a melody also other musicians don’t speak TAB.

The beginner’s course introduced the minor pentatonic scale, here we learn the major scale, the blues scale and a hybrid scale. The importance of scales is that they provide a basis for improvisation.

The intermediate course also covers some more advanced techniques including note bending and hammer on/flick off. This is handy because any cursory glance at guitar tutorials on YouTube will show tutors using these techniques fairly casually. As for the beginners book, Intermediate Course works best in combination with the video tutorials on the justinguitar.com website (which are free). I read the Blues material but the website pulls it together more clearly than the book and certain technical skills are very hard to learn off a page. nI particular the online course talks very clearly about using licks (short runs of individual notes) as “words” in a Blues language.

Alongside the course books there are also Songbooks, I have the Beginners Songbook and the Rock Songbook. These complete the online videos well, provided a record of chords and TABs for what can be complex songs.

I should probably review my “learning journey” at this point, I think the way forward here is to pick a few songs and learn them properly, maybe making a recording. Ideally these should focus on improving particular skills. So far I’ve learned riffs from a few songs – Seven Nation Army, Smoke on the Water, Teenage Kicks, Creep but not really the whole thing. The only exceptions to this are Link Wray’s Rumble, which is pretty simple and I’ve been practicing a 12-bar blues which varies from the version Justin teaches with an intro and an “outro”.

Although I’m not ready to work through this book systematically I’m glad I got it now.

Mar 20 2019

Book review: JavaScript Patterns by Stoyan Stefanov

More technology related reviewing next, JavaScript Patterns by Stoyan Stefanov. This is part of my continuing effort to learn JavaScript.

For me this isn’t a question of learning the nuts and bolts of a language but rather one of learning to use it fluently and idiomatically.

I thought this book might be in the spirit of the original “Gang of four” design patterns, but although it mentions these design patterns it is more generally about good style in JavaScript. The book is divided into eight chapters including an introduction.

The first substantive chapter on “essentials” talks mainly about variable declarations and some odds and ends. The most interesting one of these was the behaviour of parseInt which converts a string into an integer. Except if the string starts with a zero, as ISO8601 days and months would, then parseInt assumes it is a number in base 8 (octal)!! I can foresee many long hours trying to debug this problem without this forewarning. This chapter also discusses the importance of coding style conventions.

The second chapter talks about literals and constructors. It strikes me that much of this is about unwinding the behaviour of developers more used to statically-typed languages. The JavaScript way is to create objects by example, rather than take a class definition and derive from that. Although in the permissive manner of many languages it will let you do it either way. Since this book was written JavaScript has gained a “class” keyword which allows you to construct classes as you might in Java or C#.

Next up are functions, JavaScript shares Python’s view of functions as objects, allowing them to be passed as arguments. This is particularly important in JavaScript to provide “callback” functionality which is very useful when doing asynchronous programming. I learn here that the “currying” of function is named after Haskell Curry, who also has a whole language named for him. I always feel when passing functions as arguments that I am fiddling with the underpinnings of reality – it can make debugger difficult too.

I found the idea of functions that redefine themselves on first run interesting, it sounds useful and dangerous at the same time.

The chapter on object creation patterns is all about introducing module like behaviour and namespacing to JavaScript which at the time the book was written were not part of the language. Also covered are making private properties by hiding them in function closures.

The code reuse chapter is largely about patterns for achieving inheritance-like behaviour. This introduces a range of patterns which build up to almost exactly replicate class-based inheritance.

Finally we meet some of the classic Gang of Four design patterns. Some of these patterns, such as the iterator pattern, have been absorbed entirely into the core of languages like Python and more recently, JavaScript. The Observer patterns is implemented in web browsers as events, which are ubiquitous. Perhaps the lesson of this chapter is that some of the Gang of Four patterns have been absorbed into the core of languages, we use them almost without thinking. The Strategy Pattern, which determines algorithms at runtime, fits well with the chapter on functions and JavaScript’s view of functions as objects.

The book finishes with a chapter on patterns for the Document Object Model, or rather JavaScript in the browser. It includes well-known advice such as not testing for browser type but rather testing for functionality. It also has advice on optimising JavaScript for deployment.

There is minimal mention of specific tools or libraries in this regard, although Yahoo’s YUI library is mentioned a few times – Stefanov has worked on this library so this is unsurprising, and not unreasonable.

This book had more of the air of Douglas Crockfords’ JavaScript: The Good Parts than a book on patterns which was what I was expecting. Alternatively perhaps “JavaScript for users of statically-typed languages”, as such it probably works pretty well for Python programmers too although modules have always been built-in to Python and there is a “class” keyword for specifying classes.

JavaScript Patterns is readable though, I’m glad I picked it up.