GitHub-თან კავშირი პროქსის გავლით

არ მგონია რომ ეს პოსტი ბევრისთვის სასარგებლო გამოდგეს, მაგრამ მთელი დღე დამაკარგინა და ვერ მოვითმენ რომ არ დავწერო..

GitHub.com არის პროექტების ჰოსტინგის სერვისი ვებ ინტერფეისით, რომელიც Git version control სისტემას იყენებს. მოკლედ რომ ვთქვათ, თქვენ შეგიძლიათ იქ განათავსოთ პროექტის კოდები და ფაილები. ის ცვლილებების ისტორიასაც შეინახავს. შეიძლება სხვადასხვა განშტოებების და ვერსიების გამოყოფა და გუნდური მუშაობის დროს მოსახერხებელია კოდების ასე ცენტრალიზებულად არსებობა.

ძალიან არ ჩავუღრმავდები სისტემის აღწერას – კარგი ინსტრუქციები აქვთ. მაგრამ დღეს ისეთი კომპიუტერიდან დამჭირდა ცვლილებების ატვირთვა, რომელიც proxy-ის უკან იყო და ამისთვის ვერც ისე ბევრი რესურსი ვნახე.
თან არასტანდარტული პორტებიც დაბლოკილია, ssh-ით შესვლის დროს კი 22 პორტია საჭირო.

GitHub-ი რამდენიმე შესაძლებლობას გვაძლევს შესვლისთვის: ssh, https და git read-only
https-ით ssl-ის სერტიფიკატების პრობლემის გამო რატომღაც ვერ დავუკავშირდი, ამიტომ ვუკავშირდები ssh-ით ოღონდ https-ის პორტით – 443.

ჩემთან ასეთი ნაბიჯები შევასრულე:
~/.ssh საქაღალდეში შევქმენი კონფიგურაციის ფაილი config შემდეგი შიგთავსით:

Host github.com
User <მომხმარებელი>
Hostname ssh.github.com
ProxyCommand /c/connect.exe -H <პროქსის მისამართი>:<პროქსის პორტი> %h %p
PreferredAuthentications publickey
IdentityFile ~/.ssh/id_rsa
Port 443

ProxyCommand არის option, რომელიც OpenSSH-ში SOCKS პროტოკოლის შესაცვლელად ჩაემატა და საშუალებას იძლევა რომ სხვა პროგრამები გამოიყენოს ssh-მა პროქსისთან ურთიერთობისთვის. ერთ-ერთი ასეთი პროგრამაა connect.c

მე ვინდოუსიდან ვცდილობდი ატვირთვას ამიტომ გადმოვწერე კომპილირებული ფაილი აქედან: http://dl.dropbox.com/u/2177278/connect.exe (თავის საიტზე არ მუშაობდა ლინკი).

ასეთმა კონფიგურაციამ არ იმუშავა, მაგრამ connect.exe-ს აქვს ერთი კარგი პარამეტრი -d დებაგისთვის (მაგ: ProxyCommand /c/connect.exe -d -H <პროქსის მისამართი>:<პროქსის პორტი> %h %p) და მაგის მითითების შემდეგ უფრო დეტალურად წერს სად რა პრობლემა შეხვდა. ძალიან დიდი ალბათობით მანდვე იპოვით მიზეზს.

ჩემ შემთხვევაში პრობლემა პროქსისთან აუტენტიფიკაცია იყო. პროქსის პაროლის მითითებისთვის რამდენიმე მეთოდი არსებობს, მაგრამ environment variable-ებში ღია სახით გაწერა არ მომეწონა და არც იმუშავა ჩემთან. არც git-ის global http.proxy პარამეტრმა იმუშავა (აქაც ღია სახით იყო გაწერილი).

ბოლო ბოლო გადმოვწერე Cntlm Authentication Proxy, რომელიც მანქანაზე გასაშვები სერვისია, პროქსის და აპლიკაციებს შორის დგება და ავტორიზაციას გადის მათ მაგივრად. მისი გამოყენების მარტივი მაგალითი არსად ედოთ და მაინც წამაკითხეს მთელი დოკუმენტაცია :D ამიტომ მოკლედ დავწერ როგორ მუშაობს:

Cntlm სერვისია და ინსტალაციის შემდეგ ავტომატურად არის გაშვებული. შეგიძლიათ Control panel-ის Administrative Tools-ში შეხვიდეთ და ამოაგდოთ.
პროგრამა უსმენს კონფიგურაციაში გაწერილ მისამართს და პორტს, მაგალითად: 127.0.0.1:3128
ამიტომ ყველა იმ პროგრამის კონფიგურაციაში, რომელიც გინდათ რომ მისი გავლით პროქსის დააკავშიროთ, პროქსის მისამართის მაგივრად უნდა მიუთითოთ ეს მისამართი და პორტი.

