Jak wykrywać plagiaty? Część trzecia!

Dzisiaj będzie kontynuacja dwóch poprzednich wpisów (1 i 2) dotyczących sposobów wykrywania plagiatów. Dzisiaj będzie ostatni wpis z tej serii. Opiszę w nim kolejne 3 sposoby wykrywania plagiatów.

Systemy bazujące na analizie drzewa wyprowadzeń

Systemy opierające się na analizie drzewa wyprowadzeń wyszukują podobieństwa między programami poprzez wyszukiwanie identycznych lub podobnych poddrzew w drzewie wyprowadzeń.

System CloneDR

System CloneDR jest komercyjnym systemem stworzonym przez firmę Semantic Designs. Działanie systemu opiera się na sprowadzeniu kodu źródłowego programu do drzewa wyprowadzeń, a następnie każda para drzew dwóch programów jest testowana w 3 fazach:

  1. wykrywanie identycznych i bardzo podobnych powtórzeń poddrzew w badanych drzewach
  2. wykrywanie powtórzeń deklaracji w kodzie
  3. wykrywanie podobnych poddrzew, które nie zostały znalezione w pierwszej fazie

Na podstawie danych zebranych podczas tych trzech faz algorytmu system decyduje o prawdopodobieństwie zajścia plagiatu.

Systemy bazujące na analizie grafu zależności

Systemy opierające się na analizie grafu zależności opierają się na budowie i badaniu grafu zależności programów.

System GPlag

Analizowane dane w system GPlag są reprezentowane przez grafy zależności i przepływu danego programu.

Szukanie podobieństw polega na szukaniu izomorficznych podgrafów pomiędzy dwoma drzewami programów.

Systemy bazujące na aproksymacji złożoności Kołmogorowa

Podejście do wykrywania plagiatów poprzez złożoność Kołmogorowa stawia na szukanie podobieństw w ilości informacji niesionych przez program.

Teraz będzie ciężko…

Niech {\mu = (M_1,M_2,\ldots)} będzie ciągiem wszystkich maszyn Turinga zakodowanych za pomocą słów nad alfabetem {\{0,1\}}. Dla każdego słowa {x\in\{0,1\}^{*}} możemy zdefiniować jego złożoność Kołmogorowa względem {\mu} jako
{K_{\mu}(x)=min\{|M_{j}|:M_{j}(\epsilon)=x\}}

A co to znaczy bardziej po ludzku?

Intuicyjnie można powiedzieć, że złożonością Kołmogorowa jest wielkość najmniejszego ciągu, z którego można odtworzyć ciąg x.

Ideą działania systemów opierających się na aproksymacji złożoności Kołmogorowa jest znalezienie właśnie tej aproksymacji dla każdego programu poprzez kompresje danego ciągu.

W przypadku systemów do wykrywania plagiatów przez {K(x)} określa się długość mierzoną w danej jednostce (np. bajty) najkrótszego programu, który dla pustego wejścia zwróci na wyjściu x. Przez {K(x|y)} rozumie się warunkową złożoność Kołmogorowa. Określa ona ile nowych informacji wnosi napis x, w przypadku kiedy mamy już dany napis y.

Odległość między dwiema złożonościami Kołmogorowa jest definiowana jako:

{d(x,y) = 1 - \frac{K(x)-K(x|y)}{K(xy)}}, gdzie:
{K(x)-K(x|y)} określa ile informacji o słowie x znajduje się w słowie y.

System SID

Ideą działania algorytmu SID jest tokenizacja ciągu wejściowego, jego kompresja oraz przybliżenie złożoności Kołmogorowa.

Pierwszym etapem systemu SID jest zamiana kodu programu źródłowego na ciąg Tokenów przy użyciu parsera.

W kolejnym etapie ciąg tokenów jest poddawany silnej kompresji bezstratnej algorytmem TokenCompress. Twórcy systemu oparli swój algorytm kompresji na algorytmie LZ z pewnymi modyfikacjami. Istotne było uzyskanie jak największego stopnia kompresji, kosztem czasu kompresji.

