#functional programing

We have been programming with object-oriented technology for quite a while. But now we are moving away from it.

Functional Programming is getting lot of attention nowadays. Even every mainstream language is now supporting functional style i.e Java, C++, C# etc. Basically, it is one of the paradigm of writing code where we write less code and do more.

Why do we really care about it ?

Around 2003,…

It is easy to see why Kyle Simpson of You Don’t Know JS fame is so beloved amongst javascript coding newbies. He has the uncanny ability to boil down concepts to their essence without compromising conceptual rigor, and he as careful as a philosopher with his use of language. For example, at one point in his “Learn Functional-Lite Programming” tutorial on Front End Masters, he kindly corrects an audience member’s question, saying that it is not appropriate to say that in the case where:

x = [1,2,3]

y = x

“x” and “y” are the same, but rather they are references to the same array, thereby illustrating values that are passed by reference. The tutorial is a set of excellent lectures on core functional programming concepts, structures,and techniques available for use by all (javascript) programers.  

Kyle Simpson explains and give examples for the following:

Side effects

Composition

Immutability

Closure

Recursion

List operations or transformations, including:

       .map()        .filter()        .reduce()

The examples Kyle Simpson offers are carefully constructed to best illustrate the concept at hand, and the exercises are pitched at the right level of difficulty to stretch the understanding.  

He is also careful to distinguish the common usage of terms versus how they are used from a functional programing perspective. For example, one of the most interesting examples for me was that of compostability. The idea that you can set one of the parameters of a function in this way was new to me.

Tutorial #3: Getting started with HTTP Programming in Play Framework

We have already discussed about the Play development environment in Tutorial #1 and use of WebJars, jQuery, Bootstrap & Bootswatch with Play in Tutorial #2So, In this blog we would discuss about HTTP programming in Play Framework which would drive us through rest of the tutorial series.  We would be running this blog as a series and we would be looking at various aspects of Play with this blog.…

Playing MultipartFormData: A basic example to handle and test MultipartFormData request in Play Framework 2.3.8

Playing MultipartFormData

The following blog and attached code represent an example to upload file using MultipartFormData request and Testing it into Play Application.

A basic example to handle and test MultipartFormData request in Play Framework 2.3.8

The standard way to upload files in a web application is to use a form with a special multipart/form-data encoding, which lets you mix standard…

If you look at the earlier posts in the FunHop series, you would notice that Exceptions are side effects. Exceptions by their very nature also break referential transparency and are context dependent. You would have got an idea about referential transparency from our earlier post. If not, it might be a good idea to review it once.

Let us consider the code sequence below