პროქსის პაროლის შეყვანა ერთხელ არის საჭირო – თავიდან. შემდეგ დოკუმენტაციის (Configuration hints განყოფილების) მიხედვით უნდა დააგენერირებინოთ თავისი პაროლი, გადაიტანოთ კონფიგურაციის ფაილში და შემდეგ სულ იმით გაივლის ხოლმე ავტორიზაციას.

მე Git Bash-დან ვუშვებდი ბრძანებებს და კავშირს ამით ვამოწმებდი ხოლმე:
$ ssh -v git@github.com

ამ პრობლემის გადასაჭრელად ძირითადად ეს პოსტები დამეხმარა:

Using Github Through Draconian Proxies
Git SSH problem – bad file number 

ცუდი ის იყო, რომ github-დან კლონი უპრობლემოდ გაკეთდა და ფაილები წამოიღო სერვერიდან, მაგრამ push-ის დროს არაფრით ამთავრებდა ოპერაციას (არც timeout შეცდომით) და მაგის გამო კავშირის პრობლემაზე არ მიფიქრია თავიდანვე. მერე გამახსენდა, რომ კლონი IDE-დან გავაკეთე.. და push არ ჰქონდა იქ..

ფაილური სისტემის შეზღუდვები

ერთ-ერთი საიტის კოდში შემხვდა hack ლინუქსისთვის, რომელიც ფაილური სისტემის შეზღუდვის გათვალისწინების გამო იყო ჩამატებული. მივხვდი, აქამდე არასდროს მიფიქრია ასეთ წინააღმდეგობებზე და გადავწყვიტე ფაილური სისტემების აღწერისთვის მიმეძღვნა პოსტი, თუმცა იმდენნი არიან, ამ ერთი ჰეკით შემოვიფარგლები.

(ვიკიპედიაზე არის ქართული სტატიის ნაწილი მათ შესახებ, აქ კი სისტემების შედარების ცხრილებია)

კოდის ფრაგმენტი, რაც ზევით ვახსენე, საიტზე სურათების ატვირთვას ეხებოდა. როგორც ჩანს ლინუქსის ფაილურ სისტემებს (ext2/ext3) შეზღუდვა აქვთ, რომ ერთ საქაღალდეში 32000-ზე მეტი ქვე საქაღალდის შენახვა არ შეიძლება. ანუ თუ მაგალითად, მომხმარებლის ფოტოების შესანახად ერთი საქაღალდე გაქვთ გამოყოფილი და იქ თითოეული იუზერისთვის ქვესაქაღალდეს ქმნით, 32000-ზე მეტი იუზერის შექმნის შემთხვევაში ამ საქაღალდეებს ვეღარ შექმნის.

ერთი გამოსავალი ისაა, რომ ფაილური სისტემა შეცვალოთ (როგორც წერენ, ReiserFS-ს ასეთი შეზღუდვა არ აქვს და ასობით ათასს ფაილსსაც მარტივად უმკლავდება), მაგრამ თუ სხვა მხრივ ხელს არ გიშლით, ჩემი აზრით უკეთესია უბრალოდ სხვანაირად დაანაწილოთ ფაილები და ისე შეინახოთ.

მაგალითად, შეიძლება root ფოლდერში შეინახოთ საქალდეები სახელად 10000, 20000, 30000, ხოლო თითოეულში მაქსიმამუმ 10000 ცალი საქაღალდე რომელიც შესაბამისად არის გადანომრილი (1,2,3,.. ). როდესაც საჭირო იქნება იმის დადგენა თუ რომელ გარე საქაღალდეში უნდა მოიძებნოს თქვენი ფოლდერი, მისი სახელის 10000-ზე მთელი გაყოფით და შემდეგ ისევ 10000-ზე გამრავლებით გარე ფოლდერის სახელს მიიღებთ.

