Some thoughts on classes after 18 months of Clojure

I had some thoughts about classes that wouldn’t fit into a talk I’m building about functional programming in Ruby, so I recorded them as a video.

Topics:

  • Using hashes instead of classes.

  • Classes as a documentation tool—specifically, as a way of making functions easy to find.

  • Preferring module inclusion to subclassing (which is akin to preferring adjectives to nouns as a way of organizing the documentation of verbs). (Vaguely similar to duck-typing in Haskell.)

  • Object dot notation as a more readable way of writing function composition. (Similar to the motivation for the -> macro in Clojure or type-directed name resolution in Haskell.)

On mutable state

I’m working on a talk called “Functional Programming for Ruby Programmers”. While doing so, I’ve somewhat changed my opinion about mutable state. Here’s my argument, for your commentary. Being new, it’s probably at best half-baked.

  1. Back in the early days of AIDS (the disease), I remember a blood-supply advocate saying “You’ve slept with everyone that everyone you’ve slept with ever slept with.”

    The nice thing about immutable state is that it stays virginal and knowable. It is what it was when it was created. With mutable state, it’s more like “Your code might be infected by any code that ever touched your data before (or after!) you first hooked up with it.”

    However, I don’t personally find that a huge problem in programming, debugging, or understanding code. There are other problems I’d rather see fixed first.

  2. It’s often said that “code with immutable state is easier to reason about”. I realized a long time ago that there’s some sleight-of-common-language going on there, like the way people who wanted code to be less branchy got rhetorical leverage by renaming branchiness “complexity“.

    In the claim, “reason about” is (I believe) being taken to be synonymous with “prove theorems about”. Pace a whole long trend in artificial intelligence, I don’t believe theorem proving is the basis for, nor a good analogy to, reasoning. Thus I took the “reason about” statement to be a sort of solipsistic wankery from people with roots in the theorem-proving community, not an argument that should sway me, Pragmatic Man!, who left the world of proofs-of-design-correctness around 1984.

    What I’d forgotten is that optimization is theorem proving. One can only optimize if there’s a proof that the optimized code computes the same result as the original. If you consider the desire to implement, say, lazy sequences efficiently, you see how the guarantees that immutability gives are important. Ditto for automatically spreading work to multiple cores.

  3. So:

    My previous attitude was pretty much “Yeah, I have a preference for avoiding mutable state. Being immutable isn’t a huge win, but as long as I have people providing me with data structures like zippers, it’s not really any harder than fooling with mutable state. Still, I don’t see why I need an immutable language. If I don’t want to mutate my hashmaps, I just won’t mutate my hashmaps.”

    My new attitude is: “Oh! I see why I need an immutable language.”

I still don’t make a huge deal about immutability. Its benefit is greater than its cost, sure, but it’s not the Thing That Will Save Us.

Here are three Ruby functions…

Here are three Ruby functions. Each solves this problem: “You are given a starting and ending date and an increment in days. Produce all incremental dates that don’t include the starting date but may include the ending date. More formally: produce a list of all the dates such that for some n >= 1, date = starting_date + (increment * n) && date < = ending_date.

Solution 1:

Solution 2:

Solution 3 depends on a lazily function that produces an unbounded list from a starting element and a next-element function. Here’s a use of lazily:

As a lazy sequence, integers both (1) doesn’t do the work of calculating the ith element unless a client of integers asks for it, and also (2) doesn’t waste effort calculationg any intermediate values more than once.

Solution 3:

The third solution seems “intuitively” better to me, but I’m having difficulty explaining why.

The first solution fails on three aesthetic grounds:

  • It lacks decomposability. There’s no piece that can be ripped out and used in isolation. (For example, the body of the loop both creates a new element and updates an intermediate value.)

  • It lacks flow. It’s pleasing when you can view a computation as flowing a data structure through a series of functions, each of which changes its “shape” to convert a lump of coal into a diamond.

  • It has wasted motion: it puts an element at the front of the array, then throws it away. (Note: you can eliminate that by having current start out as exclusive+increment but that code duplicates the later +=increment. Arguably, that duplicated increment-date action is wasted (programmer) motion, in the sense that the same action is done twice. (Or: don’t repeat yourself / Eliminate duplication.))

