1. Never try to understand a long piece of code (or a long program) in one go. Focus on a few statements at a time. If possible, try to take a smaller chunk of the code and run it yourself to see what it does. Experimenting is always good, even if it doesn’t work and you get weird error messages, you’ve learned something!

2. Try it yourself. Make sure you try out code examples for yourself (don’t just read about them). Trying something and running it, actually helps it stick in your head. Better yet, if you change things around to see what effect that has, you’ll learn and understand more.

3. If all else fails, sleep on it. Sometimes no amount of brain effort will get you past a difficult or complicated problem. Either you don’t understand something, or a piece of your code won’t work, and you can’t figure out why. If all else fails, try sleeping on it. Or, at the very least, leave it alone for a few hours, and come back to the problem later. When you come to something fresh, often the answer will appear.

4. Never type long sections of code directly into the Shell. In Python, either in the Shell (IDLE) or the Console, you can type and run statements directly and see what happens. But if you’re entering a longer program, either use a text editor or use the Shell’s editor (select File, then New in the Shell). That way you can save your file, run it, and come back and fiddle with the code without having to re-type everything.

5. Pick the right project. If you’re looking for something to put your new-found programming skills to use, don’t think Halo, or Uncharted, or Super Mario Galaxy or Assassins Creed. Don’t even think Angry Birds, or Pocket God, or Rolando. Think arcade games from the 1970’s and 1980’s—games like Galaxian, Centipede, Donkey Kong, and Frogger have simple graphics and basic game mechanics, which makes them great first projects for budding game developers.

Do an internet search for arcade games from that period. Take a look at some examples and then try to write something similar yourself. It’s much more satisfying to take a simple project and actually finish it, rather than a hugely ambitious, complicated project that you never get working.

About the Author

O scurtă istorie a Unicode și alte code-page-uri: http://coding.smashingmagazine.com/2012/06/06/all-about-unicode-utf8-character-sets/

Slider cu toate pozițiile Unicode: http://www.babelstone.co.uk/Unicode/unicode.html

Deosebiri importante intre JavaScript  (implementare W3C) si JScript (implementare Microsoft)

Cred că toţi programatorii web ştiu că există două tipuri de browsere: care se conformează cu standardele W3C (printre care Chrome, FireFox, Opera, Safari) şi care nu se conformează (în primul rând Internet Explorer sau IE).

Specificaţiile nu acoperă toate problemele apărute la implementarea limbajului ECMA-262 (altfel spus - JavaScript) în diferite medii. Pe lângă faptul că nu toate browserele se conformează cu acest standard, divergenţe apar şi în problemele asupra cărora specificaţiile nu se pronunţă în vreun fel.

Iată câteva dintre aceste divergenţe:

• elem instanceof Object;

În mediul JavaScript din browser există două clase mari de obiecte: DOM şi non-DOM. Obiectele DOM se mai numesc Elemente şi fac parte din structura documentului HTML. Obiectele non-DOM sunt toate celelalte obiecte, toate instanţe indirecte sau directe ale Object.

Apare o întrebare firească: Elementele (obiectele DOM) sunt instante ale Object sau nu?

Raspunsul la această întrebare depinde de mediul ales: IE sau non-IE. Elementele se comporta in toate privintele ca niste obiecte obişnuite (non-DOM), având şi ceva proprietăţi specifice. Deci logic ar fi să fie instanţe ale clasei Object.

Deci, în IE elementele nu sunt instanţe ale Object, şi în general nu sunt instanţe ale căreiva clase în sensul că elem instanceof X === false pentru orice element si orice clasa

• function x() {};
alert(x.name); // expected 'x', got undefined

Atributul "name" al obiectelor de tip Function nu este un standart ECMA-262, însă a fost introdus de către Mozilla şi acceptat de către toate browserele majore, desigur cu excepţia IE.

• var y = function z(){};
alert(typeof z); // expected undefined, got 'function'

În toate browserele typeof z == undefined, iar in IE typeof z == 'function'.
Acesta e un subiect mai vast. Expresia de mai sus se numește funcție expresie cu nume (named function expression).

Iată un articol care explică în detalii această problemă și altele similare: NFE.

• var y = function z(){ return z.proprietate; };
y.proprietate = 'test';
alert(z()); // Expected 'text', got undefined in IE

Cauza acestui bug e aceeași ca și în exemplul precedent, dar efectul e diferit. În IE y != z, adică avem două obiecte diferite în memorie. Acest fapt poate provoca probleme semnificative în anumite situații.

• var s = 'abcd'; 
alert(s[1]); // expected 'b', got undefined