შეზღუდვები რომც არ იყოს, ზოგი ფაილური სისტემა არ არის ოპტიმიზირებული რომ ბევრ ფაილიან ფოლდერში სწრაფად ჩაამატოს, ამოშალოს ან წაიკითხოს ფაილები. მაგალითად ლინუქსის ext2 და ext3 დირექტორიების და ფაილების იერარქიას ბმული სიების სახით ინახავდნენ და შესაბამისად იქ ძებნას O(n) დრო სჭირდებოდა. ზოგ შემთხვევაში პრობლემა არაა, მაგრამ როცა, თუნდაც, კეშის მსგავსი სტრუქტურები იყო შესანახი, ძალიან ანელებდა ეს ყველაფერს. შემდეგ დაამატეს მარტივი ხის სტრუქტურა  - HTree, რომელიც ext3-ში შეიძლება ”ჩაირთოს”, ext4-ს კი default-ად აქვს უკვე. სხვა ფაილური სისტემებიდან ბევრი B-tree-ის მონაცემთა სტრუქტურას იყენებს სწრაფი მუშაობისთვის. ამაზე ალბათ მოგვიანებით დავწერ.

იქით მივდიოდი, რომ უკეთესი წარმადობისთვის ჩვენმა აპლიკაციამაც შეიძლება შეუწყოს ხელი ოპერაციულ სისტემას. უკვე რამდენგანმე შემხვდა ჰეშირებას გამოყენება ფაილების მენეჯმენტის დროს. მაგალითად, რომ აიღოთ ფაილის სახელის ჰეში 910a90401e7bdc0452eea5630, ამ ჰეშის პირველი რამდენიმე სიმბოლო გამოიყენოთ საქაღალდეების იერარქიისთვის, ხოლო დანარჩენი ფაილის სახელისთვის.

91\0a\90401e7bdc0452eea5630.jpg

კარგი ჰეშ ფუნქციის შემთხვევაში საქაღალდეები და ფაილები დაახლოებით თანაბრად განაწილდება და ფოლდერები არ გადაიტვირთება. არც ფაილის მოძებნა იქნება მძიმე.

მაგალითად,  Squid (web proxy cache) ინახავს კეშირებულ ფაილებს მსგავსი სახით.

Who dares, wins :D

რას მივუძვნიდი ამ პოსტს, თუ არა ჯეოლიმპს :)

ვაღიარებ, პროგრამისტს ვეძახდი ჩემს თავს, მაგრამ ამ სფეროში არსებულ შეჯიბრებების ამოცანებს ახლოსაც არ ვეკარებოდი. ბავშვობის იმედგაცრუების მერე ოლიმპიადის პრობლემებს სხვა ხილად მივიჩნევდი და არც მათგან მიღებულ ცოდნის არ არსებობას შევუწუხებივარ კარგა ხანს..

სიმართლე გითხრათ, ბავშვობის მერე დიდად არ შევცვლილვარ ამ საკითხში და ახლაც იგივე ეტაპებს გავდივარ ამოცანის ამოხსნისას – გაცნობა / ფიქრი / ფიქრი / უიმედობა /  ახალი შემართება – მე ყველაფერს მოვერევი :D / ფიქრი / ფიქრი / ევრიკა! / წერა, გაგზავნა და განაჩენის მოუთმენლად მოლოდინი..

სამ დღეს თუ გადაცდა ეს პროცესი, სასტიკად მძულს ის ამოცანა და ამოხსნა კი არა, გახსენებაც აღარ მინდა : ))

ჯეოლიმპში ის მომწონს, რომ საჩემო ამოცანებიც არის :D ჩემს ჭიასაც უხარია, როცა ნოლზე არ ვრჩები.

მეორეს მხრივ რაც არ უნდა მემართლებინა თავი, რომ ასეთი შეჯიბრებების ამოცანები საერთოდ ცალკე მიმართულებაა და თუნდაც ვებ დეველოპმენტში მათ ასეთი სახით არასდროს გამოვიყენებ, უნდა ვაღიარო – ძალიან ნელა ვაზროვნებ მათ გარეშე. ვგრძნობ, როგორი მნიშვნელოვანია ვარჯიში.

ისე კი, სიმართლე რომ ვთქვა, არც ყოველდღიური ცხოვრებისეული პრობლემებისგან დგას შორს ოლიმპიადის ამოცანები. წინა კვირას რამდენჯერმე დამჭირდა მათი ფრაგმენტების გამოყენება, მიუხედავად იმისა რომ ჩემი მიმდინარე სამუშაო დიდ ალოგირთმულ შრომას არ საჭიროებს.

