enquesta, tennis, PubSub, pubsubhub, PubSubHubbub

6 set 2009 per Prashant ·

En cas que es mostren escèptics, hi ha un mètode en la bogeria més amunt, en el títol del post. En els cercles de tecnologia, és poc probable que vostè no ha sentit parlar de PubSubHubbub. En ràpides mesos, ha estat un dels tres va parlar de les coses. Dos de ser xifrat homomórfico i Google d'ona [ 1. ]. Tornant al lloc actual - els termes en el títol d'indicar com obtenir el contingut d'altres persones. Següents dades sigui més clar, si t'imagines les coses que succeeixen pel que fa als blocs, tot i que no estan conceptualment limita als blocs.

Sondeig fa a la situació en què els clients segueixen preguntant al servidor si alguna cosa nova ha arribat. Amb quina freqüència per demanar canvis sempre serà un problema amb les enquestes molt freqüents o poc freqüents també, però com un lector va assenyalar aquí que una cosa gran, amb les enquestes és que el servidor no ha de mantenir l'estat.

Ping es refereix al cas en que quan es publiqui un article, vostè (o el seu programari) també actualitza algunes populars (central) els serveis d'actualització. Una mica d'història aquí .

El següent és PubSub que significa de publicació / subscripció, un dels primers terreny de joc ja que es va fer aquí per Evan Henshaw-Plath i Kellan Elliott-McCrea (72 diapositives, però val la pena anar a través). Exemple convincent que va donar contra l'era això - en una data determinada, es va arrossegar Flickr Friendfeed 2,9 milions de vegades per obtenir les últimes fotos de 45,754 usuaris, dels quals 6.721 havien visitat Flickr a les 24 hores i podria haver "potencialment" ha pujat una foto. Tingueu en compte que el que proposava no era una nova tecnologia, com ells assenyalen "nova i revolucionària tecnologia de 20 anys d'edat". Si ho fas per als blocs, a continuació un dels principals problemes amb XMPP - la presència de sobrecàrrega de dades, que pot ser tan alta com el 60-70% es pot reduir molt.

