[ANN] Onyx 0.10 final release

[Michael Drogalis]

We're happy to announce the final release of Onyx 0.10. Onyx is a scalable, 
distributed, fault tolerant, high performance data processing platform for 
handling batch and streaming workloads. It's written purely in Clojure, and 
supports idiomatic Clojure programs on top of it. This version upgrades the 
internal streaming engine for significantly increased performance, adds 
support for in-order message processing, and improves support for stateful 
stream processing.

Read about the 
release: 
http://www.onyxplatform.org/jekyll/update/2017/07/10/Onyx-Asynchronous-Barrier-Snapshotting.html
GitHub: https://github.com/onyx-platform/onyx
Website: http://www.onyxplatform.org
Learn: https://github.com/onyx-platform/learn-onyx

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Onyx 0.9.6: Static Analysis and Elm-grade Error Messages

[Michael Drogalis]

I'm happy to announce the release of Onyx version 0.9.6. This release of 
Onyx ships our
new static analyzer module, which is in turn bundled with a renderer to 
deliver significantly
better error messages than we were able to show in previous releases. Read 
about it
in our blog post below!

Blog 
post: 
http://www.onyxplatform.org/jekyll/update/2016/05/05/Onyx-0.9.6-Advanced-Static-Analysis.html
GitHub: https://github.com/onyx-platform/onyx
Chat: #onyx in Clojurians Slack

Thanks for everyone's contributions this time around!

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Engraver: a tool for managing Onyx clusters

[Michael Drogalis]

Hi everyone,

I'm happy to announce the release of the Onyx Platform's newest creation - 
Engraver.
Engraver is a command line tool for managing and deploying cloud 
infrastructure to
support Onyx. You can get up and running with a secure, HA set up in just a 
few commands.

Blog 
post: 
http://www.onyxplatform.org/jekyll/update/2016/03/21/Engraver-A-Tool-for-Managing-Onyx-Clusters.html

Cheers,
-- Michael Drogalis

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Jepsen testing Onyx

[Michael Drogalis]

Hi everyone,

We're happy to share that we've been busy Jepsen testing Onyx
over the last few months. We've written a blog post to share
the results with how we did it, what we found, and how we fixed
problematic areas:

Blog 
post: 
http://www.onyxplatform.org/jekyll/update/2016/03/15/Onyx-Straps-In-For-A-Jepsening.html

Thanks!

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Doubling down on Onyx

[Michael Drogalis]

Hi everyone,

I'm happy to announce that, starting next week, I'll be supporting the Onyx 
Platform  full time.
I want to thank the incredible Clojure community that's helped to make Onyx 
a
successful open source project. Read on in the blog post 

 
for specifics, but I wanted to drop
a message here to say how excited I am to push Clojure forward as a 
distributed systems/data analysis
front runner.

-- Michael

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Onyx 0.8.4: machine-aware optimization

[Michael Drogalis]

Onyx is a high performance, fault tolerant, distributed data processing 
platform for Clojure.
It uses a data driven API to transparently handle batch and streaming 
workloads
over a variety of storage mediums.

I'm happy announce release 0.8.4, which includes our next generation 
scheduling component.

Blog 
post: 
http://www.onyxplatform.org/jekyll/update/2016/01/16/Onyx-0.8.4-Colocation.html
GitHub: https://github.com/onyx-platform/onyx
Website: http://www.onyxplatform.org

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Onyx 0.8.0: Automatic State Management

[Michael Drogalis]

We're pleased to release Onyx version 0.8.0, which brings with it 
primitives for
automatic state management, failure recovery, windowed computations, and 
triggers.

Onyx is a scalable, distributed, fault tolerant, high performance data 
processing platform
for handling batch and streaming workloads. It's written purely in Clojure, 
and consequently
supports idiomatic Clojure programs on top of it.

Read about the 
release: 
http://michaeldrogalis.github.io/jekyll/update/2015/11/12/Onyx-0.8.0-Automatic-State-Management.html
GitHub: https://github.com/onyx-platform/onyx

Thanks to everyone involved in this release! It was a big one!

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [ANN] Clojure 1.8.0-RC1 is now available

[Michael Drogalis]

Upgrading Clojure to 1.8.0-RC1 passed Onyx's full test suite. Thumbs up on 
our end.