:D თავისთავად ეს შეჯიბრებები ერთგვარი სპორტია. კონკურენცია, ადრენალინი, ზოგისთვის რეპუტაცია და სახელი. დარწმუნებით შემიძლია ვთქვა, რომ თუ სწავლის გაგრძელება მენდომებოდა რომელიმე ცნობილ უნივერსიტეტში ან დამსაქმებელი კომპანია, პირველ რიგში ამ შეჯიბრებებში ჩავებმეოდი. ცხადია, რომ ერთ-ერთი რეალური გზის დასაწყისი იქნებოდა მსგავსი მიზნების მიღწევაში და ამას მხოლოდ ჩემი მეგობრების მაგალითზე არ ვამბობ. თავისთავად ჩანს კონკურენტუნარიანობის და თავის წარმოჩენის მშვენიერი, სწრაფი სასარგებლო მეთოდი რომ არის. მეორეს მხრივ, მხოლოდ მიზნისთვის ამის კეთება წამებაა და მეტი არაფერი :)  საყვარელი უნდა იყოს პროცესი და თუ პროგრამირებით არ იღებს პროგრამისტი სიამოვნებას, არ ვიცი, როგორ უძღვნის ის ამას ცხოვრების უდიდეს ნაწილს )

”ჯეოლიმპი” (ხშირად რომ ვახსენებ და აღარ ვამბობ რას ნიშნავს) პროგრამირების ოლიმპიადების სერიაა, რომელიც რამდენიმე ინტერნეტ-რაუნდის და ფინალური ჩემპიონატისგან შედგება. შეჯიბრები სტუდენტებისთვის და მოსწავლეებისთვის არის განკუთვნილი, თუმცა სხვა ნებისმიერ მსურველს შეუძლია კონკურსგარეშე მონაწილეობა. თითოეული რაუნდის შემდეგ საიტზე ქვეყნდება ამოცანების დეტალური გარჩევა და სხვადასხვა ალგორითმების განხილვა კონკრეტული ამოცანის გადასაჭრელად.

ამ წამოწყების სულისჩამდგმელები და ამოცანების ავტორები არიან მოსწავლეთა საერთაშორისო ოლიმპიადების და სტუდენტური მსოფლიო ჩემპიონატის მედალოსნები, ასევე საქართველოს მრავალგზის ჩემპიონები დავით რაჭველიშვილი, ელდარ ბოგდანოვი, ანდრო ლუცენკო, გიორგი ლეკვეიშვილი და გიორგი საღინაძე.

(თვითონ ხომ კარგს არ დაწერენ თავის თავზე.. :D )

ჯეოლიმპთან დაკავშირებით უკვე ბევრმა მოვლენამ და სიახლემ ჩაიარა, რაზეც დაწვრილებითი ინფორმაციის ნახვა მის საიტზეა შესაძლებელი. მე კი მხოლოდ მიმდინარე დაგეგმილ ტურს შევეხები – მეოთხე რაუნდი.

ბოლო დროს ჩამოყალიბებული ტრადიციისამებრ ინტერნეტ-რაუნდის პარალელურად დასწრებული შეჯიბრიც ჩატარდება ერთ-ერთ სასწავლო დაწესებულებაში – ამ რაუნდში კონკრეტულად თბილისის სახელმწიფო უნივერსიტეტის XI კორპუსში, სადაც ადგილობრივი გამარჯვებულიც გამოვლინდება :)

ჰოდა, რომ მეუბნებით ხოლმე ზოგიერთები ტრასაზე როდის დავდგეთო, :D მობრძანდით კვირას (19-ში) და ამ არენაზე შევეჯიბროთ. its more fun.  მე დიდი ამომხსნელი არ ვარ, მაგრამ მაინც სახალისოა.

”ჯეოლიმპი” თბილისის სახელმწიფო უნივერსიტეტში

”ჯეოლიმპი” თბილისის სახელმწიფო უნივერსიტეტში

Polling და Pushing აჯაქსით

მივადექი საიტის შეტყობინებების (notifications) ნაწილს და ბლოგი ძალიან რომ არ მივივიწყო, ნანახის მიმოხილვას აქ გავაკეთებ :D

შეტყობინებებში ვგულისხმობ მომხმარებელს რომ პატარა ღრუბელი გამოუჩნდება ხოლმე ”თქვენ მიიღეთ ახალი შეტყობინება”, ან ”თქვენს თემას აქვს ახალი გამოხმაურება”.. ან ჩატის ანალოგი ავიღოთ..  ეს არის შემთხვევა, როდესაც სერვერზე ხდება რაღაც მოვლენა და კლიენტს უნდა მიუვიდეს ამის შესახებ ინფორმაცია.

რადგან სერვერი ვერ იქნება ინიციატორი, აუცილებელია რომ პირველად მოთხოვნა კლიენტისგან გაიგზავნოს. პრობლემა კი იმაშია, რომ კლიენტმა წინასწარ არ იცის მოვლენა როდის მოხდება სერვერზე.

