"Understanding and Using C Pointers" - By Richard Reese - O'Reilly Media

This book is ideal for the programmer who has only had a casual introduction to pointers. One example is that type size_t is explained and not just shown. Some of the tutorials I have seen use types like this in pointer discussions without giving the full explanation of what is going on. In my opinion, those looking to really understand programming are going to spend some time looking at memory models-and this work was a gentle introduction that was approachable on topics that included dynamic memory allocations. While it wasn't in depth, I also appreciated seeing a mention of the RAII technique and an approach in C. Some new programmers should also find the discussion about function pointers as eye-opening. The section titled "Using Pointers to Support Data Structures" was also full of good introduction material to seeing how pointers could be used to implement common data structures. New users to pointers will also likely be glad to see this book addresses good things as well as bad things to look out for in using pointers as well as examples of the why.

Overall conclusion: Would be a great resource for those looking to dig further into C and trying to master pointers.

"Computer Science Programming Basics in Ruby" - By Ophir Frieder, Gideon Frieder, David Grossman - O'Reilly Media

This isn't the book for you if you want to mainly do tutorials with Ruby. I see it as a good starter book for those really new to computer science as a topic or are just interested in maybe starting to program. I would have used this book when I first began if it were around, especially as a beginner that learned with a book before I had any other exposure to CS. This book would probably be best if it was read before a formal programming class as I would think that most introductory computer courses would cover this material. I really liked Section 7.2 Complexity Analysis at least being touched on in this book. Big O notation is seen referenced in scholastic works and google results-so it is nice to at least have an introduction to these topics. Discussions on sorting and searching are also good introductions to common topics that make for a gentle introduction to this specific area. It was also nice that the authors provide a web link to slides (as well as source code) that followed the chapters in the book. Also, there are Exercises at the end of the chapters, however, I would have liked to see answers for these since this was targeted at newer readers.

Overall conclusion: Would be excellent for the a beginning independent learner.

"Mac Hacks" - By Chris Seibold - O'Reilly Media

Chris Seibold covers some interesting topics in this work. I agree with other reviews that I have seen in that potential buyers need to look at the Table of Contents and see the list of projects and if they are interesting enough for one to purchase. For example, since I prefer software, most of Chapter 11 about hardware are not likely projects that I would complete. I have no desire to dye my Mac but some users might find it exciting. This book is not specific to Macs completely. Subjects like using Tor and setting up your router are general topics that apply to various setups. I did enjoy learning more about PLIST and how to quit Finder and were items that I completed right as I read the book. I think that looking at the entire book-it is more about how to customize your setup and helps get you to think about making your workspace more enjoyable and moving beyond default settings if a user desired. Advanced computer users (in general) might not find much in this book,; however, newer Mac users or causal users might like this work in getting them more familiar with customizing their setups.

Overall conclusion: This work is for users looking for fun more than anything in my opinion.

"Programming iOS 6, 3rd Edition" - By Matt Neuburg - O'Reilly Media

Matt Neuburg's book is not for the absolute beginner (or timid) as it covers a lot of material. This is not a cookbook and the reader will need to put effort into consuming the fundamentals presented in this book. One of my pet-peeves is books that tell you to go read another book before you start; in this regards, the reader might want to know some c programming before tackling this text. However, I wouldn't want to see the size the this book with more information crammed in-so I will let that one pass. The 3rd edition focuses on iOS 6.1 and Xcode 4.6. If you are looking for a book on a specific version of iOS, you might want to make sure you buy the right version of this book as the author makes it known that his primary concern is not in backwards-compatible code. Overall, it seems that the book is very similar in chapters and sections as the last edition, but was revised to have the newest code as part of all examples. It is refreshing to see a work totally reworked to reflect current coding versions and not just updated in various sections. The added sections on iCloud and Core Data were welcome additions to this version that also show value-added updates. Personally, my favorite by far of this book itself is Part 1-Language. Objective-C seems to have various treatments in texts and online, but these five chapters are a great and complete introduction to Objective-C in regards to both syntax and concepts.probably had a limited audience and I understand why it was likely removed.