Aproksymacja {d(x,y)} jest liczone w następujący sposób:
{d(x,y) = 1 - \frac{Comp(x)-Comp(x|y)}{Comp(xy)}}, gdzie:
{Comp(x)} jest skompresowaną wielkością słowa x.

Im obliczona wartość jest bardziej zbliżona do 0 tym odległość w sensie informacyjnym jest między programami mniejsza i tym samym jest większe prawdopodobieństwo, że programy są do siebie podobne.

Podsumowanie

Tak jak wspomniałem we wstępie, wpisem tym kończę przegląd istniejących sposobów wykrywania plagiatów. Z wszystkich wymienionych sposobów wybiorę jeden i będę starał się go zaimplementować, a następnie przetestować w praktyce 🙂

Ile on waży?!

Czy zastanawialiście się kiedyś jak dużo pamięci zajmują obiekty w Javie? Dużo osób pewnie nigdy się nad tym nie głowiło, a przynajmniej nie przed pierwszym OutOfMemoryError 😉

W tym wpisie postaram się pokazać w jaki sposób oszacować wielkość obiektów, które tworzymy w Javie.

Typy prymitywne

Niewątpliwie najłatwiej jest określić ilość pamięci zajmowanej przez typy prymitywne. Poniżej przedstawiam tabelkę, która pokazuje ile każdy z typów potrzebuję bajtów w pamięci.

Typbajty
boolean1
byte1
char2
int4
float4
long8
double8

Ilość pamięci potrzebnej do przechowywania booleana może trochę dziwić. W końcu może on przyjąć tylko dwa wartości i w teorii powinien zajmować 1 bit. Specyfikacja JVM nie definiuje ile pamięci jest potrzebne na przechowanie booleana i zależy to od danej implementacji. Dla uproszczenia możemy śmiało przyjąć, że jest potrzebny 1 bajt.

Reszta wartości wydaję się być w miarę oczywista 🙂

Tablice

Każda tablica zajmuje wielokrotność danego typu (co wydaję się oczywiste ;)) oraz dodatkowe 24 bajty, które są narzutem tablicy. Poniżej przedstawiam tabelkę z przykładami, które powinny wszystko wyjaśnić.

Typbajty
byte[]N + 24
char[]2N+24
int[]4N+24
double[]8N+24

Obiekty

I teraz przechodzimy do mięsa tematu  – czyli jak oszacować wielkość obiektu naszej klasy.

Aby to zrobić potrzebujemy kilku dodatkowych informacji.

Narzut obiektu

Każdy obiekt, podobnie jak tablica, powoduje dodatkowy narzut pamięci. W tym przypadku jest to 16 bajtów.

Referencja

Każda przetrzymywana referencja w naszym obiekcie to dodatkowe 8 bajtów.

Padding

Wielkość każdego obiektu jest uzupełniana do wielokrotności 8 bajtów.

Praktyka 🙂

Jako przykład weźmy klasę String. Poniżej przedstawiam wycinek implementacji tej klasy, który jest potrzebny do oszacowania wielkości obiektu.

Do obliczenia potrzebujemy zsumować kilka rzeczy:

  1. Narzut obiektu – 16 bajtów
  2. Referencja do tablicy – 8 bajtów
  3. Tablica – 2N + narzut tablicy 24 bajty
  4. Pole offset – 4 bajty
  5. Pole count – 4 bajty
  6. Pole hash – 4 bajty

Zsumowując wszystko wychodzi nam 2N + 60 bajtów. W takim przypadku musimy jeszcze pamiętać o paddingu, czyli dodajemy 4 bajty, aby całkowita wielkość obiektu była wielokrotnością 8.

Podsumowanie

Powyżej przedstawiłem ogólne zasady, których możemy użyć, aby oszacować wielkość naszych obiektów w Javie. Dzięki temu możemy lepiej zrozumieć co jest alokowane w pamięci i jaki rozmiar zajmuje.

