user@mypc: /usr/local/games/supermeatboy
➜  ./SuperMeatBoy 
Super Meat Boy: Installed in '.'.
Super Meat Boy: Using x86 version.

Fatal Error: MojoShader compile failed!

So how to fix this?

First thing I started googling i I stumbled upon couple of links: Bug #905456 in mesa (Ubuntu): “needs to be built with –disable-asm for super meat boy to work” and explanation (on German but i translated it) SuperMeatboy und Intel-Grafik. It turns out Super Meat Boy Linux port has some kind of problems with integrated Intel graphics cards (which I have in my laptop). So after reading links above for some reason Mesa must be built with h “–disable-asm” switch. So I wanted to do the same on OpenSUSE 12.1, and here is guide how to do this:

Download Mesa srpm from Mesa srpm

$ unrpm Mesa-7.11-11.1.2.src.rpm
$ sudo zypper in build

Open up Mesa.spec and change following line in %install part of spec

%configure --disable-glw \

to :

%configure --disable-glw \
           --disable-asm \

after that you can just do:

user@mypc: /home/user/mesa/rpm
➜  sudo build

If everything goes without problems you will probably get rpm that you can update over existing Mesa. By default built rpm should be at:

/var/tmp/build-root/home/abuild/rpmbuild/RPMS/i586

I had some problems during building of rpm, I have got following error message:

expanding package dependencies...
Warning: distribution not specified, assuming '12.1-i386' (see /usr/lib/build/configs).
expansion error
  nothing provides libgcc45
  nothing provides gcc45
  nothing provides cpp45
  nothing provides libstdc++45
  nothing provides libgomp45

It turns out you have to change /usr/lib/build/configs/sl12.1.conf following line:

%define gcc_version 45

to:

%define gcc_version 45

And line :

Preinstall: filesystem fillup glibc grep insserv libacl libattr

to

Preinstall: filesystem fillup glibc grep insserv libacl1 libattr1

And now you can play Super Meat Boy.

Što je sve potrebno:

• Rootani Android telefon (uputstvo kako root vaš telefon potražite u bespućima interneta uputstva ima na tone)
• Market Access tj market-enabler
• kreditna kartica za plaćanje (plaćanje se vrši preko Google Checkout računa koji će automatski biti kreiran)

Rootanje Andorid telefona neću objašnjavati jer se rootanje razlikuje za svaki uređaj. O prednostima i manama rootnja također možete pročitati na Internetu, ali pošto ovo čitate pretpostaviti ću da ste telefon rootali.

Nakon toga potrebna vam je aplikacija market-enabler, no ja sam koristio rewrite verziju MarketAccess. Skinite i instalirajte marketaccess.apk (morate imati omogućenu instalaciju aplikacija iz nepoznatih izvora Settings->Applications->Unknown sources će vam to omogućiti).

Nakon što ste instalirali MarketAccess, pokrenite ga i dobit će te slijedeći ekran:

Prvo napravite backup odabirom na Backup value koji se backupirati vaš originalni SIM value (da bi ste ga kasnije mogli restorati ako to poželite), a nakon toga odaberite tab Providers i iz njega odaberite nekog mobilnoga operatera iz zemlje u kojoj Android Market omogućava kupnju aplikacija. (Moja preporuka je neki iz SAD ili Njemačke, ali ovo nije bitno).

Nakon što ste odabrali nekog od operatora možete otići u Android Market i kupiti aplikaciju koju ste oduvijek željeli, a niste mogli kupiti već ste ju morali piratizirati.

Android Market određuje da li i koje aplikacije možete kupovati na temelju vašeg operatera, Market-enabler/MarketAccess radi na način da “glumi” neku SIM karticu prema Android Marketu, tako da Android Market misli da imate SIM karticu nekog operatera.

Ekvivalent tome je da ste nabavili SIM karticu iz Njemačke npr. i stavili u svoj telefon, opet biste mogli normalno kupovati aplikacije iz Marketa, tada ne biste morali niti rootati telefon.

Postupak dalje je trivijalan, odaberite aplikaciju koju želite kupiti, Android Market će vas prvi puta tražiti kreditnu karticu, unesite broj kartice i gotovo. Kupili ste aplikaciju.

