According to http://en.wikipedia.org/wiki/Type_theory. "The types of type theory were invented by Bertrand Russell in response to his discovery that Gottlob Frege's version of naive set theory was afflicted with Russell's paradox. This theory of types features prominently in Whitehead and Russell's Principia Mathematica. It avoids Russell's paradox by first creating a hierarchy of types, then assigning each mathematical (and possibly other) entity to a type. Objects of a given type are built exclusively from objects of preceding types (those lower in the hierarchy), thus preventing loops."
--
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to a topic in the Google Groups "Clojure" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/clojure/0I7u5yn01qU/unsubscribe.
To unsubscribe from this group and all its topics, send an email to clojure+u...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
You received this message because you are subscribed to the Google Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clojure+u...@googlegroups.com.
--
I'm a little bit miffed over this current craze of `types` and `correctness` of programs. It smells to me of the whole `object` craze of the last two decades.
On Oct 8, 2013 5:35 AM, "Phillip Lord"
>
> > However… I find that I am writing a lot of statements like this:
> >
> > (cond (hash-map? v)
> > ……
> >
> > (vector? v)
> > ……
> >
> > (list? v)
> > …..
> >
> > :else …..)
> >
zcaudate, in what context(s) do you find yourself writing a lot of expressions like that? I rarely want to allow so much flexibility in arguments. I'm wondering if there are idioms to avoid it.
> > I'm not sure a type checker will help in that instance.
>
>
> A type-checker wouldn't no, but a type system would; pretty much
> every language with a static type system has a type based dispatch
> somewhere. It would be nice to be able to do
>
> (defun fn
> ([^vector v] ...)
> ([^list l] ...)
> ([else] ...)
How is Clojure's protocols feature different from what you're describing?
>This would be useful indeed. Although, a hard core type head would say
> 1. Types are useful for structures that HOLD data (ints, strings,
> maps, arrays… ) because they provide ways defining standard
> operations to manipulate data that make sense in the context of
> that type of data. It is helpful to have a type checker check
> that I am not accessing the 6th element of a hashmap or that I am
> adding 10 to "Hello".
"I want to distinguish between a string that is an email, someones name,
and a day of the week". This is not unreasonable.
--
--
The best explanation of these misunderstandings I've come across is "What to Know Before Debating Type Systems":http://cdsmith.wordpress.com/2011/01/09/an-old-article-i-wrote/In particular it asserts (correctly in my view) that what static type system proponents mean by "type" and what dynamic type system proponents mean by "type" are very different things. Most debates founder on a failure to recognise that difference.--
paul.butcher->msgCount++
js> Array(16).join("wat" - 1) + " Batman!""NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN Batman!"js>
On Tuesday, October 8, 2013 6:07:47 AM UTC-7, Laurent PETIT wrote:2013/10/8 Robert Day <rober...@gmail.com>Not necessarily...
On 08/10/13 13:49, Nando Breiter wrote:
If you try and add 10 to "Hello" in a typed language, you get an error. If you try to do the same in a dynamic language, you get an error.
$ perl
print 10 + "Hello", "\n"
^D
10
$
Then don't use Perl :-p
--
If you try and add 10 to "Hello" in a typed language, you get an error.
2013/10/8 Greg Bowyer <gbo...@fastmail.co.uk>js> Array(16).join("wat" - 1) + " Batman!""NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN Batman!"js>One of the many reasons we're using Clojurescript and not raw javascript :-)
> > (cond (hash-map? v)
> > ……
> >
> > (vector? v)
> > ……
> >
> > (list? v)
> > …..
> >
> > :else …..)
> >zcaudate, in what context(s) do you find yourself writing a lot of expressions like that? I rarely want to allow so much flexibility in arguments. I'm wondering if there are idioms to avoid it.
I'm a little bit miffed over this current craze of `types` and `correctness` of programs. It smells to me of the whole `object` craze of the last two decades. I agree that types (like objects) have their uses, especially in very well defined problems, but they have got me in trouble over and over again when I am working in an area where the goal is unclear and requirements are constantly changing.
BTW... This is no means a criticism of all the type system work that is going on in the clojure community. I am a huge fan of Ambrose's Typed Clojure project because it gives me the option of using types... not shoving it down my throat. I like the freedom to choose.
My experience of programming in clojure has freed me from thinking about types and hierarchies and this article rings so true: http://steve.yegge.googlepages.com/is-weak-typing-strong-enough.
However, everywhere I look, there are smug type-weenies telling me that my dynamically typed program is bad because it cannot be `proven correct` and not `checked by the compiler`. This question on SO really makes me angry.... http://stackoverflow.com/questions/42934/what-do-people-find-so-appealing-about-dynamic-languages.... because no one is defending dynamic languages on there. The reason is very simple..... because we don`t have a theory to back us up!
I do want to put up an counter argument against this barrage of abuse against dynamic languages. And I want to put some academic weight behind this. The only counter I could come up with was to use Godel's incompleteness theorem. For those that don't know... here is an introduction to the man and his theory. http://www.youtube.com/watch?v=i2KP1vWkQ6Y. Godel's theorem, invalidated Principia Mathematica as a complete system of description. Principia Mathematica btw.... effectively led to Type Theory.
According to http://en.wikipedia.org/wiki/Type_theory. "The types of type theory were invented by Bertrand Russell in response to his discovery that Gottlob Frege's version of naive set theory was afflicted with Russell's paradox. This theory of types features prominently in Whitehead and Russell's Principia Mathematica. It avoids Russell's paradox by first creating a hierarchy of types, then assigning each mathematical (and possibly other) entity to a type. Objects of a given type are built exclusively from objects of preceding types (those lower in the hierarchy), thus preventing loops."
I'm hoping to collect a few more `proofs` from the clojure community... for example... if there is a paper on "why are type systems so bad at classifying animals"... then please forward it on.
--
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clojure+u...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
-- ThisIsHardToRead, asIsThis. This_is_easier, unless_it_is_underlined. This.is.easy. This-is-easy-too. Almost as easy to read as this.
The best explanation of these misunderstandings I've come across is "What to Know Before Debating Type Systems":http://cdsmith.wordpress.com/2011/01/09/an-old-article-i-wrote/
So I can say I prefer dynamic typing, but the reasons are more personal, and molded by my development experience.Many programmers approach the question of whether they prefer static or dynamic types by comparing some languages they know that use both techniques. This is a reasonable approach to most questions of preference. The problem, in this case, is that most programmers have limited experience, and haven’t tried a lot of languages. For context, here, six or seven doesn't count as “a lot.”
--
For more options, visit https://groups.google.com/groups/opt_out.
Where would mutant elephants and the elephant god Ganesha fit in that classification?
You received this message because you are subscribed to a topic in the Google Groups "Clojure" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/clojure/0I7u5yn01qU/unsubscribe.
To unsubscribe from this group and all its topics, send an email to clojure+u...@googlegroups.com.
You received this message because you are subscribed to a topic in the Google Groups "Clojure" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/clojure/0I7u5yn01qU/unsubscribe.
To unsubscribe from this group and all its topics, send an email to clojure+u...@googlegroups.com.
--
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clojure+u...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
Dynamical languages are above all oriented toward practical programming needs in certain contexts--in other contexts, static typing is more practical.
--
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to a topic in the Google Groups "Clojure" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/clojure/0I7u5yn01qU/unsubscribe.
To unsubscribe from this group and all its topics, send an email to clojure+u...@googlegroups.com.
You received this message because you are subscribed to the Google Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clojure+u...@googlegroups.com.
--
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to a topic in the Google Groups "Clojure" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/clojure/0I7u5yn01qU/unsubscribe.
To unsubscribe from this group and all its topics, send an email to clojure+u...@googlegroups.com.
However, the more i write lisp code, the more i realise that types has its drawbacks. I'm not sure of the answer here but I have my suspicions: Can typed clojure be written in typed clojure?
My take is that required types may force premature optimization and may
inhibit the creative process.
Can typed clojure be written in typed clojure?
could just project everything into some universal type, then do case analysis based on what sort of thing you had. (Which is the nub of Bob Harper's claim that "dynamically typed" languages are just a special case of statically typed languages, if I understand it.)
Media for Thinking the Unthinkable:
Designing a new medium for science and engineering
http://worrydream.com/MediaForThinkingTheUnthinkable/
Maybe this is the argument that zcaudate should use: Static typing is the death of creativity.
Just kidding.
There is a video presentation, which could be downloaded and watchedOn Dec 24, 2013, at 02:09, Cedric Greevey wrote:
> On Mon, Dec 23, 2013 at 7:37 PM, Rich Morin <r...@cfcl.com> wrote:
> Media for Thinking the Unthinkable:
> Designing a new medium for science and engineering
> http://worrydream.com/MediaForThinkingTheUnthinkable/
>
> Is this available in a form that is skimmable, is greppable, is cheap for mobile users, can be perused at leisure, fits on a thumb drive, is convertible for Kindle use, and doesn't require installing and enabling notoriously insecure browser plugins to view, or is it only available as video? :(
at leisure (eg, on a smart phone). I don't think this presents any
security issues.