Jak wykrywać plagiaty? Część druga!

W jednej z poprzednich notek opisałem metody służące do wykrywania plagiatów, które bazują na zliczaniu atrybutów. Dzisiaj postaram się opisać i przedstawić systemy bazujące na metrykach strukturalnych.

Systemy bazujące na metrykach strukturalnych

Techniki wykrywania plagiatów opierające się na metrykach strukturalnych polegają na badaniu podobieństwa na podstawie podobnych lub identycznych fragmentów w badanych plikach. Poniżej opiszę kilka najpopularniejszych systemów służących do wykrywania plagiatów w kodach źródłowych programów, które bazują na metryce strukturalnej.

Dotplot

Metoda Dotplot jest wizualną metodą znajdującą pasujące do siebie fragmenty tekstu (w szczególnym przypadku kodu źródłowego). Decyzja o plagiacie jest podejmowana przez użytkownika analizującego otrzymane wizualne wyniki. Autor systemu uważa, że właśnie dzięki powierzeniu decyzji o plagiacie człowiekowi można zdecydowanie podwyższyć próg skuteczności znajdowania plagiatów. System działa w następujący sposób:

  • tokenizacja wejścia
  • konkatenacja tokenów z programu A i programu B
  • przedstawienie wyników w postaci graficznej

Aby lepiej pokazać działanie algorytmu, poniżej pokażę przykład działania algorytmu.

Ciągi wejściowe:

  • Ala ma kota
  • Kot ma na imie ala

Przebieg algorytmu:

  • tokenizacja: ala{\diamond}ma{\diamond}kota, kot{\diamond}ma{\diamond}na{\diamond}imie{\diamond}ala
  • konkatenacja: ala{\diamond}ma{\diamond}kota{\diamond}kot{\diamond}ma{\diamond}na{\diamond}imie{\diamond}ala
  • wyniki w graficznej formie:
    alamakotakotmanaimieala
    alaXXXXXX
    maXXXXXX
    kotaXXX
    kotXXX
    maXXXXXX
    naXXX
    imieXXX
    alaXXXXXX

Na podstawie tak przedstawionych wyników, osoba analizująca dane z pomocą wskazówek, stworzonych przez autora systemu, może stwierdzić zajście plagiatu.

JPlag

System JPlag jest darmowym systemem do wykrywania plagiatów dostępnym online. System analizując kody źródłowe programów działa w dwóch etapach:

  1. Parsowanie i tokenizacja kodu źródłowego.
    Przy pomocy parsera i tokenizera kod źródłowy programu jest zamieniany na ciąg tokenów.
  2. Porównanie par ciągów tokenów ze sobą.
    Każda para ciągu tokenów jest porównywana ze sobą przy użyciu algorytmu Greedy String Tiling
    Przy porównywaniu tokenów przestrzegane są następujące zasady:

    1. Każdy token z programu A może zostać dopasowany tylko do jednego tokena z programu B.
    2. Podciągi tokenów są znajdowane niezależnie od ich pozycji.
    3. Dłuższe podciągi są bardziej preferowane od krótszych

Uwzględniając powyższe zasady powstał algorytm, który przebiega w dwóch fazach:

  1. W pierwszej fazie algorytmu w dwóch ciągach tokenów znajdowany jest najdłuższy wspólny podciąg dla dwóch podanych ciągów wśród tokenów, które nie są oznaczone.
  2. W drugiej fazie wszystkie tokeny zawierające się w znalezionym w fazie pierwszej podciągu zostają oznaczone jako użyte i algorytm wraca do punktu pierwszego.

Algorytm jest wykonywany dopóki są znajdowane dopasowania tokenów o długości nie mniejszej niż ustalony próg.\par
W listingu poniżej przedstawiono pseudo-kod algorytmu Greedy String Tiling.