Dobra stvar u cijeloj priči da kasnije ako telefon odrootate/updateate ili što god već, i nećete imati Market-enabler/MarketAccess instaliran, vaše kupljene aplikacije biti će dostupne za vas da ih skinete s Android Marketa. Ovo je isprobano i radi.

1

Resources.toString(new URL("[http://slavus.net")][],Charsets.UTF_8);

Go ahead and try out google-guava. Guava is great java lib.

So Eclipse started to become pretty unusable WTF. However for now there is simple workaround just edit your eclipse.ini like this:

-startup
plugins/org.eclipse.equinox.launcher_1.1.0.v20100507.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.1.0.v20100503
-product
org.eclipse.epp.package.jee.product
--launcher.defaultAction
openFile
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
--launcher.defaultAction
openFile
-vmargs
-XX:MaxPermSize=256m
-Dosgi.requiredJavaVersion=1.5
-Xms40m
-Xmx512m 

You have to add -XX:MaxPermSize=256m.

The most interesting thing about this is reason why this problem reappeared, an old problem actually.

The reason is because somebody at Eclipse team hard-coded to check jvm signature by checking the file jvm.dll if the company name is “Sun Microsystems”. And as we all know because of the Sun-Oracle merge, and end of Sun existence, the company name changed to “Oracle”, and also the jvm.dll signature changed. more about this read on link

What have we learned from this, never ever hard-code a string that can change in the future, even when it is not likely to change, maybe there is some kind of “Oracle” that will come and “buy your string”.

Ref:

http://aniefer.blogspot.com/2010/07/permgen-problems-and-running-eclipse-on.html

For example:

1
2
3
4
5
6

class SimpleForm(forms.Form):
    class Media:
        css = {
            'all': ('pretty.css',)
        }
        js = ('animations.js', 'actions.js')

Than you can do get javascripts and CSS, rendered simple with something like this:

1
2
3
4
5

>>> form = SimpleForm()
>>> print form.media
<link href="http://media.example.com/pretty.css" type="text/css" media="all" rel="stylesheet" />
<script type="text/javascript" src="http://media.example.com/animations.js"></script>
<script type="text/javascript" src="http://media.example.com/actions.js"></script>

Ok, that is really nice, but when you put your form in template than you get this html fragment in the middle of you html document, and that is not a good practice. A good recommendation is to put all your CSS in head of your document (for example in HEAD), and all your javascripts on end of your html.

So what do we want? We want to all our javascripts and CSS in a context variable so we can write a our base template like:

1
2
3
4
5
6
7
8
9
10
11
12

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  {\% for css in forms_css \%}  {\% endfor \%}
</head>
<body>
{ %block body\%} {\%endblock\%}
{\% for js in forms_js %}  {\% endfor \%}
</body>
</html>

With this template we get all our javascripts and CSS injected in html. Nice. But I don’t want to manually put my media files in context every time I want to render template, so I wrote a simple extension of Context (and RequestContext) class, that looks in a context dictionary and looks for any forms that are in it. And adds all javacripts and CSS to context variables forms_js (for javascript), and forms_css(for css).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class FormMediaContext(Context):
    '''
     Context that automaticly for all Forms in context adds
     media to context
    '''
    def __init__(self, dict=None, processors=None):
        Context.__init__(self, dict)

        contexts_values = []
        map(lambda d:contexts_values.extend(d.values()), self.dicts)
        forms_in_context = [ form for form in contexts_values
                             if isinstance(form, forms.Form)]
        forms_js =  []
        forms_css = []
        for form in forms_in_context:
            forms_js += [mark_safe(js) for js in form.media.render_js()]
            forms_css += [mark_safe(css) for css in form.media.render_css()]

        self.update({ 'forms_js' : list(set(forms_js)),
                       'forms_css': list(set(forms_css)) })

Or if you like RequestContext more (like I do), than you can use:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class FormMediaRequestContext(RequestContext):
    '''
     Context that automaticly for all Forms in context adds
     media to context
    '''
    def __init__(self, request, dict=None, processors=None):
        RequestContext.__init__(self, request, dict, processors)

        contexts_values = []
        map(lambda d:contexts_values.extend(d.values()), self.dicts)
        forms_in_context = [ form for form in contexts_values
                             if isinstance(form, forms.Form)]
        forms_js =  []
        forms_css = []
        for form in forms_in_context:
            forms_js += [mark_safe(js) for js in form.media.render_js()]
            forms_css += [mark_safe(css) for css in form.media.render_css()]

        self.update( { 'forms_js' : list(set(forms_js)),
                       'forms_css': list(set(forms_css)) })

