
A comparison of Cell with OOP - networked
http://cell-lang.net/comparison.html
======
dang
Language thread from 2017:
[https://news.ycombinator.com/item?id=15797831](https://news.ycombinator.com/item?id=15797831)

------
ktpsns
Cell-Lang is interesting, but they are not the first one to address ORM code
generation or even signal-slot code generation. How do they compare to the
popular large popular libraries? The comparison is only given to handwritten
native (Java/C++) code, but it is a bit unfair to compare code generation to
human code writers.

~~~
cell-lang
Cell is not an object-relational mapper. It is a programming language that
uses relations to encode data, instead of records and pointers. There's a
world of difference between the two. ORM helps you load/store your data
from/to an SQL database, but once your data is in memory, all computation is
done using objects. In Cell, on the other hand, computation is done with
relations.

In that example, ORM is never mentioned: it's just a comparison between two
different programming paradigms, functional/relational programming and OOP.
It's not unlike comparing, for example, ML-style functional programming and
OOP.

A comparison of the reactive part of the language with a framework like, say,
ReactiveX would be interesting, and will be added at some point, once that
part of the language has matured.

------
fermigier
A couple of quick questions:

1) Who's behind the project and what's their motivation?

2) Where's the source code? (OK I get this is not an open source project.
Why?).

~~~
cell-lang
It actually is an open source project. The github repository is here:
[https://github.com/cell-lang/](https://github.com/cell-lang/). There's a link
to it on the home page

------
blondin
dragon ball z nostalgia just hit me...

------
lincpa
The Clojure language is a better and simpler Cell language.

Clojure is a functional programming language based on relational database
theory.

```

    
    
                   Clojure -> DBMS, Super Foxpro
    
                       STM -> Transaction，MVCC
    

Persistent Collections -> db, table, col

    
    
                  hash-map -> indexed data
    
                     Watch -> trigger, log
    
                      Spec -> constraint
    
                  Core API -> SQL, Built-in function
    
                  function -> Stored Procedure
    
                 Meta Data -> System Table
    

```

It officially supports jvm, js, .net platform, and third-party implementations
such as go, py, erlang and other language platforms.

You can use graalvm for native compilation, and mixing with R, python, ruby,
js, Java is very simple.

[Clojure is a FP based on
RMDB.]([https://github.com/linpengcheng/PurefunctionPipelineDataflow...](https://github.com/linpengcheng/PurefunctionPipelineDataflow/blob/master/doc/Clojure_is_FP_based_on_RMDB.md))

[Everything is
RMDB]([https://github.com/linpengcheng/PurefunctionPipelineDataflow...](https://github.com/linpengcheng/PurefunctionPipelineDataflow/blob/master/doc/Everything_is_RMDB.md))

[Implement relational data model and programming based on hash-map
(NoSQL)]([https://github.com/linpengcheng/PurefunctionPipelineDataflow...](https://github.com/linpengcheng/PurefunctionPipelineDataflow/blob/master/doc/relational_model_on_hashmap.md))

[Clojure Home]([https://clojure.org/](https://clojure.org/))