ამ ამოცანის გადასაჭრელად ძირითადად ორ გზას იყენებენ ხოლმე:

1. ყოველ 5 წამში (სიტყვაზე) ბრაუზერი ეკითხება სერვერს ჩემთვის რამე ახალი ხომ არ გაქვსო (უგზავნის მოთხოვნას XMLHttpRequest ობიექტის საშუალებით). სერვერიც თავის მხრივ პასუხს უბრუნებს და ასე გრძელდება დაუსრულებლად. ამას polling-ს ეძახიან.

2. ბრაუზერი მიმართავს სერვერს და ამის შემდეგ კავშირს არც ერთი მხარე არ ხურავს. HTTP ქონექშენი ღიაა. თუ სერვერზე რამე ახალი მოხდება, სტრიმის სახით გაუშვებს ინფორმაციას კლიენტთან ამ კავშირით. ეს push-ია.

ორივე მეთოდს თავისი დადებითი და უარყოფითი მხარეები აქვს და ამიტომ ერთი ხელის მოსმით ვერ იტყვი რომელია უკეთესი. განვიხილოთ.

polling-ს ზედვე ეტყობა როგორ ხარჯავს რესურს. ჯერ მარტო ამდენი ქონექშენის გახსნით და დახურვით სერვერს ტვირთავს, მით უმეტეს როცა მომხმარებლების რაოდენობა ძალიან დიდია. ბოლოს ვეღარ გაუძლებს იქით მხარეს სერვისი და მოკვდება :D

მიუხედავად იმისა, რომ push-ს ეს პრობლემა არ აქვს, აქ სხვა სახით გვაქვს სერვერზე დატვირთვა. მას ძალიან დიდი რაოდენობით გახსნილი ქონექშენის ხელში ჭერა უწევს.

გადატვირთვის თავიდან ასაცილებლად IE 6/7 -ში შეზღუდვაც კია დაუხურავ კავშირებზე. ამ ბრაუზერში კლიენტს არ შეუძლია ქონდეს ორზე მეტი ღია ქონექშენი სერვერთან. ანუ მაგალითად, თუ ორ ტაბში გვაქვს გახსნილი ერთი და იგივე საიტი, რომელიც ასეთ დაუხურავ კავშირს იყენებს და მესამე ტაბშიც გავხსნით, მესამე აღარ ჩაიტვირთება.

ამისთვის ჰეკები არსებობს რა თქმა უნდა. სხვა მნიშვნელოვან ბრაუზერებს ამის პრობლემა არ ქონიათ.

გასათვალისწინებელია გახსნილი ქონექშენის სტრიმის გამაჩერებლებიც – ეს შეიძლება იყოს პროქსი სერვერები, სხვადასხვა firewall-ები ან ვებ სერვერი.. მაგალითად აპაჩის mod_jk კონექტორი (ტომკეტისთვის) ხელს უშლის თურმე push-ის რეალიზაციას.

იმ ბრაუზერებისთვის, რომლებსაც ნამდვილი push-ის გაკეთებაზე ბევრი პრობლემა აქვთ, არის კიდევ ერთი მეთოდი – long polling. აქ push-იც გვაქვს და poll-იც. ბრაუზერი გზავნის მოთხოვნას სერვერთან და თუ მეორე მხარეს მისთვის ჯერ არაფერი არ არის, სერვერი არ პასუხობს და ქონექშენს ღიას ტოვებს, ხოლო როცა რამე გამოჩნდება, ნაკადად კი არ უშვებს არამედ მთელ პასუხს უგზავნის უკან და ხურავს კიდეც. შემდეგ კლიენტი ისევ თავიდან გზავნის მოთხოვნას და ასე შემდეგ.

ძალიან აღარ ჩავუღრმავდები, მით უმეტეს რომ პრაქტიკულად ამის გაკეთება გადავიფიქრე და polling ვიკმარე, რომელიც ცუდი გადაწყვეტილება არ არის, თუ რეაქციის პატარა დრო არ არის აუცილებელი ამოცანისთვის და რამდენიმე წუთში ერთხელ განახლებაც საკმარისია.

თუმცა რა თქმა უნდა ამოცანას გააჩნია. Push , რომლის პატერნს Comet-საც ეძახიან გამოიყენება GMail-ში, GMail-ის ჩატში, GDocs-ში, Meebo-სა და სხვა ჩატის თუ collaborate რედაქტირების საიტებში.

