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.
(more…)
The web is becoming an integration platform, providing open APIs for client side mashups and also a proven model for solving complex integration problems facing enterprise SOA initiatives. This one day conference is about the Web as a ubiquitous middleware and programming platform – a programmable web; attendees will how to embrace web as a platform, open APIs, mashups, and REST for complex enterprise development and integration challenges.
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.
(more…)
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
Useability: Not just a pretty interface
Reflecting user’s model in code
Ergonomics and interface design are often approached as if all what they are about were a pretty GUI that hides the complexity of the underlying software. This is the reason why, even though the importance of this issue is well acknowledged, it is often treated at the later stages of the software development cycle, once modules and components are conceived and already developed. At this stage, achieving real productivity and usability becomes too costly and might require complete rewrite and recomposition of some modules. In this presentation, I will try to put the emphasis on the importance of considering interface design early in the development cycle, and provide insights into some practices that may be instrumental for creating better and simpler user interface, such as Domain driven design and user model mapping (reflecting the way user perceives software).
The LinQ Experience
Better expressiveness with less code
For a long time now, we’ve been failing, or at best not terribly succeeding, in achieving our ultimate dream of code reuse as a means for reducing code base and avoiding recurrent bugs. In the mainstream OOP approach, and even at the enterprise level, the idea of designing pluggable reusable modules doesn’t seem to work quite often. Having a potentially reusable component implies that it becomes more generic, requiring extra parameters and logic to satisfy more than one use case thus raising complexity level. Inspired from an already mature approach to functional programming, LinQ adopts a different approach to code reusability which operates rather at the micro level. It provides language constructs that allow functionalities to be composed of smaller functions (cells) that are themselves of composite nature.
Based on my experience from a recent real world enterprise project, I will provide you with insights and examples about adopting such an approach reviewing the consequences, pros and cons of this experience, showing how composability and reuse at the micro level can yield a more expressive code with fewer bugs.
Introducing the concept of architectural shelf life, Dan Pritchett defines the average duration of an architectural life span. Stressing that failing to evolve the architecture at the end of its life span may have important business implications, he provides some advices that aim at facilitating architecture update with new technologies and patterns, thus making architectures last longer.
(more…)