Now all that you need to do is to render your template with FormMediaContext(or FormMediaRequestContext), and have now worries about your media files, if you have multiple entries of same file it will be rendered only once.

SyntaxError: Non-ASCII character '\xc4' in file

I know I have write first special comment, to tell Python I am writing in UTF-8., but I always forget what exactly I have to write. So here it is:

1

# -*- coding: utf-8 -*-

Ovdje ću opisati jedan kratki trik koji ja koristim da bi u svoj Django projekt ubacio neku od već gotovih Django aplikacija koje postoje u bespućima code.google.com i github-a.

Moja navika je sve dodatne aplikacije staviti u poseban direktorij lib izvan django projekta. No onda imam problem dodavanja skinutih aplikacija u PYTHONPATH. Prvobitno riješenje mi je bilo postaviti PYTHONPATH varijablu okoline ljusci. No ovaj pristup se pokazao nedvovoljno fleksibilan (neprenosivost putanja na različitim računalima, različite ljuske na različitim operacijskim sustavima).

Nakon nekoliko iteracija došao sam do relativno dobrog rješenja. U korijenskom direktoriju Django projekta napravim novu python datoteku, npr. python_path_for_libs.py, i u njega upišemo nešto slično ovome ispod:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from sys import path
from os.path import dirname, abspath
BASEDIR = abspath( dirname(__file__)+"/../../") + "/"

APP_DIRS = (
    # Put strings here like ''
    'django-debug-toolbar',
    'django_extensions',
    'django-evolution',
    'django-robots',
    'django-batchadmin',
)

for app_dir in APP_DIRS:
    if BASEDIR+'lib/'+app_dir not in path:
        path.insert(0, BASEDIR+'lib/'+app_dir)

E sad što tu imamo:

1
2
3
4
5
6
7
8

APP_DIRS = (
    # Put strings here like ''
    'django-debug-toolbar',
    'django_extensions',
    'django-evolution',
    'django-robots',
    'django-batchadmin',
)

APP_DIRS je popis direktorija koji sadrže aplikacije koje će biti ubačene u PYTHONPATH. Kao što vidimo ja ovdje koristim debug-toolbar , django_extensions koje bih preporučio svima. Nakon što podesite sve svoje aplikacije iz lib direktorija u APP_DIRS, sve što vam preostaje da na početak vaše settings.py datoteke dodate liniju:

1

import python_path_for_libs

I to je to, sve uredno radi.

Od zadnje objave vezije 0.96 promjenilo se dosta toga, a kako je 0.96 release objavljen skoro godinu dana ovaj release 1.0 se dugo čekao, a ljudi nestrpljivi, svi su korisitili trunk verziju koja je bila prihvatljivo stabilna.

E sad ljudi koji će prebacivati svoje postojeće projekte s vezije 0.96 na 1.0 imati će dosta posla, zbog Backwards Incompatible promjena, previše je da ih nabrajam pa za više detalja svratite na: http://code.djangoproject.com/wiki/BackwardsIncompatibleChanges.

Koje su se promjene dogodile od verzije 0.96 na 1.0 u brojkama:

• 4000 comitova na svn
• više od 2000 riješenih bugova
• 350 000 linija koda promjenjenih, dodanih ili obrisanih
• dodano 40000 linija dokumentacije

Sve ovo zvuči dosta impresivno no što od feature je dodano verziji 1.0:

