
Object Spreadsheets - necrodome
http://sdg.csail.mit.edu/projects/objsheets/
======
mattmccutchen
Hi! I'm one of the developers of Object Spreadsheets and will do my best to
answer the substantive questions in this thread. Thanks to richardboegli for
notifying us.

~~~
dustingetz
Can you handle multiple users with different security/permissions? Is it
possible to gracefully grow an object spreadsheet into a real application, on
scale of facebook.com, with performance and battery concerns along with a
fully programmable UI? If not what is missing?

~~~
mattmccutchen
> Can you handle multiple users with different security/permissions?

Not yet. We obviously need this for real-world use, but we assumed it would be
straightforward compared to the other features we've been working on, so it
hasn't been a priority to actually implement it.

> Is it possible to gracefully grow an object spreadsheet into a real
> application, on scale of facebook.com, with performance and battery concerns
> along with a fully programmable UI? If not what is missing?

We haven't thought much about this so far; the small to medium applications
are the lower hanging fruit for our approach. A few missing things I can think
of:

1\. We haven't put much work into performance, so the current implementation
doesn't scale beyond small demos. It may be straightforward to move the
execution to a relational DBMS, but it would take significant engineering (and
maybe UI design) to make the spreadsheet UI useful for large data sets and
complex schemas; there may be precedent in other tools.

2\. Our language currently does not have the abstraction features one would
want in order to write really complex business logic, e.g., object-oriented
programming (or some alternative) and the ability to pass composite data types
by value. If we wanted to support something like Facebook, our language might
end up looking somewhat like that of object-relational DBMSes such as
PostgreSQL, but with some differences for our data model.

