Git – Peepcode Screencast Review
The other screencast i finally got around to watch was the Git - PeepCode Screencast. It's about 61 minutes long and can be purchased here. This is my review.
LIKES:
The screencast was a pretty high level, albeit detailed, overview of the git version control system and was at the level I needed (beginner). The flow from part 1 to part 8 was very seamless and covered about everything a regular user would need to know to use Git at work. Some features were covered that I were new to me (from an SVN perspective), including stashing files and applying hunks instead of the whole patch.
GRIPES:
Like the clojure screencast, things moved around pretty fast (I'm starting to get accustomed to it, though). I didn't quite get the advantage of rebasing before a merge (this and this provide some good rationale). I know this wasn't a comparison screencast between VCSs (notably, SVN), but I was left wondering where the advantages were when moving from SVN to Git. This led me to some searching with links in the resources section that helped. I was mostly confused on the distributed workflow part (part 8 ) because he was going through pretty arbitrary changes to branches and I had a hard time mapping those activities to a work environment. When he was switching between authors/committers, that made a bunch more sense to me. One last thing, the speaker was about 2-3 seconds behind the commands going to the CLI which made understanding difficult especially when a 'clear' was issued and a concept was being wrapped up.
TAKEAWAYS:
git add -i ; for interactive staging, afterwards don't do 'git commit -a'
partial commit of files w/ patching
git log --stat, --shortstat, --pretty=full for logging statistics
In general, git log is extremely full featured (searching)
git blame file to see line numbers and who modified it and when
git instaweb --httpd=webrick ; to browse the repo
git stash to put away files that aren't ready to be committed in order to switch branches
run git add on a file after you have cleared out the merge conflicts
git reset --hard will revert changes back to the latest good version of the branch
CONCLUSION:
This screencast was similar to the Clojure one in that as a developer would go through software development lifecycle, various features were touched on in order (e.g. checking out a repo, adding files, committing, checking status, etc). I enjoyed this screencast less than the Clojure one but still found it valuable from a beginner's perspective. Still, at $12, this screencast provides good value for those that want to get an easy jump start on Git.
RESOURCES:
Some links I used to supplement my understanding with the PeepCode Screencast
Git - SVN Crash Course
Git Tutorial
GitSvn Comparison
Functional Programming with Clojure – PeepCode Screencast Review
I finally got around to watch the PeepCode Screencast titled 'Functional Programming with Clojure'. It's about 65 minutes long and can be purchased here. This is my review.
LIKES:
The screencast was well done with pretty high production value. I thought it had just the right amount of background information with the rest being purely technical. It had a good introduction to the language. The Mire example was pretty sweet which covered what would appear to me to be a majority of the functionality I would need to get started (e.g. basic collection usage and manipulation, concurrency, exception handling, testing, etc). The simple command line examples helped quite a bit, although they went quite fast.
GRIPES:
For a beginner, some of the earlier topics were covered fairly quickly (the let vs binding syntax, alter), but reviewing afterwards, I understood what was going on. Some more explanation on why certain imports were used (for what specific purpose like duck-stream) would've. Also, at first, I didn't understand the dot at the end of 'java.util.Date.' and how that worked but it was covered later when more java functions were used. The only thing that would have really made this screencast amazing would have been some independent work examples for the listener to do. I'm a visual learner but doing things hands-on is very appropriate for a lot of people (I like it as well :)). A quick review of the 'answer' would have really sealed some concepts.
TAKEAWAYS:
REPL: Read-eval-print loop
Binding are thread-local
Usually a bad idea to call def inside a function body
Transactions work like database transactions (dosync ...)
Only modify refs in transactions to guarantee predictable behavior
@ is a shortcut for deref
It's OK to use java libraries for system level operations (e.g file io)
Names can have punctuations in them, such as a question mark
(doc map) or some other function or type to get the documentation on it in the REPL
Lazy sequences are only evaluated when their return value is used
test-is is Clojure's test library
Function order matters
You can't compile code in a namespace less than 2 segments
CONCLUSION:
All in all, the screencast was very well-made and informative. After finishing the screencast, I'm sort of glad they went over material fast which allowed more material to be covered. Then, as I start to program my own stuff, I can just reference the screencast as needed. Although, seeing the same code over and over help solidify the concepts quite a bit. The $12 price tag for an hour's worth of technical content is well worth it. I would recommend this to others.