In my trip through Haskell programming I keep discovering how clean and enjoyable the language is. By the end I am someone that loves doing abstractions and I guess I’ve found my world.
I discussed with some colleagues lately how a programming language creates a whole culture around it. This culture inherits from language properties and shapes the language programming style.
The big milestone of C# 3.0 got me thinking, what can we do more to improve the language. After a lot of interesting discussions an debates I got with people that care about the subject, I realized that it can be really interesting to remove some unimportant complexity of the language. This can be done by abstracting and generalizing some concepts. An example that I thought of for this blog post is Methods.
In QCon London 2008, I had the opportunity to have an interview with one of my heros: Simon Peyton Jones. Simon has an enormous capacity of making the answer to almost any question precise and clear no matter how abstract the subject is. I Strongly recommend that you have a look at this interview if you are interested in programming languages in general. Following Simon’s talks and interviews requires almost no prior knowledge about functional programming or Haskell.
In this interview, computer scientist and researcher Simon Peyton Jones discusses properties of functional programming languages, and particularly Haskell, that have inspired some features in mainstream languages. He gives his opinion on the issues of syntax and language complexity and talks about some research work on subjects such as Data parallelism and transactional memory.
Bio
Honorary Professor of Computer Science at the University of Glasgow, Simon Peyton Jones currently works at Microsoft Research in Cambridge. He has led several research projects focused on the implementation and applications of functional programming languages. He has greatly contributed to the design of the Haskell language, and is the lead designer of the Glasgow Haskell Compiler.
Access this exclusive interview published at InfoQ.com
Lately I’ve been writing some programs with Haskell (a pure functional programming language) and I noticed that I am not using GoF design patterns anymore, and that got me to a question: What are GoF design patterns? And why do we need them?
This actually reminds me of a good definition I read (I can’t recall where) of these design patterns: Resolutions to programming language limitations implemented using the programming language available syntax. When one learns a programming language, he learns to express what he wants to express using a very limited set of expressions of the language. The problem with this is that his imagination in this environment gets boxed! So what are GoF design patterns?
Most of GoF design patterns are inspired from Smaltalk, so what is so special about Smaltalk? Closures! It turns out that Java and C++ didn’t have closures and higher order functions. Some of the Design Patterns came to rescue and provide "alternatives" to these powerful constructs or workarounds to resolve these limitations. Such an approach requires a kind of object gymnastics and results in an explosion of classes!
I am now on a project where I use C# 3.5 features, and guess what? Suddenly I use much less strategies, much less templates. I write much less code yet being as or even more flexible. Powerful lambda expressions!
Update: DSLs also come from fp paradigm!
This is really crazy!
The first time I got introduced to mutation, I had a bad feeling. How can x:=x+1 be logical at all?
It felt so unnatural, scary, or maybe like a hack. Then, because of society constrains, I got to forget the bad feeling about that. Well, my mind started to tolerate with counter-logic logic. And that is how I became an enterprise developer. I am not sure how proud I am with this title anyway. I feel that tolerating and accepting the counter-logic logic is one, and most important one, of the prerequisite to this title.
Having manipulated references for quite a while, in an imperative style of programming languages, we searched a lot for solutions for deploying our applications and make them run on several processors. We ve been trieng to extract some logic out of the non-logical machine friendly reference manipulation syntax, to be able to distribute it on deffirent processors. And here comes problems of synchronization of deffirent threads accesing the same reference, which is often a quite complex task.
But, what about going stateless? no synchrnization to do, and instead of telling the runtime how to do, we tell what to do, by passing fuctions that explain that. Well thats what Functional Programming is about!
Recently I crossed two interesting posts, the first is demonstrating an implementation of a paralleledList that uses several proccesors for tasks like filtering, implemented in F#, a quite promissing mixed paradigm language based on .net framework.
http://cs.hubfs.net/blogs/tomasp/archive/2007/03/25/fsharp_parallel_ops.aspx
For those of you not familiar with ML driven syntax, the second article is demonstrating PLinq in C# language which “still” looks like java.
http://community.bartdesmet.net/blogs/bart/archive/2007/04/04/introducing-plinq.aspx
Results are pretty interesting, demonstrating the effect of using more threads against limited-large number of records.
Have fun!
According to Fowler and Evans, Specification ” is to separate the statement of how to match a candidate, from the candidate object that it is matched against. As well as its usefulness in selection, it is also valuable for validation and for building to order “Â .
We might need to secify the state of an object for one of these three purposes.
in my previous post http://sadekdrobi.com/?p=25 i listed some  Satisfaction Confusions that we are having in
popular imperative procedural object oriented statically typed C-like syntax programming languages, the question was where the goodness really comes from, and what are the drawbacks to such confusions.
One epression that is lately often used to stegmatise a piece of code is to tell “not object oriented”.  This expression is a good sign of something we always waited, which is the awareness of the majority of today’s developers of the importance of the Object Oriented programming principiles. But on the other hand, the expression itself highlights another satisfaction confusion. Even myself, i sometimes feel it an insult to be told that my code is not object oriented, so what?!! should it be? or… it is not meant to be !!!
Going back into my memories, it happens to me quite often that i have good memories for a place because something good happened once for me there, or good memories for someone because he delivered me a good news … i guess feelings can be quite distracting sometimes. when i used to be a child, i used to hate fish, i didnt like fish, anykind! i used to quit the table when fish is present.
Lately i relized that what i had problem with is fish’s smell, and specifically well cooked fish meet’s smell. Now i eat fish, one of my favourite plates is Sushi and Sashimi :p
I guess it is quite human thing to hate things as a whole, tagging as bad any set of objects that have one bad property, forgetting about all the universe arround, that might have contributed to that bad, and that can change with time.
In the programming languages paradigm we had – and we are still having - a lot of such a satisfaction confusion. Imperative (procedural) programming had gained a lot of market and as it often happens this was due to a massive marketing of a good property of the product. Imperative programming consists of sets of machine instruction (more…)
Posts I find interestingPowered by WordPress
