Languages

What are programs

• Programs exist to make decision

• To automate repeatable actions

Aims of learning a language

• When you first learn a language, your job is to learn how to use it to do the jobs you already know how to do.

properties

• Interpreted means the code is executed by an interpreter rather than a compiler.

• Compiled

• Dynamically typed means that types are bound at execution time rather than compile time.

  • Dont need to declare variable, method types

  • There are disadvantages: you can’t catch as many errors as you can with static typing because compilers and tools can catch more errors with a statically typed system.

• Statically typed

• Strongly typed languages check types for certain operations and check the types before you can do any damage.

  • This check can happen when you present the code to an interpreter or a compiler or when you execute it

• Trade off between dynamically interpreted and statically compiled

  • flexibility versus execution safety

• Object-oriented means the language supports

  • encapsulation (data and behavior are packaged together),

  • inheritance through classes (object types are organized in a class tree),

  • polymorphism (objects can take many forms).

  • The whole premise of the model depends on wrapping behavior around state, and usually the state can be changed. This programming strategy leads to serious problems with concurrency.

• Look for syntactic sugar, those little features that break the basic rules of the language to give programmers a little friendlier experience and make the code a little easier to understand.

• Some languages are OO but have procedural elements

  • like java, where int a = 4; is not an object, it is a primitive. It does not have behaviour ie a.add(5); but have 4 + 5;

• Prototype languages like Io, Lua, javascript and Self use the object, not the class, as the basis for object definition and even inheritance.

  • every object is a clone of an existing object rather than a class

• Duck typing doesn’t care what the underlying type might be. If it walks like a duck and quacks like a duck, it’s a duck.

  • the idea of to code to interfaces rather than implementations

  • ie Ruby

  • Static typing allows a whole range of tools that make it easier to do syntax trees and thus provide integrated development environments.

    • poor debugging

• Mixins

  • interface

• Metaprogramming

  • programming that programs itslefs

  • reflection

  • change classes onthe fly