Wybiral

Planetary states API

2011-11-05T07:08:00.000-07:00

I needed a way to deal with planetary positions and velocities and found NASA's HORIZONS and the ephemerides. But I wanted a simpler interface than telnet or lugging around the massive ephemeris files with my applications. So instead, I wrote a simple JSON api for dealing with ephemeris files.

Suppose one wanted to get the chebyshev coefficients for computing mercury's state for today's date (November 5th), the URL query would look like this:

http://www.astro-phys.com/api/coeffs?date=2011-11-5&bodies=mercury

Which would return a JSON object whose structure looks like this:

{
  "date": 2455870.5,
  "results": {
    {"mercury": {
      "coeffs": ...
      "start": 2455856.5,
      "end": 2455872.5
    }
  }
}

Where "coeffs" contains the chebyshev coefficients for evaluating the state of mercury between the julian dates 2455856.5 and 2455872.5

To simplify it even further, you can grab the state of mercury at 9:30am on November 5th 2011 by using this url:

http://www.astro-phys.com/api/states?date=2011-11-5+9:30am&bodies=mercury

Which would return:

{
  "date": 2455870.89583,
  "results": {
    "mercury": [
      [30007449.557, -50119248.882, -29922524.4351],
      [2879610.10503, 2030853.04543, 786401.74378]
    ]
  }
}

Where the first array in "mercury" is the position vector (x, y, z) and the second array is the velocity vector (vx, vy, vz)

Multiple planets can be entered, comma-separated.

Applications requiring entire ephemeride records can use this:

http://www.astro-phys.com/api/records?date=2011-11-5+9:30am

This will give you...

{
  "date": 2455870.89583,
  "start": 2455824.5,
  "end": 2455888.5,
  "results": {
    "mercury": [
      [...]
    ],
    ...
  }
}

Where date is the date asked for, start is the beginning of the record and end is the end of the record. "results" contains every ephemeris body mapped to a list of its coefficient chunks for that record.

The ephemeris being used is DE406 for the time being, though I may add others later (and a backwards compatible means of specifying).

It doesn't include the full date range of DE406 yet, it only contains dates between 2000-2200 (I'll be adding more as needed, if you request a range increase it will probably be granted).

To see a web application using it in action, visit http://www.astro-phys.com and click "start" (its streaming the records to evaluate positions for the planets, the interface can be dragged and zoomed with the mouse).

Lastly, the constants section of the ephemeris is also available from the url

http://www.astro-phys.com/api/constants

When querying for coefficients, you can't ask for earth or moon directly. You have to use "earthmoon" (the earthmoon barycenter) and "geomoon" (the geocentric moon) and compute their states from those. However, when querying for "states", astro-phys does this for you.

PS: All api queries can also take a '&callback=somefunction' to be treated as jsonp. This works great with jquery's getJSON

Here's an example using jQuery.getJSON (note, when date is missing the current time is assumed)

var url = 'http://www.astro-phys.com/api/states?callback=?';
$.getJSON(url, {bodies: 'mercury'}, function(data) {
  var p = data.results.mercury[0];
  var v = data.results.mercury[1];
  alert('Position:\nx='+p[0]+'\ny='+p[1]+'\nz='+p[2]);
  alert('Velocity:\nx='+v[0]+'\ny='+v[1]+'\nz='+v[2]);
});

Davy's law

2011-05-14T05:43:00.000-07:00

Davy's Law: Computers can't compute/predict themselves.

No physical computer is capable of losslessly determining it's effect on every state in it's state space by means of internal simulation. That is, the only way it can accurately achieve the result of a state is by actually being put into that state.

The limiting factor here is the necessity of storing the entirety of it's state AND its rule set within it's alloted state (with room to spare for performing computation). This would be in violation of the pigeonhole principle's effect on lossless compression. Not to mention that if it were possible, it could simulate it simulating it simulating it... And unless it can solve the halting problem, that's probably just not a good feature for a system to have.

