на чем написана mac os
Создание программ для Mac OS X. Часть 1: вступление и Objective-C
Я думаю все слышали про Mac OS X как операционную систему для дизайнеров и домохозяек. Но хочется рассказать про средства разработки для OS X, а то хорошие программы пишут, а на чем — никто не знает.
Сразу скажу, что не буду рассказывать про кроссплатформенные фреймворки и тулкиты(такие как Qt) или про создание консольных приложений, я расскажу про то, что в плане создания приложений отличает Mac OS X от других операционных систем, а именно — фреймворк Cocoa. Оговорюсь сразу, что буду стараться избегать сравнений с другими фреймворками, я хочу просто рассказать про Cocoa.
Заглянем немного в историю. Mac OS X — дальнейшее развитие ОС NextSTEP. NextSTEP была первой ОС в которой очень широко использовался язык Objective-C, на нем была написана большая библиотека готовых объектов, причем как и обычные типы данных — строки, массивы, словари, так и объекты, используемые для построения GUI приложений. Поэтому, большая часть приложений под NextSTEP писалась на Objective-C с использованием готовых объектов. Эта самая библиотека и переросла в Cocoa framework.
Но включать в новую ОС почти незнакомый никому API было бы крайне плохим решением, поэтому добавили еще 2: Classic и Carbon.
Classic создан для того, чтобы запускались приложения Mac OS 9, на данный момент рассматривать его бессмысленно, т.к. после перехода на процессоры фирмы Intel по понятным причинам Classic был выкинут из системы.
Carbon был создан чтобы легко перенести приложения из Mac OS 9 в OS X, с возможностью добавить к уже готовому коду программы новую функциональность, доступную только в десятке. Как ни странно, но много приложений до сих пор написаны на Carbon(например MS Office for Mac и некоторые продукты Adobe).
На данный момент фреймворки Carbon и Cocoa развиваются паралельно, но со следующего релиза Mac OS X будут развивать только Cocoa.
Основным языком разработки под Cocoa является Objective-C, а поскольку в дальнейшем все примеры будут идти на этом языке, то впервой части я расскажу именно про него. Но если вы уже владеете Python или Ruby, то изучать Objective-C вам не надо, в XCode 3.0(срада разработки, о ней в следующей части) биндинги для этих языков «искаропки».
Язык программирования Objective-C
Помимо широкого известного и распространенного объектного расширения языка С — языка С++ — есть и другое его расширение — язык Objective-C, обладающий огромной простотой, полной совместимостью с языком С и очень мощной и выразительной объектной моделью, заимствованной из языка Smalltalk.
Язык был придуман Брэдом Коксом (Brad Cox) в начале 80-х годов прошлого века. Целью Кокса было создание языка, поддерживающего концепцию software IC. Под этой концепцией понимается возможность собирать программы из готовых компонент (объектов), подобно тому как сложные электронные устройства могут быть легко собраны из набора готовых интегральных микросхем (IC, integrated curcuits). При этом такой язык должен быть достаточно простым и основанным на языке С, чтобы облегчить переход разработчиков на него.
Одной из целей было также создание модели, в которой сами классы также являются полноценными объектами, поддерживалась бы интроспекция и динамическая обработка сообщений.
Получившийся в результате язык Objective-C оказался крайне прост — его освоение у С-программиста займет всего несколько дней. Он является именно расширением языка С — в язык С просто добавлены новые возможности для объектно-ориентированного программирования. При этом любая программа на С является программой и на Objective-C (для языка С++ это не верно).
Еще одной из особенностей языка является то, что он message-oriented в то время как С++ — function-oriented. Это значит, что в нем вызовы метода интерпретируются не как вызов функции (хотя к этому обычно все сводится), а именно как посылка сообщения (с именем и аргументами) объекту, подобно тому, как это происходит в Smalltalk-е. Такой подход дает целый ряд плюсов — так любому объекту можно послать любое сообщение. Объект может вместо обработки сообщения просто переслать его другому объекту для обработки (так называемое делегирование), в частности именно так можно легко реализовать распределенные объекты (т.е. объекты находящиеся в различных адресных пространствах и даже на разных компьютерах). Привязка сообщения к соответствующей функции происходит непосредственно на этапе выполнения.
Язык Objective-C поддерживает работу с метаинформацией — так у объекта непосредственно на этапе выполнения можно спросить его класс, список методов (с типами передаваемых аргументов) и instance-переменных, проверить, является ли класс потомком заданного и поддерживает ли он заданный протокол и т.п.
В языке есть нормальная поддержка протоколов (т.е. понятие интерфейса объекта и протокола четко разделены). Для объектов поддерживается наследование (не множественное), для протоколов поддерживается множественное наследование. Объект может быть унаследован от другого объекта и сразу нескольких протоколов (хотя это скорее не наследование протокола, а его поддержка).
На данный момент язык Objective-C поддерживается компилятором gcc. Довольно много в языке перенесено на runtime-библиотеку и сильно зависит от нее. Вместе с компилятором gcc поставляется минимальный вариант такой библиотеки. Также можно свободно скачать runtime-библиотеку от компании Apple: Apple’s Objective-C runtime. Эти две runtime-библиотеки довольно похожи (в основном отличие заключается в именах методов), хотя далее я буду ориентироваться на runtime-библиотеку от компании Apple.
Синтаксис языка
В языке Objective-C для обозначения объектов используется специальный тип id. Переменная типа id фактически является указателем на произвольный объект. Для обозначения нулевого указателя на объект используется константа nil. Кстати про id: движок игры Doom разрабатывался на рабочих станциях Next, так что может есть связь между типом id и названием idSoftware.
Для посылки сообщений используется следующий синтаксис:
[receiver message];
Сообщение может также содержать параметры:
[myRect setOrigin:30.0 :50.0];
В этом примере именем метода (сообщения) является setOrigin. Обратите внимание, что каждому передаваемому аргументу соответствует ровно одно двоеточие. При этом в приведенном примере первый аргумент имеет метку (текст перед двоеточием), а второй — нет.
Язык Objective-C позволяет снабжать метками каждый аргумент, что заметно повышает читаемость кода и снижает вероятность передачи неправильного параметра.
[myRect setWidth:10.0 height:20.0];
В этом примере в качестве имени сообщения выступает setWidth:height:.
Также поддерживается возможность передачи произвольного количества аргументов в сообщении:
[myObject makeGroup: obj1, obj2, obj3, obj4, nil];
Как и функции, сообщения могут возвращать значения, при этом в отличии от языка С, типом возвращаемым по умолчанию значения является id.
float area = [myRect area];
Результат одного сообщения можно сразу же использовать в другом сообщении:
[myRect setColor:[otherRect color]];
Как уже говорилось, в Objective-C классы сами являются объектами. Основной задачей таких объектов (называемых class objects) является создание экземпляров данного класса. При этом само имя класса играет двойную роль — с одной стороны оно выступает как тип данных (т.е. он может быть использован для описания указателей на объекты данного класса). А с другой стороны имя класса может выступать в качестве объекта, которому посылается сообщение ( в сообщениях имя класса может принимать участие только как receiver). В языке Objective-C нет встроенного типа для булевских величин, поэтому обычно такой тип вводится искусственно. Далее я буду для логических величин использовать тип BOOL с возможными значениями YES и NO(ИМХО более понятней, но не так “политкорректно” как true/false).
Создание новых классов
Все новые директивы компилятору в языке Objective-C начинаются с символа @. Как и в С++ описание класса и его реализация разделены (обычно описание помещается в заголовочные файлы с расширением h, а реализации — в файлы с расширением m).
Ниже приводится общая структура описания нового класса:
@interface ClassName: SuperClass
<
instance variable declarations
>
method declarations
end
В версии runtime от Apple все классы имеют общего предка — класс NSObject, содержащий целый ряд важных методов. Описание переменных ничем не отличается от описания переменных в структурах в языке С:
@interface Rect: NSObject
<
float width;
float height;
BOOL isFilled;
NSColor * color;
>
end
Каждое описание начинается со знака плюс или минус. Знак плюс обозначает, что данный метод является методом класса (т.е. его можно посылать только class object’у, а не экземплярам данного класса). Фактически методы класса являются аналогами статических методов в классах в языке С++. Знак минус служит для обозначения методов объектов — экземпляров данного класса. Обратите внимание, что в Objective-C все методы являются виртуальными, т.е. могут быть переопределены.
Ниже приводятся описания возможных методов для класса Rect.
@interface Rect: NSObject
<
float x, y;
float width;
float height;
BOOL isFilled;
NSColor * color;
>
+ newRect;
— (void) display;
— (float) width;
— (float) height;
— (float) area;
— (void) setWidth: (float) theWidth;
— (void) setHeight: (float) theHeight;
— (void) setX: (float) theX y: (float) theY;
end
Обратите внимание, что имя метода может совпадать с именем instance-переменной данного класса (например, width и heigh).
Тип возвращаемого методом значения указывается в круглых скобках сразу же после знака плюс или минус (но перед названием метода). Если тип не указан, то считается, что возвращается значение типа id. Далее идет имя метода, где после каждого двоеточия задается тип аргумента (в круглых скобках) и сам аргумент. Язык Objective-C позволяет для аргументов метода задавать также один из следующих описателей — oneway, in, out, inout, bycopy и byref. Данные описатели служат для задания направления передачи данных и способа передачи.
Для подключения заголовочного файла в Objective-C вместо директивы #include используется директива #import, полностью аналогичная #include, но гарантирующая что данных файл будет подключен всего один раз.
Реализация методов класса выглядит следующим образом:
#import «ClassName.h»
@implmentation ClassName
method implementations
end
Ниже приводится пример реализации методов класса Rect, описанного ранее.
#import «Rect.h»
+ newRect <
Rect * rect = [[Rect alloc] init];
[rect setWidth: 1.0f];
[rect setHeight: 1.0f];
[rect setX: 0.0f y: 0.0f];
>
— (float) width < return width; >
— (float) height < return height; >
— (float) area < return [self width] * [self height]; >
— (void) setWidth: (float) theWidth < width = theWidth; >
— (void) setHeight: (float) theHeight < height = theHeight; >
— (void) setX: (float) theX y: (float) theY <
x = theX;
y = theY;
>
end
Как видно из примера выше, в методах доступны все instance-переменные. Однако, как и в С++, есть возможность управлять видимостью переменных (видимостью методов управлять нельзя) при помощи директив private, protected и public (действующих полностью аналогично языку С++).
Как работает механизм сообщений
Компилятор переводит каждую посылку сообщения, т.е. конструкцию вида [object msg] в вызов функции objc_msgSend.
Эта функция в качестве своего первого параметра принимает указатель на объект-получатель сообщения, в качестве второго параметра выступает т.н. селектор, служащий для идентификации посылаемого сообщения. Если в сообщении присутствуют аргументы, то они также передаются objc_msgSend как третий, четвертый и т.д. параметры. Далее происходит поиск подходящей функции среди функций данного класса, если такой не найдено, то среди функций родительского класса, если и там не найдено, то среди функций родительского класса родительского класса( 🙂 ) и т.д. Если метод (т.е. соответствующая ему функция) находится, то осуществляется его вызов с передачей всех необходимых аргументов.
В противном случае объекту дается последний шанс обработать сообщение перед вызовом исключения — селектор сообщения вместе с параметрами «заворачивается» в специальный объект типа NSInvocation и объекту посылается сообщение forwardInvocation:, где в качестве параметра выступает объект класса NSInvocation.
Если объект поддерживает forwardInvocation:, то он может либо сам обработать посылаемое сообщение, либо переслать другому объекту для обработки:
— (void)forwardInvocation:(NSInvocation *)anInvocation
<
if ( [someOtherObject respondsToSelector: [anInvocation selector]] )
[anInvocation invokeWithTarget: someOtherObject];
else
…
>
Создание и уничтожение объектов
В самом языке Objective-C нет специальных команд для создания и уничтожения объектов (подобных new и delete). Эта задача ложится на runtime-библиотеку и реализуется при помощи механизма посылки сообщений.
Создание нового объекта разбивается на два шага — выделение памяти и инициализация объекта. Первый шаг реализуется методом класса alloc (реализованном в классе NSObject), который выделяет необходимое количество памяти (данный метод используется для выделения памяти не только для объектов класса NSObject, но и любого унаследованного от него класса). При этом выделяемая память обнуляется и в атрибут isa записывается указатель на class object соответствующего класса.
Обратите внимание, что сообщение alloc посылается class object-у требуемого класса и это сообщение возвращает указатель на выделенную под объект память.
Собственно сама инициализация объекта (т.е. установка значений его instance-переменных, выделение дополнительных ресурсов и т.п.) осуществляется другими методами, по традиции имена этих методов начинаются с init. Обычно такое сообщение посылается сразу же после сообщение alloc, по адресу, возвращенному этим сообщением.
id anObject = [[Rectangle alloc] init];
При создании нового класса обычно нет необходимости переопределять метод alloc, а вот необходимость переопределения метода init возникает достаточно часто (хотя во многих случаях можно положится на обнуление памяти alloc’ом).
Обратите внимание, что метод(ы) init является обычным методом, ничем не выделяющимся среди остальных (в отличии от С++, где конструктор — это особый метод, у которого например нельзя взять адрес). Поэтому при создании нового класса и метода init вызов переопределенного метода init (при помощи [super init]) должен быть произведен явно в самом начале метода.
Mac OS X (как и NextStep) для управления временем жизни объектов используют reference counting — каждый объект содержит внутри себя некоторый счетчик, при создании устанавливаемый в единицу.
Посылка объекту сообщения retain увеличивает значение этого счетчика на единицу (так все контейнерные классы библиотеки Foundation при помещении в них объекта, посылают ему сообщение retain). Установившейся практикой является посылка объекту сообщения retain всеми, заинтересованными в нем сторонами (объектами), т.е. если вы запоминаете ссылку на объект, то следует послать ему сообщение retain.
Когда объект перестает быть нужен, то ему просто посылается сообщение release. Данное сообщение уменьшает значение счетчика на единицу и, если это значение стало меньше единицы, уничтожает данный объект.
Перед уничтожением объекта ему посылается сообщение dealloc, позволяющее объекту произвести свою деинициализацию. При этом это также является обычным сообщением и в нем Вы явно должны в конце вызвать унаследованную реализацию через [super dealloc].
Objective-C 2.0
На WDC2006 Apple представила новую версию языка — 2.0. Среди нововведений были отмечены сборка мусора, быстрая энумерация, свойства в классах, 64-битная поддержка и многое другое. Следует отметить, что эти нововведения доступны только для Leopard.
Сборка мусора
Objective-C 2.0 позволяет производить автоматическую сборку мусора, правда это опционально.
Свойства
Ранее для изменения и чтения instance variables необходимо было писать методы возврата и задания значения(т.н. getters and setters), теперь можно писать так:
@interface Person: NSObject <
>
@property(readonly) NSString *name;
@property(readonly) int age;
-(id)initWithName:(NSString)name age:(int)age;
end
Получить имя можно так:
NSString *name = aPerson.name;
Быстрая энумерация
Теперь добавлен аналог оператора foreach:
for (Person *p in thePeople) NSLog(@»%@ is %i years old.», [p getName], [p getAge]);
Для первой части хватит. При составлении статьи были использованы материалы сайтов developer.apple.com и steps3d.narod.ru(кстати единственный сайт, на котором есть информация про программирование в Mac OS X на русском).
В следующей части расскажу про среду разработки XCode и редактор интерфейсов Interface Builder, а также покажу создание совсем простенького приложения.
На каких языках написаны Windows, Mac OS X и Linux?
Мне просто интересно, кто знает, какие языки программирования Windows, Mac OS X и Linux состоят из и какие языки используются для каждой части ОС (т. е.: ядро, подключаемая архитектура, компоненты GUI и т. д.).
Я предполагаю, что для каждого есть несколько языков, и, очевидно, я знаю, что ядро Linux написано на C.
Я полностью предполагаю, что Mac OS X содержит много кода Objective-C, поскольку это язык Apple, полученный из следующий.
Windows, я слышал, содержит сборку C, C++ и Intel. Содержит ли Linux или Mac OS какой-либо код сборки?
кроме того, существуют ли языки сценариев, такие как Ruby, Python и т. д., используемые разработчиками ОС для написания сценариев частей ОС? Какие части ОС будут написаны на каждом языке?
13 ответов
все ядра также будут использовать некоторый код сборки.
Linux: C. Некоторые детали в сборке.
Mac OS X: Cocoa в основном в Objective-C. ядро написано на C, некоторые части в сборке.
Mac OS X, на уровне ядра, в основном является старой, свободной операционной системой под названием BSD (в частности, это Дарвин, своего рода гибрид BSD, Mach и некоторых других вещей). почти полностью C, с небольшим количеством ассемблера. (источник)
большая часть Cocoa реализована в Objective-C, объектно-ориентированном языке, который компилируется для работы с невероятной скоростью, но использует действительно динамическую среду выполнения, что делает ее уникально гибкой. Поскольку Objective-C является надмножеством C, легко смешивать C и даже C++ в ваших приложениях Cocoa. (источник)
Windows: C, C++, C#. Некоторые части в ассемблере.
мы используем почти полностью C, c++ и C# для Windows. Некоторые области кода-ручная настройка / ручная сборка. (источник)
в Unix: C. Некоторые детали в сборке. (источник)
Mac OS X глазами Windows-юзера
Т.к. моя работа в последнее время связана с разработкой под iOS, мне периодически приходится пересекаться с Mac OS. В этой статье я расскажу о своих впечатлениях об этой системе глазами человека, который всю свою сознательную жизнь провел за виндами.
Сразу скажу — что Mac OS — это не обязательно Apple. Т.к. есть такие проекты, как «Хакинтош», которые позволяют ставить эту OS на любые компьютеры. Конечно, в этом случае вам понадобится нефиговый бубен (особенно если у вас АМД), но факт остается фактом — это возможно. Правда, не всегда гладко. Например, я ставя хакинтош на свой AMD, два дня сидел в гугле в поисках сначала сборки, потом драйверов и прочих фиксов. Кстати, один критичный баг, когда весь флэш-контент (в т.ч. и видео) периодически фризился в браузере — я не поборол. Но про установку макоси на PC я распространяться не буду — это тема для целого отдельного топика.
Есть у меня опыт и работы с родной Mac OS на Mac Mini (кстати, несмотря на свою дороговизну — эта машинка определенно обладает своим очарованием! особенно когда понимаешь, что эта алюминиевая коробочка чуть больше роутера размером может тягаться с огромным шумным компом 3-летней давности).
Плавность и красота.
Первое, что мне бросилось в глаза — это плавность. Все красиво анимированно, все выезжает, сворачивается, разворачивается… Все кнопочки и прочие элементы интерфейса вылизаны до блеска. Нет, не сказал бы, что в Windows 7 (про «восьмерку» я промолчу) все некрасиво. Но такое чувство, что в макоси оно просто еще красивее.
Шрифты.
На тему шрифтов в маке сломано немало копий. Первое ощущение после виндов — «жирные и размытые». Дело в том, что винда всегда пытается подогнать толщину линий шрифтов под целое количество пикселей, а макось рисует как есть. Кстати, по этому многие типографы предпочитают работать с маками, т.к. на маках шрифты выглядят именно так, как будут потом смотреться на бумаге.
На мониторе же… Сначала — непривычно.
Но чем больше работаешь — тем больше влюбляешься в них. Особенно красиво выглядят интерфейсы с этими шрифтами:
И уже через пару часов они не выглядят «жирными и размытыми». Более того — перелезая обратно на винды — лично мне начинает нехватать этих шрифтов.
Быстродействие.
И при этом — все очень быстро и плавно. Скорость — это второе, что ощущаешь. Как я говорил выше, я имел опыт использования MacOS (хакинтош) параллельно с Windows 7 на одном компе. Так вот — на одной и той же машине ощущение, что макось работает быстрее. Грузится она быстрее раза в 2 (но здесь — не корректное сравнение, т.к. макось у меня еще не загаженная, а «семерка» стоит испокон веков). Тяжеловесный софт (мерил на Photoshop’е и Flash’е) запускается где-то на 30% быстрее.
Но главное даже не в этом. Как часто в виндах случается такое, что какое-то действие приводит к песочным часикам о потери отклика системы? При чем иногда я «ловил» такое просто на ровном месте. Заходишь в папку — и все. Сиди, жди пол минуты, пока винда что-то там обдумает. Несмотря на то, что курсор анимируется и двигается, система — фризится. Сделать ничего нельзя.
В Mac OS такого нет (ну, или я не ловил). Даже если какая-то программа подвисла, это никак не сказывается на отзывчивости остальных программ и интерфейса. Иконки в доке продолжают няшно увеличиваться при наведении и все отлично работает.
Док — это панелька с иконками внизу экрана. Типа виндовой панели задач. Но организовано тут все несколько иначе.
На данный момент я провел достаточно времени под макосью, но все равно — мне эта идея дока кажется не слишком очевидной. Красиво — бесспорно. Но с точки зрения юзабилити…
Для тех, кто не в курсе — расскажу в паре слов, как это работает.
В левой части дока (которую на этом скрине я сократил, но она занимает где-то 70%) — то, что в Windows называлось бы «закрепленные приложения». Т.е. эти иконки есть всегда. Эта же часть работает как обычная панель задач, т.е. все свежезапущенные приложения попадают сюда же. В принципе — пока что похоже на Windows. Только вот индикатор запущенности в виндах явно очевиднее. Здесь же — узнать, запущенно ли приложение можно только по крошечной точке-лампочке внизу (видите, под первыми двумя иконками голубые огоньки?).
Правая часть дока — вообще нечто странное. Там есть корзина (это понятно), папочки «приложения», «мои документы» и т.п. — это тоже понятно. Но почему-то все сворачиваемые окошки — попадают сюда же. Но одновременно и остаются в левой части. Вот, посмотрите на Firefox. Он есть и в левой части (а т.к. он запущен — под ним горит лампочка), но т.к. я его свернул (минимизировал) — то он улетел и в правую часть тоже. В чем великая суть — я так и не понял (update: это поведение можно отключить в настройках дока).
Кстати, о том, что кнопки закрытия, максимизации и минимизации окна находятся слева, а не справа, как мы привыкли — вообще не доставляет дискомфорта. Привыкаешь моментально.
Где мою меню, чувак.
Еще одна необчыность Mac OS для вин-юзера — это меню программ. В виндах мы привыкли, что менюшки всегда под заголовком. В маке же — меню приложения всегда на самом верху экрана. Независимо от размера окна и т.п.
Ниже — наглядный пример. Окно Firefox’а не на весь экран, а менюшка все равно — в самом верху.
Стоит признать, что это удобно. Всегда знаешь, где искать меню.
Клавиатура.
Единственное, к чему придется привыкать — это Ctrl+Tab вместо Alt+Tab. И смена языка ввода на Ctrl+Space (нет, переназначить на Alt+Shift или тому подобные — нельзя).
Слава Богу, — это лечится. Но не везде одновременно. Во-первых — есть скрипт, который исправляет системный биндинг клавиш и Home/End почти везде начинают работать нормально. Но не везде. Так, где это не пофиксилось — придется искать отдельные решения. Например, во многих IDE это придется выставлять в настройках. А в Firefox — так вообще пришлось скачать отдельный плагин «Keyfixer».
Встроенные удобности.
В Mac OS X встроен функционал, который отродясь в виндах подключался либо разной кривости утилитами, либо вводится только теперь.
Во-первых — это многодесктопность. Удобное переключение между рабочими столами, возможность назначить на каком раб. столе запускать какое приложение и прочие мелочи…
Во-вторых — это активные углы экрана (настраиваемые, конечно). Т.е. подвел мышку к левому верхнему углу — и плавно выехал Mission Control (визуальное представление всех открытых окон):
Ну, и еще куча мелких полезностей, половины которых я пока и сам не знаю. Например, недавно нужно было выровнять на экране объект с точностью до пикселя. В макоси есть встроенная возможность моментально увеличить экран колесиком, зажав клавишу-модификатор. Или встроенная утилита, делающая скрин-шот и кладующая его в папку по комбинации клавиш. Да, есть возможность задавать системные горячие клавиши.
Установка и удаление программ.
Вот тут — я был очень приятно удивлен.
Админ юзер и безопасность.
Пробовали ли вы сидеть в виндах со включенным контролем учетных записей? (UAC)
По-моему — это ад. Каждая вторая программа будет запрашивать админский пароль и т.п. Даже если это какой-нить вшивый текстовый редактор на 500 килобайт — есть вероятность, что ему потребуется залезть в защищенные области системы.
В маке же с этим все гораздо лучше. Админский пароль просят только действительно системные утилиты. При обычной работе желания выключить UAC не возникает вообще (кстати, я даже не уверен — возможно ли это!).
Про почти полное отсутствие вирусов вы слышали, наверняка. (Поймать вирус на маке можно только если ты его сам себе поставишь)
Также, порадовала встроенная «Связка ключей» — утилита для хранения зашифрованной информации, паролей и т.п. Которая тесно интегрируется со всем вокруг. Теперь вам не нужно беспокоиться, где браузер хранит ваши пароли. Он их хранит в зашифрованном месте.
Сторонний софт.
Кроме того, если вам очень уж надо запустить что-то виндовое — то есть великолепное решение — «Parallels Desktop». Это не обычная виртуальная машина. Это действительно — жутко удобная система!
Вы ставите Parallels Desktop, оно тут же предлагает поставить Windows (нужен образ с виндой, конечно же). Вы ставите винду и начинается магия…
Конечно, есть возможность работать с виндой в отдельном окошке… но это неинтересно. Гораздо интереснее система интеграции винды называемая «Coherence». Суть ее в том, что после установки винды, она запускается где-то в фоне (вы об этом узнаете только по соответствующему звуку) и после чего вы сможете работать с любыми виндовыми программами как с маковскими.
Как вам такой симбиоз?
Кроме всего прочего, все ваши виндовые программы объединятся в специальную папочку и вы сможете запускать их как маковские.
А в завершение, на таскбаре появятся виндовые иконки и кнопочка, которая позволит вызвать меню «Пуск».
Да, и папка «Мои документы» — окажется тоже общей для винды и макоси.
Вывод.
Что я вам скажу? Мне очень понравилась Макось. Есть желание использовать ее всегда и везде 🙂
А вам — советую хотя бы попробовать. Особенно учитывая, что поставить ее можно почти на любую железку (все зависит только от прямоты ваших рук, качества бубна и наличия времени/желания).
UPDATE: Господа *ксоиды, не нужно, плз, советовать ставить вашу ОС. Я — работаю. Мне нужны Photoshop, Flash, Unity, XCode, iTunes. И я не хочу запускать основные программы, с которыми я работаю 90% времени под виртуализацией.
Статья претендует лишь на субъективный взгляд юзера, которому нужно решать определенные задачи. И ни в коем случае не претендует на холивар MacOS vs Linux. Вам удобнее линукс? Рад за вас! Винда? Ради Бога! Мне понравилась макось. Пис! 🙂