Advert TechBookReport logo

Independent developer book reviews by and for practitioners

 
SQL Success : Database Programming Proficiency

SQL is one of those core skills that the majority of developers need to have in the armoury. Whether you're coding in Java or JavaScript or any language in between, the chances are that at some point you will to connect to a database, run a query and draw down some data. Now, there are plenty of training materials around that will walk the beginner through some basic data definition language and some querying - we've even got that here at TechBookReport. But the truth is there's a huge gap between writing a simple query that joins a couple of fields and something that can group, filter and process huge volumes of data efficiently and effectively. Which is where this book comes in - this is aimed squarely at the developer who wants to step up a level in SQL skills.

Now, one of the key challenges in putting together a book like this is the fact that pretty much every relational database management system sports its own version of SQL - the core might stay the same across products, but there are quirks and exceptions aplenty. It's not so much the syntax, it's things like data types, how you specify constraints, how keys are handled and more. Somehow Stephane Faroult manages to negotiate all of that in the text without it being too obstructive or a big deal. For the record the book covers SQL Server, Oracle, MySQL, PostgresSQL, DB2 and even SQLite.

No real background in SQL is assumed, so the opening chapters start from the basics of data definition to simple queries. Examples are always important and in this case all the examples are structured around building a database of movies and actors/directors. [Continued]
Clojure Made Simple

There can be no denying the spike in interest in the latest generation of Lisp-like languages - including Scheme, Clojure and a relative new-comer Racket (and for those interested in the latter, take a look at our review of Realm of Racket for the gory details). Far from being consigned to history, Lisp is back in vogue, unlike some of the other languages that emerged in the same era (such as APL, for example). In my humble opinion, a good part of this renewed interest is thanks to Java. The Java run-time environment is pretty much everywhere - as a platform it's solid, offers pretty good performance and is well-supported. Building new languages on top of the run-time has really mushroomed in the last few years, so there's no surprise that in the profusion of languages exploiting the Java Virtual Machine there are some Lisp-flavoured ones like Clojure. But it's not just the run-time, the computing environment that the run-time operates in has become more complex too, particularly with the rise of increasingly parallel computing. Java the language can support concurrent programming of course, but the whole object oriented paradigm becomes more difficult when you have to worry about data mutability all the time.

All of which is to say that part of the attraction of Clojure is that is handles concurrency in a much more natural way than Java does. And for those who are looking for that fast introduction to the language, John Stevenson's 'Clojure Made Simple' has a lot to offer. For starters this really is a brief introduction - the page count doesn't make 50. This means that the explanations are stripped down so that you only get the core essentials of the language. This means no extended examples, no forays into theory and only a skim on any deep level of detail. But it's enough to introduce the language and make clear the different philosophy that underlies it - Closure is a functional language based on Lisp, and these are the key features...

The opening chapter makes a stab at explaining why you should be interested - which is a good place to start a new language. The assumption here is that you are an existing developer, this is not a book aimed at the absolute newbie (and I'll refer readers to Realm of Racket if that's what you're looking for). [Continued]
Good Math

This is a very different book to Mark Chu-Carroll's previous work 'Code In The Cloud', which earned a favourable review on this site for its coverage of software development using the Google Application Engine. The book scored points for the easy writing style, the direct tone and the technical content. This is a very different beast altogether. Where the first book is geared primarily to a technical audience and everyone reading is assumed to be a developer, this one takes us deep into more abstract territory. And while there's a definite computer science twist to all of this, the reader is not assumed to be a developer with a working knowledge of Python or Java.

Now, despite what the publicity for the book suggests, this really isn't one of those 'gee whiz' pop science books that does numbers. Neither is this a guide to the kind of math that certain types of programming requires (for example there's nothing here about binary, octal and hex bases), or anything related directly to algorithms and algorithmic analysis. So, if you're looking for a book on discrete mathematics or something more akin to a text book then you need to look elsewhere.

Instead this is a book that aims to introduce a range of topics related to pure number, the axiomatic basis of mathematics, computability, the lambda calculus and more. While the author suggests that this isn't a book designed to be read cover to cover, there's a certain narrative and historical thread that runs through the book and for this reader at least, reading it front to back seemed to make most sense.

Organised into six sections, starting with Numbers and ending with Mechanical Maths, the book consists of short chapters that tackled one specific topic. So, the Numbers chapters start with the natural numbers and ends with the irrationals. Each chapter within a section builds on the previous one, so we start by learning how to construct the natural numbers and work our way to the irrationals. [Continued]
Realm of Racket

I have to admit that I've always resisted the lure of Lisp, despite the fact that I enjoy exploring different programming paradigms. While it has never quite gone away, the last few years have seen a recurrence of interest in Lisp-style languages, particularly Scheme and Clojure. Racket is a relative new comer to the field, but is gaining traction as both a language and integrated development environment. Which brings us to this book, which promises to teach us programming 'one game at a time'.

The book is written by three university professors and a group of their students, so the unusual approach to the subject extends to how the book is put together and not just to the content. The aim is clearly to teach the non-expert and to make that learning fun - though the games themselves are not that challenging or engagins (at least not to this reader). However, this is clearly one of those books that you have to read in front of your machine - it's about following along and playing with the language. And, for those of us who're used to other languages, the Lisp/Scheme/Racket way of doing things takes some considerable getting used to. In some ways it's probably harder for the experienced programmer than for the absolute beginner.

Following along means using the DrRacket interactive environment, which includes a 'read evaluate print loop' environment that gives you a console with a prompt and the chance to enter expressions and see what they evaluate too. For old hands who've used similar REPL environments in the past, it's a great way to encourage experimentation, prototyping and having a bit of geeky fun (come on, it is fun to play with data structures and see what happens when you try this or that...). [Continued]
Excel, VBA and Variant Arrays

VBA provides plenty of methods for traversing Excel workbooks using Cell and Range objects. It's relatively straightforward to write code that cycles through a worksheet to process cells. However, when you're dealing with very large worksheets with thousands of rows and columns, then you soon see that while the code is easy to write, the performance can slow to a crawl. And it's not just VBA that starts to slow things down - large worksheets that are heavily studded with array formulas and look-ups can also be painfully slow to perform.

The good news is that VBA provides the tools and objects to massively speed things up. The key to this is to use variant arrays to grab all the data from a woksheet or range and then to work on this array. The performance improvements can be dramatic - something that takes hours can be done in minutes.

The starting point is simple - we grab the values from a range and assign them to a variant array:

Sub test()
Dim vData() As Variant

    vData = ActiveSheet.UsedRange.Value
    Debug.Print "Rows: " & UBound(vData, 1) & " Columns: " & UBound(vData, 2)

End Sub
The important thing to note is that the variant array is two-dimensional, with the first dimension mapping to rows and the second to columns. [Continued]
Coming Soon...
Programming Joomla!, Think Complexity, Scala For The Impatient and more..
Excel/VBA Tutorials
Google
Web TechBookReport

Other recent reviews

Site design by viper69 productions-All contents copyright of authors. No copying for commercial use allowed. Site © 1999 - 2014.