Course Evaluation Form - Template: Fill & Download for Free

There is a special form field type for this: Multiple choice grid:The result looks like:You can create one from scratch or using a ’Course Evaluation’ google form template.

The main differences I consider when first trying to understand what a language is all about include:Typed languages (e.g., Agda, Coq, F#, Haskell, OCaml, Scala, Standard ML, Typed Racket) rule out type errors at compile time, whereas untyped languages (e.g., Clojure, Common LISP, Racket, Scheme) wait until run time to detect attempts to apply operations to values that don’t support them.In pure languages (e.g., Agda, Coq, Haskell) expressions have no side effects, and evaluating the same expression (in the same context) produces the same value each time, whereas impure languages (e.g., all the others I mentioned) do not have this property. (Pure languages typically use other means, such as monads, to represent effectful computations.)Call-by-name languages (e.g., Agda, Haskell) pass arguments to functions as unevaluated expressions and force them as necessary (though Haskell implementations typically use call-by-need, which is an optimization of call-by-name valid in pure languages), whereas most languages are call-by-value, which means that function arguments are evaluated to values before invoking the function. (Scala supports both evaluation strategies in a type-driven manner, and it’s not clear to me what evaluation strategy Coq uses, or whether it even has one.)Languages differ in what compile-time metaprogramming facilities they offer. Macros (e.g., in Clojure, Common LISP, Racket, Typed Racket, Scheme, and Scala) allow extending the language by defining new syntactic forms that behave like built-in forms. Scala actually has several varieties of macros, including def macros, which require macro parameters to be well-typed—which prevents them from defining new binding forms—and untyped macros, which don’t require parameters to be well-typed before expansion and thus allow new binding forms. There are weaker forms of compile-time metaprogramming, such as Coq’s notation system, for defining syntactic sugar, and Template Haskell, for compile-time code generation but not defining new syntactic forms (including binding forms). OCaml’s camlp4 supports extending the language by extending the grammar directly.Safe languages (e.g., every language mentioned above, C#, Erlang, Java, JavaScript, Lua, Perl, PHP, Prolog, Python, Ruby, Rust, Smalltalk, Tcl) protect their own abstractions, whereas unsafe languages (e.g., C, C++, Objective C, Forth, FORTRAN, and most assembly languages) allow violating abstractions in ways that lead to undefined behavior. I consider this the most important difference when evaluating programming languages, but it’s less salient when talking about functional languages because all the languages mentioned before this bullet are safe (up to some carefully circumscribed features such as foreign function interfaces for interacting with unsafe languages). (Note: I’m considering languages to be safe based on language designer intent—in practice, without a formal proof, languages that we consider to be safe sometimes turn out not to be [e.g., reference cells in early versions of ML, some Java vulnerabilities].)Of course, there are also variations within the main differences delineated above:Typed languages differ in the expressivity of their type systems. Dependent types (in Coq and Agda) allow expressing and proving strong properties about programs, even up to total correctness, within the language.Typed languages differ in which and how many types you need to write down. Global type inference (e.g., in F#, Haskell, OCaml, and Standard ML) infers the most general type for each expression without requiring type annotations, whereas local type inference (e.g., in Agda, Coq, Scala, and Typed Racket) infers some types while requiring others, such as the types of most function parameters, to be written down explicitly.Macro systems differ in whether they protect against inadvertent capture of identifiers. Hygienic macros (e.g., in Racket, Scheme, and Typed Racket) preserve lexical scope (though what that means is very subtle, and some provide an escape hatch for when capture is intended), whereas nonhygienic macros (e.g., in Clojure, Common LISP, Scala) rely on the programmer to do (error-prone) name management, though some of them (e.g., Scala) provide mechanisms to make renaming easier. Among the other metaprogramming facilities mentioned, Coq notations are hygienic (I believe), Template Haskell provides some hygiene, and OCaml’s camlp4 makes hygiene especially difficult.Whether a language is pure depends on what is considered an effect. Haskell expressions can have failure and non-termination effects. That is, a Haskell expression always yields the same answer if it yields an answer at all, but it might not terminate, and if it fails, which error you see is nondeterministic. On the other hand, Agda (sort of) and Coq programs are total, which means that they always terminate with an answer. This implies that Agda (sort of) and Coq are not Turing-complete, though a Turing-complete language can be embedded in these languages, for example by using a non-termination monad.There are also features that are important but harder to classify because there’s more (sometimes subtle) variation:Languages provide different module systems that support different ways of factoring large programs. All module systems provide namespaces, which help prevent name clashes. Haskell’s module system is just a namespace system, and Common LISP’s packages are similar to namespaces, but with some subtleties that I don’t understand. (I expect a comment about this.) The module systems of Racket, Typed Racket, and some recent versions of Scheme are mainly concerned with staging to support macros: Macros can run arbitrary code at compile time, which might in turn have been written with macros that run arbitrary code, ad infinitum, and the module system keeps this all straight. OCaml and Standard ML have powerful module systems with signatures (module interfaces) and functors (modules parametrized by other modules); the module systems of these languages differ subtly with respect to type generativity, but that’s beyond the scope of this discussion. Scala has something similar, though I don’t know the details. OCaml also has first-class modules, which allow modules to be passed around as values at run time. Clojure and Scala also piggyback on Java’s package system, which is a namespace system with some security implications. Dependent types mean that Agda and Coq can encode ML-style modules directly in the core language, though each also has a module system (or two, considering Coq sections) on top of that.Some languages support overloading via ad-hoc polymorphism or some kind of dynamic dispatch. Agda, Coq, and Haskell’s type classes and Scala’s traits allow defining interfaces and then specifying how a type implements an interface separately from where the type is defined. Common LISP’s CLOS provides generic functions, which overload function names with multiple implementations that dispatch based on dynamic properties (usually type tests) of the arguments; Racket and Scheme have CLOS-like libraries as well. Clojure’s protocols are like a dynamic version of type classes, or like a more structured version of CLOS generics.Some languages have object systems, with a wide variety of designs. Clojure borrows Java’s object system, whereas Scala has its own rich object system with classes, singletons, generics (as in parametric polymorphism, not overloading), that is compatible with Java’s. F#, like C#, runs on Microsoft’s .NET (and other versions of the CLI) and uses the .NET object system. Racket has an expressive class-based object system, and work continues to adapt it to Typed Racket. OCaml’s object system uses row polymorphism for structural rather than nominal subtyping: OCaml object subtyping is about which methods are available rather than tied to class-based inheritance. Existential quantification in Haskell and first-class modules in OCaml can be used to encode objects as well.Of course, languages also differ on trivial dimensions, such as syntax. For example, some languages use a lot of parentheses (e.g., Clojure, Common LISP, Racket, Scheme), whereas other languages prefer curly braces (e.g., Scala). Some languages use significant whitespace for grouping (e.g., Agda, Haskell).There is no real definition of what makes a language “functional,” so I discussed languages that are commonly considered to be functional. These tend to be higher-order languages in which objects aren’t of paramount importance. All of the distinctions above apply to other languages as well.What makes a (functional) language more suitable for a given project depends mainly on which languages you and your collaborators know or like best, which libraries are available that you might find useful, and possibly particular requirements such as running on the JVM or proving your program correct.I’m sure I made some errors, so corrections and suggestions are encouraged.

Well, for my last job, at a media publishing company (with a heavy online presence of course), we went through the process of deciding which would be our default web app framework, and we had a few options on the table, including Play, Node Express, Python Flask/Tornado, and Ruby on Rails.We threw out Ruby on Rails for performance issues, although the Django-like insta-forms created from your database model would be missed.I was tasked with evaluating Play 2, and we had some Play/Scala experience already, although half the devs were front end focused (but they were open to Scala). So I kept the learning curve in mind, along with their familiarity with JavaScript, when considering the Play.The boss came up with a laundry list of points, and I set out to address them all (Note that we were leaning toward the Scala option, but both Java and Scala are available to you):Play is simple to get started "play new <project name>" .. no environment setup.Strong MVC supportAsynchronous requests due to netty, a mature, fast technology.Convention over configuration ... no XML, gets out of way quickly from writing code. You spend more time writing code, but in a certain way.Extremely intuitive routes file supporting regexCompile-time type checking for entire application, routes, and templates. Very good for maintaining large applications softening the need for infallible test coverage.Play is built on sbt which allows experimentation with classpath loaded. You can do things like testing your controller endpoints to see what they return.Sbt is also great for "auto test as you save". LinkedIn confirms this dramatically improves developer productivity over other Java frameworks.JVM maturity/optimization/compiled performancePlay comes with a built-in in-memory databaseJava IDEs are very powerful, and Scala IDEs are fairly good now, including debugging tools.Scala, which Play also fully supports, attracts elite developers, and the Scala userbase is growing fast in NYCAsynchronous tests in scala using specs2Websockets out of the box:def index = WebSocket.using[String] { request =>     // Log events to the console  val in = Iteratee.foreach[String](println).mapDone { _ =>  println("Disconnected")  }    // Send a single 'Hello!' message  val out = Enumerator("Hello!")    (in, out) } JVM applications are the easiest to deploy/maintain and have the most predictable performance.Java/Scala has concurrency baked in without sacrificing flexibility, such as with Node's single-threaded VM.Scala can be cryptic, but this is much alleviated by breaking functions down into simple/obvious functions with descriptive names. You are in turn rewarded with "expressivity" of code, saying more with less.Wide third-party library supportAccording to LinkedIn, just about everything is flexible/pluggable/configurablecompiles coffeescript/less and displays errors in browser.Auto-provides minified Javascript filesSimple NoSQL supportUsing Ok(anyMethodThatGenerateSomeHtml) you can wire any other existing template system.Can use with the "Japid" template framework for performance which can easily approach that of static filesAkka actors (Java/Scala), and futures/promises and for comprehensions (scala) allow non-blocking I/O without "callback hell" (deeply nested spaghetti code that jumps all over the place)Built-in authenticationFull continuous integration support with Play for Java and Scala using Jenkins. Probably the other major CI systems as well.So I finished that list, and I didn't get much of a response. It was pretty much a TL;DR. So then the guy presenting Flask/Tornado (asynchronous Python web framework) kind of didn't offer much at all, to my disappointment. The guy presenting Node.js was a front end guy with heavy Javascript familiarity. He only addressed a handful of the points, not comparing/contrasting much. Just went in Steve Jobs mode, with some slides, showing how easy it was to get started, and some of the tools available.Well, I had one foot out the door anyway, so I wasn't really going to pressure anyone to take on technologies they weren't enthusiastic about. They chose Node.js, probably for the front-end bias, and the fact that no one really said, or could say anything horribly bad about Node.js, for the purposes of what the company required. I think, independent of the existing experience and the employees' preference, in an ideal world, Play/Scala would have been the right choice, but I learned, as suggested when I initially made an inquiry on Quora here... How do I choose between asynchronous web frameworks? My tech group is fairly language agnostic and we're trying to standardize on some technologies. ...that these web frameworks had negligible differences in terms of capability, so experience/preference really should be considered with the heaviest weight.