Na podstawie wyniku działania algorytmu jest wyliczane prawdopodobieństwo w następujący sposób:

{sim(A,B)=\frac{2\cdot coverage(tiles)}{|A|+|B|}}, gdzie:

{coverage(tiles) = \sum_{match(a,b,length)\in tiles}length}

Obliczone podobieństwo jest wyrażone w procentach, zatem im wyższa wartość tym większe prawdopodobieństwo na to, że mamy do czynienia z plagiatem.

MOSS

Ostatnim systemem opierającym się na metrykach strukturalnych, który opiszę jest MOSS. Głównym algorytmem systemu jest algorytm Winnowing. Jego zasada działania opiera się na k-gramach, czyli podciągach tokenów długości k. Algorytm przebiega następująco:

  1. podanie na wejście ciągu znaków
  2. usunięcie zbędnych znaków
  3. podzielenie ciągu wejściowego na k-gramy
  4. zamiana k-gramów na hashe
  5. wybranie części hashów, według odpowiedniego algorytmu – wybrane hashe tworzą tzw. odcisk palca programu.

Tak przygotowane zestawy odcisków palca są ze sobą porównywane w celu znalezienia jak największych wspólnych części odcisków palców.

Krótkie podsumowanie

Dzisiaj pokazałem bardziej zaawansowane systemy wykrywania plagiatów. według mnie na szczególną uwagę zasługuje system JPlag, który ma całkiem niezłą skuteczność.

W jednym z kolejnych wpisów opiszę jeszcze 2-3 podejścia do tego  problemu. Po tej dawce teorii będziemy mogli z czystym sumieniem przejść do praktyki i implementacji naszego algorytmu 🙂

Adnotacje – starcie drugie!

W poprzednim wpisie o adnotacjach opisałem jak tworzyć adnotacje w Javie. I co dalej? Mamy już naszą adnotacje, więc wypadałoby ją jakoś użyć. W tym wpisie pokaże w jaki sposób możemy użyć naszych adnotacji.

Małe uzupełnienie poprzedniego wpisu

W poprzednim wpisie pominąłem jedną (przynajmniej :P) istotną sprawę przy tworzeniu adnotacji.

Dziedziczenie adnotacji

Przy tworzeniu adnotacji możemy użyć również @Inherited, który powoduje, że adnotacja będzie widoczną również jako obecna na klasach, które dziedziczą po klasie z tą adnotacją.

Zdefiniujmy naszą adnotacje następująco:

Klasę, która będzie oznaczona naszą adnotacją:

I naszą klasę dziedziczącą po MySuperClass:

W ten sposób MyAnnotation będzię widoczne również na MyClass.

Wracając do tematu…

Wydaję mi się, że najpopularniejszym przypadkiem użycia adnotacji są różnego rodzaju frameworki jak np. Hibernate czy Spring.

Jeżeli mamy naszą klasę oznaczoną np. adnotacją @Entity, to jak framework ‚znajduje’ informacje, że dana klasa ma właśnie tą adnotacje?

Jako przykład weźmy prostą adnotacje:

oraz klasę:

I teraz spróbujemy dobrać się do naszej adnotacji 🙂

Zacznijmy może od początku – czyli warto byłoby najpierw znaleźć klasy z adnotacjami, żebyśmy wiedzieli z czym będziemy pracować 😉

W Springu definiujemy pakiety, które mają być skanowane pod kątem adnotacji. Wyjdziemy z tego samego założenia – nie ma sensu skanować wszystkich klas, jeżeli nie jest to konieczne 🙂

Stwórzmy zatem dwie metody, dzięki którym będziemy mogli przejść rekurencyjnie po wszystkich folderach z danego pakietu o zwrócić listę wszystkich klas, adnotacji i interfejsów.

Metody są okraszone komentarzami, więc nie powinno być problemu ze zrozumieniem co tam się dzieje.