pubsubhub significa publicar centre de subscripció i PubSubHubbub és un protocol, el nucli és la idea de pubsubhub. Els editors en la qual (diuen els blocaires) actualitzar el centre dels quals (pot haver més d'un els centres, que parlen l'un a l'altre) es troba "en algun lloc del núvol", segons el protocol es pot empènyer o tirar d'acord amb el protocol, però el següent baula de la de la cadena, el centre al client (per exemple els lectors) que es busqui sempre el model. Aquesta pàgina és un bon punt de partida per PubSubHubbub, diapositives visió general són bones. Sempre eloqüent Anil Dash es descriu aquí , com botó de web.
Dos lectures relacionades són webhooks que és bàsicament devolucions de trucada de http. Github utilitza ell, el mateix passa amb PayPal per notificacions asíncrones de pagament en el IPN . El mateix passa amb molts altres. Concepte relacionat és RSSCloud que és una altra vegada centre de PubSub. Seguiu aquest enllaç per més detalls.

Vostè podria preguntar-se quin és el punt d'escriure tot això aquí, hi ha dos 1. Aquestes són les coses és important conèixer, com a mínim, si més no i 2. Aquest bloc és PubSubHubbub permès ara a través del centre appspot ús d'aquest wordpress plugin de alimentació i també és habilitat a través de FeedBurner PubSubHubbub, enllaç aquí
-
[ 1 ]. - Bona lectura introductòria per al xifrat complet homeomorfo és l' article de Bruce Schneier i la conversa és més o menys l'única font per a Google Wave.

-ACTUALITZACIÓ - Aquest missatge s'explica com l'exigència de devolució de trucada per al servidor públic es pot treballar al voltant dels clients d'escriptori mitjançant l'ús de passarel · XMPP (per PubSubHubbub).

Etiquetes: optimització de l'alimentació , PubSubHubbub , l'alimentació en temps real , rss

Una mica d'acoblament

29 agost 2009 per Prashant ·

Mira els comentaris de

Comentaris
Filed under: la tecnologia

Després de llegir aquest article sobre tampons de bloqueig lliures i veient l'ús de CAS (comparar i intercanviar), em vaig sentir com alliberar el codi en assemblador per fer el mateix. El cas d'ús sobre el que havia d'escriure un mètode natiu i en diuen de Java (de nou en 1,5, quan les estructures de dades concurrents en Java eren més o menys inexistent). Sense més preàmbuls, vaig a alliberar el codi en què . En primer lloc és per al CAS i el segon és per a la informàtica GCD utilitzant l'algorisme d'Euclides (aquest es pot trobar a molts llocs i tutorials, així).

Donat les instruccions de gcc file_name.c ; ./a.out

Compara i Swap

   # Include 
  # Include 
 / / Canvi - nuevovalor, comperand és vell / valor esperat
 / *
  * Funció que realment fa el següent - si el valor a * dest és igual a oldValue continuació, substituir-la per una altra nuevovalor deixar-ho com està: fer tot això de forma atòmica
  *
  * Hi ha dues opcions per al valor de retorn
  * El valor inicial de 1.is * dest i deixar la càrrega de la FXN trucant al comparar-lo amb OLDVAL
  * 2.  fer-ho aquí i tornar 0 o 1, això ha de ser més eficient
  ** /

 / * Després es convertirà en macro * /
 ques int (int * dest, int oldValue, int nuevo_valor) {
	 printf ("(% d,% d,% d)", * dest, oldValue, newvalue);
	 / * Int CAS (int dest, int oldValue, int nuevo_valor) {* /
	 / * Int CAS (int dest, int nuevovalor, int oldValue) {* /
	 int resultat = 1 ;/ * 1 mostra que el CAS va tenir èxit i 0 mostra que van fallar * /
	 / * Per cert necessitat d'establir cc per apallissar la bandera!  * /
	 __asm__ volatile__ __ (
			 "Movl% 2,%% eax \ n \ t"
			 "Movl% 3,%% ebx \ n \ t"
			 "0 movl%,%% ECX \ n \ t"
			 "Lock \ n \ t"
			 "CmpXchg ebx%%, (%% ECX) \ n \ t" / * ha de tancament pot ser en la mateixa línia * /
			 "FET jz \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "FET: \ n \ t"
			 : "= M" (destí), "= g" (resultat)
			 : "G" (oldValue), "g" (nuevo_valor), "m" (destí)
			 : "% Eax", "% ebx", "ECX", "CC"
			 );
	 printf ("(% d,% d,% d)", * dest, oldValue, newvalue);
	 return resultat;
 }

 / * TOT
  * Escriure altre FXN asm que posa per sobre de FXN en un bucle while i seguir intentant si no aconsegueix * /

 int main () {
	 int a = 5, b = 6;
	 int * c = (int *) malloc (sizeof (int));
	 * C = 6;
	 / * Int c = 6; * /
	 printf ("% d \ n", CAS (c, b, b));
	 printf ("% d \ n", CAS (c, b, a));
	 printf ("% d \ n", CAS (c, a, a));
	 printf ("% d \ n", CAS (c, b, b));
	 * C = 6;
	 / * C = 5; * /
	 printf ("valor de canvi de c * a% d \ n", * c);
	 printf ("% d \ n", CAS (c, b, b));
	 printf ("% d \ n", CAS (c, b, a));
	 printf ("% d \ n", CAS (c, a, a));
	 printf ("% d \ n", CAS (c, a, b));
	 printf ("% d \ n", CAS (c, b, a));
	 return 0;
 }

Notes de format - sembla marcador wp sintaxi és l'addició de al final, ignorar això.

GCD

 # Include 
 int mcd (int a, int b) {
     int resultat;
     / * Calcular màxim comú divisor mitjançant l'algorisme d'Euclides * /
     __asm__ volatile__ __ ("movl% 1,%% eax;"
                           "Movl% 2,%% ebx;"
                           "Cont: CMPL $ 0,%% ebx;"
                           "Je Fet";
                           "Xorl%% EDX,%% EDX;"
                           "Idivl%% ebx;"
                           "Movl% ebx%,%% eax;"
                           "Movl%% EDX, ebx%%;"
                           "JMP cont;"
                           "FET: movl%% eax, 0%;": "= g" (resultat): "g" (a), "g" (b)
     );

     return resultat;
 }

 int main () {
     int primer segon,;
     printf ("Introduïu dos enters:");
     scanf ("% d% d", i en primer lloc, i segon);

     printf ("El MCD de% d &% d és% d \ n", primer, segon, mcd (primer, segon));

     return 0;
 }

Tags: muntatge , c , CAS , comparar i intercanviar , mcd

robins per crear un revestiment de hash

20 agost 2009 per Prashant ·

Mira els comentaris de

Comentaris
Filed under: la tecnologia

Ahir, mentre passava per un dels meus vells programes, vaig trobar aquest escrit per mi fa algun temps:
#begin magic hash=Hash[*CGI.unescape(raw_text).split('&').map{|x| b=x.split("=");b.push(nil) if b.size==1;b}.flatten] #end magic
Per matar a alguns de suspens que em revelen que raw_text sembla

, A la dreta que s'ha reduït de reconeixement de pagament de PayPal.

Per sobre de la línia en cas de trencament de les peces es llegeix millor:

  unescaped_array = CGI.unescape (raw_text). split ('&')
   unescaped_array unescaped_array.collect = {| x | b = x.split ("="); b.push (zero) si b.size == 1, b}
   flattened_array = unescaped_array.flatten
   hash = hash [* flattened_array]

Farem els passos individuals a l'IRB:

  IRB (main):. 009:0> = unescaped_array CGI.unescape (raw_text) split ('&')    

 => ["Èxit", "mc_gross = 10,00", "protection_eligibility = no elegible", "payer_id = U7PPJJ4TSJ47E", "impostos = 0.00", "payment_date = 09:45:30 10 juliol 2009 PDT", "payment_status = Pendent "]                                                                         

 IRB (main): 013:0> = unescaped_array unescaped_array.map {| x | b = x.split ("="); b.push (zero) si b.size == 1, b}  

 => [["Èxit", nil], ["mc_gross", "10.00"], ["protection_eligibility", "no elegible"], ["payer_id", "U7PPJJ4TSJ47E"], ["impost", "0,00"] , ["payment_date", "09:45:30 10 juliol 2009 PDT"], ["payment_status", "Pendent"]]                               

 IRB (main): 014:0> = flattened_array unescaped_array.flatten     

 => ["Èxit", nul · la ", mc_gross", "10.00", "protection_eligibility", "no elegible", "payer_id", "U7PPJJ4TSJ47E", "imposat", "0,00", "payment_date", "09:45: 30 de 10 juliol 2009 PDT "," payment_status "," Pendent "]
 IRB (main): 015:0>
 hash = hash [* flattened_array]
 => {"Impost" => "0,00", "payment_status" => "Pendent", "payer_id" => "U7PPJJ4TSJ47E", "mc_gross" => "10,00", "l'èxit" => nil ", payment_date" = > "09:45:30 10 juliol 2009 PDT", "protection_eligibility" => "no elegible"}

Per cert, * es diu operador de splat en Ruby

Una altra forma de crear hash a partir de "matriu de parells" és l'ús de la injecció:

  hash = [[1,2], [3,4]] injectar ({}). {| resultat, l'element | resultat [element.first] = resultat [element.last];} resultat

Hi ha una manera més Escriure un bucle, que vaig a deixar com un exercici per als lectors!

Aquest és un cas poc ús sense relació de la creació de hash a partir de les matrius:

  IRB (main): 005:0> [1,2,3,4,7,9] group_by {| x | x <5.?  : Menor :: major}

 => {: Menor => [1, 2, 3, 4],: major => [7, 9]}

Pot fer més coses, bàsicament resultat de l'illa s'utilitza com a clau d'aquest element en el hash resultant.

Tags: group_by , injectar , robí

gmail, mutt i msmtp solució

17 agost 2009 per Prashant ·

Mira els comentaris de

Comentaris
Filed under: la tecnologia

Si utilitzeu mutt i smtp per accedir a Gmail. Aquesta és una notícia (dolenta). Nois cool de Google va tornar a canviar de certificat. Ah, li pregunto - ¿com s'ho coneixerà? Mutt simple va començar a queixar-se de certificat no vàlid en intentar utilitzar msmpt, infame "msmtp: la verificació de certificats TLS ha fallat:. El certificat no té un emissor conegut ' em va saludar a la pantalla.

Per creuar confirmar -
Només ha d'executar després de
$ msmtp --serverinfo --host=smtp.gmail.com --tls=on --port=587 --tls-certcheck=off
En lloc de Servidors Thawte vell et després en el segment d'emissor
Issuer: Common Name: Google Internet Authority Organization: Google Inc Country: US

Afortunadament solució és simple, això és el que ha de fer en debian
# apt-get install ca-certificates # dpkg -s ca-certificates|grep Version Version: 20090814

Després d'això només canviar la línia següent en vostè ~ /. Msmtprc
tls_trust_file /certs/Thawte SSLWeb Server Roots/thawte Premium Server CA/Thawte Premium Server CA.pem tls_trust_file /certs/Thawte SSLWeb Server Roots/thawte Premium Server CA/Thawte Premium Server CA.pem
a
tls_trust_file /usr/share/ca-certificates/mozilla/Equifax_Secure_CA.crt

Tags: gmail , msmtp , mutt , tls

La fusió dels hashes dels arxius de conf YAML

31 juliol 2009 per Prashant ·

Mira els comentaris de

Comentaris
Filed under: la tecnologia

YAML és molt útil per escriure fitxers de configuració. Principal avantatge és que, es llegeix com a fitxer de text. Això funciona molt bé si el seu fitxer de configuració és plana (sense jerarquia) i no té repeticions.
Si el seu fitxer de configuració té repeticions, llavors té sentit per separar els elements i tornar a usar-los. El que vull dir és això - diguem que el seu arxiu de configuració és la següent:

  el desenvolupament:
   input_location: common_input
   output_location: dev_location
   mail:
     smtp_server: su_servidor
     d'inici de sessió: your_login
     contrasenya: top_secret
 producció:
   input_location: common_input
   output_location: dev_location
   mail:
     smtp_server: su_servidor
     d'inici de sessió: your_login
     contrasenya: top_secret

Suposant que el codi anterior a / tmp / test.yml aquí és com es pot llegir en Python i Ruby
$cat readyml.py

 #! / Usr / bin / python env
 pprint d'importació pprint com pp
 # Debian al d'instal · lar python-YAML
 de la càrrega d'importació YAML, load_all, bolcat
 hash = càrrega (open ('/ tmp / test.yml'))
 pp (hash ['desenvolupament'])

$ cat readyml.rb

  #! / Usr / bin / env ruby
 requereix 'pp'
 hash = YAML :: load (File.open ('/ tmp / test.yml'). llegir)
 pp hash ['desenvolupament']

aquí hi ha una mà un traçador de línies de la versió de Ruby
$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]' o pots intentar el mateix a l'IRB o la consola de python.

Tingueu en compte que en el fragment de codi anterior, tot és diferent d'ubicació de sortida és la mateixa en el desenvolupament i la part de producció. Aquí és on identificador de node yml ve a rescatar. La idea és senzilla té un conjunt de valors predeterminats i reemplaçar ells en lloc diferent.
Vostè podria separar-la de la següent manera:

  per defecte i per defecte:
   input_location: common_input
   output_location: dev_location
   mail:
     sender_name: emissor
     smtp_server: su_servidor
     d'inici de sessió: your_login
     contrasenya: top_secret
 el desenvolupament:
   <<: * Els valors per defecte
 producció:
   <<: * Els valors per defecte
   output_location: prod_location

$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]["mail"]["login"]' "your_login" $
Gran, que funciona (tm)!.
Es podria dir que negocien una mica de claredat a una mica de màgia. Aquí hi ha una petita explicació: &, * i <<: i que és etiqueta d'ancoratge pot ser entès com a identificador de node, * és la referència de node i <<: és sinònim de fusió de hash.

Per a més detalls vegi bé les especificacions YAML o wikipedia
Fins aquí tot bé, però hi ha un problema aquí, aquestes fusions hash no són recursius. El que significa és el següent: diguem que vostè vol ser el nom del remitent per al correu diferents en dos ambients, vostè pot estar temptat a fer el següent:

  per defecte i per defecte:
   input_location: common_input
   output_location: dev_location
   mail:
     sender_name: emissor
     smtp_server: su_servidor
     d'inici de sessió: your_login
     contrasenya: top_secret
 el desenvolupament:
   <<: * Els valors per defecte
   mail:
     sender_name: sender_dev
 producció:
   <<: * Els valors per defecte
   output_location: prod_location
   mail:
     sender_name: sender_prod

Permet comprovar
$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]["mail"]["login"]' nil $

Vaja, alguna cosa va sortir malament, el problema com es va esmentar anteriorment és que la combinació hash no és recurrent i si bé la fusió del reemplaçar de correu electrònic per defecte per correu de la producció que té una sola clau. Solució / s treball al voltant de desenrotllar un nivell més:

  common_settings: & common_settings
 input_location: common_input
 output_location: dev_location
 mail_defaults: & mail_defaults
  sender_name: emissor
   smtp_server: su_servidor
   d'inici de sessió: your_login
   contrasenya: top_secret

 per defecte i per defecte:
   <<: * Common_settings
   mail:
     <<: * Mail_defaults
 el desenvolupament:
   <<: * Els valors per defecte
 producció:
   <<: * Els valors per defecte
   mail:
     <<: * Mail_defaults
     sender_name: sender_prod

Anem a comprovar de nou
$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]["mail"]["login"]' "your_login" $
Sabia vostè que tens un nivell de més d'implantació, així que definitivament es pot desenrotllar un nivell més, però llavors es converteix en un desastre. Per tant, si vostè no està tractant d'escriure la solució a les torres de Hanoi en un arxiu de conf, és millor restucture conf a cavar en YAML o alguna altra cosa. Però això és la crida de totes maneres.