Davy's law does not prohibit computers from computing with isolated portions of it's state. It also does not state that there aren't some global state computations that are possible. That is, some states can be losslessly compressed and manipulated in this form. Rather it postulates that a computer cannot compute the results of every state for it's entire state space.

Naive Bayes (and author detection)

2011-04-28T03:02:00.000-07:00

I've been playing around with various classification algorithms lately, so I wrote a really simplified discrete naive bayes classifier in Python. No emphasis on sample correction, simplicity was key here, but it still works quite well.

from operator import itemgetter
from collections import defaultdict

class BayesClassifier:

  def __init__(self):
    self.total_count = 0                # Observations of individual attributes
    self.class_count = defaultdict(int) # Observations of cls
    self.attrs_count = defaultdict(int) # Observations of (cls, attrs)
    self.correction = 0.0001            # Prevent multiplication by 0.0

  def train(self, cls, attrs):
    ''' Add observation of 'attrs' as being an instance of 'cls' '''
    self.class_count[cls] += 1
    for attr in attrs:
      self.attrs_count[(cls, attr)] += 1
      self.total_count += 1

  def rate(self, cls, attrs):
    ''' Return probability rating of 'attrs' being an instance of 'cls' '''
    result = float(self.class_count[cls]) / self.total_count
    for attr in attrs:
      result *= self.attrs_count.get((cls, attr), self.correction)
    return result / pow(self.total_count, len(attrs))
      
  def classify(self, attrs):
    ''' Return most likely class that 'attrs' belongs to '''
    rated_classes = [(self.rate(cls, attrs), cls) for cls in self.class_count]
    rated_classes.sort(key=itemgetter(0), reverse=True)
    return rated_classes[0][1]

Playing around with it I used various spam/not-spam training sets and various categorical training sets. Attributes can be labeled by the user instead of just "bag of words" lists by tagging the values in the attrs list, such as ['weekday:wed', 'weather:sunny', 'humidity:high']. Likewise, positional attributes can easily be tagged with their index ['0:this', '1:works', '2:well']. Its trivial to write a function that turns lists, objects, dicts, data models into such tagged attribute lists.

But playing with the algorithm in its "bag of words" form, I thought it would be neat to see how it does with authorship detection. Using an approach similar to spam/not-spam I trained it to classify quotes by author based on word and punctuation probabilities. In this example it parses brainyquote.com to train from the first pages of quotes by a given author, then tests the classifier with known quotes that weren't included on the first page. In a real world scenario, you'd want to train it with a much larger corpus, but in this case it works fairly well.

Here is it learning to classify between Richard Dawkins, George W Bush, and Charles Dickens :) (yes, I chose them for word contrast)

from urllib import urlopen
from BeautifulSoup import BeautifulSoup

def getwords(text):
  ''' Split text into words and useful punctuation tokens '''
  import string
  text = text.replace("'", '')
  # Remove useless punctuation
  for c in string.punctuation:
    if c not in '.,;?!':
      text = text.replace(c, ' ')
  # Keep useful punctuation
  for c in '.,;?!':
    text = text.replace(c, ' puncuation:%s ' % c)
  text = text.lower()
  return [str(word) for word in text.split() if len(word) > 3]

def getquotes(author):
  ''' Return list of quotes by author from brainyquote.com '''
  base_url = 'http://www.brainyquote.com/quotes/authors/%s/%s.html'
  soup = BeautifulSoup(urlopen(base_url % (author[0], author)).read())
  td = soup.find('td', {'align': 'left', 'valign': 'top', 'width': 440})
  quotes = []
  for quote in td.findAll('span', {'class': 'body'}):
    quotes.append(quote.string)
  return quotes

bayes = BayesClassifier()

# Train bayes with quotes by author
for author in ['richard_dawkins', 'george_w_bush', 'charles_dickens']:
  for quote in getquotes(author):
    bayes.train(author, getwords(quote))