The second solution has flow of values through functions, but it wastes a lot of motion. A bunch of dates are created, only to be thrown away in the next step of the computation. Also, in some way I cannot clearly express, it seems wrong to stick the inclusive_end between the exclusive_start and the increment, given that the latter two are what was originally presented to the user and the inclusive_end is a user choice. (Therefore shouldn’t the exclusive_start and increment be more visually bound together than this solution does?)

The third solution …

  • … is decomposable: the sequence of dates is distinct from the decision about which subset to use. (You could, for example, pass in the whole lazy sequence instead of a exclusive_start/increment pair, something that couldn’t be done with the other solutions.)

  • … eliminates wasted work, in that only the dates that are required are generated. (Well, it does store away a first date — excluded_start — that is then dropped. But it doesn’t create an excess new date.)

  • … has the same feel of a data structure flowing through functions that #2 has.

So: #3 seems best to me, but the advantages over the other two seem unconvincing (especially given that programmers of my generation are likely to see closure-evaluation-requiring-heap-allocation-because-of-who-knows-what-bound-variables as scarily expensive).

Have you better arguments? Can you refute my arguments?

I’m trying to show the virtues of a lazy functional style. Perhaps this is a bad example? [It’s a real one, though, where I really do prefer the third solution.]

TDD Workflow (Sinatra / Haml / jQuery) Part 1

Introduction

This is a draft. Worth continuing the series? Let me know.

Critter4Us is a webapp used to schedule teaching animals at the University of Illinois Vet School. Its original version was a Ruby/Sinatra application with a Cappuccino front end. Cappuccino lets you write desktop-like webapps using a framework modeled after Apple’s Cocoa. I chose it for two reasons: it made it easy to test front-end code headlessly (which was harder back then than it is now), and it let me reuse my RubyCocoa experience.

Earlier this year, I decided it was time for another bout of experimentation. I decided to switch from Cappuccino to jQuery, Coffeescript, Haml because I thought they were technologies I should know and because they’d force me to develop a new TDD workflow. I’d never gotten comfortable with the testing—or for that matter, any of the design—of “traditional” front-end webapp code and the parts of the backend from the controller layer up.

I now think I’ve reached a plateau at which I’m temporarily comfortable, so this is a good time to report. Other people might find the approach and the tooling useful. And other people might explain places where my inexperience has led me astray.
Read the rest of this entry »

Anarchy of Evasion

“The anarchy of evasion” is a term that (I think) I read a few years ago. I occasionally search for it, but I’ve never been able to find anything about it again. As I recall, the idea is a reaction to the fact that an anarchist movement that forms an independent new society or transforms an existing society is… hard. So an alternative is to live within an existing society but try to make as many as possible of your activities and interactions run according to the principles you wished the whole society ran with. You behave as you wish, but in a way and context that increases the chance you won’t be noticed and therefore stopped.

The idea appeals to me, perhaps because I’ve always liked the idea of complex and interesting things happening unnoticed in the cracks. Probably a result of reading The Littles as a kid and books like You’re All Alone and Neverwhere later.

Parallels with things like open source, intentional communities, squatting, and freaks and geeks in US high schools are left as an exercise for the reader.

If anyone has links to the idea, let me know.

Using functional style in a Ruby webapp

Motivation

Consider a Ruby backend that communicates with its frontend via JSON. It sends (and perhaps receives) strings like this:

Let’s suppose it also communicates with a relational database. A simple translation of query results into Ruby looks like this:

(I’m using the Sequel gem to talk to Postgres.)

On the face of it, it seems odd for our code to receive dumb hashes and arrays, laboriously turn them into model objects with rich behavior, fling some messages at them to transform their state, and then convert the resulting object graph back into dumb hashes and arrays. There are strong historical reasons for that choice—see Fowler’s Patterns of Enterprise Application Architecture—but I’m starting to wonder if it’s as clear a default choice as it used to be. Perhaps a functional approach could work well:

  • Functional programs focus on the flow of data through code, rather than on objects with changing state. The former seems more of a match for a typical webapp.

  • It’s common in functional languages to lean toward a few core datatypes—like hashes and arrays—that are operated on by a wealth of functions. We could skip the conversion step into objects. Rather than having to deal with the leaky abstraction of an object-relational mapping layer, we’d embrace the nature of our data.

