Tim Robinson - Latest Comments

Re: Moving a Perforce project to GitHub

Pablo Padilla — Fri, 20 Nov 2015 00:59:43 -0000

I have been using Git-P4 for a while now and I really like it except for certain use cases that are particularly slow due to the size of my repo. In any case, I would like to share a set of bash scripts that help me move back and forth Git<->P4 and collaborate with other people that is still in the dark ;) They are not magical but they have been very handy in my daily work, I hope someone else finds them useful: https://github.com/pgpbpadi...

Re: Inline IL assembly

jeskeca — Fri, 23 Aug 2013 15:56:53 -0000

have you considered supporting an inline IL syntax more like this:

http://blogs.msdn.com/b/jms...

Re: A render farm in Haskell

Tim Robinson — Wed, 30 Jun 2010 05:33:59 -0000

Terry: the author sounds like somebody who tried Haskell and OCaml, got bored, and gave up.

I agree with the reaction to this article on Hacker News: http://news.ycombinator.com/item?id=1471463

Re: A render farm in Haskell

terry — Wed, 30 Jun 2010 03:48:54 -0000

he's not wrong... http://www.benrady.com/2010/06/a-bit-of-heresy-functional-languages-are-overrated.html

Re: New NPackage binaries

terry — Wed, 16 Jun 2010 12:14:24 -0000

http://www.xkcd.com/754/

Re: This week on NPackage

Tim Robinson — Sun, 16 May 2010 14:24:40 -0000

Daniel, I'm looking to build something much more lightweight than Artifactory.

I want the barrier for adoption of NPackage to be as low as possible:

* For application developers, I want to make it as straightforward as possible to pull in third-party libraries. This means having a robust client app and a repository that's pre-populated with most of the libraries you're likely to need.

* Likewise for application developers, I want to make it as straightforward as possible to share code. This means putting as few constraints as possible on what you submit; having a repository that's smart enough to figure out metadata based on the structure of your library; and being able to easily run your own mini-repository for testing.

I guess I see NPackage as being the DVCS of package management systems, if you compare systems like Artifactory to centralised source control.

Re: This week on NPackage

Daniel Fortunov — Sun, 16 May 2010 04:45:18 -0000

Hey Tim, Just came across this product called Artifactory (http://www.jfrog.org/). I haven't looked at it too closely but the screencast makes it sound quite similar to NPackage.

Are you familiar with Artifactory? Can you compare and contrast Artifactory vs. NPackage?

Cheers,
Daniel

Re: Can I have a .NET package manager?

terry — Mon, 19 Apr 2010 03:45:03 -0000

hell yes! we've got various vbscripts to do this. shouldn't it be 'easy' in say MSI (if too heavyweight), or powershell. additional points if it can handle multi-level caching, i.e. cross-region or internet code is cached on a team share as well as locally.

Re: Obscure IEnumerator facts

Tim Robinson — Tue, 08 Dec 2009 11:26:14 -0000

Shuggy, this is truly nasty - it took me a little while to spot the problem. I take it the bug is due to the fact that what look like fields on an anonymous type are in fact properties, and a fresh clone of the List<string>.Enumerator is created each time it's accessed.

As Jon Skeet points out on the site, mutable structs are evil.

Re: Obscure IEnumerator facts

ShuggyCoUk — Mon, 07 Dec 2009 17:59:47 -0000

old one but worth noting that:
1. this only works if the compiler knows the exact type of the collection (if it's via an IEnumerable variable for example boxing still occurs.

2. it can expose your program to a very subtle bug involving copies of the enumerator. This is very rare (a good thing since List does it!) but is worth knowing about:

http://www.eggheadcafe.com/software/aspnet/31702392/c-compiler-challenge--s.aspx

Re: A spelling corrector in Haskell

Yitz Gale — Sat, 31 Oct 2009 20:21:22 -0000

Tim, in lieu of a trackback, note that your blog post is enjoying popularity on the
Haskell reddit.
You might also note another similar post.

Re: A spelling corrector in Haskell

Tim Robinson — Sat, 31 Oct 2009 18:46:38 -0000

Thanks Cale - the <$> operator cleans up that function nicely. (The comments box appears to want HTML markup.)

Re: A spelling corrector in Haskell

Tim Robinson — Sat, 31 Oct 2009 18:36:37 -0000

Thanks for the suggestions Twan -- in particular, the pattern matching approach makes the list comprehensions much more concise. And the train function seemed to be more complicated than it needed to be.

Re: A spelling corrector in Haskell

Cale Gibbard — Sat, 31 Oct 2009 18:30:13 -0000

x >>= return . f = fmap f x

Typically when mixing compositions and bind like this, I find =<< to be a little nicer to read:

readFile "big.txt" >>= return . train . lowerWords

return . train . lowerWords =<< readFile "big.txt"

fmap (train . lowerWords) (readFile "big.txt")

Or, importing Control.Applicative,

train . lowerWords <$> readFile "big.txt"

By the way, your comment form chews up < symbols. I had to manually replace each one with <.

Re: A spelling corrector in Haskell

Twan van Laarhoven — Sat, 31 Oct 2009 15:35:20 -0000

Here are some ways to improve your program

Use Map.fromListWith instead of an explicit fold

    > train words = Map.fromListWith (+) (zip words (repeat 1))

Use (= fmap), from Control.Applicative, instead of (>>=) and return:

    > readNWORDS = train . lowerWords <$> readFile "big.txt"

Use `splitAt` instead of both `drop` and `tail`.

    s = [ splitAt i word | i <- [ 0 .. length word ] ]

Or better yet:

    s = zip (inits words) (tails words)

When pattern matching in list comprehension, items that don't match are just ignored, so you can write:

    > deletes = [ a ++ b | (a,_:b) <- s ]
    > transposes = [ a ++ y : x : b | (a,x:y:b) <- s ]
    > replaces = [ a ++ c : b | (a,_:b) - s, c <- alphabet ]

Instead of this lambda (\w -> w `Map.lookup` nwords) you can use an operator section, (`Map.lookup` nwords).

Instead of your prompt function you can use the built in interact function

    prompt nwords = interact (unlines . map check . lines)
      where check = correct nwords

Re: Vague class names: "Manager" and "Helper"

rei — Sat, 03 Oct 2009 01:20:31 -0000

There are cases where something exists as a concept but not as a type.

For instance, I have a GUI where each view can be any kind of object, and I don't have a "View" type that they need to inherit from. In this case I need to manage the views, so I have a ViewManager, but the views themselves are of type System.Object.

Also, things are usually called "helpers" not because they help the types, but because they help the user with those types. In that sense the name makes perfect sense; they encapsulate tasks common to the type but not intrinsic to their functionality.

So no, I don't agree with this do-not.

Re: Lisp compiler in F#: Parsing with fslex and fsyacc

Lorenzo Stoakes — Thu, 20 Aug 2009 10:14:09 -0000

Thanks for this :-) great to have step-by-step instructions, saves a lot of time (esp. with fslex which takes *forever* to run for non-trivial grammars).

Cheers, Lorenzo

Re: Lisp compiler in F#: What's next?

jonnii — Tue, 09 Jun 2009 22:01:27 -0000

Great article. Looking forward to seeing more!