what happened after they, "walked into a bar"?
--
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 moderated - please be patient with your
first post.
To
€0.02 i like option #3, i think it would be possibly nice for edges to be
named based on the ports they connect.
--
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
random tangential food for thought:
https://groups.google.com/forum/#!searchin/elm-discuss/Discussion$20on$20saying$20farewell$20to$20FRP$20|sort:relevance/elm-discuss/6U74_aNXC04/UY8dIIh-CQAJ
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post
I am writing to ignorantly sincerely ask how spec + Orchestra compares to
other statically typed out of the box JVM languages. What are the succint
wins over not Scala shudder but eg Kotlin Ceylon, heck Frege, et. al.?
--
You received this message because you are subscribed to the Google
Groups
we need the TRIZ of software :-/
--
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 moderated - please be patient with your
first post.
To unsubscribe
Whatever happened to Defrac, anyway?
--
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 moderated - please be patient with your
first post.
To
Unfortunately, dynamically typed most often means what you are experiencing, as
far as I know. Python, JavaScript, Scheme, Lua, etc. all have something like
NPE that can happen at any random time, it feels like, no?
--
You received this message because you are subscribed to the Google
Groups
My $0.02 is only resort to macros when all else has failed. Can just higher
order functions and composition and injection get you closer to what you
want?
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to
On Thu, May 12, 2016 at 3:11 PM, Nicola Mometto wrote:
> Fair enough, but in this case types wouldn't really have helped: the author
> did use `Double` type hints, mistakenly assuming that would make its code use
> primitive types, which it does not since `Double` is boxed
On Thu, May 12, 2016 at 2:59 PM, Nicola Mometto wrote:
> Static types wouln't have helped at all in this case. Types are about
> correctness, not performances. This comment was needless
Here I thought maybe knowing when something was or was not something
could have been
y'know, if only there were something, i dunno, something static that
could you know have some, i dunno, 'types' that would help annotate
things such that at maybe compile time, we'd know if the things we're
handling are lazy or boxed or whatever-else or not.
--
You received this message
(Did he mention Wadler? Probably. http://lambda-the-ultimate.org/node/2538)
I have it from friends who have used TR "in anger" that it is not really a
win. My own experience with other things, e.g. the typed stuff in the lands
of JavaScript and TypedLua, is in line with that, unfortunately.
> Sorry, never heard of horses for courses. Does it mean sth like different
> strokes for different folks?
yessir.
--
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
Horses for courses. Ask all the game people who use Lua big time. :-)
--
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 moderated - please be patient
RC & GC might complement. Don't throw out RC. Also, there are different
kinds of 'performance'. Horses for courses, you know.
https://www.google.com/search?q=bacon+gc+reference+counting+equation
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To
> The main motivation would be performance gains.
blah? so many impedance mismatches and layers of indirection that i
don't think it will gain much? i mean, it would probably be better to
spend time tuning gc parameters or something. just a rant / guess.
e.g. robovm is for some use cases
things like robovm are another possible approach.
--
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 moderated - please be patient with your
first post.
You can only tell by benchmarking. And even then it can change when
you move to different hardware. You can debate about big O and
constant factors and numa and all that jazz till you are blue in the
face.
There are 3 kinds of people in the world:
1) those who think we should stick with arrays
https://www.youtube.com/watch?v=HnZipJOan54
--
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 moderated - please be patient with your
first post.
To
one word: redstone.
--
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 moderated - please be patient with your
first post.
To unsubscribe from this
Awesome would be a way for Cojure to generate C (perhaps with e.g.
Boehm–Demers–Weiser GC to get it kicked off) and JNI bindings all
automagically.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to
http://lambda-the-ultimate.org/search/node/crdt
nice to see powerful theory being made more practically available to
us masses. ;-)
--
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
re: mixins, traits, etc. those terms have all been used in both
research & shipped languages. Please see e.g. how Scala evolved with
those terms. :)
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to
Wow, thank you for sharing the info! Cool.
--
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 moderated - please be patient with your
first post.
To
flush twice, oracle is far far away?
--
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 moderated - please be patient with your
first post.
To
hi,
ignorant question from me:
F#/dotnet has 'mbrace' which lets you, apparently, *super* easily
spawn things off to a cluster (cloud based). Instead of doing async {
/*worker code*/ }; you do cloud { /*worker code*/ }; and all the
management of getting it sent to the cloud, run, and back is
The thought that came to my mind when reading it was something like,
"Hasn't anybody heard of MVCC?"
--
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
> https://www.coursera.org/course/proglang
cool. thanks for the pointer, i will have to find the time.
--
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
blah.
"Whenever you notice this pattern, you can probably turn to one of the
threading macros instead."
that would fly in the face of being more declarative; when we start to
put in explicit ordering, instead of leaving it as just relationships,
that can be bad. of course it can also be good.
https://duckduckgo.com/?q=amit+clojure+book
http://www.htdp.org/
http://realmofracket.com/about.html
http://landoflisp.com
http://book.realworldhaskell.org/
http://www.powells.com/biblio/9781617290657
etc.
--
You received this message because you are subscribed to the Google
Groups "Clojure"
> The way I like to think about FP vs OO is that OO usually couples state with
> identity and the code that operates on both, while FP defines a clear
> boundary between data, state, and the functions that operate on the data.
https://en.wikipedia.org/wiki/Expression_problem
> Designing a FP
> https://tbaldridge.pivotshare.com/media/oop-lesson-1/28290
> I do not remember if the other tutorials (2,3 and 4) on OOP are free as
> well…
i did this one a while back as a refresher on my university stuff :-)
https://www.coursera.org/course/progfun
--
You received this message because you
heck if you pay me U$D120 an hour, you can send me your code (as long
as it isn't more than a single page at 10 pt font, with regular
formatting ;-) and i'll tell ya how to do it more FPish
(kidding.)
--
You received this message because you are subscribed to the Google
Groups
> Thanks for the rapid response! You could say that you put this in there as
> an exercise for the viewer; I know that in discussing it amongst ourselves,
> we definitely sharpened our understanding of some of the concepts.
I guess I'd see it as an argument for static checking around
Inspired by YAGNI, I made this code analyzer and emacs assistant for
deleting dead code (and then used it to delete 10% of our codebase):
oh, i thought the punch line was it was either going to delete you, or
delete itself ;-)
--
You received this message because you are subscribed to the
and I need to be 10 times more productive. =)
you mean, after your 2 week ramp-up time, right?
--
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
My apologies (sincerely). Won't use that again.
--
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 moderated - please be patient with your
first post.
To
That would apply to common actions like typing and entering. Login being
slower than that isn't likely to be as much of a bother as you likely only
do it infrequently, maybe as much as once a day if you're paranoid and clear
cookies nightly.
Yeah, to me that is the sort of reasoning that
350ms sounds fast enough for a low-frequency user interaction. In fact, once
login is fast enough not to annoy your users, you don't *want* any more
speed from it, as further speedup then only benefits blackhats trying to
brute-force one of your users' accounts. So, it might be a feature, not
http://lmgtfy.com/?q=clojure+%22let+vs.+let*%22
--
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 moderated - please be patient with your
first post.
To
at least, it often feels like that is the practical reality cf.
clojure vs. java; f# vs. c#; haskell vs. c -- oh, wait a minute:
http://www.cs.ru.nl/P.Achten/IFL2013/symposium_proceedings_IFL2013/ifl2013_submission_20.pdf
--
You received this message because you are subscribed to the Google
Ditto F# vs. C#.
One has to wonder when / where / if functional-pure-immutable
approaches will ever under the covers get fast enough?
--
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
Once an engineer comes to grok FP, they tend to organize code around how
data 'flows' between these pure functions to produce output data. The
structure of how functions connect to form the structure of a functional
computation has typically been informal. Until now
see Flow Based
I.e. your time is better spent optimizing a fn that's called 1k times per
second and it's a little slow (for example, missing a type hint and has to
do reflection or using boxed math) vs. a fn that's very slow but is only
called once a minute.
not all apps, and not all developers, end up with
knowing how to break down Clojure's syntax a bit helps, too. which
means newbies are kinda screwed until they divine this.
http://stackoverflow.com/questions/8920137/clojure-caret-as-a-symbol
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to
even github gets it totally wrong, apparently?
https://github.com/laurentpetit/ccw/search?utf8=%E2%9C%93q=%22^%3Ainternal%22type=Code
because, you know, it isn't as if github is mostly all about hosting *code*.
such that, you know, you'd think they'd have realized by now this kind
of feature is
Observer is often used in Java iOS-Objective-C Android-Java.
As with any eventing kind of thing it is a very double-edged tool.
--
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
Thanks for the thoughts!
If anybody also has any other STM experience (e.g. Haskell?) to
compare/contrast, that would be nifty to hear.
--
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
hi,
What do people think of STM after all these years? What pros vs. cons
are there - has the community evolved the list of them?
thanks for any thoughts.
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to
re: lux -- keen! also, check out http://shenlanguage.org/, it has a
clojure target in the works.
--
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
Can you elaborate? Lift got it right or was a disaster?
oh! good question, sorry :-)
i believe it got it far more right than wrong.
--
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
Yes, Play has overtaken Lift, not because it is necessarily better, but
because TypeSafe are pouring marketing dollars into it, as part of their
drive to encourage Enterprise uptake of Scala. They have a vested interest in
Play being very successful as it will drive more business for them.
vulnerabilities that would not exist using an integrated framework.
fwiw, web + security always makes me think of http://liftweb.net/
--
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
Another possibility is https://github.com/takeoutweight/clojure-scheme. It
compiles Clojure to Gambit Scheme to C to metal.
another possibility is to stab oneself in the eye with a sharp stick.
just sayin'.
:-)
--
You received this message because you are subscribed to the Google
Groups
I just would guess that anything other than an embedded JVM would
be... poor r.o.i., to be polite.
--
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
all i'm trying to say is that the more layers of indirection you add,
the more i won't give you any money on kickstarter.
--
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
Both Nim and Pixie ultimately compile to C, and would have just as many
layers of indirection.
aand they are all insane for anything other than learning
themselves at this point, i'd hazard to guess. but i'm a realist, who
knows. i'd rather go for a real jvm e.g. azul's embedded stuff, or
My goodness, there are other things than Clojure in the universe.
People have been making native software with real languages for
ages. There's probably even some that are fpish or heck go get an
actual lisp that's been used for ever (franz, allegro, ecl, gambit,
chicken, clozure, tinyscheme,
From what I understand it's conceptually not ready for anything other
than toy problems yet. Like Elm's restriction on static flow graphs. It's
like programming without 1st class functions, you don't get very far.
I am not an Elm user, but I am on the mailing list :-) and I see real
things
i guess big projects at the bottom of
http://elm-lang.org/Examples.elm
--
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 moderated - please be patient with
Actually, I would just use Long's. (MAX_VALUE = 9223372036854775807)
https://www.google.com/search?q=youtube+gangnam+overflow
--
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
Code is data, and sometimes the best way to format that data for human
readability is sufficiently ad-hoc that no autoindent/pprinter could do a
fully general good job.
+1
there should therefore be a region annotation that tells IDEs to leave
it the hell alone when the user invokes reindent
http://en.wikipedia.org/wiki/Intentional_programming
--
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 moderated - please be patient with your
first post.
I remain wholly unconvinced that it's worth the hassle for a project this
small.
personally i find your points persuasive; i hate going through that
stuff when i just wanted to finish a feature or whatever. still,
losing your code would suck a lot, and not having history can be a
frustrating
Notice that he intentionally left inheritance out from that definition.
there are more connotations of object oriented than there are quills
on a porcupine.
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to
http://clojure.org/reducers
i dare say the When to use part should not be at the bottom but come
right after the otherwise laughably specious yielding code that will
get faster automatically as machines get more cores.
--
You received this message because you are subscribed to the Google
here are some related resources (books, videos). imbibe all of these
and it might help.
http://realmofracket.com/
http://landoflisp.com/
https://news.ycombinator.com/item?id=1023970
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group,
why does it require java 1.7? this newish mavericks macbook only has
1.6 so i would guess you've just made it hard for a lot of people to
try this out? :-(
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to
ugh, thanks. nice how i can just update it with app store. oh, wait??
--
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 moderated - please be patient with
I've been on Java 8 on my development Mac for ages. The only thing holding
us back from going to Java 8 in production is New Relic don't yet support
it...
We upgraded our entire stack to Java 7 back in October and I thought we were
late since Java 6 had been EOL'd for so long :)
i'm on to 7
er, should the various pages be updated to say that they are all super
deprecated now?
e.g. things that turn up in google:
http://dev.clojure.org/display/doc/Clojure+Contrib+Libraries
On Thu, Jun 26, 2014 at 3:58 PM, Sean Corfield s...@corfield.org wrote:
Clojure Contrib libraries are all
This is code Clojure programmers depend on to work. Are you suggesting
that it is easier to read this code than a few paragraphs of natural
language?
I must say I really find it puzzling that there is so much
resistance to writing words. It's not that hard.
if the code is so bad that it
update them one at a time. Obviously, I do not want to write something that
updates the enemies and, after the enemies are fully updated, the bullets
get updated. I need something that updates enemies while updating the
bullets, at the same time. Maybe a code example would help?
er... i
I am just using this as a learning exercise, I do not need to be lectured
about how to write a game loop... I said obviously since that was my
original request, I am only asking to learn clojure a little better. I
could just drop into java and write a serial loop that does this really fast
I like FSMs, but they do not compose well.
some have argued for generative grammars that generate the fsm,
because it is generally easier to compose grammars, and then generate
the final fsm. iiuc.
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To
some sort of FSM. Perhaps concurrency could be modeled using FSMs, but I do
not believe it is always a simple transition.
http://www.cis.upenn.edu/~stevez/papers/LZ06b.pdf
:-)
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group,
The thing is that our industry is based on layers upon layers of
abstractions, whether at the physical level (integrated circuits,
interfaces, etc.) or at the software level: binary (1GL) abstracted into
assembly (2GL), then C language (3GL), etc. Virtual machines is now another
you maybe
cough cough erlang cough ahem
--
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 moderated - please be patient with your
first post.
To unsubscribe from
cough cough erlang cough ahem
Care to elaborate? :-)
Now his point is that GC acts a super GIL which effectively kills all
the hard work done on the language and application design level.
erlang's approach to gc / sharing data / multi process / smp is i
think an interesting sweet spot. there
i am probably out of my depth here, i do not have extensive real-world
experience with the various ways to approach parallelism and
concurrency (to be distinguished of course), more run of the mill
stuff. so if i sound like i'm missing your point or am clueless i ask
for your patience :-)
What's
that closely match or can be massaged to match or 'have sympathy' for the
hardware realities. I think this can get lost when we stray too far.
i wish this were somehow more modeled, composed, and controllable up
in our ides and source code, rather than being esoteric tweaky options
in the
unreachable. The normal GC would then have a lot less to do, helping
achieve shorter pauses.
i have long wondered a similar wonder. :-) (i also naively day-dream
one could get the C# IDisposing style for free with something like
that.) the BitC folks have talked about all sorts of things along
(related: asteroids in cal, by way of haskell.
http://s3.amazonaws.com/ns999/cal.html)
--
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 moderated - please
bazillion pure functions. I was wondering, would a GC like this one(or
Azul's) make a significant impact so that I, or others, could make games in
a more pure fashion? I WANT MY EFFIN PURITY!
i'd rather have linear types or something like that, than some gc
solution. :-) i mean, if i'm
pure way or the mutate objects in place way? I can get great performance
with clojure, no doubt about it, by violating the shat out of functional
programming. I can not get great performance with the beautiful, pure,
composable, clojure that I desire!
(personally i think this is a great
if a programming language doesn't have something like 'where', then i
am sad. http://stackoverflow.com/questions/4362328/haskell-where-vs-let
--
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to
an olide: http://www.starling-software.com/en/tsac.html. i went once
when in town years back. it was fun. wish it were still going on.
--
--
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
But only one task was active at a time, although Executors was configured
with 4 threads. It occurred to me that map itself is lazy and it is realized
in doseq one at a time. A possible fix is to use for instead of map to
generate tasks
almost makes me wish there were types (er, sorry,
Thanks for all the responses, it looks like Linux is the predominant OS in
the Clojure community.
er, wow. that's a bit of a leap, isn't it?
--
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to
Be that as it may: if you work in a MS-centric company, shifting to JVM
clojure is iffy at best. OTOH, convincing people who've never used anything
except C# that there are alternatives worth considering is quite an uphill
battle. At least one friend over the years has gotten fed up at my
i always thought it was basically solely for letting you re-run the
test that just/previously failed, nothing more weird or silly than
that.
--
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to
yes, a constant is weird. whenever i've implemented my own variant of
this, i always use a seed from the clock or whatever, and then spit
out the seed in test/assertion failure messages so people can paste it
back in to reproduce.
--
--
You received this message because you are subscribed to
for a long time haskell did not have a debugger. that sucked, imho.
--
--
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 moderated - please be patient
potential food for thought for you:
http://s3.amazonaws.com/ns999/asteroids.html
http://prog21.dadgum.com/23.html
http://world.cs.brown.edu/
--
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send email to
Quite a difference I have to say.
well, you can still be happy that first, get it right. then, make it
fast is still easier in clojure than in java! (of course if, like me,
you are a static typing bigot, there's more to be said on that :-)
--
You received this message because you are
the design of Apache CouchDB's Multi-Version Concurrency Model.
because haskell got it from apache, i'm sure ;-)
--
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
Another concurrency model I've used a great deal is the tuplespace model,
specifically javaspaces. This is an often forgotten model that has a lot to
offer with a high expressiveness to complexity ratio.
otish:
in the back of my mind i seem to recall hearing that tuplespaces
sounded nifty
one of the things which seem to be true but nowhere completely
successfully fleshed out is the fact that equality is very
subjective. there can and should be many different ways to pose and
answer the question a == b.
--
You received this message because you are subscribed to the Google
Groups
Equality is never subjective. There maybe different equality relations
defined. In most cases (integer) one os well served by intuition.
In other cases (clojure's =) the definition may not be intuitive, but never
subjective.
ok sheesh then ^subjective^context dependent
--
You received this
On Tue, Nov 13, 2012 at 7:56 AM, Paul deGrandis
paul.degran...@gmail.com wrote:
It's difficult to spot the best time to apply metadata, since we've become
accustomed to working in languages without support for it.
not exactly, it is just that most java people put all their metadata
in extra xml
1 - 100 of 344 matches
Mail list logo