TacTechs

time sleep 1

Thu, 09 May 2013 00:53:00 -0400

time sleep 1

Photo

Mon, 06 May 2013 16:11:57 -0400

SADDLE: Scala Data Library

Tue, 02 Apr 2013 13:48:35 -0400

SADDLE: Scala Data Library:

adamlaiacano:

I sent out a tweet last night asking if there are any good data libraries for Scala. The next morning, Saddle gets released. I’ve heard it described as “Pandas for Scala,” which is great because nothing beats having data frames ported to a new language.

The other tool you can investigate is scala breeze. It’s mostly for NLP, but also good for other things.

Photo

Mon, 11 Mar 2013 11:43:05 -0400

The MongoDB NoSQL Database Blog: Introducing MongoClient

Tue, 27 Nov 2012 11:18:37 -0500

The MongoDB NoSQL Database Blog: Introducing MongoClient:

mongodb:

Today we are releasing updated versions of most of the officially supported MongoDB drivers with new error checking and reporting defaults. See below for more information on these changes, and check your driver docs for specifics.

Over the past several years, it’s become evident that MongoDB’s…

jvmblog: Guerrilla Guide to Pure Functional...

Sun, 11 Nov 2012 11:21:41 -0500

jvmblog:

Guerrilla Guide to Pure Functional Programming

Functional programming is expression-oriented programming. A functional program is not a sequence of instructions, but a single, referentially transparent expression. Computation proceeds by substitution.

markcoatney: Today’s the first test of Chris Haseman and Susan...

Tue, 06 Nov 2012 12:16:58 -0500

markcoatney:

Today’s the first test of Chris Haseman and Susan McGregor’s very cool Dispatch ap—follow it here, and find out more about the project here.

omg monica lam is on their team

Photo

Mon, 05 Nov 2012 11:38:03 -0500

get your ip address

Mon, 24 Sep 2012 12:05:36 -0400

hostname | xargs host

Github UI Update

Thu, 20 Sep 2012 11:20:37 -0400

I am definitely still in the “Anger” phase of the Github UI Update process. Why can’t I just get over it and get into acceptance?

pirate 0.1.0

Wed, 19 Sep 2012 21:18:38 -0400

implicitly-notes:

This is the first release of pirate, and it has some neat features. It parses UNIX style help text naturally, and has an extremely simple API, just the Pirate apply funtion.
Here’s an example of how it would parse the arguments for uniq.
val helpText = "[-cdu] [-i] [-f int] [-s int] [input_file [output_file]]"
val arguments = "-c -i -f 3 sorted_file".split(" ")
Pirate(helpText)(arguments)
Pirate parses CLI arguments effortlessly.

Super proud of this, took me a while to work out some features that scala parsers doesn’t support by itself. Also, braved the harsh sonatype submission process to submit this.

I agree, angry unicorn, I agree.

Tue, 11 Sep 2012 11:42:45 -0400

I agree, angry unicorn, I agree.

Scala Constructor

Fri, 07 Sep 2012 13:30:37 -0400

Scala doesn’t have a constructor for its classes, it just evaluates everything in the class. They are evaluated in order. If you evaluate

x = 3
val x = 0

x will be 0 at the end, because val x = 0 is not treated specially. All expressions are created equal.

Test Driven Development

Mon, 03 Sep 2012 11:04:34 -0400

I worked on a command line arguments parsing tool which I decided would be a good chance to try out TDD for. I knew exactly the interface that I wanted, so I knew that I could write the tests for that first. But I found that just writing tests for the public interface wasn’t enough, and that I wanted to write tests for more things. Then I wrote tests for everything I wanted to write, and it worked, and kept getting incrementally better, until I realized that I had structured it in a way that I fundamentally couldn’t add on a feature I wanted to add without changing it drastically, so I did a big rewrite. This project was actually a rewrite of an older project, so it was a rewrite of a rewrite, but I felt I was on a pretty good path. I threw out all of my tests except for the public interface, and started again.

Midway through this rewrite, I ran into a really hard problem, and then another, in quick succession. I found that TDD was not a good process for solving these problems, and that the only good process was to think really hard about the problem and then verify it. Tests were a good way to verify, but weren’t at all useful in trying to solve the problem.

