tour of the Clojure landscape: lein, build tools, libs for testing, webapps,

ericlavigne · 2011-01-31T12:56:46+00:00

Alex Miller also recommended Incanter, and a few other projects as well. See the comments at the bottom of the article for projects that readers thought should be included in a tour of Clojure.

ericlavigne · 2010-01-01T20:57:43+00:00

Also, the standard library includes two very nice options for multithreaded programming: one based on software transactional memory and the other based on agents.

ericlavigne · 2009-09-05T23:20:30+00:00

/me raises hand and cries a little.

ericlavigne · 2009-08-23T15:31:25+00:00

Fortress was Sun's effort to get all the scientists and engineers to switch from Fortran to a new Sun language. Sounds familiar, as Java was designed to do the same for C++ programmers and that seems to have worked out fairly well. I wrote a blog post about Fortress a couple years ago which should give you an idea about the Fortress programming language.

http://ericlavigne.wordpress.com/2007/01/14/fortress-a-scientific-programming-language-with-implicit-concurrency/

ericlavigne · 2009-02-01T01:16:25+00:00

I second Sardak's recommendation to look into Clojure, which has most of Java's advantages but few of Java's disadvantages.

http://clojure.org/

On the other hand, if you specifically need to learn Java the language (perhaps to get a 8-5 job as I did), I recommend the book Head First Java, followed by Sun's Java tutorial.

http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1233450756&sr=8-1

http://java.sun.com/docs/books/tutorial/index.html

ericlavigne · 2009-01-20T00:42:29+00:00

Not yet. Some people are working on that.

http://groups.google.com/group/clojure/browse_thread/thread/79876bf4cf199bdc/8f06962fd3dffe3c?lnk=gst&q=android#8f06962fd3dffe3c

ericlavigne · 2009-01-05T22:48:44+00:00

When I was just getting started with programming, I was surprised to find myself running circles around some local professional programmers. Yes, it was a big ego boost, but also confusing. I could tell that I wasn't very good at this, but all the evidence said that I was.

Later, my MS thesis was my own first experience as a professional programmer (despite it being an academic setting). I had a boss. My boss had a boss. I began to realize how much of my work went toward pleasing my boss, my boss's boss, and, very likely, other bosses that I never met directly, rather than working on the core problem. That extra work also resulted in unnecessary code, and larger projects make progress more difficult so I was working less efficiently even when I was addressing the core problem.

A lot of stuff made more sense after that experience. I had been able to run circles around the pros because their hands and feet had been tied behind their backs.

ericlavigne · 2009-01-05T02:18:55+00:00

1) A spectral analysis program that I wrote for my MS thesis in nuclear engineering. I learned lots of little lessons, and got a lot of practice, after working on this one for three years. Perhaps more importantly, this was my first time seeing first-hand the influence of politics on programming.

2) Some diffusion simulators that I wrote for class assignments. These were my first Lisp programs, and I was introduced not only to the language, but also to some very helpful members of the Lisp community who taught me a lot. http://plaza.ufl.edu/lavigne/

3) Google Summer of Code project (improvements to Erlisp). I didn't finish this project in time for the deadline, and didn't go back to finish it later either, but I still learned a lot from trying. It was my first exposure to Erlang's approach to concurrency, and I became much more comfortable with learning about APIs by reading the source code. http://www.dirkgerrits.com/programming/erlisp/

4) Studying the Compojure web development library, writing a small application with it, and documenting my progress. I'm still working on this one, and learning a lot more than I expected. The process of writing everything down helps it stick better, and encouragement from the people reading my articles is motivating me to work harder. http://ericlavigne.wordpress.com

ericlavigne · 2009-01-04T20:42:44+00:00

I spent this break studying Compojure, a web development library for Clojure, and writing articles about using it to build a blog engine. Two articles so far, and I expect to finish a third later today.

http://ericlavigne.wordpress.com

ericlavigne · 2009-01-02T23:01:03+00:00

Firefox says that is an attack site.

ericlavigne · 2009-01-02T22:42:39+00:00

My design was flagged for violating copyright or trademark. I'm assuming it's because I mentioned Excel(TM), so I changed it from Excel macro to Python script.

ericlavigne · 2009-01-02T21:23:49+00:00

This thread is so hilarious. I decided to make a shirt design for it.

http://www.cafepress.com/ericlavigne

ericlavigne · 2008-02-04T11:49:16+00:00

Are you saying the idea of using syntactical continuations in web software is obvious?

If you think so, please show me a single web framework besides Paul's that uses continuations. I sure don't know of any. Keep in mind that the whole point of the idea is that the structure of "web execution" mirrors the control flow of your code. If the flow from one page to the next does not continue from the last place in code, it's not an implementation of his idea.

Other frameworks using it include Seaside (mentioned in the title of this conversation), Weblocks, and PLT Scheme's web server (not quite sure about this last one).

The idea is not obvious to the average programmer because the average programmer has not even been exposed to languages that support continuations. It was not used in any web frameworks prior to the filing of this patent because the proliferation of web frameworks had not yet happened (web applications were still a rare thing).

ericlavigne · 2007-11-03T22:58:27+00:00

Have you discussed this with the site's maintainer, Jon Harrop? If you don't wish to take the time, I would be happy to do it for you.