პ.ს. long polling-ის თავიდან ასაცილებლად და სულ ღია კავშირების ხარჯზე ინფორმაციის მიმოცვლისთვის HTML 5-ის სპეციფიკაციაში შემოაქვთ WebSocket კლასი, რომლითაც ასეთი პატერნის რეალიზაციაა შესაძლებელი. http://dev.w3.org/html5/websockets/

პ.პ.ს. იმედია, ჩემი სიტყვებით გადმოცემული პოსტი დიდად არ დაშორდა რეალურ შინაარს :D

რეკომენდირებული საყურებელი:

Interactive Websites with Comet and DWR  by Joe Walker

კოდის წერის სიჩქარის მნიშვნელოვნად გაუმჯობესება

არა მარტო კოდის :)

ალბათ უმეტესი თქვენგანი უკვე იყენებს მას ან მის ალტერნატივას. ზოგიერთ IDE-ს ჩადგმული აქვს მისი შესაძლებლობები.

მე კი მხოლოდ დღეს ვნახე Nettuts+ საიტზე და უკვე შემიყვარდა. ლაპარაკია Texter პროგრამაზე.

მისი საშუალებით სიტყვებს ან სიმბოლოებს ვაბამთ სრულ სკრიპტებს, კოდის ფრაგმენტებს, თუნდაც წერილის შაბლონებს და წერის დროს უკვე ამ სიტყვებს ვიყენებთ shortcut-ის როლში იმ დიდი ტექსტის ჩასასმელად.

არა მარტო ტექსტს ვაბამთ. შესაძლებელია მაკროსების წერაც. მაგალითად, თუ წინადადების ბოლოს გაგვახსენდა, რომ წინადადება <p></p> პარაგრაფის ტეგებში უნდა ჩაგვესვა, Texter-ს შეუძლია ისევ რაღაც წინასწარ განსაზღვრული shortcut-ით ეს ტეგები ჩაუსვას, თუ ამ shortcuts განვსაზღვრავთ მაკროსით: {HOME}<p> {END}</p>

ძალიან ზოგადად ვლაპარკობ, იმიტომ რომ ვფიქრობ ვიდეოში ყველაფერს დაწვრილებით ხსნის ჩემი ერთ-ერთი საყვარელი რედაქტორი – ჯეფრი ვეი. ვიდეო ამ ბმულზეა.

Hotstring-ის დამატება Texter-ში

Hotstring-ის დამატება Texter-ში

როგორც ჩანს LifeHacker-ის Texter-ის გარდა კიდევ არსებობს მისი მსგავსი პროგრამები, მაგრამ მე უკეთესი ვერ შევარჩიე. ამას კი ჯერჯერობით რაც ვუპოვე ერთადერთი ნაკლი უნიკოდია. არა მარტო ის, რომ უნიკოდი თვითონ პროგრამას არ ესმის, არამედ ხელსაც მიშლის, როცა სხვაგან ვწერ ქართულად და პროგრამის გათიშვა მიწევს.. მიუხედავად ამისა მაინც საშინლად მოსახერხებელია :D

The NetBeans Collaboration Project

ამ პოსტის ესკიზი მას მერე დევს დრაფტებში, რაც Xray-იმ (იმედია არ მიწყენს) ერთობლივი მუშაობის იდეა გამოთქვა. ერთობლივ მუშაობაში კოდის ერთდროულად წერას ვგულისხმობ. წარმოიდგინეთ, რომ გახსნილი გაქვთ NetBeans IDE და რამდენიმე ადამიანი ერთდროულად არედაქტირებთ ერთსა და იმავე ფაილებს.

პირველად რომ ვცადეთ, ფრიად აღფრთოვანებული დავრჩი. დროის პრობლემების გამო, იშვიათად გვიწევდა შეხვედრა, თორემ pair programming და მისი ჯანი. არადა უკანასკნელი ძალიან მომწონს მისი ნაყოფიერების გამო. კოდი უმეტესად შეცდომების გარეშე გამოდის ხოლმე.

NetBeans-ის Developer Collaboration პლაგინი კი ზუსტად ‘remote’ pair programming-ის საშუალებას იძლევა. :) თუ ასე შეიძლება დაერქვას.

რის შესაძლებლობას იძლევა?

მომხმარებლების ჯგუფის წევრებს შეუძლიათ უყურონ ერთსა და იმავე ფაილებს და ნებისმიერი მათგანის მიერ დარედაქტირების შედეგი real-time დროში დაინახონ. თან პროგრამა გიჩვენებთ, რომელი სტრიქონების ცვლილება მიმდინარეობს და რომელი მომხმარებლის მიერ.

