როგორ ვაჯობეთ საშუალო დონის სტარტაპებს – Paul Graham

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

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

,,საიდუმლო იარაღი’’

ერიკ რეიმონდი თავის ესეში ,,როგორ გავხდეთ ჰაკერი’’ სხვა საკითხებთან ერთად, პოტენციურ ჰაკერებს ურჩევს, თუ რომელი პროგრამირების ენები ისწავლონ. ის გვთავაზობს, რომ შესწავლის პროცესი Python-ითა და Java-ით დავიწყოთ, რადგან მათი დაუფლება ადვილია. მისი თქმით, სერიოზულმა ჰაკერმა ასევე უნდა ისწავლოს C++ და Perl. დაბოლოს, ის ამბობს, რომ ჩამოყალიბებულ ჰაკერს Lisp-ის სწავლა აუცილებლად უნდა ჰქონდეს მხედველობაში  – Lisp-ის ცოდნა საუკეთესო პროგრამისტად გაქცევს, მაშინაც კი, თუ მას ხშირად არ გამოიყენებ.

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

მე და რობერტმა Lisp კარგად ვიცოდით და ვერ ვხედავდით მიზეზს, თუ რატომ არ უნდა მივნდობოდით ინსტინქტებს. ჩვენთვის ცნობილი იყო, რომ Software-ს ყველა C ++ ან Perl-ში წერდა; თუმცა, ვიცოდით ისიც, რომ ეს არაფერს ნიშნავდა. ტექნოლოგიის შერჩევისას უნდა დააიგნორო ის, რასაც სხვები აკეთებენ და მხოლოდ ის განიხილო, რაც საუკეთესოდ იმუშავებს შენს შემთხვევაში. ეს განსაკუთრებით სტარტაპებს ეხება. დიდ კომპანიაში შეგიძლია, გააკეთო ის, რასაც სხვა ყველა მსხვილი კომპანია აკეთებს; სტარტაპი კი ასე ვერ მოიქცევა. ვფიქრობ, ამას ბევრი ვერ იაზრებს. საშუალო დონის მსხვილი კომპანია წელიწადში დაახლოებით 10%-ით იზრდება. ანუ, თუ მსხვილ კომპანიას მართავ და ყველაფერს ისე აკეთებ, როგორც საშუალო დონის სხვა მსხვილი კომპანიები, შეგიძლია საშუალო დონის მსხვილი კომპანიის მსგავს შედეგს (წლიურ 10%-იან ზრდას) ელოდო. სტარტაპის შემთხვევაშიც ზუსტად იგივე მოხდება.

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

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

რა იყო ამ ექსპერიმენტის შედეგი? გარკვეულწილად გასაოცრად, გეგმამ იმუშავა. საბოლოო ჯამში, ბევრი კონკურენტი (დაახლოებით 20-30) გვყავდა, მაგრამ ვერცერთი მათგანის Software ვერ უწევდა ჩვენსას კონკურენციას, მახასიათებლების თვალსაზრისით ყოველთვის მათზე წინ ვიყავით. ზოგჯერ კონკურენტები სასოწარკვეთით ცდილობდნენ ისეთი ფუნქციების დამატებას, რომლებიც ჩვენ არ გვქონდა; თუმცა, Lisp-ის დამსახურებით, ჩვენი დეველოპმენტის ციკლი იმდენად სწრაფი იყო, რომ ახალი მახასიათებლის დუბლიკატის გაკეთება კონკურენტის მიერ პრესრელიზში გამოცხადებდან 1-2 დღეში შეგვეძლო. იმ დროისთვის, როდესაც ამ სიახლეზე მომუშავე ჟურნალისტი დაგვირეკავდა,  ჩვენ ახალი ფუნქცია უკვე მზად გვქონდა. ალბათ, ჩვენს კონკურენტებს ეგონათ, რომ რაიმე სახის საიდუმლო იარაღი გვქონდა. რეალურად, გვქონდა კიდეც, უბრალოდ ეს იმაზე ბევრად მარტივი იყო, ვიდრე მათ ეგონათ – მათი ახალი მახასიათებლების შესახებ ინფორმაცია არ ჟონავდა ჩვენამდე, უბრალოდ Software-ის სრულყოფა სწრაფად შეგვეძლო.

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

ადამიანები, რომელთაც ჩვენი ტექნოლოგია საუკეთესოდ ესმოდათ, მომხმარებლები იყვნენ. მათ არ აინტერესებდათ, რა ენაზე იყო დაწერილი Viaweb, მაგრამ ხვდებოდნენ, რომ ის მართლაც კარგად ფუნქციონირებდა. აპლიკაციის დახმარებით ისინი არაჩვეულებრივ ონლაინმაღაზიებს ზუსტად წუთებში ქმნიდნენ. ჩვენს შესახებ ინფორმაციაც ძირითადად ზეპირსიტყვიერად ვრცელდებოდა და მომხმარებელთა რაოდენობაც იზრდებოდა. 1996 წლის ბოლოსთვის 70-ამდე ონლაინ მაღაზია გვქონდა; 1997 წლის ბოლოს – 500; აქედან ექვსი თვის შემდეგ, როდესაც Yahoo-მ გვიყიდა, უკვე 1070 მომხმარებელი გვყავდა.

