(daily kata) 2010 jan 20

@waiting for

• question about post-java language on basementcoders

@next

• What is XAMPP

@placeholder

Advertisements

(droidelicious) snapshot on 2011 janvier 18

Next

• (read) googledocs on Content Providers
• (read) unlocking android ch5
• (stackoverflow) What is the point of ContentResolver.bulkInsert

Notes

• Create precompiled statements
  • SQLiteDatabase.compileStatement (String sql) : SQLiteStatement
• (stackoverflow) How to call custom methods in a ContentProvider ?
• (stackoverflow) suspend notification to observers temporarily

Saved

• (maybe) use AsyncQueryHandler
• (source) ContentResolver.java

Related (batch inserts)

• (stackoverflow) It’s not possible to insert multiple rows in one statement in sqlite
• (stackoverflow) how to improve performance of batch inserts in sqlite
  • Use PRAGMA synchronous = off
• Whenever you have to do multiple database writes, put them inside a transaction
• (stackoverflow) why are batch inserts faster
• (stackoverflow) slow batch inserts in hibernate
• C# code for bulk inserts

(software) replacement for make

• 12 jan 2011 :: why redo is the git of build systems
• 14 dec 2010 :: An implementation of djb redo in python
• 12 nov 2010 :: Things that make got right

(wiki) AMQP

Questions

• (stackoverflow) ensure consumers only take one task from the queue

Software

• Celery #python
• Beanstalkd #php
• Octobot – supports redis, rabbitmq
  • discussion at HN
• placeholder

Misc

• Sep 10th 2009 blogpost on celery & django with rabbitmq #pdf
• May 6th 2010 presentation on beanstalkd

(unix) Threads vs Subprocesses

next

• Q. How does python’s multiprocessing module sidestep the GIL ?

reference

• Q. How to kill process and subprocess ?
  • kill — -pid
• wikipedia POSIX Process Group
• wiki launching a subprocess under unix & windows

(idiom) Automatic Resource Management (ARM)

Resources

• stackoverflow scala ARM solutions (Feb 2010)
• stackoverflow python ARM
  • with statement
  • tutorial on how to handle errors
• stackoverflow in java
• Aug 2010 infoq ARM in java 7

Misc

(concurrency) use case :: Producer Consumer

pattern by downey

mutex = Semaphore(1)
items = Semaphore(0)
buffer = ....

Producer
mutex.wait()
    buffer.add( ... )
    items.signal()
mutex.signal()
Consumer 
items.wait()
mutex.wait()
    v = buffer.get()
mutex.signal()

java solution

…

scala solution

….

My python solution (threading module)

gist

"""
Producer produces numbers 1..10
Consumer runs first & then blocks
Solution: uses semaphores
"""
from threading import Thread
from threading import Semaphore
class SharedBuffer(object):    
  def __init__(self):        
    self.empty = Semaphore(0)        
    self.mutex = Semaphore(1)        
    self.slot = []

 def put(self, p):        
  """ blocking put """        
  self.mutex.acquire()        
  try:            
    print "put " + str(p)            
    self.slot.append( p )        
  except:            
    print "failed to append"        
  self.mutex.release()        
  self.empty.release()

 def get(self):        
  """ blocking get """        
  self.empty.acquire()        
  self.mutex.acquire()        
  v = self.slot.pop()        
  self.mutex.release()        
  print "get " + str(v)        
  return v
class Producer(Thread):    
  def __init__(self,buffer):        
    Thread.__init__(self)        
    self.buffer = buffer

 def run(self):        
  print "[Producer] running"        
  for i in range(0, 10):            
    self.buffer.put( i )            
    print "[Producer] sent " + str(i)
  print "[Producer] dead"

class Consumer(Thread):    
  def __init__(self,buffer):        
    Thread.__init__(self)        
    self.buffer = buffer

 def run(self):        
  print "[Consumer] running"        
  while(True):            
    v = self.buffer.get()            
    print "[Consumer] received " + str(v)            
    if( v == 9 ):                
      break                    
    print "[Consumer] dead"

if __name__ == "__main__":    
  buffer = SharedBuffer()    
  p = Producer(buffer)    
  c = Consumer(buffer)    
  c.start()    
  p.start()
 c.join()

python solution (using multiprocessing module)

• (stackoverflow) producer consumer problem with python multiprocessing
• (stackoverflow) Is this lockless approach threadsafe