Metody nie robią co prawda nic skomplikowanego, ale po co pisać coś, co zostało już raz dobrze napisane 😉 Metody te pokazałem, żeby przedstawić jak to wygląda od podstaw, w najprostszej formie. W życiu codziennym polecam używanie odpowiednich metod z Spring, Guavy czy np. Reflections Library.

I teraz samo znajdowanie klas z naszą adnotacją:

Metoda wypisze na ekranie następującą linie:

Jak widać udało nam się znaleźć wszystkie (całą jedną w tym konkretnym przypadku ;)) klasy z adnotacją @MyAnnotation i odczytać wartości atrybutów adnotacji.

Podsumowanie

We wpisie został pokazany sposób w jaki można znaleźć klasy z konkretnego pakietu z konkretną adnotacją. Dzięki temu możemy zdefiniować własne zachowania/akcje dla klas z danymi adnotacjami.

Oczywiście wpis ten nie wyczerpuje tematu. Mechanizm refleksji dostarcza wielu innych metod związanych ze znajdywaniem klas czy adnotacji. Zachęcam do zagłębienia się w ten temat 🙂

Jak wykrywać plagiaty? Część pierwsza!

Jak wspomniałem w pierwszym wpisie w ramach Daj Się Poznać 2017, aplikacja, którą piszę będzie odpowiedzialna za wykrywanie plagiatów w kodach źródłowych programów.

W tym i w kilku (0, 1 lub 2 :P) kolejnych wpisach postaram się przedstawić kilka istniejących podejść do tego problemu.

Systemy bazujące na zliczaniu atrybutów

Pierwszymi automatycznymi systemami do wykrywania plagiatów w kodach źródłowych programów były systemy polegające za zliczaniu i porównywaniu atrybutów programów.

Miara złożoności Halstead’a

Pierwszym automatycznym systemem służącym do automatycznego porównywania stopnia podobieństwa między kodami źródłowymi programów był system zaproponowany przez Halsted’a w 1977 roku. System ten do mierzenia podobieństwa programów używał czterech statystyk programu:

  • {\eta_1} – liczba unikalnych operatorów
  • {\eta_2} – liczba unikalnych operandów
  • {N_1} – liczba wystąpień operatorów
  • {N_2} – liczba wystąpień operandów

Pary programów, u których powyższe wartości były identyczne były dalej przeglądane przez człowieka w celu stwierdzenia lub odrzucenie zajścia plagiatu (spora wada tego systemu ;)).

Powyższy system miał bardzo ograniczone możliwości. Statystyki takie jak liczba wystąpień operatorów czy ilość unikalnych operatorów są wartościami, które można w bardzo łatwy sposób zmienić, a co za tym idzie oszukać opisany wyżej system.

System Accuse Grier’a

System Accuse, stworzony przez Grier’a, powstał na bazie wcześniej opisanego systemu. Grier w swoim systemie do badania podobieństw między programami używa następujących statystyk:

  • liczba unikalnych operatorów
  • liczba unikalnych operandów
  • liczba wystąpień operatorów
  • liczba wystąpień operandów
  • liczba linii kodu
  • liczba zmiennych zadeklarowanych i użytych
  • liczba wszystkich instrukcji kontrolnych

W pierwszej fazie system Accuse zliczał dla każdego programu wyżej wymienione parametry. W drugiej fazie jest obliczania korelacja pomiędzy parami programów. Przy obliczaniu korelacji używane są dwa stałe parametry:

  • rozmiar okna (window) – określa maksymalną różnicę pomiędzy zliczonymi statystykami dwóch programów
  • wartość ważności (importance) – waga danego parametru przy obliczaniu korelacji

Następnie korelacja jest obliczana w następujący sposób:

  • wartość korelacji jest ustawiana na 0
  • dla każdej metryki wykonywane jest:
    • jeżeli {A_i} jest wartością i-tej metryki programu A i {B_i} jest korenspondującą metryką w programie B wtedy {diff_i=|A_i-B_i|}.
    • jeżeli {diff_i\le window_i} wtedy {correlation_{AB} += importance_i-diff_i}.