test_data = [
  ['Bush',
   "Government does not create wealth. The major role for the government is to create an environment where people take risks to expand the job rate in the United States."],
  ['Dawkins',
   "There may be fairies at the bottom of the garden. There is no evidence for it, but you can't prove that there aren't any, so shouldn't we be agnostic with respect to fairies?"],
  ['Dickens',
   "I have known a vast quantity of nonsense talked about bad men not looking you in the face. Don't trust that conventional idea. Dishonesty will stare honesty out of countenance any day in the week, if there is anything to be got by it."],
]

# Test bayes with untrained quotes
for author, quote in test_data:
  guess = bayes.classify(getwords(quote))
  print 'Classified as %s, should be %s' % (guess, author)

Python musical update

2010-10-19T10:58:00.000-07:00

Based on my procedural music project I had been working on here. I've made some improvements. Abstracted the playback some, can now play through numpy, oss, or pyaudio. The plan is to default to the best playback method, right now it just uses the first one that seems available. I did this because I got dozens of complaints about using just pyaudio. Can save audio to wave files, other formats would be nice but are not worth my time right now. It's got a few example files to give some idea of usage, but no documentation.

Google code project page is up: http://code.google.com/p/python-musical/

Download link: http://python-musical.googlecode.com/files/python-musical.tar.gz

Examples include:
arpeggiated chord progression
randomly generated lead (with chorus effect)
basic example of waveform generating

If you want to take a listen without running it, I saved the audio output of examples 1 and 2...
Example-01.wav
Example-02.wav

My new musical instrument: Python

2010-09-30T14:06:00.000-07:00

It's still very young, but here is the library I've been working on for generating music in (nothing but) Python. "test.py" is an example of what you can do. The real purpose isn't to code your music out this way, it's intended as a backend for generating / manipulating music. My end goal is a tab-based editor that plays back with this, but I'm going to keep working on this backend and hope some brave snake wrestler comes along and has the itch to write a proper interface (and if that doesn't happen, I'll start on the interface when I feel satisfied with the backend).