Overall conclusion: Readers will need to approach this volume ready to spend some time with this reference.

"Programming PHP" - By Kevin Tatroe, Peter MacIntyre, Rasmus Lerdorf - O'Reilly Media

While not an important part of the book itself-the foreword was one of the best I have read in a technical book. It really describes how many people get started with PHP-it is accessible. This book provides a lot more structure than randomly placing PHP statements that have been googled together. I have not had the chance to review other editions, but it was noted that the material had been updated for the latest features of PHP version 5. With over 500+ pages, this feels like the O'Reilly books from the past that covered a lot of material and feels like a solid reference all around. One example was learning about Traits. While I knew of them from other languages, I had no clue that they were part of PHP until this book since I am only a causal user of the language. Chapter 7 dealing with Web Techniques will probably be immediately useful for someone trying to get a site out quickly. SQLite and MongoDB coverage was welcomed and showed that current updates are indeed included. While of course not complete by any means in scope, Chapter 12 Security was a great introduction to the various security concerns developers need to think about including XSS, filtering input, and session fixation to name a few. One minor complaint was the debugging chapter was very short and did not seem to add that much value to me. I would have liked to see the chapter about extending PHP with C from the 2nd edition, but that subject probably had a limited audience and I understand why it was likely removed.

Overall conclusion: Solid reference and learning guide for PHP. I don't think you could go wrong with "Programming PHP".

"Introducing Erlang" - By Simon St. Laurent - O'Reilly Media

Simon St. Laurent takes the reader for a gentle look at the Erlang language. I would recommend this for a programmer that knows or has a good foundation in any programming language as this is not meant to be a learning the basics of programming book. In other words, one should know what a loop is and flow control concepts before reviewing this book. While I did not have much exposure to Lisp, I did not have any trouble picking up the syntax from the book itself. This book is really about a quick introduction and it is then your job to dig into the additional resources or websites that you need to in order to learn more. One of the first things that I did after finishing this work was go out to GitHub and look at real Erlang projects which the author had suggested. I was impressed that I had a great foundation for being able to understand what was going on just from reading this book. For example, I saw the .hrl includes and knew right away that records would be defined in those files. I was also able to see the OTP templates being applied in code as well. I left this book wanting more knowledge about Erlang and looking for other books that would expand this knowledge. I would say that this book is really for those who are trying to invest time in learning more about the language beyond just a 30 web tutorial; however, one that is still only interested in an introduction.

Overall conclusion: If you want a brief introduction to Erlang-this is the book for you. If you need a complete reference or many detailed examples or tutorials: you might want to check out the other Erlang books out there.

"DOM Enlightenment" - By Cody Lindley - O'Reilly Media

Cody Lindley takes the reader into the depths of the DOM with his work. This book does what it says it will in the beginning introduction by presenting a very terse cookbook: you won't be seeing tons of lengthy explanations. One of the best perks of this book was that in ebook form->the code was presented with links to code examples in jsFiddle (with Firebug lite) or github. This made it easy to run, modify, and look at the code in depth without even having to setup an environment or retype examples. Chapter 12 was also a nice addition to this book as it showed a short example of taking what you learned about in the previous chapters and thinking about the development of a dom library in many ways similar to what jQuery does today. While not very long, I also liked the chapter on DocumentFragments. It was nice to see that this often overlooked part of the DOM got some attention.

Overall conclusion: This book is great for a very specific niche. If you want to take a quick tour of the DOM-then this is the book for you. Don't expect long lectures on the topics-just short examples.

jQuery On

As we try to get past the simple tutorials we find online and get to some real examples-I figured we could learn by looking under the covers at one of the most popular frameworks. By looking at an interesting function in jQuery you can see that while the inner workings of these functions do a lot, they still rely on the core of javascript. In other words, the magic really comes from putting multiple pieces all together.