Przy parach programów z dużą wartością obliczonej korelacji zachodzi prawdopodobieństwo plagiatu i programy te powinny zostać przejrzane przez człowieka (tym razem jest o tyle lepiej, że nie wszystkie porównania muszą zostać przejrzane ;)).

System Faidhi-Robinson

Faidhi i Robinson stworzyli listę metryk służącą do wykrywania plagiatów. Metryki te według nich miały być lepsze od metryk opisanych w systemie Accuse. Metryki te, nie korelują ze sobą, a dodatkowo w tych metrykach są ukryte dodatkowe miary, które powinny być ciężkie do zmiany przynajmniej przez programistę (a przynajmniej początkującego ;).

Pierwsze dziesięć metryk Faidhi i Robinson zakwalifikowali do grupy metryk, które według nich może bez większego problemu zmienić nawet początkujący programista.

  1. średnia ilość znaków na linię
  2. liczba linii z komentarzami
  3. liczba linii z wcięciami
  4. liczba pustych linii
  5. średnia długość procedury lub funkcji
  6. liczba słów kluczowych
  7. średnia długość identyfikatora
  8. średnia ilość spacji na linię
  9. liczba etykiet i poleceń goto
  10. liczba unikalnych identyfikatorów

Kolejne 14 metryk zostało wybranych jako metryki mierzące strukturę programu, które są trudne do zmodyfikowania przez programistę.

  1. liczba etapów programów – przy pomocy algorytmu Cocke’a i Allen’a jest tworzony graf przepływu
  2. liczba kolorów wierzchołków o kolorach 1 i 2 w pokolorowanym grafie przepływu
  3. liczba wierzchołków mających kolor 3
  4. liczba wierzchołków mających kolor 4
  5. procentowa ilość wyrażeń w programie
  6. procentowa ilość prostych wyrażeń w programie
  7. procentowa ilość termów w programie
  8. procentowa ilość współczynników w programie
  9. liczba zbędnych rzeczy w programie – np. zbędne średniki lub pary BEGIN/END
  10. liczba linii wewnątrz funkcji i procedur
  11. liczba funkcji i procedur
  12. procentowa ilość wyrażeń warunkowych
  13. procentowa ilość powtarzających się wyrażeń
  14. liczba instrukcji w programie

W systemie Faidhi-Robinson, podobnie jak w poprzednim systemie, do obliczania podobieństwa użyto dwóch stałych parametrów:

  • rozmiar okna (window)
  • wartość ważności (importance)

Algorytm obliczania podobieństwa wygląda następująca:

  • dla każdej metryki:
    • {increment_i=\frac{window_i-diff_i}{window_i}\cdot importance_i}

Całkowita korelacja wynosi zatem:

{\sum_{i=1}^{24} increment_i}.

Im otrzymana korelacja miała większą wartość tym zachodziło większe prawdopodobieństwo plagiatu.

Krótkie podsumowanie

W tym wpisie przedstawiłem kilka pierwszych systemów do wykrywania plagiatów w kodach źródłowych. Niestety nie były one zbyt efektywne.

W kolejnych wpisach opiszę kilka innych podejść do wykrywania plagiatów, które charakteryzują się większą skutecznością.

Adnotacje w Javie

W Javie 1.5 zostały wprowadzone adnotacje. Możemy je często spotkać przy pisaniu testów jednostkowych, ORMach lub różnych frameworkach. Czym są właściwie adnotacje i co nam dają?

Adnotacje są to metadate, które dostarczają nam informacji na temat programu, ale same nie są częścią kodu, ani bezpośrednio nie wpływają na kod.

Najprostszą adnotacje możemy stworzyć w następujący sposób:

Teraz możemy użyć jej w naszym kodzie:

Pola

Do naszych adnotacji możemy dodawać pola. Aby to zrobić musimy je zdefiniować w ciele naszej adnotacji.

I samo użycie:

