tyb

What is Lambda Calculus in layman's terms? by Robert Harper Answer by Robert Harper:

There are two important models of computation, the lambda calculus and all the others. 

The "others" are all "machine models" that differ from one another in uninteresting ways; they are all based on the idea of a program acting on data by modification.  So a TM consists of a program (the finite control) acting on the data (the so-called tape).  A RAM consists of a program (machine language) acting on the data (in memory).  And so on.  The machine-based models are inherently imperative, and offer no notion of composition of programs from parts.  It's all "first-order"; programs are not data, data does not contain programs.  (Yes, I am aware of encodings, but those are not programs, those are representations of programs as data.)

The lambda calculus is the sole "language model".  It is markedly different from machine models because it is based on one of the most important inventions of the human mind, the concept of a variable in mathematics (which is not at all related to the concept of a "variable", a misnomer for "assignables" in imperative programming languages and machine models).  A variable is given meaning by substitution, which captures the concept of composition of a whole from parts.  There is no separation of program from data; the lambda calculus is inherently "higher order".  And it does not rely in any way on modification of storage or data, giving rise to much greater flexibility in programming.  And the lambda calculus is utterly trivial to define, it has variables, functions, and applications, that's it.

The sole virtue of the machine models is their psychological motivation as given by Turing shortly after Church defined computation using the lambda calculus.  Turing's formulation makes clear that computation is a faculty of the human mind, and that we externalize it using computers.  This view gave rise to the field of Artificial Intelligence, in which Turing was interested from the start.  The machine models have no practical uses at all.  There is no such thing as software development using Turing machines, because there cannot be --- there is no notion of composition, so no libraries, no shared code, no reuse, no abstraction, nothing.  It's worthless from a practical viewpoint.

The lambda calculus, however, has launched a thousand ships.  It is based on the mathematical concept of a variable, properly so-called, and has given rise to many, many serious programming languages, largely because it inherently supports composition.   It also provides a much richer concept of computation that extends to higher order, and that does not mandate mutation.

In the long run the only model that matters is the lambda calculus.  Church got it right from the get-go, before the machine models existed, and it has not changed since (but for one detail that he later dropped, the requirement that all variables introduced actually be used---it is cleaner to think of a term that does not involve a variable x as being vacuously dependent on x, much as a univariate polynomial is "automatically" a multivariate polynomial.)

How much lambda calculus is needed to learn functional programming? by Toby Thain Answer by Toby Thain:

In my opinion, none. Nor is Category Theory necessary to learn how to use monadic style (or Monads). Of course, later on, studying Lambda Calculus and some of the theory behind objects like monoids, semigroups, functors, etc, is valuable. But it is not a prerequisite to using these functional tools by any means. You can see this in good Functional Programming texts like SICP and Thompson's Haskell: The Craft of Functional Programming.

Haskell (programming language): What are type classes and how are they useful? by Costya Perepelitsa Answer by Costya Perepelitsa:

You could think of type classes as an analogue of interfaces in object-oriented languages. It's a way of making polymorphic functions which don't care which type is used so long as it is capable of some small set of generic things. Let's say you implement a really awesome sorting algorithm. It combines two or more different sorting algorithms and chooses intelligently between them based on the list's size. Your use case was to sort a list of integers, so that's how you wrote it: superSort :: [Int] -> [Int] As you produce more code, you decide you would do well to sort a potentially giant list of strings, and you realize that the superSort function you wrote would be perfect for it. Since superSort is only for integers, you copy/paste the function definition but specify the types as strings, instead: superStringSort :: [String] -> [String] As you develop further, you find that you could really benefit from a sort on a type you created. So you copy/paste again and then modify superSort to make the proper comparisons between two values of your type. You miss one and forget an argument somewhere else, but then fix those bugs in a few minutes of debugging. superFooSort :: [Foo] -> [Foo] Then it happens that you need to sort a list of Foo by a different property of Foo than your current superFooSort does. You are sick of copy/pasting and making minor modifications to the same function, so you consider other possibilities, and that's when inspiration strikes. You realize that instead of hard-coding the proper comparisons into the superSort function, you could specify it when you call superSort to begin with. You realize further that this will now allow you to sort any type by any criteria so long as you can provide the comparator to use! So you write this:

data Comparison = Less | Equal | Greater genericSuperSort :: (a -> a -> Comparison) -> [a] -> [a]

