Re: [dev] Conversation with Anselm R. Garbe of suckless.org

On Fri, 18 Sep 2009 06:22:44 -0700, frederic <fdubois76_AT_gmail.com> wrote:

>> The OO debate in this thread is also very interesting. I would argue
>> that its really a trade-off between "predicting" future changes in your
>> source and "getting the prediction wrong". I would argue that it is
>> _great_ to see a lot of code reuse due to OO inheritance and
>> polymorphism (the good thing about OO) but at the same time extremely
>> painful if the inheritance and polymorphic structure is not aligned to
>> new changes to the source.
>>
>
> Code reuse is not the monopoly of OO. Code reuse is just a matter of
> librairies and their usability.
> When a program is well designed, you generally end up with an aggregate of
> modules, each one doing one thing. They may be turned into libraries with
> little
> extra efforts and be reused in another project.
>

I agree. I was talking about evolving a given module itself (say adding acceleration support to a canvas library). Of course, bigger problems exist when you start changing the library interfaces themselves.

>
>> Also, I would like to know, what do people on this list feel about type
>> checking in general? A lot of language research in academia focuses on
>> typing constructs when at the same time the industry seems to be
>> favoring scripting languages and "duck" typing for productivity. What do
>> you think?
>
> I favour static typing because of the extra safety and optimisations; it
> also help
> communications between programmers at source level (when the types are not
> automatically
> inferred, that is). I detest those dynamic languages with which a typo in
> the name of a variable
> makes your app blow at runtime (if you're lucky).
>
>

Isn't it amazing, then, to see a lot of developers grab onto dynamic languages like crazy? Something must be working well for the dynamic languages...

Also, something else crossed my mind when thinking about type checking. When reasoning about OO complexity shouldn't we separate OO type checking from OO itself? Aren't dynamic OO languages prone to less of OO problems we discussed in this thread (modulo, the new problems they create as aptly pointed out by parent)?

Cheers,

-- 
Pinocchio