Seems plausible, I’ve been thinking. However, I’ve never been wildly good at understanding the problems of an approach just by thinking about it. It’s more efficient for me to learn by doing. So I’ve decided to strangle an application whose communication with its database is, um, labored.

I’m going to concentrate on two things:

  • Structuring the code. More than a year of work on Midje has left me still unhappy about the organization of its code, despite my using Kevin Lawrence’s guideline: if you have trouble finding a piece of code, move it to where you first looked. I have some hope that Ruby’s structuring tools (classes, modules, include, etc.) will be useful.

  • Dependencies. As you’ll see, I’ll be writing code with a lot of temporal coupling. Is that and other kinds of coupling dooming me to a deeply intertwingled mess that I can’t change safely or quickly?

This blog post is about where I stand so far, after adding just one new feature.
Read the rest of this entry »

Top-down design in “functional classic” programming

While waiting for my product owner to get back to me, I was going through open browser tabs. I read this from Swizec Teller:

The problem is one of turning a list of values, say, [A, B, C, D] into a list of pairs with itself, like so [[A,B], [A,C], [A,D], [B, C], [B,D], [C,D]].

He had problems coming up with a good solution. “I can do that!” I said, launched a Clojure REPL, and started typing the whole function out. I quickly got bogged down.

This, I think, is a problem with a common functional approach. Even with this kind of problem—the sort of list manipulation that functional programming lives for—there’s a temptation to build a single function bottom up. “I need to create the tails of the sequence,” I thought, “because I know roughly how I’ll use them.”

For me (and let’s not get into all that again), it usually works better to go top down, mainly because it lets me think of discrete, meaningful functions, give them names, and write facts about how they relate to one another. So that’s what I did.

First, what am I trying to do? Not create all the pairs, but only ones in which an element is combined with another element further down the list. Like this:

As I often do when doing list-manipulation problems, I lay things out to visually emphasize the “shape” of the solution. That helps me see more clearly what has to be done to create that solution. There’s one set of pairs, each headed by the first element of the list, then another set, each headed by the second element. That is, I can say the above fact is true provided two other facts are true:

It’s easy to see how I get the heads—just map down the list (maybe I have to worry about the last element, maybe not—I’ll worry about it if it comes up). What are those heads combined with? Just the successive tails of the original list: [2 3], [3]. I’ll assume there’s a function that does that for me. That gives me this entire fact-about-the-world-of-this-program:

Given all that, downward-pairs is easy enough to write:

It’s important to me that I have reached a stable point here. When building up a complicated function from snippets in a REPL, I more often create the wrong snippets than when I define what those snippets need to do via a function that uses them. (I’m not saying that I never backtrack: I might find a subfunction too hard to write, or I may have carved up the world in a way that leads to gross inefficiency, etc. I’m saying that I seem to end up with correct answers faster this way.)

Now I just have to solve two simpler problems. Tails I’ve done before, and here’s a solution I like:

For those who don’t know Clojure well, this produces this sequence of calls to drop:

This does roughly the same work as an iteration would do because of how laziness is implemented.

That leaves me headed-pairs, which is a pretty straightforward map:

This seems like a reasonable solution, doesn’t strike me as being terribly inefficient (given laziness), has a readability that I like, doubtless took me less time than developing it bottom-up would have, and comes with tests (including an end-to-end test that I won’t bother showing).

The whole solution is here.

UPDATE: Yes, I could have used do or even gotten explicit with the sequence-m monad, but that wouldn’t have addressed the original poster’s point, which I took to be how to think about functional problems.

How mocks can cut down on test maintenance

After around 11 months of not working on it, I needed to make a change to Critter4us, an app I wrote for the University of Illinois vet school. The change was simple. When I tried to push it to Heroku, though, I discovered that my Ruby gems were too out of date. So, I ended up upgrading from Ruby 1.8 to 1.9, to Sinatra 1.3 from a Sinatra less than 1.0, to a modern version of Rack, etc. etc. In essence, I replaced all the turtles upon which my code-world was resting. There were some backwards-compatibility problems.

