On Tue, Dec 24, 2013 at 12:23 PM, Rich Morin r...@cfcl.com wrote:
On 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
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
On 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
Maybe this is the argument that zcaudate should use: Static typing is the
death of creativity.
Just kidding.
I'm doing a short study of how hair affects language design.
http://z.caudate.me/language-hair-and-popularity/
I'd be more than happy to draw up a chart of how many hours a person
Just a link to the Gilad Bracha post Richard Cole is referring to: Types
Are Anti-Modularhttp://gbracha.blogspot.it/2011/06/types-are-anti-modular.html
.
Il giorno lunedì 23 dicembre 2013 02:24:08 UTC+1, Richard Cole ha scritto:
The things is that dynamically typed languages are easier to
This ties in nicely to my summary of how I feel about static typing: Static
typing is a premature optimisation. Like most optimisations, it has
genuine value, but if you apply it globally and too early, you end up
causing more pain than you gain.
sometime type discussions lead to lead to early
Do you guys have any concrete examples?
Sent from my iPhone
On 23 Dec 2013, at 10:13, Korny Sietsma ko...@sietsma.com wrote:
This ties in nicely to my summary of how I feel about static typing: Static
typing is a premature optimisation. Like most optimisations, it has genuine
value, but
I agree entirely with Korny's
statements.
As for concrete examples ?
Hard to enumerate some, I can only
say I agree after more than 30 years
coding in various languages and
finally getting out of Java hell.
When I started there were a variety
of dynamic languages used in the
industry and given
This article makes some interesting points, but it seems to draw the wrong
conclusions.
The thing that is anti-modular isn't the types: it is depending on the
internal implementation details of another module. If you expose too much
of the implementation details in your interface declaration,
I came to this thread late, and have only skimmed some of the answers, but
I think that the following, somewhat oblique, opinion hasn't yet been
expressed about the, I don't know, maybe ... harassment by type weenies
that zcaudate feels. Apologies in advance if I've missed a similar point.
Dynamical languages are above all oriented toward practical programming
needs *in certain contexts*--in other contexts, static typing is more
practical.
Agreed -- which is why I find your speculation about lightening up with
more experience ... meeting the demands of practical coding to
Agreed -- which is why I find your speculation about lightening up with
more experience ... meeting the demands of practical coding to be unsound.
For those of us whose practical programming context includes a high cost
associated with most any runtime bug, greater embrace of static typing,
I don't think we disagree. The guesses I gave in my post only concerned
people like those who frustrated zcaudate, and who, from what was said,
seemed to feel that anything other than strict static typing was wrong in
all contexts. Maybe I'm reading too much into zcaudate's post, though.
@Richard. I would have said the same as you before I joined a relatively large
organisation heavily influenced by scala and the Coursera FP lecture series. We
are slowly moving into Clojure code but there now seems to be a huge
misconception that FP and Type Systems are joined at the hips.
My
I'm not sure what you mean by invoking the putative silliness of an any
type, but existential types aren't just a way of saying anything goes
here, typewise---they do enable further substantive static guarantees
(such as those used by e.g. Haskell's ST system).
On Mon, Dec 23, 2013 at 2:16 PM,
About:
The question, then, is whether the flexibility of
dynamic types lets you develop, test, unit test, and system test code
so much faster than you would in a language with strong static types
that you are able to prevent all runtime type errors anyway.
Yes! In the past years, I coded in
@mars0i That is how I feel. Of course static typing has its use. For starters,
it makes my programs go faster.
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
On Mon, Dec 23, 2013 at 2:34 PM, Chris Zheng z...@caudate.me wrote:
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?
Why in the world couldn't it be?
On Dec 23, 2013, at 14:16, Chris Zheng wrote:
I completely agree with Korny that types are a premature optimisation.
My take is that required types may force premature optimization and may
inhibit the creative process. So, I like dynamic languages. However,
optional types (preferably with type
On Monday, December 23, 2013 5:39:54 PM UTC-6, Rich Morin wrote:
My take is that required types may force premature optimization and may
inhibit the creative process.
That's an interesting point. I like it. Kind of off topic, but my earlier
remark about psychological factors that might
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
On Dec 23, 2013, at 16:03, Mars0i wrote:
... creativity often requires a intermediate stage of messiness.
Then you have to clean it up to get something interesting, in
many cases, but you wouldn't have gotten to some place new and
interesting if you only went via purely rational, rigorous
The things is that dynamically typed languages are easier to implement than
statically typed languages. Static typing comes down to making statements
about the program and deriving other statements from them. It leads to all
sorts of interesting work including I think into systems like Z.
@dennis - how would this model work on a type system?
I also believe that type systems are very awkward for modelling change -
whereas a schema system like datomic is do much better because it is a lot
looser in the constraints. For example, if we are modelling the stages if
growth of a
@philip lord.
Where would mutant elephants and the elephant god Ganesha fit in that
classification?
--
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are
zcaudate z...@caudate.me writes:
@philip lord.
Where would mutant elephants and the elephant god Ganesha fit in that
classification?
It might surprise you to know that there is actually quite a lot work on
both of these.
The problem with mutant elephants generalises into the problem with
in my mental world, there is a pure human, and a 4 armed human would
probably be a 95% human or something, just like a hobbit would be. the
other way round, a human would be a 95% hobbit. an elephant would be 4%
hobbit on that scale.
this model is flexible, covers everything, and is not really
Thanks Phil.
I'm exploring how type theory works at doing partial classifications,
especially where there can be arbitrary models on the same object. I'm not
sure that it does and I'm of the opinion that in these cases, type systems
aren't really that useful.
Ganesha is surgically grafted
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/
I have learned quite a lot from reading this article and following this
discussion, particularly that type and type
let's see...
really used:
sql
java
javascript
basic
pascal/delphi
scala
experimented with:
logo (some old language intended to teach people to make their first steps)
haskell
kotlin
clojure
seen in action:
php
groovy
still prefer smart static typing :D
2013/10/9 Nando Breiter
Let's see:
strong data typing:
Fortran
Cobol
Pl/1
Pascal
C/C++
Java
C#
Ruby
à la carte data typing or no data typing at all:
Basic (more or less depending on the implementation)
Lisp
Clojure
A dozen assemblers
A dozen scripting languages
And I probably forgot some while excluding the ones I
especially haskell scala are missing in your list :)
as long as you haven't at least seen haskell, you haven't seen the creme de
la creme of statically typed languages
2013/10/9 Softaddicts lprefonta...@softaddicts.ca
Let's see:
strong data typing:
Fortran
Cobol
Pl/1
Pascal
C/C++
And JavaScript is missing (OK, a dozen scripting language)
But today, JavaScript is very important in the picture.
Even Clojure has ClojureScript
On Wed, Oct 9, 2013 at 8:36 AM, Dennis Haupt d.haup...@gmail.com wrote:
especially haskell scala are missing in your list :)
as long as you
That's what I said earlier, I need to find some type to dive into it.
As far as Scala is concerned, it's not on my list of items to learn.
Too Java-ish to me and clunky. It's not because you mix all the latest
features in a single language that the result is a significant landmark.
It took a
Yeah but I hate JavaScript so no wonder it's not on the list.
I do however code in ClojureScript and avoid JS interop like
the plague as much as possible :)
I had to deal too much with browser based GUIs before things like JQuery
and similar things came to life or because the back end framework
Oh!
I don't hate JavaScript ;-)
I'm not a Clojure programmer, (and not a ClojureScript programmer). But I
usually program in C#, Java, PHP and JavaScript. I know Lisp, Ruby and
Python, but I don't work with them, only toy projects.
I found JavaScript the most flexible programming language (less
I hate quirks, too many things to achieve, less time remaining, less
brain estate to remember quirks :)
Luc P.
Oh!
I don't hate JavaScript ;-)
I'm not a Clojure programmer, (and not a ClojureScript programmer). But I
usually program in C#, Java, PHP and JavaScript. I know Lisp, Ruby and
I think what you're banging your head against is the tension between
computer science qua pure science, versus software engineering qua
engineering practice.
This tension isn't unique to our field; mathematicians look down on
theoretical physicists, who look down on practical physicists, who
On 6 Oct 2013, at 04:35, zcaudate z...@caudate.me wrote:
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.
This debate is as old as the hills (it certainly predates object-oriented
There's a link to his presentation there actually:
http://www.infoq.com/presentations/data-types-issues?utm_source=infoqutm_medium=QCon_EarlyAccessVideosutm_campaign=StrangeLoop2013
However is says this:
*Thank you for attending Strange Loop 2013*
This is a restricted presentation that can only
Chris Zheng z...@caudate.me writes:
Hahaha, thanks Philip. Does it really take a doctorate to understand
classification of elephants?
I have a doctorate in how yeast divide. Trust me, computers are easy in
comparison to elephants.
I think the overall consensus is that having basic type
This demonstrates yet another problem with not simply *writing a blog post*
or something on The Trouble With Types. Not only do videos require
enormous bandwidth (which mobile users often pay metered rates for, and
most people not actually metered have caps with overage charges for
exceeding
It will be at some point. Like most conferences taped by InfoQ, the videos
will be released slowly over time. Those who attended this conference got a
key that they can use to access the video.
Timothy
On Tue, Oct 8, 2013 at 4:32 AM, Leonardo Borges leonardoborges...@gmail.com
wrote:
There's
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
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
Just bc it's dynamically typed doesn't mean you can't leverage types for
dispatch. Remember, you can single dispatch on type (using protocols), or
multi-dispatch using a function applied to the arguments (multimethods).
---
Joseph Smith
j...@uwcreations.com
@solussd
On Oct 8, 2013, at 7:46
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.
Not necessarily...
$ perl
print 10 + Hello, \n
^D
10
$
Rob
--
--
You received this message because you are
2013/10/8 Robert Day robertk...@gmail.com
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.
Not necessarily...
$ perl
print 10 + Hello, \n
^D
10
$
The video will be available sometime in the next couple months. Usually we
do keynotes early. No schedule yet (need to get working on that!).
The slides are at:
https://github.com/strangeloop/StrangeLoop2013/blob/master/slides/sessions/Odersky-TroubleWithTypes.pptx
Alex
On Tuesday, October
I think there's a case to be made for a theoretical subjectivity.
Mathematical purity is nice and elegant, sometimes useful, but 'useful'
refers to utility. The ease or the cost of making some valuable change to
code in the possibility-space of changes you might make, and the
ramifications of
John D. Hume duelin.mark...@gmail.com writes:
On Oct 8, 2013 5:35 AM, Phillip Lord
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
Short comment in bad English:
I found that TDD is the great equalizer btw dynamic and static languages.
I don't have any trouble writing code in dynamic language wo/code
completion, etc.. if I wrote baby steps using TDD. And then, the dynamic
nature (less ceremony, etc...) starts to shine.
I use
Nando Breiter na...@aria-media.com writes:
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
I am now allergic to integrated type systems mostly because of the lack of
efficiency that they impose, at least in my world.
If I can spare some time, I would like to immerse myself in Haskell to see
if I can cope with its type system on a daily basis.
Still I would think twice before
On Tuesday, October 8, 2013 6:26:20 AM UTC-4, Paul Butcher wrote:
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)
Laurent PETIT laurent.pe...@gmail.com writes:
print 10 + Hello, \n
^D
10
$
Then don't use Perl :-p
PHP does the same thing and it's really useful. We all think that the
ability to build DSLs in Clojure is good; ultimately, what this means is
that we think that good language behaviour is
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 javascript:
On 08/10/13 13:49, Nando Breiter wrote:
If you try and add 10 to Hello
2013/10/8 Greg Bowyer gbow...@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
:-)
On Tuesday, October 8, 2013 6:07:47 AM UTC-7, Laurent PETIT wrote:
On Tue, Oct 8, 2013 at 8:49 AM, Nando Breiter na...@aria-media.com wrote:
If you try and add 10 to Hello in a typed language, you get an error.
Interesting. I hadn't realized that the following's language was not typed:
package foo.bar;
public class Main {
public static void main
On Tuesday, October 8, 2013 10:19:07 PM UTC+3, Laurent PETIT wrote:
2013/10/8 Greg Bowyer gbo...@fastmail.co.uk javascript:
js Array(16).join(wat - 1) + Batman!
NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN Batman!
js
One of the many reasons we're using Clojurescript and not raw
The string concatenation operator in java calls 'toString' on it's args.
---
Joseph Smith
j...@uwcreations.com
@solussd
On Oct 8, 2013, at 2:29 PM, Cedric Greevey cgree...@gmail.com wrote:
On Tue, Oct 8, 2013 at 8:49 AM, Nando Breiter na...@aria-media.com wrote:
If you try and add 10
Hopefully, we all knew it :))
And you should add that auto boxing
Is done on the literal, otherwise this
magic would not work.
Otherwise, Java would be the most
brittled language.
It probably is anyway :))
Luc P..
The string concatenation operator in java calls 'toString' on it's args.
Holy wars are fun for a while (if I wanted to start one on this list, I'd
go into the superiority of vim over emacs),
It wasn't me =)
Don't get me wrong, I'm not ANTI-type. I'm ANTI-ANTI-untype… which is a much
more partial position to take =)
On 08/10/2013, at 11:46 PM, John D. Hume
I have another question re types…. I find it hard to express the absence of
properties….
Like in Haskell… if you want to display something.. you have to derive Show for
that object… which I think is allowing .toString to work
Wouldn't it be more helpful to have a type Unshow which stops the
Some things that I see most of the time when I read debates about
dynamic vs static are:
1. Statically defined types don't solve everything, so they are not useful.
Some help is better than no help even if the help doesn't solve all of
your problems.
Yes, you should wash your hands before
This is Clojure- we can have both, at the same time!
clojure.core.typed
---
Joseph Smith
j...@uwcreations.com
@solussd
On Oct 8, 2013, at 5:36 PM, Kendall Shaw ks...@kendallshaw.com wrote:
Some things that I see most of the time when I read debates about dynamic vs
static are:
1.
while i can see the strengths of both sides, the ideal solution is imho
this:
everything is statically typed. always. but you *never* have to write
the type explicitly. you *can* do it, but it is always optional.
i made good experiences with both scala and haskell (although i just
wrote minor
Yes the kind of app you are working on may make your mileage vary.
But not only this criteria impacts how good you can fare with
imposed data types.
One tendency in software development is to normalize everything up to
a point where two values are identical but because they have been typed
zcaudate z...@caudate.me writes:
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.
Programming is a highly fashion-centric occupation for any number of
reasons. This shouldn't be a
IMHO, the question is irrelevant. It implicitly assumes that statically
typed vs dynamically typed is a black / white choice, and that either
static wins over dynamic or dynamic wins over static will be a true
statement whatever the context.
Bu still ... :
I assume you are talking about the
Thanks for the link! I really liked the interview, it was interesting and
fun to watch.
J
On Monday, October 7, 2013 9:49:24 AM UTC+9, brad bowman wrote:
zcaudate z...@caudate.me javascript: Oct 05 08:35PM -0700
I'm a little bit miffed over this current craze of `types` and
Martin Odersky gave a keynote at Strangeloop this year called The Trouble
With Types (https://thestrangeloop.com/sessions/the-trouble-with-types)
which made me never want to use a type system again (probably the exact
opposite of his intention). The video should be coming out on infoq at some
Hahaha, thanks Philip. Does it really take a doctorate to understand
classification of elephants?
I think the overall consensus is that having basic type checking is good... but
over doing types is bad.
Would this be a reasonable guideline for using types?
1. Types are useful for structures
I suspect you are going to have zero success proving the superiority of
dynamic languages (in an academic proof sense). For a start, people are
even going to disagree about the precise definition of better. What
matters more: Runtime performance? Flexibility with respect to changing
Thanks Mike for your reminder to be pragmatic. It is definitely the way to go.
Clojure's an incredible language for this.
This is going to be a longish post as I should better explain my position. It
is just a brief sketch of the problem but I think that we should be thinking
about it more as
I support the sentiment expressed in your email. +1
Type systems are nice, just don't force them upon anyone. Keep the C++ at bay.
--
Please do not email me anything that you are not comfortable also sharing with
the NSA.
On Oct 6, 2013, at 7:16 AM, Chris Zheng z...@caudate.me wrote:
Thanks
zcaudate z...@caudate.me Oct 05 08:35PM -0700
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
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
78 matches
Mail list logo