In general, I think that tests are great for a few reasons. First of all, if you have good public interface tests, you can refactor your code and know that it is still correct if it still passes your public interface tests. Second of all, at a lower level, at your private interface level, if you write a quick script to check that a private interface works, you can shove it into a test and make sure you never break it. Both of these things are good, and help give you confidence when refactoring. Furthermore, for very simple problems, test first design lets you know the entire way along that you’re correct, which means you don’t have to double back and fix anything, which is much slower. This makes the assumption that coding is sort of like running down a track, where you just have to make sure that you’re staying within the white lines.

However, what is test-first good for? It seems good for teaching you to refactor, but if you refactor anyway, what remains? It’s good to specify your interface immediately. But you can get that with README driven design, and then you’ve also written up your docs by the time you’re finished.

I think that in many ways, test-first is like training wheels for using tests properly. By forcing someone to conform to a test they’ve written, they will have to have a test, because they aren’t permitted to write the real code until after the test has been written. Beyond that, it seems about as useful as README driven development.

Protocol Buffers, Avro, Thrift & MessagePack

Sun, 26 Aug 2012 12:39:53 -0400

Protocol Buffers, Avro, Thrift & MessagePack

the colon's role in Scala type description

Sun, 26 Aug 2012 11:08:42 -0400

Something that I ran into recently when reading code is the : in type arguments. Specifically, in algebird, from twitter, in the Operators.scala file, there was an generic class that was parameterized with a weird type—it was [T : Group], where Group is a trait that was described elsewhere in the project. Later in the code, they called implicitly[Group[T]] to invoke it, which also struck me as odd. It turns out that this is an optional replacement for implicit arguments, which you might have seen when trying to sort something. Instead of writing

class ClassName[T] (implicit arg: Ordered[T]) = ...

you can instead write

class ClassName[T : Ordered]

Much more succinct, but not very intuitive.

git things I learned this week

Fri, 24 Aug 2012 16:27:40 -0400

mt:

jacob:
git bisect
Do a binary search between a known good and bad state to find the first bad commit.
git commit --verbose
Show a diff of the changes to be committed below the commit summary.
git add --patch
Choose which changed lines (a hunk, heh) in a file you want to commit.
Similarly,
git stash --patch
is awesome. (let’s you stash changes hunk-by-hunk)

git stash —keep-index is also useful, although I didn’t realize at first that although your index is kept in the directory, the stash you create ALSO has the index, not just things which are not yet in your index, which can create confusion if you try to use it as you use git stash —patch.

phrasing the question properly

Tue, 21 Aug 2012 01:05:58 -0400

I was just going to ask a question on stackoverflow, but I think that by phrasing the question properly, I answered it for myself. I wonder if that’s why it’s often so useful to talk to someone about your problem, that when you’re asking someone for help about it, you figure it out while describing the problem. It seems like a good way to save time for yourself and others would be if whenever you had a problem, you very carefully formulated the question, and if the careful formulation didn’t solve it for you, then you asked it.

scala reduce for possibly empty collections

Sun, 19 Aug 2012 00:49:16 -0400

Part of what makes scala great is that you always know exactly what you’re getting when you get back when you call a function. A spade will be a spade, and not a null. However, with collections, a collection will sometimes be empty when you get it back—it happens to everybody sometimes. There are some operations you can do on an empty collection, like a map, which will just do nothing, but there are some others that just don’t know what to do if they find that the collection is empty. reduce is the biggest one, and it makes a lot of sense. If you know that with a list of integers, you want to sum them, what is it supposed to do with an empty list? At least with a fold, it can default to the initial value (and often you will be able to fix your problem by just using a fold instead of a reduce), but a reduce has bupkis if the collection is empty.

Here comes reduceOption to save the day! If the reduce would fail because the collection was empty, it will just return a None instead, and a Some(returnvalue) for nonempty collections. Then, just call a getOrElse and supply your alternate value. If there was some operation you wanted to do to the result of the reduce if it returned properly, this supports that too! Just throw in a map after your reduce, and then getOrElse on that.

collection reduceOption (_ | _) map (func(_)) getOrElse 0

patch for all changes back to last commit

Fri, 17 Aug 2012 11:41:00 -0400

git diff implicitly creates a patch, but the default is to patch from tracked changes to index, so that a naked

git diff

doesn’t show the changes you’ve made but added to the index, for example if you just added a new file. In order to do that, you can run

git diff HEAD