If you tried out, or at least read the Cedalion DSL tutorial, or at the very least watched the “hello, world” video in the “first steps” page, you would agree that Cedalion is different than any other programming language you know.
Cedalion is not new. I published my first paper on Cedalion back in 2011, about five years ago. So why did I start blogging about it just now? Why did I not make an effort to showcase it to people who may find it useful?
Why? because until recently, it wasn’t that useful. In this post I will tell you why, and share the insight that I believe makes Cedalion matter.
We ended part II of this tutorial at a point where our DSL allowed us to define functions. But these functions are limited. We easily defined a function that squares a number, but if we were to generalize this to say, raise a number by a given power, we were in for a problem. We could do this with recursion, of course, but recursion needs to stop at some point. For that, we need support for conditionals — a way to ask whether we need to stop or to carry on recursing.
In this part we will define the two necessary components: a >= predicate that compares expressions, and a conditional expression. We will focus on giving both the look and feel of their mathematical counterparts. To demonstrate our new abilities we will implement the factorial operator.Read More »
In Part I we started defining a small DSL in Cedalion. For now, our DSL consists of expressions, but the only type of expression we currently support is a constant. Not a very interesting DSL…
We will now change this, by adding some arithmetics into our expressions.Read More »
During the last few days I wrote a few tutorials on installing Cedalion and getting started with it. All tutorials are accompanied by videos. In this post I will guide the reader (you…) as you will implement your first DSL in Cedalion. To keep things simple, I’ll base this DSL on the one we implemented in Prolog in my previous post.Read More »
In my previous post I wrote about the two insights that lead to the development of Cedalion, and the first of them was realizing the true power of logic programming. In this post I would like to explain this.
I am assuming most reader have heard about logic programming, and maybe some of the readers even studied Prolog at one point in their life, but I cannot assume readers remember much of it. So I’ll try to take it slow…Read More »
It’s been three months since my last post. During these three months I was busy mainly with writing a paper for submission to a conference, and I find it hard to invest in “side write-ups” while being totally invested in authoring a paper.
For a week or so I thought about how I should continue the tale this blog was intended to tell, the line of thought behind my research, along with some technical information, tutorials maybe, to help readers interested in trying things themselves. Looking for a story, I looked back at the early days of my research, and then I realized this is a story worth telling. So in this blog post I will tell the story of the first half of my research so far (my MSc thesis) — how I started, and mainly why. Why I went to research, and why this particular research topic.Read More »
In my previous posts I talked about why declarative programming and in particular logic programming are relevant to software developers everywhere. In this post I will take a step back and try to look at a bigger picture: programming languages in general, and ask why. Why after we had Cobol we needed Fortran, and after we had Python there was still room for Ruby. Why are there so many programming languages? Is it possible to have one language to rule them all?
To answer these questions we will go away from programming, and see how other kinds of languages evolve and adopt to their surroundings, just like living things…Read More »
In Part 1 of this post I covered the NoSQL movement, and described what I think is not ideal there. A short recap would be the following points:
- Lack of standardization – each database provides its own API and query language, that is often tightly coupled with its implementation.
- “No fancy queries” – users need to write their own de-normalization routines outside the database, which is prone to errors.
- Data migration – de-normalized data more sensitive to software updates than normalized data. As a result, more throw-away code needs to be written just to perform data migrations.
In this post I will present what I call NoDatalog, and explain how it can, at least in theory, overcome these three issues.Read More »
In this post I’ll talk about NoSQL, what it is, why it is important, and what is wrong about it. In Part 2 I’ll present and alternative: a new concept that my co-author and I coined in a recent paper: NoDatalog, and explain how it can give us the benefits of NoSQL, but without the disadvantages (at least in theory…)Read More »
In this blog I will discuss two computer languages, Cloudlog and Cedalion – the former is a query language and the latter is a programming language, but both languages are pure declarative. This means that none of these languages has commands. Instead, they have declarations, definitions and rules of different kinds. We will discuss these languages in depth in future posts, but in this post I would like to talk about what declarative languages are, and why do we need them?Read More »