Tags: YAML

Una mica de redirecció de shell

10 maig 2009 per Prashant ·

Mira els comentaris de

Comentaris
Filed under: la tecnologia

Així és com ho fem normalment la redirecció de shell
$ ./pgm.sh args >out.txt 2>err.txt
Jo volia que modificar una mica i executar de la manera
$ ./pgm.sh args
amb el requisit que la producció i l'error ha d'anar a tenir el nom a l'interior pgm.sh calcula sobre la base d'arguments. Un cas il · lustratiu podria ser quan la data és part de args. Així que li agradaria stdout per anar a dir / seu / directori / pgm_out_YYYYMMDD.txt 1

El problema amb el mode estàndard per reorientar N>file.txt és a dir, l'associació de descriptor de fitxer en al fitxer.txt, és que funciona només per al procés de nova forma de forqueta i no per al procés actual.
tan
$ echo hi 1>out.txt ; echo hii . enviarà hola a out.txt, però s'imprimirà HII a la sortida estàndard 2

Aquí és on exec ve al nostre rescat. Si a això afegim exec 1>somefile.txt llavors la sortida de la resta de la seqüència de comandaments anar a algun_archivo.txt
$ cat test.sh #!/usr/bin/env bash exec 1>out.txt echo hi echo hii $. / Test.sh redirigirà alta, així com a la HII out.txt

