Around 750 people commented on the online preview of the Real World Haskell book. As described by one of its co-authors, John Goerzen, in a recent interview to O’Reilly, the book introduces Haskell with real code, real examples and tips to exploit in a business environment. In his interview, Goerzen explains why, in his opinion, this language is worth learning; he provides insights into its specificities and addresses some issues that may be a source of reluctance.
January 25, 2009
January 19, 2009
Quizz:: SharpLight |> What does this do?
div <<
a "sadekdrobi.com"
<< img "http://is.gd/gqVX"
++ "my lil’ friend"
January 10, 2009
Programming Languages: 2008 Review and Prospects for 2009
In the beginning of last year, Ehud Lamm launched on Lamba the Ultimate a thread about programming languages predictions for 2008. Several subjects popped up: concurrency, functional programming, future of Java, Ruby, C++, and many others… What really happened in 2008 and what are the prospects for 2009? Bloggers have addressed these questions on demand of James Iry, echoing at last year thread.
January 5, 2009
You’ve got 100 pages to convince me of your shiny language!
In the rapidly spanning world of programming languages, I find myself buying and reading a lot of books about new and old programming languages. There are a few interesting concepts in each language, and if you think about employing more than one language in your projects then you better know about the existence of these concepts (see Paradigm based Polyglot Programming).
One thing that annoys me though about most programming language books is how raw they often are.
November 10, 2008
RefX:: ORMs, Relational Data, Mismatch, LinQ and DSLs
Having worked with several Object-Relational mapping frameworks in the last few years, I got to a point where I couldn’t justify their complexity in my project. We often talk about the mismatch between the database and the object worlds, and that is where ORMs are often stated and referenced for “bridging the gap”!
Well I prefer to call it lifting the gap, or highering the gap, to have it now between DAOs and the rest of the code than having it between database and code.But I wouldn’t call this in any way reducing the gap.
November 2, 2008
Code Safety and Correctness is a matter of Mindset Cultured by the Language
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.
October 28, 2008
Ted Neward on Present and Past Languages
This is an interview I did at QCon with Ted Neward. Talking to Ted was very interesting even though arguing with him turned to be not easy at all :)
September 25, 2008
Paradigm based Polyglot Programming
How many languages are you using on the same project? If you go counting you will see that they are many. I mean XML, Java, XSLT, HTML, CSS… etc. But the reason why you are using almost all of them is that they happen to be mainstream and, oftentimes, they are the only language choice for a needed framework. You are actually almost obliged to use them. The choice is done for you. Style? CSS. Configuration? Often XML. Web interface description? Html. However, if you want to adopt true polyglot programming, you will have to face inevitable decision of language choice.
September 19, 2008
Simon Peyton Jones on Programming Languages and Research Work
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
Mots clés Technorati : simon peyton johnes,haskell,functional-programming,C#,F#,immutability,transactional memory,data parallelism,monads,fp,scala,LinQ
April 20, 2008
And Design Patterns suddenly Degrade!
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!
