Un riassunto del talk di Cuong Do su come fa YouTube a scalare

<http://kylecordes.com/2007/07/12/youtube-scalability/>

Il Sun, 15 Jul 2007 10:16:30 +0000, Matteo Bertini ha scritto:

Python ha un debugger integrato.
Non occorre lanciare l'applicazione "dentro" un debugger esterno.

On Jul 15, 12:16 pm, Matteo Bertini wrote:

Buonasera,
vorrei (per la prima volta) creare, con distutils, una distribuzione
per un mio programma, ma non ho ben chiaro come dichiarare il "proprio
albero di sorgenti" in setup.py (neanche dopo aver letto "distribuire
moduli Python"!). La mia applicazione consta di più moduli
(distribuiti in più cartelle tutte allo stesso livello), i quali
moduli (eccetto quello principale) sono condivisi da altri miei
programmini. Non c'è una directory principale del package che li
contiene tutti, infatti le directory che li contengono hanno questa
semplice struttura:

uliano ha scritto:

Premetto che l'ho usato per piccole cose, ma il parere è favorevole.
Considera che per anni avevo usato java RMI per fare (quasi) le stesse
cose, in modo _decisamente_ più complesso, ed ero arrivato ad odiarlo.

Pyro secondo me ha tre vantaggi fondamentali:
1. è semplice da configurare e usare (e ben documentato);
2. è molto elastico nella gestione di tutto ciò che riguarda la rete (al
contrario di RMI, dove solo per cambiare le porte si deve accendere un
cero a qualche divinità voodooo);
3. permette di affiancare due name server, in load balancing, nel caso
uno si blocchi.

Poi se hai qualche dubbio specifico, basta chiedere.

Ciao,
Paolo

Ciao,

vi sottopongo un problema difficile, di cui ho parecchi indizi, ma NON
la soluzione.

Devo congelare un programmino per Windows (e successivamente per Linux)
realizzato con PyGTK + Kiwi, e ho deciso di utilizzare PyInstaller
anziché Py2Exe, perchè mi piace di più, e i suoi "makefile" sono facili
da rendere cross-platform.

Problema: la riga "import kiwi" impedisce ai programmi di avviarsi!
Commentandola in un programma di test, l'eseguibile congelato parte
perfettamente.

Secondo me, il problema sta nel fatto che non ci sono "import hooks" per
Kiwi, che utilizza 3 volte __import__:

in kiwi.environ.py (linee 220 e 226)
in kiwi.python.py (linea 74)

Inoltre, la funzione "_is_frozen()" di kiwi.environ.py richiederebbe
(forse?) una piccola modifica per funzionare con PyInstaller.

Pubblico infine le righe di warning relative a Kiwi, estratte dal file
di warning generato da PyInstaller al momento del congelamento di un
eseguibile:

-------------------------------------------------------------------------
W: no module named kiwi.ValueUnset (top-level import by kiwi.ui.proxywidget)
W: no module named kiwi.ValueUnset (top-level import...

Stavo leggendo una discussione su Slashdot, il cui tema e' il seguente:

"Spesso si sente dire che il codice del programma X o Y e' un casino, ma
raramente si sente dire che il codice del programma Z e' un controesempio
di bello stile. E allora, quale e' un esempio di codice ben scritto, sia a
livello di architettura che di implementazione?"

Qualcuno e' intervenuto scherzando, e portando come esempio "Hello world"!
:)

Pero' questo mi ha fatto venire in mente un paio di domande che vorrei
rivolgere a voi Pythonisti:

1. Se "Hello world" e' l'archetipo del primo programmino (un po' come le
vocali sono le prime lettere che si insegnano al bimbo che impara a
scrivere), quali sono gli archetipi dei successivi programmini
(l'equivalente delle prime paroline che i bimbi imparano a scrivere)?

2. Quale e' un software ben scritto per Python (possibilmente non troppo
complesso nelle cose che fa)?

Ciao, Fabio.

sto quasi per imbarcarmi in un impresa "disperata" e questo python
remote objects potrebbe, a una prima lettura della documentazione, darmi
qualche chances in piu', solo non vorrei spenderci troppo tempo per poi
scopirre che' e' una ciofega...

Dopo il PyCon di Firenze e il PgDay di Prato, non ho resistito e mi sono
tuffato in plpython (python come linguaggio procedurale in postgresql).

Ho "scoperto" una cosa interessante, con plpython posso versionare le
mie procedure! Creo una funzione che importa un modulo da filesystem, e
quindi versiono la procedura, senza noiosi "CREATE OR REPLACE", yuppie!

Prima di decantare le lodi di questo approccio volevo limare alcuni
aspetti. Io uso il debugger veramente di rado, ma se uno volesse
debuggare una procedura scritta in plpython come potrebbe fare?

plpython gira nel processo di potgresql (credo) quindi non è possibile
usare un qualsiasi approccio che prevede di lanciare l'applicazione
"dentro" il debugger.

Mi viene in mente di creare un breakpoint che tira su un server e
aspetta... credo sia una delle opzioni del debugger di komodo...

C'è qualcosa del genere (magari libero) già pronto?

Ciao,
Matteo

Ciao,
sto convertendo del vecchio codice Java in cui effettuavo un'operazione
di questo tipo:
(level & CONSTANT) > 0
che mi restituiva un booleano.
level rappresenta un generico valore espresso come somma di potenze di
due (es. 9=2^3+2^0); CONSTANT è la particolare potenza di due che sto
cercando.
Entrambi sono di tipo int.
Se non ricordo male la stessa cosa la facevo in C, ma son passati decenni.

Mi chiedevo se/come effettuare la stessa operazione di confronto in
Python, ho provato con vari operatori (and, &, > , __cmp__) ma non ho
risolto.

Grazie anticipatamente, ciao,
Paolo