05:33 <pattern> i saw a book on types in the bookstore today

05:33 <pattern> they used ocaml for all of their example code

05:53 <Nutssh> ocaml does seem to be growing in interest, or is it me?

05:55 <pattern> it seems that way to me

05:55 <pattern> and i've heard very few negative things said about it from people who've actually taken the trouble to learn it

05:56 <pattern> but i still think it's going to take at least six years to reach the popularity of even something like ruby

05:56 <pattern> ...if the trend continues

05:58 <Nutssh> I think it will. Its fairly approachable. But at the same time, its very different, and I've grown to accept that programming isn't a technology of the future, but seems incredibly tied to the past.

05:58 <pattern> and it'll probably never be as popular as java or vb

05:59 <pattern> programmis is certainly tied to the past with bounds of backwards compatibiilty and the reluctance of most programmers to learn anything too different from the way they've been taught

05:59 <Nutssh> Advertise it as much lighter weight than java, but also as fast or faster, and SAFE?

05:59 <pattern> and ocaml has too much of a feel of math, imo, for most people to take a liking to it

06:00 <pattern> i think the early adopters of ocaml don't mind math, or even actively like math... can't say the same thing about the masses

06:00 <pattern> and it's harder to just hack away in ocaml

06:01 <Nutssh> I still find ocaml amazing for its agility. Fast compilation. And, a lot of the time, you can substitute datastructures by just changing types and fix the type errors.

06:01 <Nutssh> I don't know what you mean by that.

06:01 <pattern> making sense of all those type errors and figuring out how to combine functions can be pretty tricky... though i guess nothing'll stop someone from using ocaml in an imperative style, but that's kind of a waste

06:01 <cleverdra> Indeed? I sometimes jot down notes to myself in the form of O'Caml type declarations and pattern-matches, because I can figure out key parts of my program just by looking at the types.

06:02 <pattern> yeah, _you_ can

06:02 <pattern> because you're comfortable with ocaml's type system

06:02 <Nutssh> And I like the math orientation of it. Great for symbolic reasoning, and that probably really is the essence of programming.

06:03 <pattern> i'm saying that there's a learning curve to get to that point, and to the average programmer that learning curve is pretty steep, maybe too steep

06:03 <pattern> it's not like learning just another imperative language

06:03 <cleverdra> I don't really care, but OK.

06:03 <Nutssh> No, I think its just lack of familiarity and a huge lack of interest in anything new.

06:04 <pattern> yeah, if they were taught it early on then i think they'd probably find it more natural and easier

06:04 <pattern> but i doubt that's going to happen any time soon either

06:04 <Nutssh> Its taken almost 15 years for OO to become mainstream. 40 years for GC to become mainstream.

06:05 <pattern> yeah, but using GC is not tough for the programmer

06:05 <pattern> there's no learning curve in using GC

06:05 <pattern> just some preconceptions to overcome, which is easier to do with young people

06:05 <Nutssh> But 40 years for acceptance! Now thats being tied to the past.

06:07 <pattern> and OO gained acceptance in a fad-like fashion... and i do see the potential for the functional paradigm to become the next programming fad... i'm just not sure how easy programmers will find picking up the functional style compared to previous fads (not that the functional style is _just_ a fad... i think it's very valuable, but anything percieved as "new" has the potential to be embraced because it's fashionable rather than on technical merits)

06:08 <pattern> like "extreme programming"

06:08 <pattern> another fad that, like using GC, really doesn't require much of the programmer to embrace it

06:09 <Nutssh> I think its not the functional style --- lisp has had that for 35 years too. I think its the typing in ocaml I find more useful, but higher order functions sure come in handy.

06:09 <cleverdra> Nutssh - no, lisp really didn't have it for 35 years.

06:09 <pattern> actually, same with OO, as i hear many programmers are paying lip-service to the OO paradigm, but really write in a procedural style even in languages like java

06:09 <cleverdra> and "it's".

06:09 <cleverdra> pattern - have you read topmind, yet?

06:10 <pattern> nutssh, yes, i love the typeing in ocaml... i think both are a hurdle for the average programmer

06:10 <pattern> cleverdra, no, what's that?

06:12 <cleverdra> pattern - c2.com/cgi/wiki?TopMind -- TOP for Table Oriented Programming, a fairly nifty and tenacious anti-OO person.

06:12 <pattern> heh

06:13 <pattern> i've read a few anti-OO wiki threads

06:13 <pattern> they're usually not too coherent

06:13 <cleverdra> Follow that link to his site, at least.

06:13 <pattern> sure

06:13 <pattern> i'm game

06:15 <pattern> "Believes that non-trivial taxonomies, relationships, and structures should be data instead of code because data is allegedly easier to customize one's view of in order to inspect, study, and test."

06:15 <pattern> so code should be trivial?

06:15 <pattern> ;)

06:17 <Nutssh> From the summary, it strikes me as an instance of 'when all you have is a hammer, everything is a nail.' But could be willing to buy the premise that relational abstraction is underused.

06:17 <pattern> "Believes that the majority of most algorithms can be reduced to DatabaseVerbs if one knows how" (database verbs being things like "search", "sort", "delete") wow, that's deep

06:18 <pattern> i dunno... i don't like databases

06:18 <pattern> it's just a personal thing

06:18 <cleverdra> This manner of read-quote-comment-read strikes me as an instance of not really wanting to read, but OK.

06:18 <pattern> they just rub me the wrong way