This works wonderfully for a while. Then you start getting tired of having to write the same comparator functions over and over. So you define each comparator you use one time and refer to it. You were used to giving superSort one argument, so you periodically leave out the comparator when calling genericSuperSort, but that's a minor annoyance. You daydream for a bit about how convenient it'd be if data types somehow knew how to compare themselves, as part of their definitions. And then you get to a point where you have a list of Foo and need to find the maximum for a criteria you already have a comparator for. So you whip out this bad boy: let biggestFoo = foldl1 (\biggest f -> case compareFoo f biggest of | Greater -> f | _ -> biggest) foos That's annoying to write and annoying to read, and you have to do it a few more times in your code. So you consider writing something like this:

genericMax :: (a -> a -> Comparison) -> [a] -> a genericMin :: (a -> a -> Comparison) -> [a] -> a

Then you need to insert a Foo into an already-sorted list of foo. Ugh, here we go again: genericInsert :: (a -> a -> Comparison) -> a -> [a] -> [a] One day, genericInsert stops inserting things correctly. It takes you a day of debugging and second-guessing yourself to realize that you used a different comparator in genericInsert than you did to sort the list. Bloody hell. There has to be an easier way. Let's talk about Ord. Ord is a type class. If a type is a member of the Ord type class, that means the type knows how to order itself relative to other values of the same type. That means that all of the (a -> a -> Comparison) argument in all of the above functions are now implicit; it's always the comparator for the type you're sorting, inserting, or finding the min or max of. If you look at the sort function in Data.List, you'll see that its signature looks like this: sort :: Ord a => [a] -> [a] The type class specification Ord a => means that this function is effectively saying, "I don't care what type you give me, so long as it knows how to compare itself with itself." There are also functions:

insert :: Ord a => a -> [a] -> [a] maximum :: Ord a => [a] -> a minimum :: Ord a => [a] -> a

...and more, scattered in other libraries, including third-party libraries you may end up using. So the benefit with Ord is this: once you make the type an instance of the Ord type class (i.e. you teach it how to order itself), you can use it with any function you find forevermore which is defined for members of the Ord type class, without any extra work or glue code on your part. Another good example is the Show type class, which allows you to use this little guy: show :: Show a => a -> string If you make your type an instance of the Show type class, you avoid a problem OCaml has with redundancy:

string_of_int : int -> string string_of_float : float -> string string_of_bool : bool -> string string_of_your_type_here : your_type_here -> string

d) beam search: Maintain a set of K best states. Then expand the neighbourhood each of these states to some KN states, and then take the best K out of these. (Note that greedy mentioned above is beam search with K = 1). Answer by Pradeep George Mathias:

So I haven't participated myself in any TC Marathon match, but I'm assuming that its similar to what you have in Codechef Long Contest tie-break problems. Look at various techniques people use to get good solutions: (a) local search: from each state, try to go to a nearby better state. (b) greedy: same as above, here you're going to best state in neighbourhood. The problem with the above is that you may get stuck in local optima, so... (c) simulated annealing: probabilistically go to the best state. As time goes, the relative probability of going to the best state increases. (d) beam search: Maintain a set of K best states. Then expand the neighbourhood each of these states to some KN states, and then take the best K out of these. (Note that greedy mentioned above is beam search with K = 1). For all the above methods, you'd need a metric, to calculate how good a particular state is. In reality, you'd generally end up coding up something of (a) and (b) first, and testing how good it is. (I've noticed that atleast half the time, (a) or (b) gives me a score of like 0.9 of the best, which is very good). You'd then have to add a concept of probability or a state-based comparison etc. Which means, you'd better ensure that your code is modular!!! throughout. The next thing you'll need to ensure, is that your code is efficient. The more your code "searches" for the best solution, the better your solution is after all. Which means that you'll need to ensure that calculating your metric is as efficient as possible, that your overall loops and data structures work as efficiently as possible etc. Some things I've had to do are: (a) exp(b * log(a)) instead of pow(a, b) (b) coding a Binary Indexed Tree to handle probability. Basically, putting in effort in making your code efficient is well worth it. Finally, include "time" constraints into your code. This means that you should allow your code to "search" for a solution for as long as the specified time limit allows. Do this last, because this generally means that you're stuck and out of ideas as to how to "in general" improve your code. And of course, read the forums for how to get started. I have heard that TC forums are great for giving tips on various things, including hacks that you may need. Also, the things I stated above aren't all that exist. There are other tricks you could use also, keep looking and you'll find them. :)