def fetchEmployeeName(id:…

Lets write some functional code!!

All levels welcome :D

When: 15th July - 7pm

Where: Engine Yard

Learn functional programming with people from different backgrounds and interests

Practice functional coding skills by working on fun problems

Compare the solutions with other languages

We need to get some small and medium problems to solve, I was thinking perhaps implement some well know algorithms and/or data structures? I see a lot of differences in ways to implement this and it might be valuable to explore this, suggestions welcome, but we could start with 

- Trees

- Tries

- Any of the text search algorithms

-----------

Suggestions very welcome

上了一个多月班了，都是弄些无聊的框架，接口，查数据，取数据，简直要无聊死了，趁着清明节的三天假期宅在宿舍又重温了一下SICP，不得不说每一次看这本书都有新的体会。 看了一下一道关于找零钱的方法数的题目： 有5种零钱，分别是1美分，5美分，10美分，25美分，50美分，给定一张大面额的纸币，问有几种方法来找开这张钱。  书上说的是用递归的方法来解决这个问题，假设要找的钱总数是a，有n种零钱来找，那么这个找钱的过程可以分为2部分：     1. 某种零钱没有用到。     2. 这种零钱至少出现一次。 用伪代码来表示就是： cc(a, n) = cc(a, n-1) + cc(a-d, n)，其中d是被排除的那种零钱的币值，在这里我们假设被排除的顺序是从大到小来排除的，因为找零钱的时候都是先找大的，然后在往小的找。 书中的代码写的特别美观，复制一份来放到这里：

(define (count-change amount)  (cc amount 5)) (define (cc amount kinds-of-coins)  (cond ((= amount 0) 1)        ((or (< amount 0)             (= kinds-of-coins 0))         0)        (else         (+ (cc amount (- kinds-of-coins 1))            (cc (- amount (first-denomination                           kinds-of-coins))                kinds-of-coins))))) (define (first-denomination kinds-of-coins)  (cond ((= kinds-of-coins 1) 1)        ((= kinds-of-coins 2) 5)        ((= kinds-of-coins 3) 10)        ((= kinds-of-coins 4) 25)        ((= kinds-of-coins 5) 50)))

好久没看到这么优雅的括号了。思路清晰，看起来很轻松。顺便吐槽一句，现在看php代码真是不开心，从一个入口文件开始看，本来一路下来就行了，但是继承太厉害了，看到一个函数，得往里扒3、4层才能找到它的定义，一个简简单单的方法直接实现就好了，但是php非得层层封装，让我这种用vim来看代码的人情何以堪，而且服务器上的vim还没有安装任何插件，要找一个函数的定义得手动找打那个父类的定义，然后查找到那个函数。找类的时候有时候还得用find命令来找。而include, require功能还能执行代码，更加加重了找函数的复杂度。 看到书上用scheme实现的算法，自己用python重新写了一遍，因为这个问题我也还没有想到好的别的算法，所以加点语法糖进去：

#!/usr/bin/env python def cc(amount , types_of_coins):    d = rest(types_of_coins)    if amount == 0:        return 1    elif amount < 0 or types_of_coins == 0:        return 0    else:        return cc(amount, types_of_coins-1) + cc(amount-d, types_of_coins) def rest(types_of_coins):    if types_of_coins == 1:        return 1    elif types_of_coins == 2:        return 5    elif types_of_coins == 3:        return 10    elif types_of_coins == 4:        return 25    elif types_of_coins == 5:        return 50 if __name__ == '__main__':    print cc(100, 5)

Fibonacci数有很简单的递归形式，Fib(n) = Fib(n-1) + Fib(n-2), n>=3,Fib(0) = 1, Fib(1) = 1。要算第n个斐波那契数真是太简单了，编程初学者都会，但是计算方法很多，都很典型，今天来复习一下。 1. 用C语言迭代实现。

int fib(int n) {    int a, b, z, i;    a = b = 1;    for (i = 3; i <= n; i++) {        z = a + b;        a = b;        b = z;    }    return z; }

2. 用C语言递归实现。

int fib2(int n) {    if (n == 1 || n == 2) {        return 1;    } else {        return fib2(n-1) + fib2(n-2);    } }

这是树形递归，如果对于大的n效率是很慢的，左分支和右分支会重复计算相同的内容，而且这也是自顶向下的递归，也要做2^n次递归计算。 3. 尾递归的scheme实现。

(define (fib n)    (define (iter a b count)        (if (or (= count 1) (= count 2))            a            (iter (+ a b)                a                (- count 1))))    (iter 1 1 n))

这个递归实现已经类似与第一个C版本的迭代过程了，但是在方法1中要定义一个额外的变量z来保存a,b的状态，而scheme不用，这就是没有变量没有副作用的好处。 尾递归的C实现。

int fib4(int n, int a, int b) {    if (n <= 2)        return a;    return fib4(n-1, a+b, a); }

尾递归就是用额外的变量把线性的空间复杂度降为常量空间复杂度。 4. 借用一个数组来保存状态。这是一种自底向上的方法，没有重复计算，也没有多余的函数调用开销，在形式上也是递归的，时间和空间复杂度都是theta(n)，以后遇到递归问题都要想想能不能自己建数组来保存状态。

int fib3(int n) {    int a[n], i;    a[0] = a[1] = 1;    for (i = 2; i < n; i++) {        a[i] = a[i-1] + a[i-2];    }    return a[n-1]; }

这种方法是从动态规划里面学来的，如果用递归计算太慢的话就用数组来保存状态。 5. 从SICP上学来的新算法，不是直接用递归公式编程，而是跳跃式的计算，因为规模减半了，所以这种算法时间复杂度只有theta(log n)。下面来看看scheme代码吧。

(define (fib5 n)    (define (even? n)      (= (remainder n 2) 0))    (define (fib-iter a b p q count)      (cond        ((= count 0) b)        ((even? count)         (fib-iter a b (+ (* p p) (* q q)) (+ (* q q) (* 2 p q))           (/ count 2)))        (else          (fib-iter (+ (* b q) (* a q) (* a p))            (+ (* b p) (* a q))            p            q            (- count 1)))))    (fib-iter 1 0 0 1 n))