In the first part of this article series we looked into the objects that make up Git’s datastore (blobs, trees and commits). We also saw how commits participate in a directed acyclic graph (or DAG).
In this second, and final part of this series we examine a few Git commands and see how they work with and manipulate the DAG.
Since it’s inception Git has fast become one of the most popular distributed version control systems in use. Despite its pervasive use, Git often still comes across as arcane — with obtuse commands, many of which seem to do similar things. In this article series we will attempt to unravel the mysteries of Git by taking a deep dive into the internals of Git. We will explore the core data-structure Git uses to store our repository’s history and then look at a few commands to see how they mutate and manipulate this data-structure. This will enable us to get a better understanding of the workings of Git, and allow us to better leverage Git for our daily use.
Clojure 1.2 (and partly 1.3) introduced protocols and records. These new constructs give us the ability to define not only new “types” in Clojure but also contracts, much like Java classes and interfaces. In this article we will take a look at what these new constructs mean and how to use them. We will also attempt to find out the reasoning behind these new constructs and how they differ from earlier constructs such as
Considering the little computers that we carry around in our pockets (or purses) all day help us with our email, internet access, personal GPS recorder, social networking, (very) personal journals and once in a while also act as a phone, it makes sense for us to want to protect all that data. The easiest way to keep our phones from prying eyes is to switch on the passcode functionality.
Of course this presents itself as a Catch-22. On one hand we know if we were to forget our phone at a coffee shop or a public library (or even worse lose our phone), it would prevent someone from getting to know pretty much everything there is to know about us. On the other hand it also prevents a good Samaritan from returning the phone to us in the event they find it.
Furthermore, locking the phone also obstructs emergency services from getting a contact person in the event of an unfortunate accident.
So what does one do?
In the first part of this article series, we saw how we can identify with an incremental mindset. We also explored how we could identify the start and end points of our journey using the Dreyfus model of skill acquisition and then chart a “game plan” to get there. In this second, and final, part of the series we will explore the notion of “deliberate practice”. We will also look at some tools and techniques to improve our comprehension and retention of the material at hand.
We, as developers, live and thrive in an industry which not only sees its languages, tools, and techniques change every few years, but one that also regularly experiences tectonic shifts in the very paradigms upon which these tools are built! From desktop to web to mobile, from object-oriented to functional programming, we are not only expected to keep abreast of these changes, but also be proficient in them. How can we keep up? How can we best leverage our time to learn and retain knowledge effectively? In this article, we will consider a few strategies to help align ourselves with being a better student, and we’ll also take a look at some tools and techniques that can make our learning more meaningful, insightful, and long-lasting.