The Timeline and Hit classes are just ideas right now. I'm not sure they'll stay in the form they are (I'm thinking a guitar-oriented timeline, holding fret/string/amplitude per hit, is more along the lines of what I need).

I'm also on the hunt for efficient numpy/scipy implemented effects and sound sources. I've been playing around some with generating Karplus-Strong pluck sounds and delay/chorus/flanger effects, but I'm not exactly satisfied with the sound and runtime efficiency of what I have.

Be sure to check out the "minor" scale version of this "major" progression.

Also be sure to let me know if you have any advice on optimizing (without jumping into the C just yet) or creating a better code interface / representation of these concepts.

Procedural music with PyAudio and NumPy

2010-09-21T21:48:00.000-07:00

Combining two of my favorite pastimes, programming and music... This is the hacky "reduced to it's basic components" version of a library I've been working on for generating music and dealing with music theory.

Tweaking the harmonics by changing the shape of the harmonic components and ratios can produce some interesting sounds. This one only uses sine waveforms, but a square / saw generator is trivial with numpy.

It takes a second to generate, so don't turn your volume up too loud in anticipation (it may be loud).

import math
import numpy
import pyaudio
import itertools
from scipy import interpolate
from operator import itemgetter


class Note:

  NOTES = ['c','c#','d','d#','e','f','f#','g','g#','a','a#','b']

  def __init__(self, note, octave=4):
    self.octave = octave
    if isinstance(note, int):
      self.index = note
      self.note = Note.NOTES[note]
    elif isinstance(note, str):
      self.note = note.strip().lower()
      self.index = Note.NOTES.index(self.note)

  def transpose(self, halfsteps):
    octave_delta, note = divmod(self.index + halfsteps, 12)
    return Note(note, self.octave + octave_delta)

  def frequency(self):
    base_frequency = 16.35159783128741 * 2.0 ** (float(self.index) / 12.0)
    return base_frequency * (2.0 ** self.octave)

  def __float__(self):
    return self.frequency()


class Scale:

  def __init__(self, root, intervals):
    self.root = Note(root.index, 0)
    self.intervals = intervals

  def get(self, index):
    intervals = self.intervals
    if index < 0:
      index = abs(index)
      intervals = reversed(self.intervals)
    intervals = itertools.cycle(self.intervals)
    note = self.root
    for i in xrange(index):
      note = note.transpose(intervals.next())
    return note

  def index(self, note):
    intervals = itertools.cycle(self.intervals)
    index = 0
    x = self.root
    while x.octave != note.octave or x.note != note.note:
      x = x.transpose(intervals.next())
      index += 1
    return index

  def transpose(self, note, interval):
    return self.get(self.index(note) + interval)


def sine(frequency, length, rate):
  length = int(length * rate)
  factor = float(frequency) * (math.pi * 2) / rate
  return numpy.sin(numpy.arange(length) * factor)

def shape(data, points, kind='slinear'):
    items = points.items()
    items.sort(key=itemgetter(0))
    keys = map(itemgetter(0), items)
    vals = map(itemgetter(1), items)
    interp = interpolate.interp1d(keys, vals, kind=kind)
    factor = 1.0 / len(data)
    shape = interp(numpy.arange(len(data)) * factor)
    return data * shape

def harmonics1(freq, length):
  a = sine(freq * 1.00, length, 44100)
  b = sine(freq * 2.00, length, 44100) * 0.5
  c = sine(freq * 4.00, length, 44100) * 0.125
  return (a + b + c) * 0.2

def harmonics2(freq, length):
  a = sine(freq * 1.00, length, 44100)
  b = sine(freq * 2.00, length, 44100) * 0.5
  return (a + b) * 0.2

def pluck1(note):
  chunk = harmonics1(note.frequency(), 2)
  return shape(chunk, {0.0: 0.0, 0.005: 1.0, 0.25: 0.5, 0.9: 0.1, 1.0:0.0})

def pluck2(note):
  chunk = harmonics2(note.frequency(), 2)
  return shape(chunk, {0.0: 0.0, 0.5:0.75, 0.8:0.4, 1.0:0.1})

def chord(n, scale):
  root = scale.get(n)
  third = scale.transpose(root, 2)
  fifth = scale.transpose(root, 4)
  return pluck1(root) + pluck1(third) + pluck1(fifth)

root = Note('A', 3)
scale = Scale(root, [2, 1, 2, 2, 1, 3, 1])

chunks = []
chunks.append(chord(21, scale))
chunks.append(chord(19, scale))
chunks.append(chord(18, scale))
chunks.append(chord(20, scale))
chunks.append(chord(21, scale))
chunks.append(chord(22, scale))
chunks.append(chord(20, scale))
chunks.append(chord(21, scale))

chunks.append(chord(21, scale) + pluck2(scale.get(38)))
chunks.append(chord(19, scale) + pluck2(scale.get(37)))
chunks.append(chord(18, scale) + pluck2(scale.get(33)))
chunks.append(chord(20, scale) + pluck2(scale.get(32)))
chunks.append(chord(21, scale) + pluck2(scale.get(31)))
chunks.append(chord(22, scale) + pluck2(scale.get(32)))
chunks.append(chord(20, scale) + pluck2(scale.get(29)))
chunks.append(chord(21, scale) + pluck2(scale.get(28)))

chunk = numpy.concatenate(chunks) * 0.25

p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paFloat32, channels=1, rate=44100, output=1)
stream.write(chunk.astype(numpy.float32).tostring())
stream.close()
p.terminate()

The scale in use is Harmonic Minor.
It's encoded via halfsteps as: "[2, 1, 2, 2, 1, 3, 1]"
Try changing it to natural minor: "[2, 1, 2, 2, 1, 2, 2]"

I'd be interested in teaming up with anyone willing to write some actual input methods (matrix sequencer, tab reader, however else it could be done) as well as an interface for tweaking synthesized sounds. My present code base is a bit much for a blog post, so contact me if interested.

Javascript insort function

2010-09-09T18:06:00.000-07:00

I recently had the need for some sorted insertion in Javascript arrays, thought I'd share this tiny bit of code:


Array.prototype.bisect = function(x, lo, hi) {
  var mid;
  if(typeof(lo) == 'undefined') lo = 0;
  if(typeof(hi) == 'undefined') hi = this.length;
  while(lo < hi) {
    mid = Math.floor((lo + hi) / 2);
    if(x < this[mid]) hi = mid;
    else lo = mid + 1;
  }
  return lo
}

Array.prototype.insort = function(x) {
  this.splice(this.bisect(x), 0, x);
}

Of course, these methods only work on an already sorted (or empty) array, so if you're using them on an array that came from elsewhere, sort it first. But once sorted, these insertions will maintain the sortedness, no need to 'push' and 'sort' every time you need to insert something into a sorted array.

(lo and hi parameters are optionally possible for the bisection method to allow restricted searches)

The names behind the languages

2009-02-22T14:45:00.000-08:00

If we're going to continue to spill blood in these language wars, it's important that we all know who our generals are (and who our enemy generals are). Feel free to offer corrections or extensions to the list.

C - Dennis Ritchie

C++ - Bjarne Stroustrup

Forth - Charles H. Moore

Lisp - John McCarthy

Perl - Larry Wall

PHP - Rasmus Lerdorf

Python - Guido van Rossum

Ruby - Yukihiro Matsumoto

Tcl - John K. Ousterhout

Venn Diagrams with google charts

2009-01-19T20:31:00.000-08:00

I recently had the need to view some data sets as venn diagrams, so I found google's chart api and hacked out a little AJAX application to do so, you can try it out here. And, for the fun of it, a VERY simple Python implementation:


import urllib
from PIL import Image
import StringIO

def venn_diagram_url(a, b, c, width=400, height=200):
   values = [width, height, len(a), len(b), len(c)]
   values.append(len(a & b))
   values.append(len(a & c))
   values.append(len(c & b))
   values.append(len(a & b & c))
   base_str = 'http://chart.apis.google.com/chart?'
   args_str = 'cht=v&chs=%sx%s&chd=t:%s,%s,%s,%s,%s,%s,%s'   
   return base_str + (args_str % tuple(values))
  
a = set((1, 2, 3))
b = set((2, 4))
c = set((3, 4, 5))

data = StringIO.StringIO(urllib.urlopen(venn_diagram_url(a, b, c)).read())
Image.open(data).show()

Not much to it... But maybe someone will find it useful.

Trampolining for recursion...

2008-11-25T08:27:00.001-08:00

In essence, CPS (continuation passing style) is a method of calling functions where instead of returning a value, you pass the results to another function (the continuation) provided as an argument. I wont go too deep into the reasoning behind this, as it's usually not used directly but rather as a middle representation of programming languages by some compiler/interpreter (read more on the wikipedia link).

The big downside is that you're bombarding the stack with function frames for every call, going deeper and deeper, but never returning (you just keep passing what would be the return value to another function).

One nifty method of avoiding this is to use a trampoline. A trampoline resembles a stream/lazy-list to anyone who's read SICP. Essentially, instead of calling functions from within another function, you return a bounce "call" to the trampoline which makes the call for you, doing the same with the return value of that call until it gets a land (a non-bounce return). This avoids the use of the stack for function calls, but allows you to use function closure as a means of saving state.

That being said, here is a simple trampoline implementation in Python showing a recursive fibonacci function implemented in CPS:

class Call:
  def __init__(self, fn, *args, **kwargs):
    self.call = lambda: fn(*args, **kwargs)

def trampoline(obj):
  while isinstance(obj, Call):
    obj = obj.call()
  return obj

def fibonacci(k, n):
  if n < 2:
    return Call(k, n)
  def with_a(a):
    def with_b(b):
      return Call(k, a + b)
    return Call(fibonacci, with_b, n - 1)
  return Call(fibonacci, with_a, n - 2)

call = fibonacci(lambda x: x, 20)

print trampoline(call)

Here is a normal fibonacci function, memoized, that fails due to exceeding Pythons recursion limit. The problem being, of course, that you have to recurse down deep enough to use the leaf calls to accumulate to the trunk:

def memoized(func):
  cache = {}
  def decorator(*args):
    if args not in cache:
      cache[args] = func(*args)
    return cache[args]
  return decorator

@memoized
def fibonacci(n):
  if n < 2:
    return n
  return fibonacci(n - 2) + fibonacci(n - 1)
print fibonacci(1000)

Here, however, is essentially the same function (memoized) implemented using a trampoline. The trampoline allows it to "recurse" all the way to the leaf calls because the calls are actually being made external to the function and state is being preserved in the with_a/with_b closures:

def kmemoized(func):
  cache = {}
  def decorator(k, *args):
    if args in cache:
      return Call(k, cache[args])
    def with_value(value):
      cache[args] = value
      return Call(k, value)
    return Call(func, with_value, *args)
  return decorator

@kmemoized
def fibonacci(k, n):
  if n < 2:
    return Call(k, n)
  def with_a(a):
    def with_b(b):
      return Call(k, a + b)
    return Call(fibonacci, with_b, n - 1)
  return Call(fibonacci, with_a, n - 2)

Practical for typical application development? Probably not...

A neat concept to play around with (or an interesting strategy at generating Python code)? Definitely!

(Somewhat) related wikipedia articles: continuation, functional-programming, tail-call-optimization, thunk, closure

Python: know when to be lazy

2008-08-06T14:00:00.000-07:00

Lazy is good. One Python trend I've noticed quite a bit is the severe under-usage of generators. I often see list comprehension being used in situations where building a temporary list is not only wasteful, but more work.

Example:


print sum([x * 2 for x in something])

In this case, LC is being used to build a temporary list whose only purpose is to be iterated by "sum". Instead of constructing this list, why not pass an iterable object to "sum" and have it accumulate the sum from that? Well, not only can you, but it's even less to type (a whopping two characters less):


print sum(x * 2 for x in something)

Simply excluding the square brackets takes it from a list-comp to a generator expression, which is lazily evaluated. To demonstrate, proof that generators don't actually compute anything until they are pulled:


def f(x):
    print x

a = [f("LC") for x in xrange(10)]
b = (f("GE") for x in xrange(10))

print "outside"
b.next()

print "outside"
b.next()

So naturally, these can be a really useful and compact way to transform a sequence. But the generator-expression syntax doesn't really allow for very complex stuff... Lucky Python also supports generator functions using the "yield" keyword that allows you to lazily preserve state between calls to "next"


def powersof2():
    x = 1
    while True:
        yield x
        x *= 2

g = powersof2()
print g.next()
print g.next()
print g.next()