On Tuesday, November 10, 2015 at 9:30:47 AM UTC-8, Alex Miller wrote:
>
> Clojure 1.8.0-RC1 is now available. *This build is a "release candidate"!* 
> We would appreciate any and all testing you can do on your own libraries or 
> internal projects to find problems. If no problems are found, we expect to 
> make this the 1.8.0 final release! 
>
> Try it via
>
>- Download: 
>https://repo1.maven.org/maven2/org/clojure/clojure/1.8.0-RC1
>- Leiningen: [org.clojure/clojure "1.8.0-RC1"]
>
> Below is the only change since 1.8.0-beta2. See the full 1.8 change log 
> here: https://github.com/clojure/clojure/blob/master/changes.md.
>
>- CLJ-1845  Make 
>clojure.core/load dynamic so it can be redef'ed even with direct linking
>
>
>

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Onyx Cheat Sheet

[Michael Drogalis]

Onyx  [https://github.com/onyx-platform/onyx] is a distributed, fault 
tolerant, high performance data processing
platform for Clojure that supports batch and streaming workloads. The 
majority of the surface area of its API
is data-driven. We've documented the information model in several ways, and 
today we're announcing another
branch of documentation.

The Onyx Platform is pleased to release the Cheat Sheet 
[http://www.onyxplatform.org/cheat-sheet.html].
We hope this helps you navigate the increasingly-large information model 
that Onyx offers. We're also
happy to take any suggestions about how to make it better.

Cheers!
-- Michael


-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Onyx 0.7.0: 2x Throughput, 5x Latency Improvement

[Michael Drogalis]

We're happy to announce version 0.7.0 of the Onyx Platform. This release of 
Onyx features a massive jump in performance with the integration of the new 
peer-to-peer library Aeron. Additionally, we've begun to open the door for 
cross language support into Java.

Blog 
post: http://michaeldrogalis.github.io/jekyll/update/2015/06/08/Onyx-0.7.0.html
Core: https://github.com/onyx-platform/onyx

Thanks to everyone that contributed!

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Onyx 0.6.0

[Michael Drogalis]

I'm happy to announce that Onyx 0.6.0 is officially out!

Blog 
post: 
http://michaeldrogalis.github.io/jekyll/update/2015/06/08/Onyx-0.6.0:-Going-Faster.html
GitHub: https://github.com/onyx-platform/onyx
Website: www.onyxplatform.org
Chat: https://gitter.im/onyx-platform

Thanks to all the contributors that helped make this happen!

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Onyx 0.5.3: Flow Conditions

[Michael Drogalis]

Onyx is a distributed, masterless, fault tolerant data processing system 
for Clojure. Version 0.5.3 is out with a new feature called Flow 
Conditions. Flow Conditions isolate logic for message routing within your 
cluster, offering extraordinary flexibility for runtime specification.

Blog 
post: 
http://michaeldrogalis.github.io/jekyll/update/2015/03/04/Onyx-0.5.3:-Flow-Conditions.html
GitHub: https://github.com/MichaelDrogalis/onyx
Gitter: https://gitter.im/MichaelDrogalis/onyx

Thanks to everyone who helped with this release!

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: ANN: Onyx Dashboard 0.5.2.1

[Michael Drogalis]

Hi Colin,

This is well supported within Onyx, and has seen recent progress 
(http://yuppiechef.github.io/cqrs-server/)
The examples should give you a good indication if it's a fit for your 
problem (https://github.com/MichaelDrogalis/onyx-examples).

We hang out in Gitter if you have any 
questions: https://gitter.im/MichaelDrogalis/onyx

-- Mike

On Wednesday, February 18, 2015 at 10:22:07 AM UTC-8, Colin Yates wrote:
>
> Hi Lucas, 
>
> This looks great - thanks. 
>
> [off topic] 
> I don't know much about Onyx but I am just about to start committing 
> code for server app which is going to use a CQRS design. It doesn't 
> need to be internet scale at all, will be a single machine, and spend 
> all of its time taking a command, executing it, persisting the events 
> which a number of views will then respond to. It is all very trivial 
> stuff. Would Onyx be a good fit here? 
>
> It looks pretty lightweight and I was jumping for joy as I was reading 
> the "persistent data over API" and general design rationale, so my 30 
> second investigation says yes, but what do you think? 
>
> Thanks, 
>
> Colin 
> [/off topic] 
>
> On 18 February 2015 at 18:12, Lucas Bradstreet 
> > wrote: 
> > Onyx is a batch/stream processing hybrid, written in Clojure, for 
> > Clojure. https://github.com/MichaelDrogalis/onyx 
> > 
> > Today I released a dashboard for Onyx, that leverages Onyx's 
> > information model to provide some nifty monitoring and job management 
> > features. You can read about its use of its information model, and 
> > view some nice screen shots at 
> > 
> http://lbradstreet.github.io/clojure/onyx/distributed-systems/2015/02/18/onyx-dashboard.html.
>  
>
> > 
> > You can find the code and uberjar release at 
> > https://github.com/lbradstreet/onyx-dashboard. 
> > 
> > Cheers 
> > 
> > -- 
> > 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/d/optout. 
>

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] Onyx 0.5.0: The Cluster as a Value

[Michael Drogalis]

For those unfamiliar, Onyx is a batch/stream processing hybrid distributed 
platform for Clojure. It uses aggressive data-driven techniques to bridge 
languages.

Onyx 0.5.0 has been released, featuring a new masterless design and a 
built-in event notification service.

Source at GitHub: https://github.com/MichaelDrogalis/onyx
Read the blog 
post: 
http://michaeldrogalis.github.io/jekyll/update/2015/01/20/Onyx-0.5.0:-The-Cluster-as-a-Value.html
Changelog: https://github.com/MichaelDrogalis/onyx/blob/0.5.x/changes.md
Release 
notes: 
https://github.com/MichaelDrogalis/onyx/blob/0.5.x/doc/release-notes/0.5.0.md

Thanks to everyone who participated!

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Where can one find low hanging fruit for open source contribution?

[Michael Drogalis]

Hi there,

About a week ago, I open sourced Onyx, a new distributed computation 
platform: https://github.com/MichaelDrogalis/onyx

I've been looking for help from developers of all skill levels, though I 
have 3 or 4 open tasks particularly well suited to someone with 
intermediate skills.

Two tasks about validating data shape and throwing good error messages:
- https://github.com/MichaelDrogalis/onyx/issues/2
- https://github.com/MichaelDrogalis/onyx/issues/3

And two feature-level tasks:
- Exposing a Java API: https://github.com/MichaelDrogalis/onyx/issues/1
- Creating a simple monitoring 
dashboard: https://github.com/MichaelDrogalis/onyx/issues/12

Takes a bit of learning about the project, but it's pretty cool stuff, and 
I'd be happy to help you along.

On Friday, September 26, 2014 11:34:19 PM UTC-7, kurofune wrote:
>
> I am an looking for a good, active, open source Clojure library/project to 
> contribute to, but am not sure where to start. Could somebody give an 
> intermediate level programmer a  few pointers as to where to begin? 
>

-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[ANN] The long awaited Dire 0.5.0 - Slingshot integration

[Michael Drogalis]

This feature has been requested for a few months, and it's finally made its 
way
into Dire. I'd like to thank Dylan Paris for sending in a patch to do this.

The tl;dr: error handling can now dispatch based on predicates rather than 
types.

Dire: https://github.com/MichaelDrogalis/dire

Slingshot: https://github.com/scgilardi/slingshot

Blog post: 
http://michaeldrogalis.tumblr.com/post/65520940178/dire-0-5-0-slingshot-integration

-- 
-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

ANN: Rush Hour - an example Clojure architecture

[Michael Drogalis]

Hi everyone,

I'm happy to announce the Rush Hour platform - highly realistic traffic 
simulations
done with a careful, exemplar architecture all in Clojure.

GitHub platform page:

https://github.com/MichaelDrogalis/rush-hour

Blog post about the architecture:

http://michaeldrogalis.tumblr.com/post/65274692089/clojure-understood-the-rush-hour-platform

-- Michael Drogalis

-- 
-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

Re: In-order triggering of watches on mutable state

[Michael Drogalis]

I can precisely exemplify the behavior here:

https://gist.github.com/MichaelDrogalis/6123177

On Wednesday, July 31, 2013 11:13:17 AM UTC-4, Michael Drogalis wrote:
>
> Aaron: Yep, I'm aware - and am using the value provided by the last 
> parameter.
>
> This is going to be tough to show the problem without bringing more 
> details of my concurrency set up.
> I'm not sure if this will exhibit the problem, but this is what it boils 
> down to:
>
> https://gist.github.com/MichaelDrogalis/6122834
>
> When enough threads are trying to write to the queue, the watches
> triggered later can finish before watches triggered earlier.
>
>
> On Wednesday, July 31, 2013 11:05:16 AM UTC-4, Aaron Cohen wrote:
>>
>> A watcher fn has 4 parameters: key, reference, old-state, new-state
>>
>> If you use old-state and new-state rather than the reference, you should 
>> not see your problem.
>>
>> --Aaron
>>
>>
>> On Wed, Jul 31, 2013 at 11:00 AM, Michael Drogalis wrote:
>>
>>> Problem:
>>>
>>> I have a ref representing a queue of people in line.
>>> I add a watch to the ref to print out the contents of the queue whenever 
>>> it changes.
>>> Naturally, and expected, the following can happen if queuing happens in 
>>> rapid succession:
>>>
>>> Queue: []
>>> 
>>> 
>>>
>>> console: "Queue is Mike, John"
>>> console: "Queue is Mike"
>>>
>>> I'd like to write a UI for this program, but I clearly can't reliably 
>>> render based on the result delivered
>>> by the add-watch hook. What's the solution for this problem?
>>>
>>> -- 
>>> -- 
>>> 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.
>>>  
>>>  
>>>
>>
>>

-- 
-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

Re: In-order triggering of watches on mutable state

[Michael Drogalis]

Aaron: Yep, I'm aware - and am using the value provided by the last 
parameter.

This is going to be tough to show the problem without bringing more details 
of my concurrency set up.
I'm not sure if this will exhibit the problem, but this is what it boils 
down to:

https://gist.github.com/MichaelDrogalis/6122834

When enough threads are trying to write to the queue, the watches
triggered later can finish before watches triggered earlier.


On Wednesday, July 31, 2013 11:05:16 AM UTC-4, Aaron Cohen wrote:
>
> A watcher fn has 4 parameters: key, reference, old-state, new-state
>
> If you use old-state and new-state rather than the reference, you should 
> not see your problem.
>
> --Aaron
>
>
> On Wed, Jul 31, 2013 at 11:00 AM, Michael Drogalis 
> 
> > wrote:
>
>> Problem:
>>
>> I have a ref representing a queue of people in line.
>> I add a watch to the ref to print out the contents of the queue whenever 
>> it changes.
>> Naturally, and expected, the following can happen if queuing happens in 
>> rapid succession:
>>
>> Queue: []
>> 
>> 
>>
>> console: "Queue is Mike, John"
>> console: "Queue is Mike"
>>
>> I'd like to write a UI for this program, but I clearly can't reliably 
>> render based on the result delivered
>> by the add-watch hook. What's the solution for this problem?
>>
>> -- 
>> -- 
>> 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.
>>  
>>  
>>
>
>

-- 
-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

In-order triggering of watches on mutable state

[Michael Drogalis]

Problem:

I have a ref representing a queue of people in line.
I add a watch to the ref to print out the contents of the queue whenever it 
changes.
Naturally, and expected, the following can happen if queuing happens in 
rapid succession:

Queue: []



console: "Queue is Mike, John"
console: "Queue is Mike"

I'd like to write a UI for this program, but I clearly can't reliably 
render based on the result delivered
by the add-watch hook. What's the solution for this problem?

-- 
-- 
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
clojure+unsubscr...@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+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [ANN] Dire, Erlang-style error handling

[Michael Drogalis]

The CL article is really interesting, thanks. What do you think of the idea 
of using Slingshot's try+ within Dire?

On Saturday, December 29, 2012 3:55:13 PM UTC-5, Ben wrote:
>
> On Sat, Dec 29, 2012 at 12:44 PM, Michael Drogalis 
> > 
> wrote: 
> > I've never seen that before, Ben. Can you link me? 
>
> Overview of CL conditions/restarts here: 
>
> http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-and-restarts.html
>  
>
> The Clojure lib was clojure.contrib.error-kit 
> (http://richhickey.github.com/clojure-contrib/error-kit-api.html), 
> which has been superseded by slingshot---but I think that slingshot 
> does not aim to provide conditions and restarts. 
>
> > Just pushed version 0.1.1 with these suggestions: 
> > 
> > - Tasks are now simple functions, not macros 
> > - Using metadata to keep track of handlers rather than an atom. 
> > - Fixed namespace collision issue 
> > - Pass original arguments of task function to error handler 
> > 
> > Any way we can make this better? 
> > 
> > On Saturday, December 29, 2012 1:22:30 PM UTC-5, Ben wrote: 
> >> 
> >> On Sat, Dec 29, 2012 at 10:13 AM, Michael Drogalis  
>
> >> wrote: 
> >> > On Saturday, December 29, 2012 9:57:56 AM UTC-5, Adam Clements wrote: 
> >> >> One thing that worries me though. While this is fine for examples 
> where 
> >> >> you simply log the exception and move on, what if you need to do 
> >> >> something 
> >> >> more complicated with the actual data? Say for example you need to 
> >> >> queue/trigger a retry, you no longer have your local bindings to 
> work 
> >> >> with 
> >> >> so you'd have to go back to a normal try/catch (disclaimer - didn't 
> >> >> read the 
> >> >> paper, just going off the code and your comments) 
> >> > 
> >> > 
> >> > I agree. There's certainly cases where the handler will want to 
> restart 
> >> > the 
> >> > task and need access to the original bindings. I'll tinker around 
> with a 
> >> > clean way to do this. Open for suggestions. 
> >> 
> >> Isn't this what Common Lisp's condition system allowed? (And wasn't 
> >> there a condition-like library for Clojure?) 
> >> 
> >> -- 
> >> Ben Wolfson 
> >> "Human kind has used its intelligence to vary the flavour of drinks, 
> >> which may be sweet, aromatic, fermented or spirit-based. ... Family 
> >> and social life also offer numerous other occasions to consume drinks 
> >> for pleasure." [Larousse, "Drink" entry] 
> > 
> > -- 
> > 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 
>
>
>
> -- 
> Ben Wolfson 
> "Human kind has used its intelligence to vary the flavour of drinks, 
> which may be sweet, aromatic, fermented or spirit-based. ... Family 
> and social life also offer numerous other occasions to consume drinks 
> for pleasure." [Larousse, "Drink" entry] 
>

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: [ANN] Dire, Erlang-style error handling

[Michael Drogalis]

I've never seen that before, Ben. Can you link me?

Just pushed version 0.1.1 with these suggestions:

- Tasks are now simple functions, not macros
- Using metadata to keep track of handlers rather than an atom.
- Fixed namespace collision issue
- Pass original arguments of task function to error handler

Any way we can make this better?

On Saturday, December 29, 2012 1:22:30 PM UTC-5, Ben wrote:
>
> On Sat, Dec 29, 2012 at 10:13 AM, Michael Drogalis 
> > 
> wrote: 
> > On Saturday, December 29, 2012 9:57:56 AM UTC-5, Adam Clements wrote: 
> >> One thing that worries me though. While this is fine for examples where 
> >> you simply log the exception and move on, what if you need to do 
> something 
> >> more complicated with the actual data? Say for example you need to 
> >> queue/trigger a retry, you no longer have your local bindings to work 
> with 
> >> so you'd have to go back to a normal try/catch (disclaimer - didn't 
> read the 
> >> paper, just going off the code and your comments) 
> > 
> > 
> > I agree. There's certainly cases where the handler will want to restart 
> the 
> > task and need access to the original bindings. I'll tinker around with a 
> > clean way to do this. Open for suggestions. 
>
> Isn't this what Common Lisp's condition system allowed? (And wasn't 
> there a condition-like library for Clojure?) 
>
> -- 
> Ben Wolfson 
> "Human kind has used its intelligence to vary the flavour of drinks, 
> which may be sweet, aromatic, fermented or spirit-based. ... Family 
> and social life also offer numerous other occasions to consume drinks 
> for pleasure." [Larousse, "Drink" entry] 
>

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: [ANN] Dire, Erlang-style error handling

[Michael Drogalis]

Thanks for the awesome feedback.

On Saturday, December 29, 2012 9:57:56 AM UTC-5, Adam Clements wrote:
>
> Hey,
>
> I really like the idea of pulling out exception handling from the function 
> bodies. The try catch form has always bugged me a little bit.
>
> One thing that worries me though. While this is fine for examples where 
> you simply log the exception and move on, what if you need to do something 
> more complicated with the actual data? Say for example you need to 
> queue/trigger a retry, you no longer have your local bindings to work with 
> so you'd have to go back to a normal try/catch (disclaimer - didn't read 
> the paper, just going off the code and your comments)
>

I agree. There's certainly cases where the handler will want to restart the 
task and need access to the original bindings. I'll tinker around with a 
clean way to do this. Open for suggestions. 

>
> Couple of thoughts on the code:
>
> If you want to attach the error handlers to a particular function var 
> (task), why not alter-meta and add the handler function there rather than 
> maintaining a separate atom? Given that the deftask is pretty much 
> redundant anyway, I don't really see the point in making the distinction. 
>  Plus I think your current code is dropping namespaces, causing potential 
> future explosions?
>

Correct, deftask is redundant. I wanted more language to be able to talk 
about what a task is though. This might not be necessary due to what you 
said below this. Also, can you give an example of dropping namespaces?  I 
don't think I see where this happens, but I'm sure it's present. 

>
> I'd be tempted to make a supervise function which simply takes a handler 
> map and do away with the macros altogether, you can still def handlers at 
> the top level if you want to re-use them, but you could also merge sets of 
> handlers if you wanted, or pass in handlers which have some idea of what 
> task you're supervising because they have been declared in the same lexical 
> scope, e.g.
>
> (let [currenturl "..."] 
>(supervise {ConnectionError (fn [e] (queue-retry! currenturl))
>NotFoundError   (fn [e] (log "failed:" currenturl 
> (.getMessage e))}
>   fetch-url currenturl :timeout 10))
>
> or your example would look like:
> (defn divider [a b]
>(/ a b))
>
> (def div-zero-handler 
> {ArithmeticException (fn [e] (println "Cannot divide by zero"))})
>
> (def npe-handler
> {NullPointerException (fn [e] (println "..."))})
>
> (def supervised-divider (partial divider (merge div-zero-handler 
> npe-handler)))
>
> (supervised-divider 10 0)...
>
> Which I would argue is a lot more idiomatic and flexible. I think macros 
> are overkill and unnecessary complexity here, you just need a supervise 
> function which takes responsibility for catching errors and lets you re-use 
> handlers
>
> Adam
>

Joe's paper (for reference 
http://www.erlang.org/download/armstrong_thesis_2003.pdf), in section 4.3.2 
on page 106 states that the goals are:

1. *Clean separation of issues*.
Dire achieves this by total separation of worker logic and supervisor 
logic. (IE "let it crash")

2. *Special processes only for error handling*.
Dire does not have this. Erlang processes aren't OS processes, but they are 
strongly isolated. These handlers that we set up in Dire have to be more 
resilient. I'm not sure how to do this at the moment.

3. *Workers can be run on different physical machines*.
Dire does not have this. Drawing on more knowledge from the Language of the 
System, what if we put queues between supervisors and workers? Is this 
worth it? I'm curious if you guys think it's a good idea for this 
environment.

4. *Error processing code becomes generic*.
To some degree Dire has this. The functions bound to defhandler can be 
reused.

I'm not comfortable with axing defhandler because I wanted this to feel 
like multimethods. I think it's a good idea for users of the supervise 
function to call their worker/task function and away it goes. If a new 
handler is defined, the map passed to supervise has to be modified, which 
violates the Open/Closed principle. That said, if you fork it and give your 
approach a try, I'm sure we can further this idea in some respective.

>
> On Friday, December 28, 2012 7:14:34 PM UTC, Michael Drogalis wrote:
>>
>> Hey folks,
>>
>> After watching The Language of the System and being directed to Joe 
>> Armstrong's paper on error handling, I concurred that his approach is 
>> fantastic. I really wanted the same thing for more rudimentary operations, 
>> like file handling. So I wrote Dire 

Re: Unseemingly Eager Clojure Apprentice Seeking FizzBuzz Feeback

[Michael Drogalis]

Use a cond rather than nesting ifs. Otherwise looks good.

On Saturday, December 29, 2012 7:35:38 AM UTC-5, Sean Chalmers wrote:
>
> Greetings all!
>
> I'm just starting out in the so far wonderful world of Clojure and to help 
> me get started I had a crack at one of my favourites, the FizzBuzz program. 
> For anyone that isn't familiar with FizzBuzz, it is designed to count from 
> 1 to N and take the following actions when certain conditions are met:
>
>- When the remainder of i divided by 3 is 0 print "Fizz"
>- When the remainder of i divided by 5 is 0 print "Buzz"
>- When both the former are true of i print "FizzBuzz"
>
> I crafted the following as a solution and I would really appreciate some 
> more experienced Clojurians casting their eye over it and letting me know 
> if what I've done is in the style and spirit of Clojure. Also this is my 
> first functional language so any feedback on that would be awesome too. :)
>
> I'm aware it's only a tnsy piece of code so not terribly 
> indicative of the hilarity that might ensue on a larger project but all the 
> same. Enough of my blathering here is the meaty bit:
>
> (defn zero-remainder? [x y]
>   (zero? (rem x y)))
>
> (defn fizzy [x]
>   (let [fizz (zero-remainder? x 3) buzz (zero-remainder? x 5)]
> (if (and fizz buzz)
>   (println "FizzBuzz: " x)
>   (if buzz
> (println "Buzz: " x)
> (if fizz
>   (println "Fizz: " x))
>
> (doseq [x (range 1 25)]
>   (fizzy x))
>

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: [ANN] Dire, Erlang-style error handling

[Michael Drogalis]

Indeed, that is the paper - Joe Armstrong's 2003 dissertation "Making 
Reliable Distributed Systems in the Presence of Software Errors".
The video for Rich's The Language of the System: 
http://skillsmatter.com/podcast/scala/the-language-of-the-system

On Friday, December 28, 2012 8:40:28 PM UTC-5, Dave Sann wrote:
>
> I see joe's thesis is linked on your github page. is this thesis the paper 
> you are referring to?
> Do you have a link to the video you refer to?
>
> thanks
>
> Dave
>
>
> On Saturday, 29 December 2012 06:14:34 UTC+11, Michael Drogalis wrote:
>>
>> Hey folks,
>>
>> After watching The Language of the System and being directed to Joe 
>> Armstrong's paper on error handling, I concurred that his approach is 
>> fantastic. I really wanted the same thing for more rudimentary operations, 
>> like file handling. So I wrote Dire 
>> https://github.com/MichaelDrogalis/dire
>>
>> The pros are of this are that error handling code is removed from 
>> application logic and it is not order complected.
>> The cons are that tasks are not as strongly isolated as they are in 
>> Erlang. Also, because it is so simple (16 lines),
>> there's no way for a supervisor to "restart" a child task. (Yet, I guess. 
>> Ideas?)
>>
>> Can such a thing be useful in a non-distributed environment? Or does this 
>> look like a hassle to use?
>>
>>
>>

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: [ANN] Dire, Erlang-style error handling

[Michael Drogalis]

I kind of forgot about user defined exceptions containing useful things. 
Good point. Deployed this adjustment to dire-0.1.0 with commit 
https://github.com/MichaelDrogalis/dire/commit/4a493e85ca88dd59806651264103de53a2879b66

On Friday, December 28, 2012 3:32:41 PM UTC-5, Craig Brozefsky wrote:
>
> Michael Drogalis > writes: 
>
> >Perhaps. Is there anything in the exception object that is useful? I 
> >passed on it because the implementer of a handler already knows what 
> >exception occurred. I'm happy to pass it as an argument if we have 
> good 
> >reasons for it. 
>
> If my handler is going to log error details for later debuggery? 
>
> If my restart or other aspect of handling it depends on a detail of the 
> failure, like the schema of the URL that I couldn't request... 
>
> Basically, nearly all of my current error handling logic assumes I have 
> access to the exception.  Without this, I have almost no hope of 
> translating them to dire. 
>
> -- 
> Craig Brozefsky > 
> Premature reification is the root of all evil 
>

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: [ANN] Dire, Erlang-style error handling

[Michael Drogalis]

Perhaps. Is there anything in the exception object that is useful? I passed 
on it because the implementer of a handler already knows what 
exception occurred. I'm happy to pass it as an argument if we have good 
reasons for it.

On Friday, December 28, 2012 2:54:45 PM UTC-5, marc wrote:
>
> Would it make sense for the handler to have access to the exception 'e' ?
>
> On 29/12/2012, at 6:14 AM, Michael Drogalis > 
> wrote:
>
> Hey folks,
>
> After watching The Language of the System and being directed to Joe 
> Armstrong's paper on error handling, I concurred that his approach is 
> fantastic. I really wanted the same thing for more rudimentary operations, 
> like file handling. So I wrote Dire 
> https://github.com/MichaelDrogalis/dire
>
> The pros are of this are that error handling code is removed from 
> application logic and it is not order complected.
> The cons are that tasks are not as strongly isolated as they are in 
> Erlang. Also, because it is so simple (16 lines),
> there's no way for a supervisor to "restart" a child task. (Yet, I guess. 
> Ideas?)
>
> Can such a thing be useful in a non-distributed environment? Or does this 
> look like a hassle to use?
>
>
>  -- 
> 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 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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

[ANN] Dire, Erlang-style error handling

[Michael Drogalis]

Hey folks,

After watching The Language of the System and being directed to Joe 
Armstrong's paper on error handling, I concurred that his approach is 
fantastic. I really wanted the same thing for more rudimentary operations, 
like file handling. So I wrote Dire https://github.com/MichaelDrogalis/dire

The pros are of this are that error handling code is removed from 
application logic and it is not order complected.
The cons are that tasks are not as strongly isolated as they are in Erlang. 
Also, because it is so simple (16 lines),
there's no way for a supervisor to "restart" a child task. (Yet, I guess. 
Ideas?)

Can such a thing be useful in a non-distributed environment? Or does this 
look like a hassle to use?


-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: [ANN] Dibble - A new way to seed databases

[Michael Drogalis]

Thanks Brian! I'll check it out soon and let you know if I make any headway 
with integration.

On Monday, December 10, 2012 1:35:58 PM UTC-5, Brian Marick wrote:
>
> Here's the SCNA talk link 
>
> http://scna.softwarecraftsmanship.org/media#videos 
>
>
> On Nov 11, 2012, at 5:28 PM, Michael Drogalis 
> > 
> wrote: 
>
> > Interestingly enough, I did something very similar to Peano. The 
> difference is that my version used a "base value" and constraints are used 
> to adjust that value to something else. 
> > 
> > https://github.com/MichaelDrogalis/zombie 
> > 
> > In any case, drop the link here when you find the talk. We should take a 
> stab at merging these two concepts. 
> > 
> > On Sunday, November 11, 2012 6:23:24 PM UTC-5, Brian Marick wrote: 
> > 
> > On Nov 11, 2012, at 2:35 PM, Michael Drogalis wrote: 
> > > Wouldn't it be great to generate rows in a customer table without 
> having to make up names, email addresses, and balances? That's the idea of 
> Dibble. 
> > 
> > Vaguely related: I wrote up a proof-of-concept of using core.logic to 
> generate structured (hierarchical) test data that satisfies constraints. I 
> could imagine the two code bases being complementary. Mine is at: 
> > 
> > https://github.com/marick/peano 
> > 
> > I gave a talk on the idea at Software Craftsmanship North America 
> (yesterday). I believe it was recorded. 
> > 
> > - 
> > Brian Marick, Artisanal Labrador 
> > Contract programming in Ruby and Clojure 
> > Occasional consulting on Agile 
> > Writing /Functional Programming for the Object-Oriented Programmer/: 
> https://leanpub.com/fp-oo 
> > 
> > 
> > 
> > -- 
> > 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 
>
>  
> Occasional consulting on programming technique 
> Contract programming in Ruby and Clojure 
> Latest book: /Functional Programming for the Object-Oriented Programmer/ 
> https://leanpub.com/fp-oo 
>
>

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: [ANN] Dibble - A new way to seed databases

[Michael Drogalis]

Interestingly enough, I did something very similar to Peano. The difference 
is that my version used a "base value" and constraints are used to adjust 
that value to something else.

https://github.com/MichaelDrogalis/zombie

In any case, drop the link here when you find the talk. We should take a 
stab at merging these two concepts.

On Sunday, November 11, 2012 6:23:24 PM UTC-5, Brian Marick wrote:
>
>
> On Nov 11, 2012, at 2:35 PM, Michael Drogalis wrote: 
> > Wouldn't it be great to generate rows in a customer table without having 
> to make up names, email addresses, and balances? That's the idea of Dibble. 
>
> Vaguely related: I wrote up a proof-of-concept of using core.logic to 
> generate structured (hierarchical) test data that satisfies constraints. I 
> could imagine the two code bases being complementary. Mine is at: 
>
> https://github.com/marick/peano 
>
> I gave a talk on the idea at Software Craftsmanship North America 
> (yesterday). I believe it was recorded. 
>
> - 
> Brian Marick, Artisanal Labrador 
> Contract programming in Ruby and Clojure 
> Occasional consulting on Agile 
> Writing /Functional Programming for the Object-Oriented Programmer/: 
> https://leanpub.com/fp-oo 
>
>
>

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

[ANN] Dibble - A new way to seed databases

[Michael Drogalis]

Hey folks,

I recently encountered a situation where developers on a team needed to 
seed their databases with large amounts of data. The data didn't have to be 
the same across all machines, it just had to be logical. Thus, the concept 
of inferential database seeding was born in my little mind!

Wouldn't it be great to generate rows in a customer table without having to 
make up names, email addresses, and balances? That's the idea of Dibble. 
Dibble inferences what the table structure looks like and picks suitably 
random values. You can nudge Dibble to narrow it's randomization, or 
specify concrete values all together. It's a very flexible idea.

The various datatypes of any arbitrary database vendor map to a "standard 
Dibble type". This elevates our level of abstraction, and let's us extend 
the library without worrying about details of MySQL or Postgres.

This idea is in its infancy. I've only implemented Dibble to infer 
information about varchars and numeric types in MySQL. I would *love* if 
some help came in to make Dibble work with more vendors and datatypes. This 
is a really easy open source project to contribute to.

Additionally, it's a great way to sneak in Clojure to a company that's 
apprehensive about it. It's low risk to write your developer seeding 
instructions with a Clojure library.

Website is at http://michaeldrogalis.github.com/dibble/
Source is at https://github.com/MichaelDrogalis/dibble

Hope this is useful!
--Mike

-- 
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
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en