One incompatibility was that I was sending an incorrectly formatted URI to fetch some JSON data. The old version of Rack accepted it, but the new one rejected it. The easy fix was to split what had been a single `timeslice` parameter up into multiple parameters. [Update: I later did something more sensible, but it doesn’t affect the point of this post.] “Crap!”, I thought. “I’m going to have to convert who knows how much test data.” But I was pleased when I looked at the first test and saw this:

The key point here is that neither the format of the URI parameters nor the resulting timeslice object is given in its real form. Instead, they’re represented by strings that basically name their type. (In my Clojure testing framework, Midje, I refer to these things as “metaconstants“.)

The only responsibility this code has toward timeslices is to pass them to another object. That object, the `internalizer`, has the responsibility for understanding formats. The test (and code) change is trivial:

The test is even (and appropriately) less specific than before. It says only that the GET parameters (a hash) will contain some key/value pairs of use to the internalizer. It’s up to the internalizer to know which those are and do the right thing.

The point here is that the size of the test change is in keeping with the size of the code change. It is unaffected by the nature of the change to the data—which is as it should be.

This application is the one where I finally made the important decision to use mocks heavily in the Freeman and Pryce “London” style and—most importantly—to not fall into the trap of thinking “Mocks are stupid!” when I ran into problems. Instead, I said “I’m stupid!” and, working on that assumption, figured out what I was doing wrong.

I made that decision halfway through writing the app. One of the happy results of the mocking that followed was that a vast amount of test setup code devoted to constructing complete data structures went away. No more “fixtures” or “object mothers” or “test factories.”

A postscript on expressiveness and performance

In some way, my original post makes it seem as if normal programmers are like the drug dealer D’Angelo Barksdale eating in a fancy restaurant in “The Wire“—everyone stared, the waiter rubbed D’Angelo’s ignorance of fine-restaurant customs in his face, and D’Angelo’s introspective attitude doesn’t hide a desperate desire to leave. Well, yes (though nothing in a programmer’s life is as bad as anything in a “The Wire” character’s life), but there’s more to it.

I think Clojure already suffers from being a language for hardcore programmers to solve hardcore problems. For example, that hardcore attitude makes things like nice stack traces seem unimportant. More: fishing through stack traces can almost become a perverse right of passage. Do you have what it takes to program in Clojure, punk?

The history of programming, as I’ve lived it, has been a march where expressiveness led the way and performance followed. I came of age when the big debate was whether us new-fangled C programmers and our limited compilers could ever replace the skilled assembly-language programmer. C won the debate. When Java came out, the debate was whether a language with byte codes and garbage collection could be fast enough to be a justifiable choice over C/C++. Java won the debate. Ruby is still being held up as too slow in comparison with Java, but even the pokey MRI runtime is fast enough for a whole lot of apps. Perhaps the emerging consensus is that Twitter-esque success will require migrating from Ruby to JVM infrastructure—and that’s exactly the kind of problem you want to have.

Against that background, it’s notable that Clojure 1.3 is taking a step backward in expressiveness in the service of performance. (By this, I mostly mean that performance—calling through vars, arithmetic operations—is the default and people who are worried about rebinding and bignums have to act specially. So my super-cool introduction-to-Clojure “Let’s take the sum of the first 3000 elements of an infinite sequence of factorials” example will become less impressive because arithmetic overflow is now in the programmer’s face.) That’s worrisome. There’s not much new in 1.3 to tempt the hitherto-reluctant Java or Ruby programmer. And unless I care about performance or am a utility library maintainer, I don’t see very much in 1.3 to tempt me away from 1.2.

Now, 1.3 is not a huge hit to expressiveness, and Clojure already has pretty much all the expressive language constructs that have stood the test of time (except, I suppose, Haskell-style pattern matching). So what else is left for someone of Rich Hickey’s talents to work on but performance? Documentation?

