tag:blogger.com,1999:blog-1781749203477657712012-02-02T00:35:22.119-08:00An exploration of software development.James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.comBlogger461100tag:blogger.com,1999:blog-178174920347765771.post-62434570489156285512012-01-05T16:03:00.000-08:002012-01-06T13:01:24.023-08:00

Paul Snively and I are having a bit of disagreement about the value of treating type errors as warnings during development. It's hard to make anything like a cohesive point on Twitter so I thought I'd write a quickie post on what I mean and why I think it's valuable.What I'm talking about is not revolutionary. Eclipse JDT does it and I'm sure others do as well. The idea in a nutshell is that

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com29tag:blogger.com,1999:blog-178174920347765771.post-13981859080643974312011-06-17T09:38:00.000-07:002011-06-17T11:40:14.672-07:00

The world's stupidest, racy sort algorithm ported to Scala actors for no good reason.import scala.actors._ import Actor._ def sleepSort(xs : List[Int]) : List[Int] = { def sorter(aggregator : Actor, n : Int) = actor { reactWithin(n * 1000) { case TIMEOUT => { aggregator ! n exit } } } xs map (sorter(self, _)) foreach (_.start) val

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com3tag:blogger.com,1999:blog-178174920347765771.post-17197195436370529592011-05-09T14:32:00.000-07:002011-05-11T08:02:54.812-07:00

In The Point of Laziness, Bob Harper mentioned a core duality between lazy and eager languages[1]. Eager languages have sum types but not product types and lazy languages have product types but no sum types. I've seen a few questions about what he means. I thought I'd try to explain. It all has to do with non-termination, our old friend "bottom" which I'll write ⊥. In this entire article I'm

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com15tag:blogger.com,1999:blog-178174920347765771.post-38197565745452790582011-01-19T07:49:00.000-08:002011-01-19T08:14:37.025-08:00

It's a common misconception that a language must be "dynamic" or "interpreted" to have a REPL, a Read Evaluate Print Loop (also sometimes confusingly called an interpreter), or to have an "eval" function. That's not true at all.Haskell, OCaml, F#, and Scala are all statically typed languages with very sophisticated static type systems, yet all have REPLs. All are usually compiled although

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com5tag:blogger.com,1999:blog-178174920347765771.post-6465739681693709972010-11-10T09:32:00.001-08:002010-11-10T11:34:04.970-08:00

My company uses a centralized version control system. It works reasonably well, but of course has all the downsides of centralized VCS. So I wanted to explain how I use a local version control system to supplement even if there isn't a real "bridge" like git-svn.WhyBefore I start let me sum up why you might want to.It's not uncommon to work on task A only to have it interrupted by super

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com3tag:blogger.com,1999:blog-178174920347765771.post-36196840655505574572010-10-18T15:07:00.001-07:002010-10-18T15:58:46.912-07:00