În mod normal în toate browserele s[1] == 'b', cu exceptia IE până la versiunea 8, unde s[1] === undefined.

• var a = Array.prototype.slice('abcd');
alert(a);

Aceasta este o metodă eficientă de obţinere a obiectelor de tip Array din orice obiect ce conţine proprietatea 'length' (de ex. String).
Cu părere de rău nici în IE8 aceasta nu e o metodă în cazul String. În aces caz recomand 'abcd'.split('');

• var a = [1, 2, 3, 4, 5];
try{ alert(a.indexOf()); } // W3C
catch(e) { alert(e.description); } // IE

Obiectele de tip String au metoda indexOf. Însă cele de tip Array în IE nu au, deoarece IE foloseşte o versiune mai veche de JScript (1.3, ECMA-262 3rd edition).

• var x = 10;
function a(){ return x; try{}catch(x){} };
alert(a()); // Expected 10, got undefined

În browserele W3C a() === 10, însă nu şi în IE... Pentru simplul fapt că există catch(x), variabila x este redeclarata in scopul functiei a(), ca şi cum am avea declaraţia: function a(){ var x; return x; };

• window.b = 1;
var b = b || 2;

Nu am cercetat până la urma această situaţie, dar în unele imprejurări b == 2, deşi ar trebui sa fie 1.
Am avut o situaţie în care prima instrucţiune se efectua într-un fişier JS, iar a doua în alt fisier JS şi am obţinut efectul nedorit (în IE).

Recoman să cercetați tabelul de compatibilitate ES5

Operatorul '==' nu este tranzitiv!

Care este proprietatea tranzitivă a unei relaţii? Dacă '==' ar fi tranzitiv, ar satisface relaţiile: dacă a == b şi b == c, atunci a == c. 
Dar operatorul '==' nu este relaţie binară în sens matematic, ci este un operator al limbajului care în majoritate cazurilor se comportă ca o relaţie de echivalenţă.

Iată un exemplu ilustrativ:

<?php
var_export('' == 0);   echo '<br />'; // true
var_export(0 == '0');  echo '<br />'; // true
var_export('0' == ''); echo '<br />'; // false - surpriza :-)
?>

JavaScript:
console.log('' == 0);   // true
console.log(0 == '0');  // true
console.log('0' == ''); // false - surpriza :-)

Poate părea evident, dar iatăa incă un exemplu:

JavaScript:

var a = '', b = 0, c = '0';
console.log(a == b); // true
console.log(b == c); // true
console.log(c == a); // false - ai putea aștepta să fie true

Mai sunt și alte exemple care demonstrează acest lucru, așa că folosiți === când nu sunteți siguri.

Totuși atenție în JS:

NaN !== NaN

- - -

Sursa: http://www.w3.org/History/19921103-hypertext/hypertext/WWW/TheProject.html

Sursa: norvig.com

Funcţia strpos este foarte rapidă şi recomandată pentru căutarea unui subşir într-un şir.

Funcţia stripos este asemănătoare cu strpos, însă ignoră registrul literelor (majuscule/minuscule). Cât despre performanţă, nu e cea mai bună alegere... De ce?

Să vedem cum lucrează:

    $pos = stripos($str, $substr);

este echivalent cu:

    $str    = strtoupper($str);
    $substr = strtoupper($substr);
    $pos    = strpos($str, $substr);

Parcă nu se petrece nimic deosebit, însă în cazul când $str este destul de mare se pierde mult timp la convertirea în majuscule. Şi dacă stripos este apelată repetat pentru acelaşi şir $str, de fiecare dată se converteşte registrul şirului, deci se face acelaşi lucrul de mai multe ori şi în zadar.

De exemplu, să considerăm următorul cod:

<?php

    $t1 = microtime(1);
    $str = str_repeat('abcdefghijklmnopqrstuvwxyz', 1<<16); // se genereaza un şir de 1.7Mo
    echo strlen($str) . '<BR>';
    $sub = substr($str, rand(0, strlen($str)-10), 10); // un subşir aleator al str de lungimea 10
    for($i=0; $i<1000; $i++) stripos($str, $sub); // apoi sa incercati cu strpos
    echo $sub . '<BR>';
    $t2 = microtime(1);
    echo 'Executat in '. ($t2 - $t1) . ' sec.';

?>

Pe calculatorul meu personal acest cod s-a executat în aproximativ un minut. Însă cu strpos - 0.002 secunde, deosebire radicală!

