Tahir on Programming for the Web
I have a properly working Seagate Backup Plus Hub. However, I’m now using a Samsung 870 QVO for Time Machine backups on my Mac, despite its bottom-of-the-pile TBW (durability) rating. It actually makes sense.
One of the decisions a CTO has to frequently make is whether to build some piece of functionality in-house or buy it from a third party vendor. In this post, I share my framework for making these decisions.
Continue reading “Buy or Build?”The technology universe is in a constant state of flux with new advancements arriving faster than one could keep up. A technology leader, in this scenario, needs to look for something durable to build the foundation of their new (or improved) technology organisation.
Spending 36 months leading the charge (and occasionally failing) at a fast growing business that’s powered by technology can teach a lot. Coming off the back of a career built with customer-facing development teams at companies serving over 100 million customers, I now have some idea of what it takes to make a strong technology foundation for a modern business.
After a reflective 3-week slate-wiping vacation, I’m good to write down and share my thoughts.
Continue reading “5 Competitive Advantages in Technology”I started programming in Go in 2012 and since then I haven’t wanted to program in any other language. I’ve had a handful of large Go implementations across two companies and by now I have my own short list of favourite features.
One of those features is not mentioned very often but it has changed things significantly for me, and that’s what I’m going to discuss here.
Even though I knew about embedding and interfaces, their connection with classic inheritance wasn’t quite obvious. I set out to understand how I could emulate the coarse inheritance semantics in Go, without going into fine nuances. That in turn has helped me understand embedding and interfaces in a deeper way and I hope it would help me better design Go types and methods for extensibility.
Any resources on how to map OO design (controlled state change via methods) to RESTful services? #help
— Vijay Ramachandran (@vijay750) October 24, 2013
Here’s what I think about it. Continue reading “Mapping OO Interfaces to REST”
I started out by creating a new directory for the package to be split out and moved the files that contained most of the relevant code into that directory, without thinking of the consequences. I could just invoke the compiler and let it guide me through the process of fitting the pieces of the puzzle together. One of the nice features of modern compilers is that they don’t continue dumping out errors beyond a limit. This allows fixing a program in small steps, going by the changes in errors produced by the compilers.
Continue reading “The Compiler as a Refactoring Aid”
I started day 1 with the excellent Go at Google presentation by Rob Pike, followed by my own presentation of Go’s key features. The rest of Day 1 was spent taking the Go Tour.
The coolest thing I did was on day 2. I mirrored my laptop on the projector and went through a fresh install of Go from source on my [newly allocated] dev box. Everyone else had identical dev environments so they could follow what I was doing on-screen. At the end of it everyone had a functional Go workspace!
What’s even better, I showed them how super easy it is to create packages and use them in a program. From conducting the installation to demonstrating package creation, it only took 1 hour. This included 10 minutes fiddling with Vim settings for syntax highlighting — the most difficult part of the entire session 😉
Presenting slide decks is one thing. It’s a totally different experience when you do a live demo with no prior preparation except the confidence that what you’re about to demo will work without much fuss.
Think about it. How often do you come across a programming innovation that improves productivity and computational performance? Continue reading “Why I Program in Go”
Foo would be found in Foo.class.xx or something like that.
Thankfully, ack makes it easy to find the location files in a project. Just say, ack -g Foo.class and voila! it tells you to dig in modules/frob/model/include/Foo.class.xx or whatever abominable directory hierarchy it may be embedded in. So when you decide to kill that error at line 324 of class Foo, all you need to do is:
vim `ack -g Foo.class` +324
Unfortunately, typing this out is a bit tedious as well, so we bring in a little shell script (I call it vis, for vim on searched filename):
#!/bin/bash
# Search and edit files. Use it like:
# $ vis Foo.bar [...]
if [ $# -lt 1 ]; then
exit 255;
fi
fname=$1;
shift;
vim `ack -g \\\b${fname}[^\/]*\$ | head -1` $@
This will invoke vim with the first filename that ack returns for the filename pattern (yes, it can be a Perl regex), and you can pass all other vim arguments as usual after the file name. Nifty, eh? The regex above will match file names starting with the given search pattern (with some caveats).
PS: It’s not too hard to make the script choose the editor dynamically, but people usually love to use one editor consistently. I use both Emacs and Vim, so I’m planning to make this script take the editor as an argument and have two convenient aliases, one each for vim and emacsclient which will handle passing the editor as an argument.