Igual que redirigir stdout stderr, així com farem alguna cosa com això
cat test2.sh exec 1>out.txt exec 2>err.txt echo out text echo 1>&2 err text somenoneexitent command ls -ld /tmp
Ara que s'acosta de nou al punt original de tornar a dirigir a algun arxiu des de l'interior de la closca, diguem que el programa calcula el nom de l'arxiu en alguns outfile variable, podríem haver fet exec 1>$OUTFILE

Això resol el problema actual. Però vostè pot tenir gust d'anar a través de l'exemple següent, que aconsegueix el "accés aleatori" de l'arxiu de script de shell. Exemple és de aquí
echo 1234567890 > File # Write string to "File". exec 3<> File # Open "File" and assign fd 3 to it. read -n 4 <&3 # Read only 4 characters. echo -n . >&3 # Write a decimal point there. exec 3>&- # Close fd 3. cat File # ==> 1234.67890
Amb els comentaris, aquest codi és autoexplicatiu.
-
1 També es pot fer per $ ./pgm.sh args >pgm_out`date +%Y%m%d` però la idea és generar aquest nom de fitxer basat en una lògica en el programa en si.
2 1 gen> out.txt és redundant, però aclareix que aquí estem redirigint FD 1

Etiquetes: Bash , Linux , l'script de shell