• refactoring dokumentacije, posebno mi se sviđa da se konačno i offline može koristii - http://docs.djangoproject.com/
• refactoring admin aplikacije, ako ste koristili integriranu admin aplikaciju sad vam ne gine portanje, no stvar je dobro izvedena i sad je omogućena sitnija granulacija admin aplikacije i konačno je opis admin sučelja izdvojen iz opisa modela gdje mu nije bilo mjesto
• Poboljšana podrša za Unicode (iako niti do sada nije bila loša)
• Poboljšana ORM
• Automatskoiescaping template varijabli
• Dodan django.contrib.gis (GeoDjango) kao podršga za GIS(Geographic Information Systems).
• Podrška za Pluggable file storage, tako se sad FileField i ImageField može preusmjeriti na Amazonov S3 ili npr. FTP a ne kao do sada samo na lokalno računalo gdje se vrti Django instanca
• Django je kompatibilan sad i s Jython, no zašto bi ga netko vrtio na JVM-u?
• Generic relations in forms and admin
• Razlikovanje INSERT/UPDATE kod save() u nekom modelu
• sitnija granulacija CacheMiddleware što omogućuje bolje upravljanje cachom
• Refactorirani django.contrib.comments, moj omiljeni feature koji mi je zadavao najviše problema kod promjena na tranku, ako ste koristili stare komentare biti će potrebna migracija podataa
• uklonjeni deprecated dijelovi (npr. nema više oldforms)

Pošto sam pratio razvoj Djanga što mi se posebno svidjelo u 1.0 verziji

• newforms - super
• comments framework
• novi signali - pomoću njih se zgodne stvari mogu raditi
• refactoring dokumentacije me posebno oduševio, sad konačno mogu imati weblike dokmentaciju i lokalno i nemoram ići na web, malo mi je teško čitati RST

Stvari koje mi fale u 1.0(a nadam se pojaviti će se u 1.1):

• podrška za agregaciju u ORM, baš bezveze da nema te mogućnosti pa nemogu napraviti opibćan select SUM(polje) from table; već moram sam pisati svoj manager i SQL da mi to odvrti
• podršak za više baza, priča se da posotji low-level API koji čak i radi, ali nažalost nije nigdje dokumentiran, dok high level API ne postoji

Kao poklon na kraju link na django šalabahter: http://www.mercurytide.co.uk/media/whitepapers/django-cheat-sheet/django10-cheat-sheet.pdf

With PyDev and Aptana, another irreplaceable plugin(but that is another story), you can do great Django development.

There are lot’s of tutorial how to use Django and PyDev (Configuring PyDev to work with Django : configuring pydev to work with django is a good place to start).

One thing that is very nice in Django is interactive shell, but this feature must be integrated with IDE, I missed this feature for long time, but in version 1.3.15 PyDev released new interactive console, great feature. First you need PyDev version 1.3.15 or higher (try to use latest one).

You can start interactive console from Console View by clicking on the button Open Console(look picture below).

You will get a dialog asking for a type of console you want to open, select Python console and press OK.

That is it, you have now working python interactive console. Out of the box you get some nice features like autocompletition and syntax coloring. What we want do next is to have interactive console for Django.

Here is a little tutorial how take advantage of PyDev interactive console for Djagno shell.

1. Open Window–>Preferences…
2. In Preferences Window go to PyDev-> Interactive console

3.In initial interpreter command put following code:

1
2
3
4
5
6
7
8
9
10

import sys
from YOUR_OWN_PROJECT import settings
from django.core.management import execute_manager
execute_manager(settings,['','shell'])

import sys; print '%s %s' % (sys.executable or sys.platform, sys.version)
from django import get_version;print "Django version %s" % get_version()
from django.core.management import execute_manager
from slavus import settings
execute_manager(settings,['','shell'])

Where YOUR_OWN_PROJECT is the name of yours top level Django project. It is important to mention that if you have multiple Python/PyDev projects in your workspace you have to change your preferences configuration every time you want start interactive console for anathor project. After starting the shell, you will get output something like this:

1
2
3
4
5
6
7
8
9
10
11

import sys; print '%s %s' % (sys.executable or sys.platform, sys.version)
C:\Python25\python.exe 2.5.2 (r252:60911, Feb 21 2008, 13:11:45) [MSC v.1310 32 bit (Intel)]
from django import get_version;print "\Django version %s" % get_version()
\Django version 0.97-pre-SVN-7568
from django.core.management import execute_manager
from slavus import settings
execute_manager(settings,['','shell'])
>>> Python 2.5.2 (r252:60911, Feb 21 2008, 13:11:45) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>>

That is it, you have working Django interactive console. Now you can do things like this:

1
2
3

from slavus.article.models import Article
Article.objects.all()
[<Article: example1>,  <Article: example2>,  <Article: example3>]

But there is also autocompletition:

Enjoy!