That’s a good point, but I worry about how performance will drive the constructs available to Clojure users. For example, multimethods feel a bit orphaned because of the drive to take advantage of how good the JVM is at type dispatch. There’s a whole parallel structure of genericity that’s getting the attention. And conj is a historical example: it’s hard to explain to someone how these two things both make sense:

user=> (conj [1 2 3] 4)
[1 2 3 4]
user=> (conj (map identity [1 2 3]) 4)
(4 1 2 3)

As with arithmetic overflow, it strikes those not performance-minded (those not hardcore) as odd to have lots of generic operations on sequences except for the case of putting something on the end. “So I have to keep track of what’s a vector? In a language that creates lazy sequences whenever it gets an excuse to?”

Catering to performance increases the cognitive load a language puts on its users. Again, the hardcore programmer will take it in stride. But Lisp and functional languages are different enough that I think Clojure needs more focused attention on the not-hardcore programmers.

Now, the quick retort is that Clojure isn’t my language. It’s a gift from Rich Hickie to the world. Who am I to demand more from him? That’s a good retort. But my counter-retort is that I demand nothing. I only suggest, based on my experience with the adoption of ideas and languages. It’s hard making something. More information (from users like me) is probably better than less.

A postscript about the validity of claims

The problem with talking about the tone of the Clojure community is that almost no statement can ever be proven. Rich Hickey and I went around and around about this on Twitter. So after citing this statement of his:

If people think that spending fifty percent of their time writing tests maximizes their results—okay for them. I’m sure that’s not true for me—I’d rather spend that time thinking about my problem.

… I could say that I read a snarky “[those losers]” implicitly attached to “okay for them.” I could say that “fifty percent of your time writing tests” and “rather spend that time thinking about my problem” are complete mischaracterizations of TDD as it’s actually done. And I can say that those mischaracterizations and that snark will be aped by programmers who want to be Rich Hickey.

I could say all those things, but the statement as written isn’t false. It can even be given a generous reading. But—if I’m right—programmers like me won’t stick around to hear defensible statements defended. They’ll just look for friendlier places where they aren’t expected to deal with decade-old arguments as if they were new and insightful.