------
necrodome
Demo video:
[https://drive.google.com/open?id=0B8oi3hbhFCrpZEhtMEZSSm9wLV...](https://drive.google.com/open?id=0B8oi3hbhFCrpZEhtMEZSSm9wLVU)

------
cheriot
A startup tried this with IronPython to draw financial analysts away from
excel. Here's the result:
[https://www.resolversystems.com/](https://www.resolversystems.com/)

The product was pretty slick, too. I hope someone can crack the nut.

~~~
kornish
There's also a company developing a web spreadsheet solution that allows for
inlining code of different dialects into spreadsheets to reference cells like
a SQL table: [http://alphasheets.com/](http://alphasheets.com/). They're
targeting financial analysts too, iirc.

~~~
cheriot
Looks like a cool idea. "Contact for a price" to get more than 1,000 rows is
ambitious.

------
conception
This seems to duplicate a lot of the functionality of Airtable
([https://airtable.com/](https://airtable.com/)). Anyone catch what it's doing
new?

~~~
david927
The idea has been around at least since 1981 when Adele Goldberg at PARC
implemented something like this.

I think that Kayia ([http://kayia.org](http://kayia.org)) is also similar but
more relational than both this and AirTable.

~~~
mattmccutchen
Kayia had intrigued me before but I seem to have lost my notes about it, so I
watched the video again. I confess I still don't feel like I have a solid
understanding of the semantics. It looks like Kayia (like many general-purpose
programming languages) has more than enough flexibility to set things up so
that applications can be built with similarly clean code as in Object
Spreadsheets, but also enough flexibility for novice users to mess things up
in unobvious ways once they start creating nontrivial nested structures. I
believe we're better off enforcing a schema and showing the entire
hierarchical data set on one screen so novice users can recognize more quickly
when something isn't the way they want. (For large data sets, we may need
folding, or drill-down in separate windows as in Kayia may even be preferable,
but showing everything at once is a great place to start to build user
understanding of the tool on small data sets.)

~~~
david927
I need first to say that you should be commended on working on Object
Spreadsheets. Alan Kay has always warmly received anything effort in that
space -- it's simply neglected and for no clear reason.

For Kayia, you can set constraints which enforce schema, if you want, but it's
not recommended. I would rather have too much flexibility for novice users
than not enough, because that's the side we err on. We often (I'm speaking
generally) remove complexity by removing or limiting function, and I disagree
with that, philosophically. I would rather steer than stop.

------
twoodfin
Reminds me of this talk from SPJ, "Spreadsheets: Functional Programming for
the Masses" [https://www.slideshare.net/mobile/kfrdbs/peyton-
jones](https://www.slideshare.net/mobile/kfrdbs/peyton-jones)

~~~
mattmccutchen
FWIW, user-defined functions as such and the ability to pass composite data
types by value are part of our vision but haven't been a priority to
implement. In the meantime, a formula can be mapped over a set with a computed
field (you only really need a user-defined function when you need the same
logic at two different places in the schema), and the typical use cases for
relations are also accommodated by our existing features.

------
pjmlp
When I read the title this is what came to my mind.

Lotus Improv on NeXTStep

[https://www.youtube.com/watch?v=TbsfvdZXE7s](https://www.youtube.com/watch?v=TbsfvdZXE7s)

------
dustingetz
Demos are down (from here: [http://objsheets-
demo.csail.mit.edu/?examplesNamePrefix=fvQ6...](http://objsheets-
demo.csail.mit.edu/?examplesNamePrefix=fvQ6Ru7jacmojXcbg))

------
misterdata
See also [https://warp.one](https://warp.one) for a similar tool on Mac

~~~
wruza
It seems like a blog with completely different posts. Did you mean some
specific article?

~~~
dangoor
I think this is the link: [http://warp.one](http://warp.one)

~~~
misterdata
Ah yes, sorry!

------
tjl
The product I miss most is Lotus Improv. I used it on NeXT all the time.
There's no mainstream product that's quite like it.

~~~
aheilbut
Quantrix isn't quite mainstream, but is very similar to Improv.

~~~
tjl
I know about it, but I'm guessing it's quite expensive. The certainly make it
difficult to figure out pricing (or even just get the trial).

~~~
aheilbut
There are a couple of recorded webcasts where they mentioned the pricing; it's
approximately $2k/seat/year, if I recall correctly. They do make you register
for the trial, but they approve it quickly. It's definitely worth checking
out.

~~~
tjl
Thanks for the info. It's a bit expensive for me. I've been wondering about a
good long term project and this might be it. I'll have to think about it.

------
tedmiston
I'm not sure if I quite understand this. It's like a database GUI tool but for
spreadsheets with some structured data inside the cells? Is it for
researchers? Is the idea that you'll generate an underlying explicit schema
for the end user?

~~~
richardboegli
Abstract from paper [1] gives a better explanation:

Abstract Spreadsheets offer many advantages as the computational and data-
storage engine for applications that are authored by end users. Paradoxically,
however, their main failing in this regard is their computational model.
Despite being used in almost all cases to represent data that is essentially
relational (with some hierarchical structuring), the spreadsheet model treats
the two-dimensional grid as largely unstructured, with formulas linking cells
in an ad hoc way. This paper reports on a quest to rethink the spreadsheet
model. The model we propose supports not only conventional flat tables, but
also nested variable-size lists and object references. It includes a formula
language suited to the data model and procedures to specify updates. The model
has been implemented in a tool called Object Spreadsheets, which is intended
for the development of data-centric web applications. We describe several
example applications we built using the tool to demonstrate its applicability.

[1] [http://sdg.csail.mit.edu/projects/objsheets/objsheets-
onward...](http://sdg.csail.mit.edu/projects/objsheets/objsheets-
onward2016-preprint.pdf)

------
ams6110
_Completely missing at this point are (1) the ability to edit stored
procedures via the spreadsheet UI and (2) integration with a UI builder to
design the application UI._

So they're trying to reinvent Microsoft Access?

~~~
jrcii
Access isn't exactly a model of usability, we should encourage efforts to
develop new and better things.

~~~
tracker1
Lotus Notes was a bit more usable than Access, InfoPath was interesting as
well... In the end, the more "usable" it is, the harder it generally is to
migrate when you need scale beyond what's in the box.

------
spullara
Reminds me of Trifacta. It has a similar spreadsheet + objects used for ETL.

------
fiatjaf
These are the features [https://fieldbook.com/](https://fieldbook.com/)
currently offers, but this is open-source, right?

~~~
fiatjaf
Fieldbook has some memory and general slowness problems with 30MB of data, as
I currently have there.

Would this be faster and more flexible? It seems to be using Handsontable for
the spreadsheet component. It seems heavy, but I guess the computations, views
and queries is where things get complicated.

~~~
benbernard
Interestingly, we (Fieldbook) used handsontable for a long time, but
eventually found it wasn't performant enough for the size of data we had (also
we just needed to be able to do more customization than we could wrangle out
of it)

~~~
duncanawoods
I thought hansontable did virtual rendering/scroll which if done right should
scale. Where did you see performance problems?

------
daveed
I didn't see this in the video, but is there a planned way to read/write the
stored data from one of your instances? What does it look like? For certain
things (anything with real volumes of data) it's impossible to do data
population by hand.

~~~
mattmccutchen
We want to have a good API for this, but we haven't figured out yet what it
should look like. Right now, it's possible to read and write the underlying
data representation via the Meteor Dynamic Data Protocol, and we have some
JavaScript library code to help with this. That's what the spreadsheet client-
side code does for all reads and most writes, and what the client-side code of
the example applications does for all reads. (For completeness, I'll mention
that certain complex data writes and all schema writes from the spreadsheet go
through APIs, and all writes from the example applications go through an API
to invoke stored procedures.) We're planning to build a better API bit by bit
as we do more things with the system; I don't think I can estimate a time by
which it will be stable.

------
transfire
And every teacher would be lost 5 mins into that tutorial.