პლაგინს მესენჯერიც აქვს ჩადგმული, რომელსაც სხვადასხვანაირად ფორმატირებული შეტყობინებების გაგზავნა/მიღება შეუძლია (ფორმატირებაში კოდის ფორმატირებას ვგულისხმობ. ანუ, იგივენაირად შეიძლება წერა, როგორც ჩვეულებრივ NetBeans IDE-ში – თავისი shortcut-ებით)

NetBeans Collaboration

გარემოს ასაწყობად საჭიროა:

1. Collaboration სერვერის დაყენება და დაკონფიგურირება (ასეთი სერვერი რამდენიმე არსებობს, თუმცა NetBeans-ის Developer Collaboration მოდულები კარგად არის შემოწმებული OpenFire XMPP სერვერთან ერთად სამუშაოდ, ამიტომ მის საიტზე ამ სერვერის დაყენებას გვირჩევენ და ინსტრუქციაც დევს).

2. NetBeans IDE-ში საჭიროა Developer Collaboration პლაგინის დაინსტალირება.

3. მომხმარებლების დამატება OpenFire-ის ადმინისტრატორის პანელიდან და შემდეგ ამ მომხმარებლების შესვლა (log in) NetBeans IDE-დან.

თამაში გამოცანებით

:) არა, მე არა.

ერთ ქართულ ბლოგზე გადავაწყდი თამაშს, რომელიც ბავშვობას მახსენებს :) ) პატარა გამოცანებს ვწერდით და ბაღში ვმალავდით ხოლმე.. ერთის პასუხი იყო შემდეგის ადგილსამყოფელი. ანუ, ცნობილი თამაშის – ენქაუნთერის ბავშვური ვარიანტი :)

ამ ბლოგზეც (”თითქმის EXCLUSIVE!”)  მსგავსი თამაშია :) საინტერესო კითხვები. თითოეულის პასუხი შემდეგი ტურის პაროლია.

მოკლედ, ისიამოვნეთ :) და ბლოგის ავტორს კი დიდი მადლობა, კარგად ვიმხიარულეთ :) ))

RAID მასივები

ამ საკითხზე სემინარი მქონდა მოსამზადებელი და ბარემ პოსტსაც მივუძღვნი :)

რა არის ეს RAID (Redundant Array of Independent Disks) და რისთვის გამოიყენება? : )

როგორ შევინახოთ ინფორმაცია სისტემის აგების დროს დამოკიდებულია თვითონ ამოცანაზე. რა გვჭირდება: დიდი რაოდენობით ჩაწერა, წაკითხვა, სისწრაფე, საიმედოობა?

მაგალითად, არსებობს ამოცანები, სადაც კრიტიკული მნიშვნელობა აქვს ინფორმაციის საიმედოდ შენახვას და მასზე წვდომის შესაძლებლობას დროის ნებისმიერ მომენტში. ანუ, დისკის დაზიანების დროს უნდა არსებობდეს მისი შემცვლელი იგივე ინფორმაციით და თანაც რაც შეიძლება სწრაფად.

არის ამოცანები, სადაც წარმადობა უფრო პრიორიტეტულია. მაგალითად, როდესაც სერვერიდან დიდი რაოდენობით ვიდეო ნაკადები მოდის.

თავდაპირველად RAID-ის ძირითადი იდეა იყო, რომ რამდენიმე მყარი დისკი გაეერთიანებინა დისკების მასივში და ამით გაეუმჯობესებინა წარმადობა, რომელიც ერთ დიდი ზომის დისკს ჰქონდა.

ახლა RAID-ის არქიტექტურული დიზაინებიდან ყველაზე გავრცელებულია 5 ვარიანტი:  RAID 0, RAID 1, RAID 5, RAID 6, RAID 10.

ისინი ძირითადად ორ მიზანს ემსახურებიან: მონაცემთა შენახვის საიმედოობის გაზრდას, შეტანა/გამოტანის (დისკზე ჩაწერა/წაკითხვის) წარმადობის გაზრდას.

განვიხილოთ თითოეული მათგანი:

RAID 0

ჩაწერის დროს მონაცემები იყოფა ფრაგმენტებად და ეს ფრაგმენტები სათითაოდ ნაწილდება მასივში შემავალ დისკებზე. წაკითხვის დროს კი ყველა დისკიდან ერთდროულად ხდება წაკითხვა.

raid0