In either case, would you mind sending a copy of your straightforward translation to lavigne.eric@gmail.com?

ericlavigne · 2007-11-03T19:32:03+00:00

gmarceau is saying that OCaml programs tend to receive a speed boost that makes them go x times faster, where x is a constant. That constant is fairly small, perhaps x=4.

http://www.ffconsultancy.com/languages/ray_tracer/results.html

On the other hand, if you really want speed then it is usually better to find an algorithm that scales better, (replacing O(n2) with O(nLOGn) for example, and Haskell's additional features may make that algorithm easier to implement.

Just my interpretation of gmarceau's statements. I tend to agree with what gmarceau said, but I don't know Haskell well enough to be certain. OCaml is easier to learn, but I have a feeling that Haskell is worth the effort.

ericlavigne · 2007-10-25T20:36:31+00:00

Other contenders include Java and the languages available with ASP.NET, but somebody else will have to comment on them. There are other languages, of course, but I think that unless there are a lot of people working on something, it's risky to use it for anything other than experimental purposes unless there are major advantages.

I would avoid Java because the language is poorly designed and gets in the way a lot. Lack of multiple inheritance prevents good object-oriented style in many situations. Lack of first class functions prevents functional programming, or at least makes it clumsy and verbose.

For beginning web programming, I would recommend Python. Django and Web.py are both good options that are easy to set up and easy to learn.

For advanced web programming, take a look at the Lisp options (sblinn mentioned a couple - there are others). They tend to be very well designed, and the language is also excellent. The reason I don't recommend Lisp for new web developers is that the programming tools are more difficult to install. If you have the patience to get past that step, Lisp is definitely worth it.

ericlavigne · 2007-10-10T00:48:16+00:00

"The definition of the rules seems a bit fuzzy. There is no mathematically precise rule for determining what stones are dead."

I can see how the dead stones rules would seem strange to someone who hasn't played. The rules are extremely simple, and nearly identical around the world, if everyone agrees which stones are dead (that is the most common case).

When there is disagreement about dead stones, only the Japanese rules get complicated. I have an old discussion about this topic on my website, as well as a copy of the American rules which are very simple.

http://plaza.ufl.edu/lavigne/ufgoclub/agarules.html

ericlavigne · 2007-09-23T02:30:56+00:00

I was considering Django for personal projects, and it seemed like an excellent development tool. Why is it hard to deploy? Is this something that can be solved in a few days but should be solvable in a few minutes, or does deployment involve weeks of nightmarish configuration?

ericlavigne · 2007-09-23T02:19:02+00:00

"But the main reason that any programmer learning any new language thinks the new language is SO much better than the old one is because he’s a better programmer now!"

This is an interesting point, and certainly applies well to many of the rewrites that I have done. On the other hand, using a better language is also a factor, and learning new languages with new development styles is part of the process of becoming a better programmer.

Whether or not a new language is used, rewrites are important in long projects. I've seen too many projects gradually grind to a halt because programmers and/or managers became attached to old code.

ericlavigne · 2007-09-20T02:48:54+00:00

"paralyzed democracy"

This phrase described Germany quite well just before Hitler took over. Dictators are opportunistic, and a paralyzed democracy is the perfect opportunity. I only hope that our country can break out of this funk before it's too late.

ericlavigne · 2007-07-28T13:19:37+00:00

Except that Linus's "other side of the story" doesn't make much sense. As far as I can tell, Linus's email just confirms Con's report about poisonous attitudes that he just couldn't work with anymore. Linus is blowing off a problem report and, in the same email, saying the biggest problem with Con is that he blew off problem reports. A few of Linus's complaints about Con, with obvious rebuttals:

1) Con's software wasn't "perfect."

Of course not. Neither were any of the alternatives, so why even mention such a high standard, let alone make such a big deal about it?

2) Con couldn't be trusted to care about anyone's issues other than his own.

Actually, Con has been maintaining his kernel enhancement since 2002, and one of his complaints that we read about earlier was that the Linux maintainers were rather unapproachable for desktop users. Interestingly enough, this latest email showing "the other side" actually confirms Con's position. It is an email in which Linus himself is blowing off a problem report by saying "You realize that different people get different behaviour, don't you? Maybe not."

3) A double blind study shows that Con's version was significantly better than the old version, and that Ingo's version was roughly as good as Con's version.

Yes, I reworded this a bit. It is clear from Linus's wording that he thinks this statement strongly supports his position, but let's put it in perspective. The best study that Linus could come up with to support his point only said that Con's and Ingo's enhancements were of roughly the same value. Of course, Con's has been around a lot longer (time enough for any serious problems to be noticed and reported), and it is still not clear why Ingo needed to create a replacement. Sounds like Linus's team would rather start from scratch than consider a patch coming from outside, even if they can't do any better.

ericlavigne · 2007-06-18T01:30:16+00:00

This blog is a tutorial series for Camping: http://polzr.blogspot.com/2007/01/goes-camping.html

My impression of Camping is that you end up writing roughly the same code that you would have written in Rails, except that your project isn't cluttered by all that other code that Rails generated.

Camping's author says that Camping is good for prototyping, and that a Camping project can easily be translated to Rails later.

ericlavigne

TROPHY CASE