Which are the 10 algorithms every computer science student must implement at least once in life? by Anonymous Answer by Anonymous:

More important than algorithms(just problems #$!%), the techniques/concepts residing at the base of such algorithms is more important. There are broadly 4 ways in which classification of algorithms can be done.

Classification by purpose

Each algorithm has a goal, for example, the purpose of the Quick Sort algorithm is to sort data in ascending or descending order. But the number of goals is infinite, and we have to group them by kind of purposes. 2.  Classification by implementation

Recursive or iterative A recursive algorithm is one that calls itself repeatedly until a certain condition matches. It is a method common to functional programming. For example, the towers of hanoi problem is well understood in recursive implementation. Every recursive version has an iterative equivalent iterative, and vice versa.

Logical or procedural An algorithm may be viewed as controlled logical deduction. A logic component expresses the axioms which may be used in the computation and a control component determines the way in which deduction is applied to the axioms.

Serial or parallel                                                                                Algorithms are usually discussed with the assumption that computers execute one instruction of an algorithm at a time. This is a serial algorithm, as opposed to parallel algorithms, which take advantage of computer architectures to process several instructions at once. Sorting algorithms can be parallelized efficiently.

Deterministic or non-deterministic Deterministic algorithms solve the problem with a predefined process whereas non-deterministic algorithm must perform guesses of best solution at each step through the use of heuristics.

3.   Classification by design paradigm

Divide and conquer A divide and conquer algorithm repeatedly reduces an instance of a problem to one or more smaller instances of the same problem (usually recursively), until the instances are small enough to solve easily. One such example of divide and conquer is merge sorting. The binary search algorithm is an example of a variant of divide and conquer called decrease and conquer algorithm, that solves an identical subproblem and uses the solution of this subproblem to solve the bigger problem.  

Dynamic programming The shortest path in a weighted graph can be found by using the shortest path to the goal from all adjacent vertices. When the optimal solution to a problem can be constructed from optimal solutions to subproblems, using dynamic programming avoids recomputing solutions that have already been computed. - The main difference with the "divide and conquer" approach is, subproblems are independent in divide and conquer, where as the overlap of subproblems occur in dynamic programming. - Dynamic programming and memoization go together. The difference with straightforward recursion is in caching or memoization of recursive calls. Where subproblems are independent, this is useless. By using memoization or maintaining a table of subproblems already solved, dynamic programming reduces the exponential nature of many problems to polynomial complexity.  

The greedy method A greedy algorithm is similar to a dynamic programming algorithm, but the difference is that solutions to the subproblems do not have to be known at each stage. Instead a "greedy" choice can be made of what looks the best solution for the moment. The most popular greedy algorithm is finding the minimal spanning tree as given by Kruskal.  

Linear programming The problem is expressed as a set of linear inequalities and then an attempt is made to maximize or minimize the inputs. This can solve many problems such as the maximum flow for directed graphs, notably by using the simplex algorithm. A complex variant of linear programming is called integer programming, where the solution space is restricted to all integers.  

Reduction also called transform and conquer Solve a problem by transforming it into another problem. A simple example:finding the median in an unsorted list is first translating this problem into sorting problem and finding the middle element in sorted list. The main goal of reduction is finding the simplest transformation possible.  

Using graphs Many problems, such as playing chess, can be modeled as problems on graphs. A graph exploration algorithms are used. This category also includes the search algorithms and backtracking.  

The probabilistic and heuristic paradigm

Probabilistic Those that make some choices randomly.

Genetic Attempt to find solutions to problems by mimicking biological evolutionary processes, with a cycle of random mutations yielding successive generations of "solutions". Thus, they emulate reproduction and "survival of the fittest".

Heuristic Whose general purpose is not to find an optimal solution, but an approximate solution where the time or resources to find a perfect solution are not practical.

__________________________________________________________________ You can look at Algorithms Repository 1. Searching and sorting algorithms - Sorting algorithms include Quicksort , Merge sort, Heapsort, Bubble sort,Insertion sort, Radix sort. Other imp soting algorithms are Topological sort, Counting sort, Shell sort A comprehensive list can be found here. Important searching algorithms include breadth/ depth first  search, binary search etc. 2. Dynamic Programming -- To name a few DP problems, Longest Common Subsequence problem, Knapsack, travelling salesman problem etc. A list of dynamic  programming algorithms can be found here. 3. Graph algorithms -- Important graph algorithms are Dijkstra, Prim, Kruskal, Bellman-Ford. A comprehensive list can be found here. Good luck !!!

What are some of the best life tips? by Peter Mayer Answer by Peter Mayer:

Here are 55 life tips in the form of quotes:

1. "If you want something you never had, you have to do something you've never done."

2. "Don't limit your challenges. Challenge your limits."

3. "Do what is right, not what is easy."

4. "If it does not challenge you, it won't change you."

5. "Do more than just exist."

6. "You are your only limit."

7. "I don't stop when I am tired, I stop when I am done."

8. "If there is no way, create one."

9. "There are no regrets in life. Only lessons."

10. "You can't start the next chapter of your life, if you are still reading the last one."

11. "One day everything will make perfect sense."

12. "Everything happens for a reason, even though that reason is not clear at the moment."

13. "Whatever you're thinking, think bigger."

14. "Your best teacher is your last mistake."

15. "You were born to be real, not perfect."

16. "It feels good to be lost in the right direction."

17. "There is no elevator to success. You have to take the stairs."

18. "Be somebody who makes everybody feel like a somebody."

19. "Sometimes you just have to let it go."

20. "Your life isn't yours, if you care what others think."

21. "Everything is going to be OK at the end. If it is not OK, it is not the end."

22. "Never apologize for being who you are."

23. "Don't complain about things, you are not willing to change."

24. "Create a life that feels good on the inside, not one that looks good on the outside."

25. "Enjoy the little things in life, because one day you'll back and realize they were the big things."

26. "Broken crayons still color."

27. "Don't wait. Life goes faster than you think."

28. "Only dead fish go with the flow."

29. "Hard work beats talent."

30. "In the end we only regret the chances we didn't take."

31. "Sometimes just stop and look around and realize life indeed is amazing."

32. "Collect moments, not things."

33. "Your worst battle in life is between what you know and what you feel."

34. "Life is 10% what happens to you, and 90% how you react to it."

35. "Mistakes are proof that you are trying."

36. "Everyday is a chance to change your life."

37. "Sometimes life is about risking everything for a dream no one can see but you."

38. "The best investment you can ever make is in yourself."

39. "Remember when you forgive, you heal, and when you let go, you grow."

40. "I believe in the person I want to become."

41. "Change your thoughts and you change the world."

42. "Sometimes you win, sometimes you learn."

43. "To change your life, you need to change your priorities."

44. "Never make permanent decisions on temporary feelings."

45. "If it was easy, everybody would do it."

46. "Stars can't shine without darkness."

47. "The best way to project your future is to create it."

48. "When life puts you in tough situations, don't say: Why me?, say: Try me!"

49. "The only disability in life is a bad attitude."

50. "If the plan does not work, change the plan but not the goal."

51. "What consumes your mind, control your life."

52. "Wake up. Kick ass. Repeat."

53. "Be busy working on your own grass to notice the neighbor's is greener."

54. "Stay positive, work hard and make it happen."

55.

Post on @Quora by @RobertFrost01: 10 Greatest Westerns Post by Robert Frost:

10 Greatest Westerns

Post on @Quora by @RobertFrost01: 10 Greatest Shakespearean Adaptations Post by Robert Frost:

10 Greatest Shakespearean Adaptations

Post on @Quora by @RobertFrost01: 10 Greatest Erotic Movies Post by Robert Frost:

10 Greatest Erotic Movies

Post on @Quora by @RobertFrost01: 10 Greatest Films of Kenneth Branagh Post by Robert Frost:

10 Greatest Films of Kenneth Branagh

Post on @Quora by @RobertFrost01: 10 Greatest Road Films Post by Robert Frost:

10 Greatest Road Films

Post on @Quora by @RobertFrost01: 10 Greatest Films of Bill Murray Post by Robert Frost:

10 Greatest Films of Bill Murray

Post on @Quora by @RobertFrost01: Blog Recap 2015 - Most Mentioned Movies Post by Robert Frost:

Blog Recap 2015 - Most Mentioned Movies