/* Some literate Haskell and Scala to demonstrate 1) phantom types 2) I am a masochist 3) ??? 4) profit! The code is probably best viewed with a syntax colorizer for one language or the other but I've colorized all my comments. > {-# LANGUAGE EmptyDataDecls #-} > module RocketModule(test1, test2, createRocket, addFuel, addO2, launch) where */ object RocketModule { /* None of these data

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com5tag:blogger.com,1999:blog-178174920347765771.post-40387977882654187332010-10-15T08:50:00.000-07:002011-06-17T08:09:39.647-07:00

EDIT: Since I wrote this BART has finally implemented an integration between parking payment and the Clipper card. It's a little more complicated to set up than it should be, but it works. I'll leave the rant up because the meta-point still stands.This article will look like a random rant about public transportation, but it's really a random rant about bad systems design, especially when

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com1tag:blogger.com,1999:blog-178174920347765771.post-83932669788402188142010-10-08T16:18:00.000-07:002010-10-11T13:36:21.033-07:00

A guide to estimating percentage complete and remaining time.I haven't looked at the problem. Completed: 0% Time esimate: about 2 weeks.I've looked at the problem. Completed: 50% Time estimate: about 2 more weeks.I've implemented almost everything. All that remains is the difficult stuff that I don't really know how to do. Completed: 90% Time estimate: about 2 more weeks.I've done everything.

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com13tag:blogger.com,1999:blog-178174920347765771.post-30659458947545040302010-09-13T15:51:00.000-07:002010-09-14T07:52:26.590-07:00

In response to a previous article a poster in some forum called me an idiot and said "everybody knows that C is a portable assembly language with some syntax sugar." The idiot insult hurt deeply and I cried, but once the tears were dry I resolved to write a bit more on why C isn't assembly, or is at best an assembly for a strange, lobotomized machine. Also, I may have misspelled "more on" in

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com49tag:blogger.com,1999:blog-178174920347765771.post-25893558828701960972010-08-27T13:55:00.000-07:002011-02-07T08:11:35.751-08:00

Cedric Beust makes a bunch of claims in his post on Why Scala's "Option" and Haskell's "Maybe" types won't save you from null, commenters say he doesn't get it and he says nobody has argued with his main points. So I thought I'd do a careful investigation to see what, if anything, is being missed.First, right off the top here: Scala has true blue Java-like null; any reference may be null. Its

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com23tag:blogger.com,1999:blog-178174920347765771.post-33864859613992232010-08-13T13:18:00.000-07:002010-08-13T13:21:59.088-07:00

Kernighan: "I know, let's open the book with a program that displays 'hello, world.'" Ritchie: "Great idea! I'll start the patent search."

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com3tag:blogger.com,1999:blog-178174920347765771.post-9098104781786883192010-08-02T07:43:00.000-07:002010-08-02T15:29:52.768-07:00

/*What do you do in Java when you need to throw a checked exception in a context where it's not allowed, for instance when implementing a third party interface with no declared throws clause? If you're smart and its allowed you just write the code in another language. Otherwise you probably just wrap the bastard checked exception in an unchecked exception and be on your way.But the wrapping

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com12tag:blogger.com,1999:blog-178174920347765771.post-91204678418018384592010-07-20T12:36:00.000-07:002010-07-31T07:22:17.590-07:00

/*Occasionally somebody will suggest that statically typed language X (Java, C#, Scala, F#, whatever) would be better off with C++'s "const", a type qualifer that supposedly makes objects immutable in certain contexts[1]. I'm not convinced. Const requires a fair amount of work and provides fairly small guarantees. This post is a bit of literate C++ program demonstrating some of the weaknesses

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com6tag:blogger.com,1999:blog-178174920347765771.post-91523487246357481022010-07-09T09:24:00.000-07:002010-07-11T20:17:24.789-07:00

Stephan Schmidt makes several points in Scala Is Unfit For Serious Development . Some are even valid. Unfortunately, the valid points are buried in over-generalizations and attacks on the attitudes of the developers and community.It's unfit because the developers and the community are unwilling.At the end of his little diatribe he thanks 2 members of the community for helping him with his

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com13tag:blogger.com,1999:blog-178174920347765771.post-70411421136367472632010-05-27T06:54:00.000-07:002010-05-27T14:42:18.808-07:00

During the 1984 Super Bowl, Apple released an ad where gray, drab people are transfixed on a giant screen with a talking head who tells them how utopian their uniform world is. A female athlete jogs in and throws a hammer at the screen, the screen explodes, and a new voice announces the release of the Apple Macintosh.The ad riffed off of the George Orwell dystopian novell Nineteen Eighty-Four.

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com6tag:blogger.com,1999:blog-178174920347765771.post-29332523205652172292010-05-25T07:32:00.000-07:002010-05-25T09:53:51.407-07:00

The warning "Type safety : A generic array of T is created for a varargs parameter" is so irritating it makes me want to beat Java with a snoracle, an implement that allows defunct tech companies to breath while underwater. This article will explain what the warning is, where it comes from, and why it is pretty boneheaded. The warning also shows just how hard it is to extend an existing language

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com15tag:blogger.com,1999:blog-178174920347765771.post-56713211006390974842010-05-05T08:43:00.000-07:002010-05-10T08:18:02.010-07:00

I recently saw a debate on whether a certain language had a "weak" or "strong" type system. Naturally the debate ended in flames. As far as I could tell neither side knew what the other was talking about which isn't surprising as I've almost as many definitions of "weak" and "strong" typing as there are developers who use the words. Frankly the words have too many meanings to be useful.If the

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com19tag:blogger.com,1999:blog-178174920347765771.post-44795983682622265832010-04-12T15:23:00.000-07:002010-04-13T16:18:39.734-07:00

In my last article I dug down into some of the joys of undefined pointer behavior in C. But I did it in the context of an architecture that most developers aren't too likely to ever see again, the Intel 8086. I wanted to show that this stuff matters even with more mainstream architectures because compilers are free to do a lot of non-obvious things. C is not assembly.The United States Computer

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com12tag:blogger.com,1999:blog-178174920347765771.post-28288608655939337822010-04-08T08:42:00.000-07:002010-04-08T12:31:43.342-07:00

Heard about the new C bandwagon? According to April's Tiobe report C has eclipsed Java as the number 1 most popular language by a whopping 0.007%. So while all the rest of you Java suckers have just lost all professional relevance, I'm OK. I cut my professional teeth on C.Sometime ago on Twitter I gave in-jest advice to new C programmers: all your code and data are in one giant mutable array

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com8tag:blogger.com,1999:blog-178174920347765771.post-60311735934661599272010-03-08T07:40:00.000-08:002010-10-11T09:36:36.111-07:00

Robert Fischer saysIf your language doesn’t lead people to re-discover point free programming at least in the small, then the language really isn’t taking function manipulation and functional language type conceptions seriously.Thus Fischer has finally recognized that Scala is functional. val double : Int => Int = 2 * // point free function definition List(1,2,3) map double /* removes one point

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com22tag:blogger.com,1999:blog-178174920347765771.post-50597099254466681582009-08-21T14:17:00.001-07:002010-11-23T09:31:30.354-08:00

Except when I'm being a total smart ass or self indulgent emo telling the Ruby community to f' off, most of what I write talks about practical stuff, often with a small dose of theory. But this time it's about theory with a small dose of practice.Last time I talked about the way programmers in popular C derived languages C++, Java, and C# think of a void function as being one that returns

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com17tag:blogger.com,1999:blog-178174920347765771.post-70377262229946260382009-07-23T15:11:00.000-07:002010-11-23T09:26:31.363-08:00

I suspect most people who come to one of the statically typed functional languages like SML, OCaml, Haskell, F#, or Scala will have only seen static typing in one of the popular C derived languages like C++, Java, or C#. Some differences in type system become clear fast. One particular spot is the relationship and difference between void and unit.So imagine your favorite C derived language.

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com22tag:blogger.com,1999:blog-178174920347765771.post-71400488317950032152009-07-16T08:03:00.000-07:002009-07-16T09:41:37.656-07:00

In response to my last article on Groovy's lack of static typing James Strachan, the original Groovy guy, tweeted "groovy should fix this really IMHO." Well, perhaps. But "fixing" it would substantially change Groovy's semantics. Most importantly it would prevent Groovy from executing some programs that work just fine right now.An ExampleHere's a simple example of a program that works now but

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com10tag:blogger.com,1999:blog-178174920347765771.post-25600891813816698722009-07-15T16:54:00.000-07:002010-08-27T10:35:28.763-07:00

Every now and then somebody writes that Groovy supports optional static typing. But it doesn't. They've confused the use of type annotations on variables with a static type system.This article is emphatically not an entry in the long, sad, and mostly insipid static vs. dynamic debate. It is a clarification of a misunderstanding.DefinitionsThe word "static" in "static type system" is related to

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com13tag:blogger.com,1999:blog-178174920347765771.post-51269724531664583052009-05-15T08:42:00.000-07:002009-05-15T12:56:40.739-07:00

Robert Fischer claims Scala is not a functional language. But if you go by his post then Erlang isn't either.ModulesFischer says In OCaml, we define a function like this:let f x = x + 1;;In Scala, though, we define the function somewhat differently: object SomeHolderObject { val f(x:int):int = { x + 1 } }Now some Erlang -module(SomeHolderModule). -export([f/1]). f(X) -> X + 1. Erlang requires

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com22tag:blogger.com,1999:blog-178174920347765771.post-45020787310216426542009-05-07T19:28:00.000-07:002010-08-02T14:28:15.416-07:00

1801 - Joseph Marie Jacquard uses punch cards to instruct a loom to weave "hello, world" into a tapestry. Redditers of the time are not impressed due to the lack of tail call recursion, concurrency, or proper capitalization.1842 - Ada Lovelace writes the first program. She is hampered in her efforts by the minor inconvenience that she doesn't have any actual computers to run her code.

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com505tag:blogger.com,1999:blog-178174920347765771.post-48290310393315340972009-04-24T18:09:00.000-07:002009-04-24T18:31:24.065-07:00

When enthusiasts talk about Scala they frequently start with "it's a lot like Java but with all this other cool stuff like type inference and structural types and..." I guess it's okay to introduce Scala that way. I've done it myself. But it does give the impression that Scala has somehow heaped complexity onto the Java. Oddly enough, it hasn't, at least not in the areas of type inference and

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com18tag:blogger.com,1999:blog-178174920347765771.post-61166302114430161622009-04-16T17:07:00.001-07:002009-04-29T10:21:56.569-07:00

I managed to offend a few Erlangers by talking about actors as being shared stateful objects a couple of articles back. Now I'm going to continue the tradition by talking about the actor locking model. And I'm not just talking about Erlang, but any of the libraries that have sprung up for other languages to support actor style concurrency. Let me emphasize again that I like both Erlang and

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com7tag:blogger.com,1999:blog-178174920347765771.post-83338082932627536042009-04-14T17:22:00.000-07:002009-04-17T07:28:40.128-07:00

In a private email, somebody asked of my previous article "Okay, I can see that there must be state since you've created a state machine. But you aren't mutating any variables so where does the state come from?" It's a good question. If you feel you "got it" then skip this article. But if you're still hesitant or think I'm misusing the word "state" please read on.First, let me remind that I

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com10tag:blogger.com,1999:blog-178174920347765771.post-30658825432755313332009-04-06T16:59:00.000-07:002009-04-17T07:29:16.144-07:00

Actors have become quite the popular topic. Besides Erlang, there's a famous library implementation in Scala and at least 3 for Java. But the "no shared state" propaganda is setting people up for failure. In last week's exciting episode I defined both what state is and what it isn't. It is the fact that something responds differently to the same inputs over time. It is not the details of how

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com29tag:blogger.com,1999:blog-178174920347765771.post-85510274495832726172009-04-03T16:40:00.000-07:002009-04-17T07:29:35.229-07:00

Oddly, given that state is such a central notion to so much programming, it's awfully misunderstood. How do I know? Because OO programmers think they can make it private and Erlang programmers think they don't share it. If you agree with either of those statements then this article is for you.I want to start with a simple, hypothetical vending machines. It dispenses socks in a tube, which is

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com9tag:blogger.com,1999:blog-178174920347765771.post-50913920805683839232009-04-01T11:48:00.000-07:002010-10-15T09:19:05.107-07:00

A common tenet in user interface design is to be consistent, especially to be consistent with de facto standards. It's certainly a good goal, but I think that kind of consistency can be pushed too far. I recently thought of some real world examples: humble, ordinary, every day doors.Doors share a common functional requirement: be closed sometimes and be open others. That leaves a lot of room

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com10tag:blogger.com,1999:blog-178174920347765771.post-44134662362569797822009-03-16T09:00:00.000-07:002009-03-17T07:32:58.297-07:00

Bruce Eckel's recent blog post on The Positive Legacy of C++ and Java has opened a small can of worms on the Internet. The argument is on operator overloading[1]: tool of Satan or road to bliss? The arguing that's resulted is the usual well thought out, reasoned debate I've come to expect from software engineers. Which is to say, not at all.The Argument AgainstEckel mentions issues with

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com51tag:blogger.com,1999:blog-178174920347765771.post-73945569097666783452009-01-12T22:03:00.000-08:002009-01-27T08:47:48.231-08:00

Joel Spolsky has a post about the Java installer using the the word "Java" 7 times without really saying much. It's funny because it's true. It's even more funny that Joel writes his post without a hint of irony. (click for full screen Technicolor)

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com2tag:blogger.com,1999:blog-178174920347765771.post-64470687953553904612008-07-24T13:54:00.001-07:002008-07-30T14:05:33.311-07:00

This was originally published as a trip report for Tom's Dive and Swim in Austin, TX. If you happen to be a scuba diver in that area, they're a great bunch of people and the Flower Gardens is a great place to dive. This account is loosely based on a real encounter on October 11, 2003.  Unlike most fish tales, however, the size of the fish is about the only thing

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com2tag:blogger.com,1999:blog-178174920347765771.post-72377551959071573402008-07-18T10:42:00.000-07:002009-01-26T17:33:42.740-08:00

Occasionally you'll hear people praising Java because it's incredibly readable; there's only one way to do things; and other languages are too academic. But I have proof that they're wrong. After you view the code below I think you'll agree with me that with Java: It's far too easy to write code that's illegible to most programmers. There are far too many ways to do things. It's far too

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com15tag:blogger.com,1999:blog-178174920347765771.post-83595535419116372152008-07-16T10:42:00.000-07:002010-10-26T10:45:39.123-07:00

I can't for the life of me figure out how to get a comment to post on Ted Neward's blog article critiquing the discussion in my previous post. Perhaps my comment is being moderated, but the system didn't say so. So I'll put it here. [Edit: whatever was wrong seems to be fixed now. I was able to post a comment, but the original seems to have been eaten. That's okay, it's more complete here.]

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com1tag:blogger.com,1999:blog-178174920347765771.post-26723419523869579152008-07-15T10:35:00.000-07:002008-07-30T14:03:37.834-07:00

This one isn't going to be a meaty technical article nor a deep philosophical exploration. Instead it's about perception vs reality. What moves me to post is the following 3 twits from Tim Dysinger. The guys in #scala on irc are academics... Just got kicked from #scala for arguing. scala sucks at gaining any momentum with that kind of academic egomaniac cliques Edit: A few more R.I.P.

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com41tag:blogger.com,1999:blog-178174920347765771.post-17308957983300682362008-06-23T12:25:00.003-07:002008-08-01T12:35:32.030-07:00

Announcing the creation of Southern California Functional Programmers (SoCalFP), a group for people in LA, Orange County, and San Diego to meet in person and/or virtually to discuss, debate, present, and learn about functional programming concepts and techniques in various languages. You might ask, "why a functional programming group in Southern California?" Well, SoCal, wake up and smell the

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com2tag:blogger.com,1999:blog-178174920347765771.post-56752984085128719782007-11-06T19:50:00.001-08:002009-08-21T15:01:02.086-07:00

Until you experience an adult elephant first hand you won't really understand just how big they can be. If monads are elephants then so far in this series of articles I've only presented baby elephants like List and Option. But now it's time to see a full grown adult pachyderm. As a bonus, this one will even do a bit of circus magic.Functional Programming and IOIn functional programming

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com18tag:blogger.com,1999:blog-178174920347765771.post-15607484529195904432007-10-18T20:31:00.000-07:002009-01-26T17:28:31.043-08:00

In this series I've presented an alternative view on the old parable about the blind men and the elephant. In this view, listening to the limited explanations from each of the blind men eventually leads to a pretty good understanding of elephants.So far we've been looking at the outside of monads in Scala. That's taken us a great distance, but it's time to look inside. What really makes an

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com17tag:blogger.com,1999:blog-178174920347765771.post-18840140505936960282007-10-02T21:03:00.000-07:002009-01-27T12:38:42.345-08:00

In part 1, I introduced Scala's monads through the parable of the blind men and the elephant. Normally we're supposed to take the view that each blind man doesn't come close to understanding what an elephant is, but I presented the alternative view that if you heard all the blind men describe their experience then you'd quickly build a surprisingly good understanding of elephants.In part 2 I'm

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com12tag:blogger.com,1999:blog-178174920347765771.post-81386488273367482232007-09-18T18:14:00.000-07:002009-01-26T17:05:15.813-08:00

Introductions to monads are bit of cottage industry on the Internet. So I figured, "why buck tradition?" But this article will present Scala's way of dealing with monads.An ancient parable goes that several blind men were experiencing their first elephant. "It's a tree," one said while wrapping his arms around its legs. "A large snake," another said while holding its trunk. A third said...um

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com15tag:blogger.com,1999:blog-178174920347765771.post-85571592747432382752007-08-26T14:44:00.000-07:002009-01-26T17:02:02.312-08:00

I hate null. More specifically I hate NullPointerExceptions(NPEs). Scala has an alternative, but let me explain why I hate NPEs. They're like evil, sneaky muppets. Remember the Martians on Sesame Street? They'd ask each other if a phone was a cow and then say "nope, nope, nope, nope." To my eye, NPE looks a lot like "NoPE."Me: Is my unit test working?Computer: NoPEMe: Um...okay, fixed that

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com24tag:blogger.com,1999:blog-178174920347765771.post-69436951334550801872007-08-16T07:07:00.001-07:002009-01-26T15:55:43.453-08:00

In his famous rant Execution in the Kingdom of Nouns, Steve Yegge hilariously excoriates Java for being so "noun oriented" that it's difficult to express ideas that are simple to express in functional programming languages. Scala is a language for the JVM that attempts to unify the funcional and object oriented worlds using first class functions, pattern matching, and what I'm going to call

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com8tag:blogger.com,1999:blog-178174920347765771.post-4611904757919388672007-08-13T20:33:00.000-07:002007-08-13T21:37:50.988-07:00

In Beating the Averages, Paul Graham formulated the Blub paradox. In short a programmer who only knows a language called Blub looks down on all languages that don't support features that Blub has. At the same time, he1 is incapable of understanding why he would want to use some weird language that has features that Blub doesn't have. The Blub programmer is so used to thinking in Blub that he

James Iryhttp://www.blogger.com/profile/02835376424060382389noreply@blogger.com4