Please note that I’m not saying Rich Hickie’s design approach is wrong. I suspect for the kinds of problems he solves, it may even be true that his approach is better across all designers than TDD is.


  • Buy Cheap drug fluconazole Now Discount Pharmacy Online. Best Internet.
  • Buy Cheap clonazepam fedex Now Online Medical Shop. 24/Online Pharmacy.
  • Buy Cheap side effects of xanax Online Pharmacy At The Best Price! Best Prices.
  • Buy Cheap valtrex dose Online Best Online. 100% Satisfaction Guaranteed.
  • Buy Cheapest pain med Now Pharmacy Store. Guaranteed Shipping.
  • Buy Cheapest vardenafil united kingdom Online Low Prices. Internet Prices For vardenafil united kingdom!
  • internet drugstores in usa Online Without Prescription Pharmacy Store. Best Prices.
  • Buy Cheap depression valium Now Pharmacy Store. Buy Medications Online.
  • Buy Cheap non prescription medication for depression Online Pharmacy At The Best Price! Pharmacy Store.
  • Buy Cheap codeine ingredients Online Best Internet. Internet Prices For codeine ingredients!
  • Buy Cheap sildenafil citrate side effects Online Discount Online Pharmacy. Best Drugstore.
  • Buy Cheap erythromycin online Online Discount Online Pharmacy. Low Prices.
  • Buy Cheapest using levitra Online Cheap Online Pharmacy. Low Prices.
  • Buy Cheap order cheap levitra Now WorldWide Shipping. Buy Medications Online.
  • Buy Cheap cialis for sale Online 24/Internet)(safe Pharmacy. Low Prices.
  • Buy Cheapest levitra benifits Online Cheap Prescription Drugs. Best Online.
  • Buy Cheapest lowest prices medications Now Special Prices For lowest prices medications! Best Drugstore.
  • Buy Cheap jelly viagras Now Pharmacy Store. Top Online Pharmacy Supplier.
  • Buy Cheap finasteride proscar Now Online Medical Shop. Cheap Pharmacy Online.
  • Buy Cheap buy prescription diet pills online Now Guaranteed Shipping. Cheap Pharmacy Online.
  • Buy Cheapest levitra low price Now Top Online Pharmacy. Best Drugstore.
  • Buy Cheap tramadol florida Now Online Prices For tramadol florida! Online Medical Shop.
  • Buy Cheap long term use of viagra Now No Prescription Needed. Cheap Pharmacy Online.
  • Buy Cheap half life of klonopin Now Online Medical Shop. Cheap Online Pharmacy.
  • Buy Cheapest weight loss for women over 50 Online WorldWide Shipping. Best Internet.
  • Buy Cheapest nexium pills Now 24/Online Pharmacy. Best Drugstore.
  • Buy Cheap how do i order medicines on-line Online Cheap Prescription Drugs. Best Drugstore.
  • Buy Cheap phentermine overdose Now Best Online. No Prescription Online Pharmacy.
  • Buy Cheapest how to stop headaches Online Guaranteed Shipping. Best Internet.
  • Buy Cheap cialis professional no prescription lowest price Now Buy Medications Online. Cheap Pharmacy Online.
  • top 20 appetite supressant Online Without Prescription Guaranteed Shipping. Low Prices.
  • Buy Cheap zyban bupropion Now WorldWide Shipping. Drugs, Health And Beauty.
  • Buy Cheap buy anti anxiety pills Now Best Online. The Largest Internet Pharmacy.
  • Buy Cheapest pain pills cheap Now Online Medical Shop. WorldWide Shipping.
  • Buy Cheapest weight loss medication over the counter Online Pharmacy Store. Cheap Pharmacy Online.
  • Buy Cheapest usa online pharmacy Online Pharmacy Store. Buy Medications Online.
  • Buy Cheap buy alprazolam overnight Now Best Online. 100% Satisfaction Guaranteed.
  • Buy Cheap acne drug Online Pharmacy Store. Top Online Pharmacy.
  • Buy Cheap phentermine risk Now Drug Store Without A Prescription. Low Prices.
  • Buy Cheap phentermine and pregnancy Online Internet Prices For phentermine and pregnancy! Best Drugstore.
  • Buy Cheapest speed of viagra Now Best Drugstore. Buy Medications Online.
  • Buy Cheapest cialis faq Now Best Prices. Discount Online Pharmacy.
  • Buy Cheap new arthritis medicine Online Best Drugstore. Cheap Prescription Drugs.
  • Buy Cheap purchase diflucan Now Cheap Prescription Drugs. Pharmacy Store.
  • Buy Cheap sales viagra Now Pharmacy Store. No Prescription Needed.
  • Buy Cheapest viagra for her Online Top Online Pharmacy. Best Internet.
  • purchase cheap cialis online Online Without Prescription Best Online. Free Viagra Pills!
  • Buy Cheapest pain med Online Best Internet. No Prescription Needed.
  • Buy Cheap cialis generic pharmacy Now Best Online. All Medications Are Certificated!
  • Buy Cheap effexor dose Online Online Medical Shop. Guaranteed Shipping.
  • buy diazepam Online Without Prescription Best Drugstore. Pharmacy Store.
  • Buy Cheapest lorazepam online no prescription Online Best Prices. No Prescription Needed.
  • Buy Cheapest generic cialis softtab Now Cheap Online Pharmacy. Pharmacy Store.
  • Buy Cheap valium dosages Online The Largest Internet Pharmacy. Low Prices.
  • Buy Cheapest cheap proscar Online Free Viagra Pills! Best Drugstore.
  • Buy Cheap cheap phentermine for sale Online Free Viagra Pills! No Prescription Needed.
  • Buy Cheapest diazepam cheap wothout rx Now No Prescription Needed. Free Viagra Pills!
  • Buy Cheap generic valium no prescription Online Cheap Prescription Drugs. Best Drugstore.
  • Buy Cheap cialis male enhancement Now Order Cheap Meds Without Rx. Best Prices.
  • Buy Cheap medical weight loss pill Now Guaranteed Shipping. Cheap Online Pharmacy.
  • Buy Cheap buy doxycycline online Now Cheap Online Pharmacy. Free Viagra Pills!
  • Buy Cheap prescription drug costs Now 24/Online Pharmacy. Buy Medications Online.
  • Buy Cheap mexican ambien Online Low Prices. 24/Internet)(safe Pharmacy.
  • Buy Cheap ultram er side effects Online Internet Prices For ultram er side effects! Pharmacy Store.
  • american generic diet pills Online Without Prescription Best Prices. Free Viagra Pills!
  • Buy Cheapest buy viagra online in canada Now Cheap Prescription Drugs. Best Online.
  • Buy Cheapest use clomid Now We Can Offer You Visit Our Online Pharmacy.
  • Buy Cheap valium 2mg Online WorldWide Shipping. Guaranteed Shipping.
  • Buy Cheap buy online viagra phentermine xanax Online Internet Prices For buy online viagra phentermine xanax! Pharmacy Store.
  • Buy Cheap arthritis killer pain Online Buy Medications Online. Best Internet.
  • Buy Cheapest phenergan side effects Now Drugs, Health And Beauty. Best Prices.
  • Buy Cheap cheap meclizine Online WorldWide Shipping. No Prescription Needed.
  • Buy Cheap free viagra prescription Now Best Prices. FDA Approved Rx: Online Pharmacy.
  • Buy Cheapest cialis dosage 20mg Online WorldWide Shipping. Pharmacy Store.
  • Buy Cheapest health med Online 24/Online Pharmacy. Best Drugstore.
  • Buy Cheap medications ativan Online Low Prices. 100% Satisfaction Guaranteed.
  • Buy Cheapest cialis fast shipping Now Guaranteed Shipping. Best Drugstore.
  • Buy Cheap new medicines for depression Now Drugs, Health And Beauty. Best Internet.
  • Buy Cheapest treatment for parasites in humans Now 24/Online Pharmacy. Pharmacy Store.
  • Buy Cheap mexican rx generic cialis Now Pharmacy Store. Cheap Prescription Drugs.
  • Buy Cheap foreign purchase pain killers Now Pharmacy Store. Cheap Prescription Drugs.
  • Buy Cheapest ambien buy cheap Online Cheap Pharmacy Online. Pharmacy Store.
  • Buy Cheap free sample of viagra Now Cheap Prescription Drugs. Best Internet.
  • Buy Cheap weight loss medicine buy online Now Online Medical Shop. Cheap Pharmacy Online.
  • Buy Cheapest vitamin pill Now Buy Medications Online. Best Drugstore.
  • Buy Cheapest xanax paypal Online Free Viagra Pills! Top Online Pharmacy.
  • Buy Cheapest tramadol pain killer Now Free Viagra Pills! 24/Online Pharmacy.
  • Buy Cheapest buy ultram on line Online WorldWide Shipping. Best Drugstore.
  • Buy Cheap valium dosage Now All Medications Are Certificated! Low Prices.
  • Buy Cheapest foreign prescription meds Now 100% Satisfaction Guaranteed. Best Online.
  • Buy Cheap ezetimibe zetia Now Safe And Secure Payment System. Best Online.
  • Buy Cheapest phentermine no prescription fast delivery Now Guaranteed Shipping. Cheap Online Pharmacy.
  • Buy Cheap how do i burn belly fat Now Discount Online Pharmacy. Best Drugstore.
  • Buy Cheapest phentermine shipped cod Now WorldWide Shipping. Cheap Pharmacy Online.
  • Buy Cheap viagra prescription uk Now Buy Medications Online. 24/Online Pharmacy.
  • Buy Cheapest online pharmacy prescription viagra Now Best Drugstore. No Prescription Needed.
  • Buy Cheapest levitra efficacy Online Cheap Pharmacy Online. Best Prices.
  • Buy Cheap lexapro antidepressant Now Free Viagra Pills! Discount Pharmacy Online.
  • Buy Cheapest relief migraine headache Now Online Prices For relief migraine headache! Best Prices.
  • Buy Cheapest xanax information Online Pharmacy Store. Guaranteed Shipping.