up_iconრაც უფრო მეტი დისკია, უფრო მეტად იზრდება სისწრაფე. უხეშად რომ შევადარო, ეს იგივეა, წყლის არხიდან ერთის მაგივრად რამდენიმე მილი გამოვიყვანოთ. იგივე რაოდენობის წყალს უფრო მალე მივიღებთ.

up_iconარ ვკარგავთ ადგილს. მთლიანად ვიყენებთ დისკების მოცულობას ჩვენი ინფორმაციისთვის.

down_iconასეთი სტრუქტურის სისუსტე დისკის დაზიანების დროს ჩანს. საკმარისია ერთ-ერთი მათგანის ამოვარდნა, რომ მთელი მასივი გადასაგდებია. წარმოიდგინეთ, წიგნში ყოველ სიტყვას მისი მესამედი რომ ჩამოვაჭრათ. წიგნი გამოუსადეგარი გახდება. თანაც მისი აღდგენა შეუძლებელია.

Continue reading

RSS (Really Simple Syndication)

ანუ როგორ არ გამოგვრჩეს ახალი პოსტები საყვარელი ბლოგებიდან :)

RSS ლოგო

RSS ლოგო

”RSS ვებ წყაროების (feed) ფორმატების ოჯახის წარმომადგენელია და ხშირად განახლებადი ინფორმაციის (ბლოგის წერილები, ტვიტერის სტატუსები, ახალი ამბები) გამოსაქვეყნებლად გამოიყენება.” – ვიკიპედია

მაგალითისთვის ბლოგი ავიღოთ. არსებული სკრიპტების უმრავლესობას უკვე აქვს RSS დოკუმენტის დაგენერირების შესაძლებლობა. ეს არის განსაზღვრული ფორმატის ფაილი, რომელშიც ის ყველაფერი წერია, რაც ბლოგზე, მხოლოდ არა ადამიანის, არამედ პროგრამისთვის აღქმად ენაზე. პოსტების სათაურები, პოსტები, გამოქვეყნების თარიღები და ყველა დანარჩენი ინფორმაცია. ასეთი დოკუმენტის მაგალითია xml ფაილი http://samurai.ge/feed/ ბმულზე. მაგრამ რისთვის არის საჭირო ბლოგის ასე გადაწერა, როცა ისედაც მოხერხებულად ვკითხულობთ ადამიანურ ენაზე?

ასეთი feed-ების წასაკითხად სპეციალური აპლიკაციები/საიტები არსებობს. მაგალითად, ერთ-ერთი ყველაზე გავრცელებულია Google Reader.  ამ Reader-ის საშუალებით ’გამოვიწერთ’ ბლოგებს :) (ან თუნდაც სხვა ტიპის საიტებს, რომლებსაც RSS feed გააჩნიათ). გამოწერაში იგულისხმება, რომ თქვენს რიდერში თავს მოიყრის ყველა პოსტი, რაც ’გამოწერილ’ ბლოგებზე გამოქვეყნდება. ისინი თარიღის და საიტების მიხედვით ლაგდება. თანაც მიგითითებთ, რომელი სიახლე წაიკითხეთ უკვე და რომელი – არა.

კიდევ ერთი რამ, რაც ძალიან მომწონს, სიახლეების sharing-ის შესაძლებლობაა. ანუ, თუ ვთქვათ მეგობარმა ზე-საინტერესო პოსტი ნახა რომელიმე მის გამოწერილ ბლოგზე, შეუძლია ის სხვებს ’გაუზიაროს’  : ) სხვებში მისი google მეგობრები იგულისხმება, ანუ კონტაქტები. ამიტომ გემრიელი რაღაცეები შეიძლება ისეთი საიტებიდან მოგივიდეს, რომ არც გქონდეს ნანახი..

უარყოფითი მხარეც არის, რა თქმა უნდა :D

მკითხველში ყველაფერი ერთნაირია გარეგნულად. მხოლოდ ტექსტი და ფოტოები. ბლოგების დიზაინი კი არსად ჩანს :) მე კი ვთვლი, რომ დიზაინი (საერთოდ ბლოგის გარეგნული გარემო) ძალიან მოქმედებს პოსტის აღქმაზე. ამიტომ საყვარელ საიტებს მაინც ჩვეულებრივ პირდაპირ ვსტუმრობ და არა რიდერის გამოყენებით :)

პ.ს. Google Reader-ით სარგებლობისთვის google-ის ექაუნთია აუცილებელი. (თუ ჯერ არ გაქვთ, შეგიძლიათ დაარეგისტრიროთ ბმულზე : ) )