Jeżeli nasze pole będzie miał nazwę value, wtedy możemy pominąć nazwę pola w użyciu adnotacji.

Domyślne wartości pól

W przykładach powyżej podanie wartości zdefiniowanych pól jest obowiązkowe. Jeżeli chcemy, aby podanie pola nie było wymagane musimy zdefiniować jego domyślną wartość.

Wtedy przy użyciu adnotacji możemy, ale nie musimy, podawać wartość pola.

Zakres adnotacji

Adnotacje domyślnie mogą być używane na:

  • innych adnotacjach
  • konstruktorach
  • metodach
  • polach
  • lokalnych zmiennych
  • pakietach
  • parametrach metod
  • klasach, interfejsach, enumach
  • typach generycznych (od Java 8)

Domyślnie nowo stworzona adnotacja może być używana w każdym z  wymienionych wcześniej miejsc. Możemy jednak ograniczyć jej zasięg poprzez użycie adnotacji @Target z parametrami definiującymi zasięg.

Wszystkie dostępne wartości ElementType to:

  • ANNOTATION_TYPE
  • CONSTRUCTOR
  • METHOD
  • FIELD
  • LOCAL_VARIABLE
  • PACKAGE
  • PARAMETER
  • TYPE
  • TYPE_PARAMETER

Kolejne wymienione wartości ElementType odpowiadają wcześniej wymienionym miejscom opisującym gdzie można użyć adnotacji.

Dodatkowo w Javie 8 wprowadzono ElementType.TYPE_USE, który może być użyty na wszystkich typach.

Retencja adnotacji

Dla każdej adnotacji możemy ustalić jej zakres widoczności. Definiujemy to przez dodanie adnotacji @Retention.

Dostępne są trzy wartości dla adnotacji @Retention:

  • RetentionPolicy.SOURCE – informacja o adnotacji jest dostępna jedynie podczas kompilacji; przykładami takich adnotacji są @Override i @SuppressWarnings
  • RetentionPolicy.CLASS – adnotacja jest dostępna podczas ładowania klas; jest to domyślny poziom retencji
  • RetentionPolicy.RUNTIME – adnotacja jest dostępna podczas działania aplikacji, dzięki czemu mamy do niej dostęp poprzez refleksje; przykładem takiej adnotacji jest @Deprecated

Krótkie podsumowanie

W wpisie przedstawiłem najważniejsze informacje na temat adnotacji w Javie. Mam nadzieję, że okażą się one przydatne i choć trochę ułatwią poruszanie się po frameworkach, które pełne są najróżniejszych adnotacji 🙂

Daj się poznać 2017

Ruszyła kolejna edycja Daj się poznać i po raz kolejny postanowiłem się zgłosić 🙂

Kilka słów o aplikacji

W ramach konkursu zamierzam napisać aplikacje służącą do wykrywania plagiatów pomiędzy kodami źródłowymi programów.

Co będzie dokładnie robiła aplikacja? Będziemy mogli wysłać kilka kodów źródłowych programów w wybranym języku, a następnie dostaniemy informacje jak bardzo poszczególne kody są do siebie podobne.

Aplikacja będzie napisana w Kotlinie i AngularJS. Dlaczego własnie te dwie technologie? Ponieważ nie znam żadnej z nich 🙂

Backend zostanie napisany w Kotlinie. Będzie składał się z dwóch części, Pierwsza część – ‚corowa’ – będzie implementowała algorytm do wykrywania podobieństw. Druga część będzie wystawiała restowe web serwisy, udostępniając funkcjonalność.

Frontend, tak jak wspomniałem wcześniej, zostanie napisany w AngularJS. Będzie to prosta (przynajmniej w założeniu) stronka, na której będziemy mogli załadować pliki do sprawdzenia, a następnie wysłać do naszego serwisu, otrzymać odpowiedź i wyświetlić ją użytkownikowi.

To by było na tyle, jeżeli chodzi o ogólny opis aplikacj 🙂