Skip to main content

Some notes from an ebay newbie

I was always suspicious of eBay (mostly because of Paypal). But I decided to jump in (like, what, about a few decades behind the curve) and try it out. I have fairly specific things I look for on eBay: photo stuff, my idea is that eBay is the giant garage sale in the ether and sometimes you can find exactly what you want for exactly what you want to pay for.

I don't have any deep observations, but I think one simple rule is important. I saw a lot of advice about sniping (bidding at the last second) and I think eBay does a very fair thing, in the true spirit of trying to find the appropriate price for an item.

Ebay allows you to set a maximum bid and will automatically bid just enough to keep you ahead up to the maximum. If someone comes in after you with a series of bids your bid always has precedence until your limit. I think this, if you are using eBay as a garage sale to find cheap items for a hobby, is the proper way to go.

When you first see an item, decide how much at most you want to pay for it, set that as your maximum bid AND THEN FORGET ABOUT IT.

EDIT: Now, however, I think this not literally how you should do it. You should write your maximum bid out, to remind yourself of what the real valuation of the item is. However, if everyone entered their max bid into eBay right away, all the prices would instantly saturate out, leaving the price at some small increment above the second highest bid. I think I understand "sniping" a little better - you should slowly work your way up to your max bid in relation to other bids, and as late as possible. However, the crucial key here is to remember your own maximum valuation and not budge from that, otherwise you will overpay.

eBay, of course, makes money off commissions, so it has an interest in you bidding on items and keeping increasing your bid. It's site is tuned to competitiveness in bidding, and I can see how people with a weakness for gambling or a misplaced competitive streak would get into a bidding war forgetting what their original base valuation for an item was. eBay is not really at fault here.

In general, item prices on open auction (where the lowest bid is very low) tend to be exponential, with prices racing up in the last 15min or so. I can see how, for expensive items, you can occasionally get a deal - there is probably a lot of noise in the price curve and since the growth is exponential the last few minutes/seconds of a bidding war can lead to large fluctuations in final price. The danger is that even with fluctuations, if you forget your original valuation, you are ending up paying more than the item is worth to you if you were not in a 'war': the only difference is in how much more you are paying than what the item was really worth to you.

One set of items I had been looking at were old 85mm primes. I was surprised at how much money people were paying for these old lenses. I can understand that a lens that has never been used, with its original packing and caps etc, would have a collector value. I could not understand how a lens with bits and pieces missing could sell for nearly $300. In all of these auctions I could see this exponential bid growth in the last hour. I guess there is a craze for Nikon 85mm f/1.8 D lenses well beyond their actual value as a photographic instrument!

Any how, it is possible to get deals from eBay, but it can't be something that there is a craze for, otherwise the item becomes over priced.

Comments

Popular posts from this blog

A note on Python's __exit__() and errors

Python's context managers are a very neat way of handling code that needs a teardown once you are done. Python objects have do have a destructor method ( __del__ ) called right before the last instance of the object is about to be destroyed. You can do a teardown there. However there is a lot of fine print to the __del__ method. A cleaner way of doing tear-downs is through Python's context manager , manifested as the with keyword. class CrushMe: def __init__(self): self.f = open('test.txt', 'w') def foo(self, a, b): self.f.write(str(a - b)) def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.f.close() return True with CrushMe() as c: c.foo(2, 3) One thing that is important, and that got me just now, is error handling. I made the mistake of ignoring all those 'junk' arguments ( exc_type, exc_val, exc_tb ). I just skimmed the docs and what popped out is that you need to return True or...

Remove field code from Word document

e.g. before submitting a MS, or hand manipulating some formatting because Word does things (like cross-references) so half-assed [from here ] Select all the text (CTRL-A) Press Ctrl+Shift+F9 Editing to remove anonymous comments that only contain thanks. I really appreciate the thanks, but it makes it harder to find comments that carry pertinent information. I'm also going to try and paste informative comments in the body of the post to make them easier to find.

h5py and multiprocessing

The HDF5 format has been working awesome for me, but I ran into danger when I started to mix it with multiprocessing. It was the worst kind of danger: the intermittent error. Here are the dangers/issues in order of escalation (TL;DR is use a generator to feed data from your file into the child processes as they spawn. It's the easiest way. Read on for harder ways.) An h5py file handle can't be pickled and therefore can't be passed as an argument using pool.map() If you set the handle as a global and access it from the child processes you run the risk of racing which leads to corrupted reads. My personal runin was that my code sometimes ran fine but sometimes would complain that there are NaNs or Infinity in the data. This wasted some time tracking down. Other people have had this kind of problem [ 1 ]. Same problem if you pass the filename and have the different processes open individual instances of the file separately. The hard way to solve this problem is to sw...