A few days ago, I posted a video about how to become a better developer. There were a few interesting comments made, but one in particular from the Reddit threadpeaked my interest. So I decided to do a reply.

You can watch the video either in his blog or over on Youtube. He's also included the some of the contents of the Reddit post and a funny (relevant) comic about learning "C++ in 21 days".

In today's episode, I talk a little bit about what it takes to become a better developer. Nobody will ever expect you to know everything, but you better know how to find it...

You can watch the video either in his post or over on YouTube. He also has this and his other videos set up in a playlist if you'd like to see coverage of other topics like design patterns, iterators, dependency injection and prepared statements.

Today we are joined by open source contributor Larry Garfield. Larry introduces us to design patterns through his own unique style: Cooking With Crell. He introduces the concept of Design Patterns, goes through a few basic patterns and closes out with some pretty solid justification for why we should care.

You can watch this latest episode either on Anthony's site or over on YouTube. There's several other videos in his series, so be sure to check out the playlist for other great videos.

The Mediator Pattern is an extremely flexible and useful tool to help decouple your code and provide added flexibility in your applications. We'll explore the basic concept of a Mediator, some places you've used it and some things that you can do to improve upon the basic concept.

You can watch the video either in the post or over on YouTube. If you enjoy the episode, you should also consider the rest of the videos in the series, all available from this playlist.

Today's Programming With Anthony video focuses on the concept of Iterators. We'll look at the abstraction that they represent, how they can be used and some of the benefits of using them. When used correctly, Iterators can lead to very efficient, flexible and clean code.

You can also watch the video directly on YouTube and check out the rest of the series in his playlist. Other topics include dependency injection, boolean logic and prepared statements.

This week, we're going to talk about the topic of Dependency Injection in Object oriented code (specifically PHP). You don't need a fancy container to do it, it's actually quite simple to do manually!

He also talks some about the difference between a dependency injection container and a service locator. This is just the latest in his video series - he has others covering things like prepared statements, encryption and references in PHP.

When it comes to multi-tasking and interacting with the operating system, PHP is no lightweight. In this December 6, 2012 presentation Jonathon Hill (@compwright) explores PHP's little-known POSIX, Process Control, and Semaphore extensions and shows you how to introduce a parallel dimension to your applications.

His presentation covers the use of multi-tasking to accomplish some common tasks in PHP (like batch processing or creating daemons). He talks about multi-processing vs multi-threading, forking, race conditions and semaphores.

You can watch the video of the presentation over on Vimeo and check out the software and links to other resources mentioned in the talk in this link bundle.

This week we are joined by Responsive Design thought leader Sam Richard. He introduces us to the concept of responsive web design, tells us a little bit about its history and talks about best-practice and the future of the web!

You can catch up on Anthony's previous videos in his playlist over on YouTube including ones covering encryption, prepared statements and boolean logic.

This week's Programming With Anthony video is up! In it, we discuss the foundations of Boolean Logic and introduce some very interesting tools for analyzing logical constructs (including Truth Tables and De Morgan's Laws).

You can view this latest video over on YouTube or get caught up on the entire series with the full playlist of this and past episodes.

The goal is to figure out some way of measuring what features in programming systems help programmers understand wht they are doing, and how this can be used to make systems that lead to higher quality software. Mike is currently running an experiment where he shows people several short Python programs and asks them to tell the output of the program. The test subject is sitting in front of an eye tracker, so afterwards Mike can see where you were looking at various times during the experiment.

The results are pretty interesting and Eric likens it to a sort of "just-in-time compilation" that the mind is doing as it reads through the code, not a straight forward read through. The timing of the read is interesting too, noting that once something is figured out, it's run through faster the following times.

One aspect he's interested in is how the approach of inexperienced programmers differs from that of experienced programmers. For example, there seems to be some evidence that following variable naming conventions helps experienced programmers understand the code much quicker, while breaking these conventions leads to a severe penalty. On the other hand, inexperienced programmers seem to take about as long regardless of how the variables are named.

This study is still going on and, if you're in the Bloomington, Indiana area and would like to lend your eyes to the cause, send an email over to Mike Hansen (more on the subject on his blog here).