javascript:(function(di,u,m){var R=0,a=.1,x=.05,b=.25,y=.24,c=1.6,z=.24,w=(screen.width>>2)+100,h=(screen.height>>2)+100,l=di.length,s,i; function A(){for(i=0;i-l;i++){s=di[i].style; s.position='absolute'; s.left=(m.sin(R*a+i*b+c)*w+w)+u; s.top=(m.cos(R*x+i*y+z)*h+h)+u;}R++};di&&setInterval(A,5);})(document.images,'px',Math);void(0);

Sper să-ți placă ;-)

HTML5 face revoluție pe web!

Recent am descoperit noi posibilități pe care le oferă HTML5, legate de editarea conținutului paginilor web. Nu vreau să descriu prea mult ce am descoperit. Vreau să vă convingeți singuri de puterea acestor noi tehnologii! Doar încercați să editați acest articol (să tapați ceva text sau să adăugați text prin copy&paste...).

 De asemenea vă recomand să vedeți și acest articol: „Editează orice pagină pe WEB!”

Ca să aveți cu ce vă juca, ceva text aici: 

Iată ce am făcut din google.md :-)

Simțiți-vă liberi să trageți imaginea de mai sus oriunde în cadrul acestui articol!

Deși inspirat din limbajul Java (care la rândul său este inspirat din C/C++), JavaScript (sau JS) are un mare plus de flexibilitate sintactică, dat fiind faptul că este un limbaj de tip script.

Iată un bun exemplu care îl face pe JS deosebit față de alte limbaje (chiar de timp script): operatorii logici „&&” și „||".

În limbajele tradiționale (C/C++, PHP, ș.a.) expresiile de genul „v1 && v2” sau „v1 || v2” se evaluează ca booleene (true sau false, 1 sau 0). E bine cunoscut faptul (cel puțin printre programatori) că orice valoare nenulă se evaluează ca true și orice valoare nulă (0, false, null, undefined, '') se evaluează ca false. Atunci de ce să forțăm expresiile de mai sus să se evalueze strict la aceste două valori booleene (true sau false)?! De ce să nu se păstreze valoarea inițială a operanzilor, care n-ar fi ea (null, undefined, '', <not nul>, ...).

Cred că ați prins firul, nu? JS așa si face, nu forțează pe nimeni și nimic, adică expresia „v1 && v2” ia valoarea „v1”, dacă v1 este o valoare nenulă și ia valoarea „v2”, dacă v1 e nul.

Exemplu:

var v = true && 'avioanele nu zboara';
alert(v); // v == 'avioanele nu zboara'
var u = true || 'avioanele zboara';
alert(u); // u == true
v = 123 && ''; // v == '', nu false, ci ''
u = 123 || ''; // u == 123, dar nu true
...


Folosind aceste proprietăți ale operatorilor logici specifice JS, putem emita operatorul ternar „?:” în felul următor:

Expresia „v1 ? v2 : v3” poate fi scrisă „v1 && v2 || v3”.

Dar atenție! Această emitație nu este identică cu operatorul ternar autentic. Iată cum se citesc expresiile de mai sus în limbajul omenesc:

„v1 ? v2 : v3” - dacă v1, atunci v2, altfel v3;

„v1 && v2 || v3” - dacă v1 și v2, atunci v2, altfel v3.

Ați prins firul? Sper că da!

După o mică analiză a ideilor și exemplelor expuse mai sus, conchidem că putem construi noi „operatori” logici în JS, care să răspundă necesităților noastre în fiecare situație concretă. Astfel putem scrie mai puțin cod și realiza mai multă funcționalitate - o trăsătură specifică JS și rar întâlnită în alte limbaje de programare.

Autor: Dumitru Uzun

Un program pentru calculator face ceea ce ii spui tu sa faca, nu ceea ce vrei tu sa faca.

La originea oricarei erori care este atribuita computerului vei gasi cel putin doua greseli umane, incluzand-o pe aceea de a da vina pe computer.

Erorile nedetectabile sunt infinite in varietate, spre deosebire de erorile detectabile care sunt limitate prin definitie.

Daca constructorii ar face constructiile in felul in care programatorii concep programe, atunci prima ciocanitoare care ar veni, ar distruge civilizatia.

Toate computerele asteapta cu aceiasi viteza.

Unul din motivele pentru care computerele pot sa faca mai multa treaba decat oamenii este faptul ca nu trebuie sa se opreasca pentru a raspunde la telefon.