06:18 <pattern> i am reading

06:18 <pattern> perhaps i should save up my comments, though

06:18 <Nutssh> Oh, relational calculi is interesting. and a great high-level abstraction.

06:20 <pattern> yeah, i'm no expert on databases to make a knowledgeable rejection of them... that oppinion is just coming from the gut... but maybe that's just an aversion bred of my familiarity with databases mostly thruogh administering them or dealing with their users rather than having explored their implementation and the theory behind them

06:22 <pattern> and, now that i think more of it, i remember having to develop for an MS Access long, long ago... and remember how SQL was probably the simplest language i've ever learned (not simple in a good, elegant way either... though not the abortion that is HTML either)

06:23 <pattern> but, i guess i could get in to the theory behind them, from a math perspective

06:23 <pattern> anyway, back to reading...

06:26 <Nutssh> The relational calculi is nice for expressing incredibly high levels of abstraction: SELECT a,b,c FROM foo, bar WHERE foo.a = bar.b && foo.d> bar.e Manually coding a procedure for this would take at least 10 lines of code, assuming a full datastructure library, and be slower.

06:27 <pattern> yes, sql is simple

06:30 <pattern> cleverdra, topmind's critique of heirarchical classification reminded me of faceted classification... have you heard of it?

06:31 <cleverdra> pattern - no, but the name seems evocative enough.

06:33 <pattern> http://www.welie.com/patterns/showPattern.php?patternID=faceted-navigation

06:34 <Nutssh> Their type discussion page seems to have a few strawman.

06:35 <pattern> faceted classification is like an automatically generated, dynamically changing heirarchy, with multiple entrypoints

06:36 <pattern> tomind's objections to heirarchical classificatoin seem to be really only relevant to rigid, simple heirarchies

06:36 <pattern> there are other ways of using heirarchies which are more flexible, though, as faceted classification illustrates

06:37 <pattern> nutssh, where is their type discussion?

06:42 <Nutssh> http://c2.com/cgi/wiki?ThereAreNoTypes

06:43 <pattern> i hate wiki threads

06:43 <pattern> same with lambda threads

06:43 <pattern> hopefully one day someone will reinvent the usenet news reader and end the pain

06:44 <pattern> this is one case where heirarchy is very useful

06:54 <pattern> "The problem with a static type system is that it tends to force us to distinguish crisp dollar bills from crumpled ones through-out the system, even if only one part of the system cares. This can be tolerable for small, stable systems but it doesn't scale well"

06:55 <pattern> not hard to see the holes in that argument

06:56 <Nutssh> Yeah. You store seperate flags like that not via inheritance/subtyping or even mixins, but as a seperate attribute. 'billstatus' that is a component of a abstractbill.

06:58 <pattern> the route i took was to extend his analogy of passing around crumpled dollar bills

06:58 <Nutssh> But figuring out the right way to decompose a messy problem using both inheritance and encapsulation is a bit of a black art. Ever used a MUD?

06:58 <pattern> until the bills just fell apart

06:58 <pattern> and you could hardly tell what was a bill anymore and what wasn't

06:58 <pattern> (ie. a system with no types)

06:59 <pattern> but, this makes me wonder if there's been any research on "fuzzy types" (ie. combining fuzzy logic with strong type systems)

06:59 <pattern> probably not a good idea

06:59 <pattern> i used to play muds, yes

07:00 <Nutssh> Heh. :) Yeah, The rants seem like a reaction to a perceived fad of using OO to represent large amounts of data that would be better suited to a relational database.

07:05 <Nutssh> And on http://c2.com/cgi/wiki?ReplaceConditionalWithPolymorphism IMO, OO is useful because it centralizes your data and your functions for modifying it, and it helps you think of a problem. The notion of inheritance and dynamic dispatch is less important.

07:06 <pattern> well, modularization and encapsulation are important

07:06 <pattern> and strong typing provides the link between functions and data

07:07 <pattern> no need to have them both be in an "object"

07:07 <Nutssh> Oh, and for the wiki, Wiki's have one advantage over news, they can be edited to remove the cruft, leaving the valuable arguments.

07:07 <pattern> you can filter news

07:07 <pattern> anyway, there's nothing stopping someone from creating a wiki page from a discussion, once you've distilled it to the essentials

07:08 <pattern> but while it's in living thread form it makes more sense for it to be in news format, imo

07:08 <Nutssh> Agreed. But C doesn't have that sort of nice encapsulation. You're right though, I never really noticed or cared that sml-nj didn't have objects.

07:54 <pattern> http://xahlee.org/UnixResource_dir/_fastfood_dir/fastfood.html

08:09 <det> IMO, OO is useful because it centralizes your

08:09 <det> data and your functions for modifying it, and it helps you think of a problem. The notion of inheritance and

08:09 <det> dynamic dispatch is less important.

08:09 <det> oops

08:09 <det> - quoting nutssh

08:09 <det> but he is gone :(

10:21 <Banana> hello.

10:22 <Kinners> hi Banana

12:35 <pattern> http://www.geocities.com/tablizer/oopbad.htm

12:39 <Banana> fun.

12:39 <Banana> OOP better models spoken language ^_^

12:45 <Nutssh> Better than?

12:51 <Nutssh> *hmms* I note that he discusses his opinion on OOP for 'small to medium' business applications. On the other hand, he is true pointing out that it is those that account for around half of the software out there, and its an area that is lacking an academic treatment.