Per escalar o no escalar a

11 gener 2009 per Prashant ·

Mira els comentaris de

Comentaris
Filed under: la tecnologia

En parlar de divisió horitzontal de bases de dades, DHH de ROR fama suggereix això l'ampliació pot esperar, sens dubte esperar fins al punt de les seves necessitats empresarials ho requereixin. El seu article definitivament té sentit per a les configuracions dels petits diuen que recentment s'inicien. No vol dir que en l'arrencada has d'escriure programes de demostració, però tenint en compte que només hi ha 24 hores en un dia en què s'ha de centrar en servir a dir que 1000 usuaris d'una forma més satisfactòria que perdre el son per preocupar per com va la meva sol · licitud de manejar la càrrega dels 13.142.000 usuaris. Si vostè rep els molts usuaris sabran com escalar. Per escalabilitat startups és un bon problema per resoldre un problema, però molt millor tenir, em refereixo a qualsevol posada en marxa li encantaria trobar-se amb aquest problema!

En un altre relacionat amb l'article de Jeremy Zawodny escriu no ha de dependre de el Sr Moore, si vostè té problemes d'escalabilitat.

Com que aquests articles es refereixen a la llei de Moore no puc deixar d'escriure que la llei de Moore ha de ser un de la llei més generalitzada en Ciències de la Computació. A partir del seu predicció original sobre la densitat de transistors, aquesta llei està citat arreu et trobes amb un creixement exponencial.

Tags: enllaços i tecnologia