On Monday, August 3, 2015 at 5:19:34 AM UTC-5, Colin Yates wrote:
I have heard this approach before, but I have never seen how it works in
real life.
Interesting. I don't think I've ever worked anywhere that didn't take this
kind of approach. Even if we weren't doing it formally.
For
Hi,
I have had good 6 months of fun with Clojure and have big appreciation for
it's way of doing things. Coming from the Java/Spring world however, I
still have this nagging desire to be able to annotate functions and have
some preprocessor pick up these annotations and decorate the code
On Monday, August 3, 2015 at 10:21:09 PM UTC-5, Dmitri wrote:
My understanding is that the problem is actually caused by the stateless
nature of the functions.
You're talking about database interactions. By definition, those are not
stateless. The trick is to isolate this statefulness as
The page http://clojure.org/metadata states that it can also be used by
application developers for many purposes, annotating data sources, policy
etc.
Could anyone elaborate about some real use case scenarios where they need
to use this metadata feature ?
Regards,
--
Eric Le Goff
I think we are talking at cross purposes - I thought you were talking
about delaying the mutation until the 'main' logic has finished, whereby
the main logic would push the mutation into a queue which were then
executed later. Something like queueing up a bunch of commands to be
executed later.
What I'm talking about is whether it's a better pattern to leave a
repetitive and error prone task to the user or encapsulate it in a single
place. The whole discussion boils down to following options.
The first option is that we keep functions pure and the connection is
passed as a parameter
Trying to compile an application using ztellman/vertigo 1.3.0 library.
Worked with Clojure 1.7.0, Clojure 1.8.0-alpha4 raises the following
exception:
An app that worked with vertigo 1.3.0 and Clojure 1.7.0 causes the
following exception in the Clojure compiler:
java.lang.NoClassDefFoundError:
Codox looks for ^no-doc when it is generating documentation to elide docs
for that function or namespace.
On Thu, 6 Aug 2015 at 12:24 AM Eric Le Goff eleg...@gmail.com wrote:
The page http://clojure.org/metadata states that it can also be used by
application developers for many purposes,
Metadata is perhaps most frequently used on vars:
user= (meta #'comp)
{:arglists ([] [f] [f g] [f g fs]),
:doc
Takes a set of functions and returns a fn that is the composition\n of
those fns. The returned fn takes a variable number of args,\n applies the
rightmost of fns to the args, the
I wish I could do that in Clojure:
(defn ^:transactional someFunction [...] ...)
and then have somehow means to decorate someFunction (yes, I am aware there
is no container)
The code you proposed does have an effect on the someFunction var (but not the
function it ends up bound to).
This is a latent bug (now exposed due to other changes in 1.8) in
potemkin's deftype+ used by vertigo which was fixed here:
https://github.com/ztellman/potemkin/commit/de6b6e8af5ae19adfc21841e029f3f126cfe28a6
I'm not sure what is involved in upgrading your version of potemkin or
vertigo to
Are there plans for a new release of core.async? The last release was in
September last year, and there have been some new features and updates
added since, including using the latest version of tools.analyzer.jvm.
--
--
Daniel
--
You received this message because you are subscribed to the
Adding potemkin and clj-tuple dependencies explicitly solves the problem
until they upgrade vertigo. Thanks a lot for the tip!
On Wednesday, August 5, 2015 at 4:33:06 PM UTC+2, Alex Miller wrote:
This is a latent bug (now exposed due to other changes in 1.8) in
potemkin's deftype+ used by
Thank you Steve
with the help of the robect-hooke library I got close:
(defn ^:test-meta t [a] (println a))
;;copy the metadata to the function object
(def tt (with-meta t (meta #'t)))
(defn adv1 [f a]
(println advising f with meta (meta f))
(f a))
(defn adv2 [f a]
(println hey! f your
On 5 August 2015 at 14:03, Dmitri dmitri.sotni...@gmail.com wrote:
What I'm talking about is whether it's a better pattern to leave a
repetitive and error prone task to the user or encapsulate it in a single
place. The whole discussion boils down to following options.
The first option is
On Wednesday, August 5, 2015 at 4:58:42 AM UTC-7, Georgi Danov wrote:
I wish I could do that in Clojure:
(defn ^:transactional someFunction [...] ...)
How about
https://clojure.github.io/java.jdbc/#clojure.java.jdbc/with-db-transaction?
These kinds of scope macros are pretty common and
FWIW, We use edn (serialized with nippy [1]) in hadoop it works very well for
us:
https://github.com/Netflix/PigPen
In some places we use maps for the expressiveness and in some we use vectors
for more performance.
Whatever I lose in raw performance I can trivially throw a few more boxes
I would also recommend reconsidering the premise that this is a feature
that is needed. Go back to what your design goals and think about
implementing them in a slightly different way. Function composition, for
example, can do all sorts of wonderful things.
At the risk of sounding rude, I've
I agree that wrapping the functions is a sensible approach. Using
wrap-transaction is precisely how I ended up doing it with the conman yesql
wrapper https://github.com/luminus-framework/conman
The approach I took there is to have the generated functions use the
connection atom, and have
This.
I would repeat with as strong an emphasis as possible the sanity
of using a dedicated test database - how else can you test schema
creation for example...
Dmitri writes:
I agree that wrapping the functions is a sensible approach. Using
wrap-transaction is precisely how I ended up doing
Mike, thanks for this tool. I want to use it to introduce ClojureScript to
some local JavaScript devs, since they would be less likely to install
anything that required the JVM. I cannot seem to get `brew install planck`
to work, however. It just hangs. It looks like `brew upgrade` hangs
Ryan Schmitt rschm...@u.rochester.edu writes:
I'm currently working on some problems in the big data space, and I'm
more or less starting from scratch with the Hadoop ecosystem. I was
looking at ways to work with data in Hadoop, and I realized that
(because of how InputFormat splitting works)
Hi Zach,
Yeah, it definitely sounds like your Homebrew install has an issue.
You can also just download the binary from http://planck.fikesfarm.com
http://planck.fikesfarm.com/ (it is a self-contained single-file executable).
It works on Mavericks or later.
- Mike
On Aug 5, 2015, at 1:24
I wish I could do that in Clojure:
(defn ^:transactional someFunction [...] ...)
and then have somehow means to decorate someFunction (yes, I am aware there
is no container)
The code you proposed does have an effect on the someFunction var (but not the
function it ends up bound to).
On 5 August 2015 at 18:04, Dmitri dmitri.sotni...@gmail.com wrote:
I agree that wrapping the functions is a sensible approach. Using
wrap-transaction is precisely how I ended up doing it with the conman yesql
wrapper https://github.com/luminus-framework/conman
The approach I took there is to
There are a number of options here depending on your workflow. You could
override the dynamic var, create a separate connection for tests and pass
it around explicitly in test code, or get the connection from the
environment. The last option is what I tend to do, the profiles.clj will
contain
Hi!
I was using Clojure for a long time. It has been used for private and
commercial projects (sniffed by me and hated by others).
Now it has been abandoned. It's not giving me any money nor there is no
agreement in peers to use it.
But...
I think that Clojure has a future. Datomic is
This would be mighty useful:
http://dev.clojure.org/jira/browse/ASYNC-137
I was planning on moving away from using core.async because I had assumed
this issue would not be fixed and released in the forseeable future.
Should I have hope? :-)
On Thursday, August 6, 2015 at 9:22:56 AM
Yes.
--
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 group, send email to
Immutant provides a lot of enterprisy things out of the box.
On Wednesday, August 5, 2015 at 5:28:02 PM UTC-4, Olek wrote:
Hi!
I was using Clojure for a long time. It has been used for private and
commercial projects (sniffed by me and hated by others).
Now it has been abandoned. It's
ClojureScript, the Clojure compiler that emits JavaScript source code.
README and source code: https://github.com/clojure/clojurescript
Leiningen dependency information:
[org.clojure/clojurescript 1.7.48]
This release updates the Google Closure Compiler and Library
dependencies to the
On 5 August 2015 at 22:28, Olek aleksander.nas...@gmail.com wrote:
Problem: there is no a bind for the JEE servers - they should be treated
as the SQL - you will never reach its maturity
Solution: so you should parasite it and make a wrapper around timed
services, jms queues, web services,
I suggest using prismatic`s schema library, and generating kryo serializers for
your schematized records at compile time. These serializations can be very
compact by leveraging the schemas, and kryo is very fast. I've been having
success with this approach on Apache Spark. If you aren't married
33 matches
Mail list logo