Definitiile lui Murphy privind sistemele computerizate:
Hardware: Acele parti ale sistemului pe care le poti lovi cu piciorul.
Software: Acele parti ale sistemului care nu functioneaza.
Hard disk: Acea componenta a sistemului care intepeneste in momentul cel mai nepotrivit cu putinta.
Periferica: Acele componente care sunt incompatibile cu sistemul tau.
Imprimanta: Acea componenta a sistemului care se blocheaza cand nu te uiti la ea.
Cablu: Acea parte a sistemului care e prea scurta.
Backup: O operatie care niciodata nu este efectuata la timp.
Restaurare: O precedura care functioneaza perfect pana cand e nevoie de ea.
Memorie: Acea parte a sistemului computerizat care este insuficienta.
Mesaj de eroare: O solicitare de aprobare a distrugerii propriilor tale date.
Fisier: Acea parte a sistemului care nu poate fi gasita.
Procesor: Acea componenta a sistemului computerizat care este depasita tehnologic.

Un afisaj digital furnizeaza informatii gresite cu o precizie mai mare decat a fost posibil anterior.

Daca computerele devin prea puternice, le putem organiza intr-un comitet - asta o sa le termine.

Este mai usor sa adaptezi specificatia la program decat viceversa.

Nu exista limbaj in care sa fie cat de cat dificil sa se scrie un program prost.

Un computer face tot atatea greseli in doua secunde cat doi oameni care lucreaza in douazeci de ani.

Indiferent ce cauti pe internet, cel putin un site pornografic se va potrivi cu criteriile tale de cautare.

Inteligenta artificiala nu se poate compara cu prostia naturala.

Iata cum arata un șablon pentru articolele publicate aici.

Astfel se ajunge la înțelegere între programist și designer. Aceștia doi nu trebuie să se amestece unul în lucrul celuilalt, însă sunt nevoiți să colaboreze.

Designerul are grijă de aspectul exterior al informației și de structura ei (în pagină), iar programistul asigură ca informația din sistem (site) să ajungă în carcasa creată de către designer. Legătura dintre aspect și conținut se realizează în baza „constantelor” de tipul {NUME_CONSTANTĂ}. Acestea sunt înlocuite de către sistem (lucrul programistului) cu conținut relevant. Numele acestor „constante” poate fi oricare (îl definește fie programistul, fie designerul, dacă lucrează împreună la crearea sistemului).

La olimpiadă au participat studenții anilor 1, 2, 3 și 4.

Aceasta a fost prima olimpiadă de informatică la care am participat și eu :-)

Kids Math Software - 3D Shapes - Funny bloopers R us

În lumea POO (Programării Orientate pe Obiect) există două tipuri de limbaje:

1. Bazate pe clase,
2. Bazate pe prototipuri (de obiecte).

JS (JavaScript) este unul dintre cele mai vestite și cele mai folosite limbaje POO bazate pe prototipuri din lume (jumate din site-urile de pe web folosesc acest limbaj). Candva era un hobby, iar acum e un instrument indispensabil al programatorilor web. A devenit popular foarte repede tocmai pentru ușurința și puterea pe care o aduce unei aplicații web. Mulți acuză JS că îi lipsesc clasele. Aceasta de regulă o zic cei care n-au „gustat” din frumusetea și puterea acestui limbaj. Sau poate s-au deprins numai cu limbajele statice, bazate pe clase.

Pentru ce ar trebui unui limbaj dinamic, fără tipuri de date stricte ale variabilelor, să aibă clase. Clasele sunt tipuri de date, dar un limbaj bazat pe prototipuri are tot ce-i trebuie și fără clase; de altfel nu devenea atât de răspândit JS!

JavaScript 2 vrea să facă o revoluție în vechiul nostru JS 1. Adaugă clase și multe alte noțiuni străine unui limbaj bazat pe prototipuri. Se observă o tendință spre Java. 

Se pune întrebarea: Este nevoie de clase în JS?

Părerea mea este că nu avem nevoie de clase în JS, el se descurcă foarte bine și cu ce are! Clasele vor aduce numai dureri de cap. În loc să se introducă clasele în limbajul JS, mai bine s-ar scrie cărți cum de implementat funcționalitatea unui limbaj bazat pe clase în JS și despre specificul fiecărui tip de limbaje, ca să-i împăcăp pe toți, atât pe începători, cât și pe „veterani”.

Apreciați valoarea membrilor privați prin funcții închidere:

function Point(x, y) { // funcția constructor
  return {
    getX:  function () { return x },
    getY:  function () { return y },
    getXY: function () { return [x, y] }
  }
}
  for(var i = 101, a = []; i > 0; i--  )
     a[i] = new Point(i, i); // crearea obiectelor

  for(var i in a) with(document) {
     write(a[i].getXY());
     write('<BR />');
  }

Încercați așa ceva, de ex., în PHP !

Dar sunt și lucruri bune în JavaScript 2... Aici m-am referit doar la introducerea claselor.

Mai multe la acest subiect puteți citi și în engleză.

Autor: Dumitru Uzun