Blub-ის პარადოქსი

რა არის ასეთი გასაოცარი Lisp-ში? და თუ Lisp ასეთი კარგია, რატომ არ იყენებს მას ყველა? ეს კითხვები რიტორიკულად ჟღერს, მაგრამ მათზე პირდაპირი პასუხები არსებობს – Lisp ძალიან კარგი იმიტომ არის, რომ ხელმისაწვდომთა შორის ყველაზე მძლავრი პროგრამირების ენაა; მიზეზი, რის გამოც მას ყველა არ იყენებს, არის ის, რომ პროგრამირების ენები არა მხოლოდ ტექნოლოგიები, არამედ ადამიანთა ჩვევებიცაა. ახლა კი ორივე პასუხი განვმარტოთ.

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

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

არ მინდა ვინმეს შეურაცხყოფა მივაყენო, ამიტომ ამ საკითხის ასახსნელად გამოვიყენებ ჰიპოთეტურ ენას, სახელწოდებით Blub. ჩავთვალოთ, რომ ის ზემოთ ხსენებული აბსტრაქტული კონტინუუმის შუაშია – ანუ არ არის ყველაზე ძლიერი, თუმცა Cobol-სა და მანქანურ ენაზე უფრო მძლავრია. ჩვენი ჰიპოთეტური Blub-ის პროგრამისტი, რომ გვეკითხა, არცერთ უკანასკნელ მათგანს არ გამოიყენებდა – მანქანურ ენაზე, რა თქმა უნდა, არ დააპროგრამებდა, კომპილატორები ხომ სწორედ ამისთვის არსებობს; რაც შეეხება Cobol-ს, ის ვერ ხვდება, რანაირად მუშაობენ ამ ენაზე სხვები, მას ხომ X არ აქვს (Blub-ის რაიმე ფუნქცია). მოკლედ, მანამ, სანამ პროგრამისტი არსებულ ენების კონტინუუმს უყურებს, იცის, რომ ქვემოთ (ნაკლებად ძლიერი ენებისკენ) იყურება. Blub-ზე სუსტი ენები აშკარად ნაკლებად ეფექტურია, რადგან მათ არ გააჩნიათ ისეთი ფუნქცია, რომელსაც იგი იყენებდა. თუმცა, როდესაც პროგრამისტი მეორე მიმართულებით (უფრო ძლიერი ენებისკენ) გაიხედავს, ის ვერ ხვდება, რომ მაღლა იყურება, უბრალოდ რაღაც უცნაურ ენებს ხედავს და ალბათ, ფიქრობს კიდეც, რომ მათ Blub-ისნაირი სიძლავრე აქვთ. Blub მისთვის საკმარისია, რადგან ის  Blub-ის გადმოსახედიდან ფიქრობს.  აი, როდესაც უკვე იმ პროგრამისტის თვალსაზრისში გადავინაცვლებთ, რომელიც სიძლიერის კონტინუუმზე არსებულ უფრო მაღლა მდგომ ენას იყენებს, აღმოვაჩენთ, რომ ის, თავის მხრივ, Blub-ს ზემოდან დაჰყურებს – როგორ აკეთებენ რაიმეს საერთოდ Blub-ში? მას Y-იც კი არ აქვს.

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

რჩევა სტარტაპებისთვის

არ მაქვს იმის მოლოდინი, რომ ვინმეს (25 წელზე უფროსს) Lisp-ის სწავლას მოვანდომებ. ამ სტატიის მიზანი არა ვინმეს აზრის შეცვლა, არამედ იმ ადამიანების დაარწმუნებაა, რომლებიც უკვე დაინტერესებულნი არიან ამ ენის გამოყენებით – ადამიანები, რომლებმაც იციან, რომ Lisp ძლიერი ენაა, მაგრამ ნერვიულობენ, რადგან ის ფართოდ არ გამოიყენება. რეალურად, სწორედ ესაა მათი უპირატესობა კონკურენტულ სიტუაციაში.

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

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

Viaweb-ზე მუშაობისას ახალი კონკურენტები ყოველთვიურად ჩნდებოდნენ. პირველი რასაც ვაკეთებდი (იმის ნახვის შემდეგ, ჰქონდათ თუ არა ონლაინდემო)  მათი სამუშაოს განცხადებების მოძიება იყო. ამ საქმიანობაში გარკვეული გამოცდილების დაგროვების შემდეგ კი უკვე ვხვდებოდი, რომელი კომპანიის გამოჩენა იყო საგანგაშო და რომლის – არა. მაგალითად, თუ ვაკანსიით C++ ან Java დეველოპერს ეძებდნენ, საშიში არაფერი იყო; ხოლო თუ Perl ან Python პროგრამისტები სჭირდებოდათ, ოდნავ საფრთხილო იყო კომპანია. ოდესმე რომ წამეკითხა განცხადება, რომელშიც Lisp იყო ნახსენები, ძალიან ავღელდებოდი.