And then, another thing I see is similar use of the map, filter, zip functions, which here in Python2.5 land return an entire list (this won't be an issue in Python3, however). For the time being, if you need a lazy map/filter, either use generator expressions or use the itertools module


from itertools import imap, ifilter

def even(x):
    return not(x % 2)

print sum(ifilter(even, imap(int, "1 2 3 4 5 6 7 8 9".split())))

In this case, the imap/ifilter works better than generator expressions (IMO) because of the need for the strings as integers in the "even" function. With GE I'm forced to either call the int function twice, or to break it up across lines:


print sum(int(x) for x in "1 2 3 4 5 6 7 8 9".split() if even(int(x)))
# OR
ints = (int(x) for x in "1 2 3 4 5 6 7 8 9".split())
print sum(x for x in ints if even(x))

But, since this is lazy, the filtering is done as the mapping takes place (neither are bundled into any temporary lists or anything)

Likewise, using "range" instead of "xrange" for integer iteration is also a wasteful practice (this will be fixed in Python3 as well).

To wrap it up, just for fun (no practical value to a Python coder at all), how would you make a lazy sequence in Python if it didn't support generators or iterators? The way the lisp gods did before us... (lazy cons streams)


def fibonacci(a=0, b=1):
    return (a, lambda: fibonacci(b, a + b))

def take(n, seq):
    if n:
        return (seq[0], lambda: take(n - 1, apply(seq[1])))

def lmap(f, seq):
    while seq:
        yield f(seq[0])
        seq = apply(seq[1])

print sum(lmap(int, take(1000, fibonacci())))

(I know, I cheated with the lmap function, but Pythons recursive limit makes it a bit impractical)

GAE: Batch operations

2008-07-23T12:56:00.000-07:00

Given the limit on individual requests with GAE, doing things like batch updates to your database (live) can be an interesting challenge. I recently had to update all of the votes for Challenge-You! to support a new rating system. The best approach I found was an AJAX-style solution. Have one request that returns a list of references to the entities you need to change (or if you're working with more than 1000 entities, you might want to partition the list into chunks by date or some other order, and work with one chunk at a time). Keeping those references in a stack in Javascript, pop them off one-by-one and send each to the controller that applies the change, repeating until the stack is empty. If the operations aren't too expensive, you could even send a handful of them per-request to speed things up. It's also trivial to implement some kind of progress bar or other graphical update to keep you informed.

And example of the Javascript code (using jQuery) that handles the client side:

var data = null;

function doupdate() {
    if(data.length == 0) return;
    $.ajax({
        type:"POST",
        url:"doupdate",
        data:"id=" + data.pop(),
        success:function(msg) {
            setTimeout(function() {
                doupdate();
            }, 1000);
        }
    });
}

$(document).ready(function() {
    $.ajax({
        type:"POST",
        url:"getlist",
        data:"",
        success:function(msg) {
            data = msg.split(" ");
            doupdate();
        }
    });
});

In this example, my site would have two urls for handling this, "getlist" which returns a space-delimited list of references/ids (however you're handling the entities) and "doupdate" which takes in one reference and applies the needed change.

Speed kiddies

2008-07-20T11:18:00.000-07:00

Speed kiddie:

Someone who learns or uses a low-level (often compiled) language for the constant coefficient performance increase. These people often have no regards for computational complexity and are usually confused by asymptotic notation. They frequently suffer from severe cases of premature optimization and believe that manageability comes second to runtime speed (in all applications). You can often find them trolling around web-forums bragging about their pointer or bit manipulation skills (the code is generally characterized by non-reusable design and a significant lack of readability).

Examples:

"What do you mean my algorithm runs at O(n!)? It's twice as fast as yours with this small test set"
"How do you write efficient code in Python... It doesn't even have pointers!"
"I don't need to write readable code, I'm not going to forget my own code..."
"High level languages are for the weak, real men enjoy pain... PAIN!!!"
"Lisp doesn't offer anything new to me, C has macros too!"
"RAWRRR POOINTERRRZZZ!!!!!!!!!!!!!!!!!!"

Javascript == bad

2008-01-13T19:15:00.000-08:00

Along the way while writing Epy, I've noticed some things about Javascript (a language I once considered perfectly reasonable) that are in serious need of a revamp (at least at the time of writing this). Here are just a few of the (many) issues I have with Javascript:

Namespaces. In the world of most Javascript, everything is global or function-scope, there seems to be no use of namespace or module-style development at all. It's possible to simulate namespaces by wrapping entire modules in an object definition, but this is usually too much of a hassle for practicality.
Objects. Javascript's object system is, well, crap. Sure, it's ad-hoc like Python, but it has no formal way of creating simple constructors. You can use the "this" object in a function, or create a new instance of "Object" to append methods to, but there are no standards for constructing an object.
Objects do not support destructors. Many might argue that a memory-safe language like Js doesn't need them, but destructors have more use than freeing memory. They serve a very useful purpose in a lot of OO designs, memory-safe or not.
Javascript does not support associative arrays! You can use the "Array" object, or even the "Object" object to assign associative values to using the index operators, but this is deceiving... Any time you use "obj['index'] = something" you could replace it with "obj.index = something" which causes major problems with naming collisions. This style of object/hashtable is bad, there should be a clear distinction between the two.
Javascript is not cross-browser compatible... Don't get me started...

Yet Javascript remains at the heart of our internet! Projects like Epy could help to solve some of these problems by abstracting away the issues allowing you to develop your client-side scripting in a more pleasant syntax (such as Python). But maybe someday we'll just use another language all-together :)