Я студент. Я изучил Java в течение 2-го года. Теперь я на четвертый год. Мне стало скучно с java и я начали изучать Scala. Поскольку я изучаю это, я нахожу его очень сложным (хотя я его люблю). Мой вопрос может применяться ко всему новому сложному языку.
Почему scala является сложным?
это потому, что нам нужно создавать сложные программы?
или я единственный, кто считает, что он сложный?
@Anantha В течение последних десяти лет большинство университетов преподавали своим ученикам Java как первый язык. Я слышал о поразительно большом числе случаев, когда он даже остается единственным учеником, которого учащиеся учатся в колледже, - если только они не берут что-то другое самостоятельно.
Чисто с точки зрения языка, Java три наиболее характерные функции:
Особенности 1 и 2 делают его очень похожим на широкий набор языков из семейства Algol/C и С++. Все эти языки либо имеют сходство в своей парадигме, либо даже используют точно то же самое.
С#, например, несмотря на синтаксические различия, Windows как основная целевая ОС и .NET framework как "библиотека классов", очень легко подобрать для Java-программиста. Это связано с тем, что оба языка используют одну и ту же парадигму программирования.
Scala, с другой стороны - несмотря на работу на JVM, обеспечивающую легкую функциональную совместимость с Java API, - это то, что обычно называют языком мультипарадигмы. Язык обеспечивает глубокую синтаксическую интеграцию функций функционального программирования, но структурирует код объектно-ориентированным способом.
Концепция функционального программирования - особенно после того, как вы попадаете в код, выходящий за рамки тривиальных обучающих программ, оказывается трудной для разработчиков, которые имеют опыт только с императивными языками OO. Мой личный опыт помогать коллегам-разработчикам ускориться на Scala и др., Так это то, что он очень помогает научить их схеме сначала;) Это хороший, маленький, чистый диалект Lisp. Это помогает при передаче расширенных функциональных концепций. Если вы решите сделать это, я рекомендую вам взглянуть на "The Little Schemer" и "The Seasoned Schemer". Как только вы закончите работу с обеими книгами, я готов поспорить, что вам будет легче смотреть прямо через синтаксис Scala и более четко понимать его.
Вкратце: ИМХО это не Scala, что трудно понять, парадигма функционального программирования является причиной для большинства разработчиков, которые только подвергаются воздействию императивных языков, с трудом поднимаясь на скорость.
Здесь есть два вопроса:
Первый вопрос легче ответить: язык Scala богаче Java. В частности, его система типов более выразительна, чем Java, что означает, что можно выражать более логические ошибки как ошибки времени компиляции. Однако для того, чтобы использовать эти возможности, нужно познакомиться с различными конструкциями языка (зависимые типы, классы случаев, аннотации вариаций, представления, чтобы назвать несколько). Для овладения ими требуется время, и поэтому Scala сложнее изучить, чем Java.
Второй вопрос сложнее. Сторонники Scala утверждают, что эти новые конструкции облегчают запись правильных программ и что полученный код проще. Другие говорят, что Scala дополнительная мощность не перевешивает сложность понимания семантики его конструкций (например, взгляните на эту беседу Найдите "Scala" ). Это проявление более широкого спора: статического и динамически типизированного языков.
Scala является сложным, поскольку он дает вам гибкость. Время от времени, не имея достаточной гибкости, трудно выполнять некоторые задачи, но слишком большая гибкость - это слишком много денег, это позволяет вам совершать действительно большие ошибки.
Scala является объектно-ориентированным и функциональным. Оба эти типа языка когда-то считались довольно сложными (хотя объектно-ориентированные стали более популярными), но их объединение открывает всевозможные новые двери. Некоторые из этих дверей выглядят как короткие сокращения до "миссии"! У некоторых из этих дверей есть львы. Функциональное программирование дает вам всю веревку, чтобы выполнить задание, повеситься и связать свое соседство в узлах в течение многих лет. Это зависит от вас, чтобы не повредить себе функциональный язык программирования.
Ключом к успешному Scala является распознавание того, что вы должны быть успешным объектно-ориентированным программистом, успешным функциональным программистом, а затем научиться смешивать эти два способа таким образом, чтобы вы достигли своей цели. Это много работы. Возможно, в будущем люди узнают, что такое "лучший" подход к обучению Scala, но пока единственный известный подход - это хорошо в двух разных подходах к прогаммингам, и быть хорошими в их смешении.
Что сложное в Scala - это система типов. Он очень гибкий, но, к сожалению, раскрывает эту гибкость в сигнатурах сложного типа.
Или может быть, что вы находите переход парадигмы к использованию функций более высокого порядка.
В любом случае, я рекомендую вам придерживаться его. Он предлагает степень власти над Java-языком, который не может быть передан.
Я единственный, кто не считает это сложным? Конечно, вы можете написать сложный материал. Но альтернатива не могла бы писать сложные вещи, что не совсем улучшилось. Но я считаю, что язык очень прост.
То, что я действительно думаю, вы переживаете, - это удар по изучению второго языка. Вероятно, вы сочли бы C своей арифметикой указателей очень сложной.
Если вы считаете, что язык сложный, вы можете изучить его поэтапно.
Это руководство по распаду Scala в разные части - это то, что многие люди делают инстинктивно и, как правило, обязательно, но это руководство написано Мартином (создателем Scala), поэтому он имеет свою уникальную перспективу. http://www.scala-lang.org/node/8610
Обратите внимание, что большинство конструктов, которые вызывают увлечение, находятся на уровнях дизайнера библиотеки. Промежуточный разработчик приложений может получить много работы без слишком много концепций школы CS.
**
Level A1: Beginning application programmer
Java-like statements and expressions: standard operators,
method calls, conditionals, loops, try/catch
class, object, def, val, var, import, package
Infix notation for method calls
Simple closures
Collections with map, filter, etc
for-expressions
Level A2: Intermediate application programmer
Pattern matching
Trait composition
Recursion, in particular tail recursion
XML literals
Level A3: Expert application programmer
Folds, i.e. methods such as foldLeft, foldRight
Streams and other lazy data structures
Actors
Combinator parsers
Level L1: Junior library designer
Type parameters
Traits
Lazy vals
Control abstraction, currying
By-name parameters
Level L2: Senior library designer
Variance annotations
Existential types (e.g., to interface with Java wildcards)
Self type annotations and the cake pattern for dependency injection
Structural types (aka static duck typing)
Defining map/flatmap/withFilter for new kinds of for-expressions
Extractors
Level L3: Expert library designer
Early initializers
Abstract types
Implicit definitions
Higher-kinded types
**
Я бы предположил, что вы не смотрите на Scala как сложный, просто расширенный. Scala представляет собой широкое и удивительно последовательное продвижение практически по всем аспектам традиционных императивных языков программирования, однако каждый из этих достижений легко усваивается и применяется. Попытка принять слишком много улучшений Scala сразу, вероятно, приведет к путанице и повреждению доверия.
Scala заслуживает основного усыновления, но, похоже, страдает от его собственных опьяняющих эффектов. Попытка довольствоваться небольшими улучшениями очень сложна в такой богатой среде, но не откладывается.
Scala является сложным по нескольким причинам:
Он привносит парадигмы функционального программирования. Из-за этого библиотека коллекции Scala значительно отличается от Java.
Это позволяет создавать модульные и плавные API. Например, в Scala метод #map реализован в TraversableLike (один из корневых классов в библиотеке коллекции), но его тип результата является типом наиболее подходящей конкретной коллекции (для BitSet он вернет BitSet, если преобразование преобразует Int в Int и Set в противном случае). Это стало возможным благодаря языку, а не компилятору.
Это статически типизировано. Легче создать динамический язык с указанными выше функциями, но статическая типизация дает вам поддержку и производительность IDE.
ИМХО все эти функции очень важны и стоят дополнительной сложности.
Я был когда-то там, где ты есть. Когда я столкнулся с Scala в 2006 году, я отказался от него через некоторое время, пытаясь изучить его, за его сложность. Я должен был изучить его для проекта, который я делаю, и очень рад, что сделал это. Я считаю, что не изучать в 2006 году одну из самых больших ошибок в моей профессиональной жизни.
Scala предоставляет возможность создавать библиотеки, которые могут быть использованы очень короткими способами. Библиотеки Java часто имеют подробный, громоздкий интерфейс. Это не похоже на плюс для Scala, но не обязательно. В Scala две функции могут работать совершенно по-другому и все же выглядят очень похожими в использовании - синтаксис не является руководством к поведению. В то время как в Java некоторые вещи всегда становятся очевидными по синтаксису.
Предположим, что у вас есть функция foo в Java и она называется вот так:
foo(v > 5);
Итак, мы, по-видимому, передаем значение boolean. Не так быстро! Предположим, что у Java была функция, позволяющая функции foo захватывать выражение и оценивать его позже (возможно, в другом потоке). Поэтому вместо принятия значения boolean foo принимает функцию, которая не принимает параметров и возвращает boolean. Вы не можете сказать, что происходит, просто глядя на сайт вызова; вы должны знать, как работает foo, чтобы знать, когда будет оцениваться выражение v > 5. Если в Java сегодня выражение всегда будет оцениваться до выполнения foo.
Для программистов на Java это, вероятно, показалось бы весьма неприятным. Но Scala имеет эту точную функцию.
Это нарушение связи между синтаксисом и поведением - это то, что делает Scala более склонным путать неосторожных. С другой стороны, это позволяет создавать встроенные языки, специфичные для домена, где вся суть заключается в том, что существует краткая, эффективная нотация, подходящая для конкретной проблемной области.
Java является отличительной чертой, сильно поощряя определенный стиль написания. Если вы берете образцы кода у двух профессиональных программистов, Java, возможно, является единственным языком, на котором вы, вероятно, не сможете отличить их друг от друга. Одной из причин этого является то, что Java относительно негибкая, поэтому для многих проблем существует только один способ сделать что-то.
Scala гораздо более гибкий, но это приводит к тому, что многие способы делают одни и те же вещи. Например, чтобы заполнить карту с другой Карты, вы можете выполнять итерацию (Java, императивный стиль), или вы можете применить закрытие (функциональный стиль). Последнее, вероятно, будет более компактным, но более загадочным, если вы привыкнете к императивным языкам. Хуже того, Scala имеет множество ярлыков, чтобы сделать функциональный стиль еще более компактным - потенциально более читаемым для экспертов, но более загадочным для неспециалистов.
Другими словами, Scala - это язык для записи доменных языков. Он дает вам инструменты для добавления ключевых слов для вашего конкретного домена. Например, вы можете легко превратить Scala в отличный язык для учета или физики частиц. Но тогда у бухгалтеров и физиков возникнут проблемы с чтением программ друг друга.
К сожалению, одним из таких доменов является сбор. Вы можете написать код Java, стиль и список. Или вы можете использовать более критический код, который может быть намного более понятным и кратким - как только вы узнаете все трюки.
Я не думаю, что любой язык может иметь это в обоих направлениях.
Он такой же сложный, как Java (или любой современный язык программирования) - я могу только предположить, что вы не видели больших программ на Java.
Это не только объектно-ориентированный, но и функциональный, который представляет собой другую парадигму программирования.
Не путайте свои трудности с функциональным программированием с жестким языком. Функциональное программирование может быть очень запутанным для тех, которые используются для объектно-ориентированного (или процедурного) программирования.
Я сложнее, потому что он должен иметь всю силу, которая у него есть. Java проще, но Java также не имеет такого же количества возможностей, как Scala.
Java:
Мои дети могут кататься на велосипеде, моя мама не может
Моя мама может водить машину, мои дети не могут
Scala не является сложным - он отличается
Один из самых популярных вопросов Scala pn Qaru прямо сейчас связан с сложностью библиотек Scala 2.8. Я предлагаю вам прочитать его.
Как было сказано выше, причина Scala настолько сложна, что из-за системы типа. Это впечатляющий инженер, но даже опытные программисты Scala справляются с этим. Я настоятельно рекомендую, чтобы кто-либо, рассматривающий возможность обучения и использования Scala, долго смотрел на Clojure. Он предлагает практически все функции и преимущества Scala без постоянного кошмара в борьбе с системой типов.