Integralist

What we cover:

• defining functions
• anonymous functions
• short hand anonymous functions
• complex reducing
• alternatives to the reduce example
• demonstrate how vectors and lists are different
• custom method that separates the specified predicate from a sequence
• destructuring with let bindings

Integralist

The problem

If a function calls itself recursively then the JavaScript engine has to create a new 'stack' (i.e. allocate a chunk of memory) to keep track of the function's arguments.

Let's look at an example of this happening:

function sum(x, y) {
    if (y > 0) {
      return sum(x + 1, y - 1);

Integralist

# When calling a method with a splat then the parameters are passed as a comma separated list
# When receiving arguments with a splat then they are converted into an Array
# When using a double splat (2.0+) then the argument is converted into a Hash (i.e. named parameters)

def foo(*args)
  p args
end

foo 'a', 'b', 'c'
# => ["a", "b", "c"]

Integralist

strs = ['foo', 'bar', 'baz']

# standard long form way
caps = strs.map { |str| str.upcase }

# short hand
caps = strs.map(&:upcase)

# The & takes any object and calls to_proc on it
# In the above example we're using a Symbol and not an object

Integralist

class MyCustomError < StandardError
  attr_reader :object

  def initialize(object)
    @object = object
  end
end

begin
  raise MyCustomError.new("an object"), "a message"

Integralist

cd "$HOME/.vim/bundle"

plugins=( airblade/vim-gitgutter \
          ap/vim-css-color \
          bling/vim-airline \
          edkolev/tmuxline.vim \
          ervandew/supertab \
          gcmt/wildfire.vim \
          godlygeek/tabular \
          kien/ctrlp.vim \

Integralist

Lambda: standard

# Creating a lambda
l = lambda { |name| "Hi #{name}!" }

# Executing the lambda
l.call("foo") # => Hi foo!

Integralist

class Foo
  def initialize(a=[], b=[])
    @a = a
    @b = b
  end
  
  def add(item)
    if item.is_a? A
      @a.push item
    else

Integralist

UPDATE

Every time I accidentally git commit --amend instead of a normal git commit I have to google git reset --soft HEAD@{1} to save the day.

---

Imagine you have a file called foo.txt and your Git history looked like this:

A -> B -> C (HEAD)

Integralist

What is AOP?

Aspect Oriented Programming is a means to change the behaviour of – or add behaviour to – methods and functions (including constructors) non-invasively. The added behaviour is called “advice” and can be added before, after, or around the function it advises.

This description is similar to the Extract Surrounding refactoring method. The difference is in the direction of the change. It seems AOP is more focused at modifying existing behaviour non-invasively; where as the Extract Surrounding Method actually changes the source code to allow this type of behavioural modification.

Libraries

• Ruby: https://github.com/deanwampler/Aquarium
• JS: http://mulli.nu/2010/05/07/aop-js.html