This specific example is from the 1.7.1+ version. I encourage you to look at the api document for the function on. Past users might have used live or delegate. However, by looking at the code you the meat of the logic is passed on to a different method: on.

bind: function( types, data, fn ) {
    return this.on( types, null, data, fn );
},

live: function( types, data, fn ) {
    jQuery( this.context ).on( types, this.selector, data, fn );
    return this;
},

delegate: function( selector, types, data, fn ) {
    return this.on( types, selector, data, fn );
},


You notice a common theme here...all of those methods are calling on.
BTW, you can find the on api document here: http://api.jquery.com/on/



Enough with all the documents-lets look at the code and find the interesting parts.  I found this code out at:
https://github.com/jquery/jquery/blob/master/src/event.js


on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
    var origFn, type;
    
    // Types can be a map of types/handlers
    if ( typeof types === "object" ) {
        // ( types-Object, selector, data )
        if ( typeof selector !== "string" ) { // && selector != null
            // ( types-Object, data )
            data = data || selector;
            selector = undefined;
        }
        for ( type in types ) {
            this.on( type, selector, data, types[ type ], one );
        }
        return this;
    }
    
    if ( data == null && fn == null ) {
        // ( types, fn )
        fn = selector;
        data = selector = undefined;
    } else if ( fn == null ) {
        if ( typeof selector === "string" ) {
            // ( types, selector, fn )
            fn = data;
            data = undefined;
        } else {
            // ( types, data, fn )
            fn = data;
            data = selector;
            selector = undefined;
        }
    }
    if ( fn === false ) {
        fn = returnFalse;
    } else if ( !fn ) {
        return this;
    }
    
    if ( one === 1 ) {
        origFn = fn;
        fn = function( event ) {
            // Can use an empty set, since event contains the info
            jQuery().off( event );
            return origFn.apply( this, arguments );
        };
        // Use same guid so caller can remove using origFn
        fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
    }
    return this.each( function() {
                     jQuery.event.add( this, types, fn, data, selector );
                     });
},

Lets take a step back and think about this code from a high level. Even if you are a beginner to Javascript: notice that most of this logic is what you learned in almost all basic tutorials. If, else if, the difference between === and ==, and typeof all take up a large part of this code base. This famous framework that is popular boils down to some pretty basic stuff. No disrespect to the creators and contributors to jQuery-I am just trying to let the beginner coders know that advanced and cool code is within their reach. Just think->the ability to add events to elements that you dynamically update your page (such as by ajax) that weren't even there when your page loaded is done with this logic.

How, lets look at the interesting parts (in my opinion that is!). While you may have seen it before: lines like this are cool: data = data || selector; You might wonder why this is being used since you are used to if being found in conditional statements. However, you can use this trick to check for checking for defined. If the variable data is undefined->then selector is assigned to data. This is a quick way in which you don't have to wrap an if statement around it.

Another interesting part of this code that might not be familiar to everyone is the call to apply. return origFn.apply( this, arguments ); Lets look at the apply function documentation: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/apply All this comes down to is an ability that the language itself gives you to take a function and using the object passed in, allows you to call that function you wrote once on whatever object you pass it. It also lets you give arguments to that function and is similar to the call() function.

Perhaps the most important line of this function is the following: jQuery.event.add( this, types, fn, data, selector ); This delegates most of the logic to another jQuery function event.add(). Guess what your assignment is->follow the source code to figure out where it goes from there ;)

In summary, the important thing to take from this is that cool things can be accomplished with just a little advanced knowledge. You see that most of the code is decision logic and formed from common and basic building blocks. And perhaps the best part of all of this is that the source code is out there for us to learn from. While it is even better to contribute if we can, until we fell comfortable-it is still doing a great service by being an example of what we can aspire to understand and accomplish.