If you’re a developer shopping for a new MacBook, choosing a CPU can be confusing. Apple always gives you a handful of different CPUs options, all with different specs and prices, but it’s very difficult to understand how your development experience will be affected by this choice.
You can put thought into the other options that Apple lets you customize. For hard drive capacity, it’s easy to check the amount of space you’re using on your current machine and decide on a hard drive size for your new machine. If you’re comparing two different screen sizes, you can decide if you’d rather have a cheaper and lighter machine or a larger screen.
You can’t do that with CPUs. For instance, the latest round of 15″ Pro Retinas (released in late 2013) gives you three CPU options: Read more on Develop Smoothly with the Right MacBook CPU…
Also posted in Developer Tools
Here are some of my favorite lesser-know features of DevTools. Read more on 5 Awesome Lesser-Known Chrome DevTools Features…
Vim is a good friend of mine. When we met during my freshman year of college at MTU, we quickly hit it off. I never looked back with any regret at my tiny TI-85 screen, Notepad, or QBasic where I first tinkered with bending computing devices to my whims. Since then I have tried other editors, and even used a few for extended periods for a variety of reasons (e.g., Kate because of its SSHFS and KDE tie-ins, Visual Studio for its strength with all things Microsoft). Still, through it all, Vim has been my go-to editor for nearly 15 years.
Read more on A Month with the Atom Editor…
I love Emacs. I’ll take it hands down over vim, Sublime, Atom, and company any day. I thought I would take some time to list some of my favorite bits of Emacs and how I use them in my daily workflow.
Magit is an Emacs interface for git. Beyond that, it’s the best interface for git I have ever used — better than the git CLI or third-party apps like SourceTree. Magit reduces most git commands (and all of their cryptic flags) to a series of one-character shortcuts. It also introduces interactive status and log buffers that are comparable to any other git gui out there (and better than many). The best part is that version control becomes part of my editing workflow and requires no context switching. Overall I find that it massively speeds up and simplifies my git workflow and encourages me to use my VCS to its fullest extent. Read more on My Favorite Emacs Add-Ons…
I started pair programming in 2000 on my first real software job, while I was still working on a computer science undergraduate degree. I’ve been mostly pairing in daily practice since then.
First Impressions Matter
My earliest perspectives on pairing are useful because I’ve seen bad results when people are denied the chance of finding out its benefits for themselves. Pair programming wasn’t prescribed or preached to me, it was encouraged. Read more on Reflections on 10+ Years of Pairing – What Works, What Breaks, and What’s Next…
Over the years I’ve had to revisit or work on software projects created by other developers. Outside of an effective test suite, there 4 things that I really appreciate when work in a codebase that I am not familiar with:
- Good Build Documentation
- Extensive Logging
- Support for Localization
Read more on 4 Development Practices that Make Software Easier to Update and Maintain…
Gradient descent is one of those “greatest hits” algorithms that can offer a new perspective for solving problems. Unfortunately, it’s rarely taught in undergraduate computer science programs. In this post I’ll give an introduction to the gradient descent algorithm, and walk through an example that demonstrates how gradient descent can be used to solve machine learning problems such as linear regression.
At a theoretical level, gradient descent is an algorithm that minimizes functions. Given a function defined by a set of parameters, gradient descent starts with an initial set of parameter values and iteratively moves toward a set of parameter values that minimize the function. This iterative minimization is achieved using calculus, taking steps in the negative direction of the function gradient.
It’s sometimes difficult to see how this mathematical explanation translates into a practical setting, so it’s helpful to look at an example. The canonical example when explaining gradient descent is linear regression. Read more on An Introduction to Gradient Descent and Linear Regression…
When I was college, I found it odd that my Computer Science classes were located in the natural science building. We weren’t studying the universe, the laws of physics, chemistry, or biology. I felt that the discipline of writing software had much closer ties to the philosophy department and the study of logic.
I have since found a number of ways that the tools of the scientific method can be key to success or failure in software projects, and I’d like to discuss my top five ways to use these tools to help your projects run smoothly.
1. Experiment Regularly
Could you ship your product using SQLite as a production database, or would its performance bog down your application? You could read a few reviews, consider the pros and cons of the architecture, and discuss with colleagues. One way to know for sure, though, is to do the experiment! Read more on Putting the Science back in Computer Science…
When building a user interface, I appreciate an IDE that allows me to easily change visual elements without having to write code. Writing code for simple things like colors, borders, fonts, or shadows clutters my project. Fortunately, I work with talented designers at Atomic Object who can already use Xcode to make some of these aesthetic changes in the UI without needing to write extra code.
However, while these designers can currently make selective changes to some controls, not all of what they want to do is possible in the IDE. For instance, I cannot set a border or shadow on a UIView without writing code or change the font of a UISegmentedControl. I wish Xcode’s interface builder was more capable of changing simple properties as these.
Fortunately, there is a feature of Xcode’s interface builder that will allow you to manually add user defined runtime attributes. You tell it the name of the property you want to change then specify the type of the property and finally the value. Read more on Expanding User-Defined Runtime Attributes in Xcode with Objective-C…
How far should we take unit testing? Should every line of code be covered by a unit test? What about code that’s hard to test? Let’s look at the cost and value of unit testing in a couple of different situations.
Tests We Can All Agree On
It’s easy to see the value of unit tests when we’re writing actual functions. Let’s say we’re writing a helper function called
next_valentines_day for our greeting card application. Here are some tests that we might write:
describe next_valentines_day do
it "returns next year's valentine's day when after Feb 14" do
it "returns same year's valentine's day when on Feb 14" do
Even from just these two tests, we we’ve significantly reduced the risk of calculating the wrong Valentine’s day in our software. And that means we’re less likely to lose valuable time fixing bugs in the code or dealing with other fallout from the code being wrong (like decreased greeting card sales). Read more on The Cost of Unit Testing…