chrisdone

hace 5 añosdiscuss

The Economist stylized this as “tweets are appraised as speech, but punished as writing.”

hace 5 añosdiscuss

I’m working on https://inflex.io/ which can achieve the data / logic separation of Improv, by putting functions in cells. But Improv isn’t an inspiration. Inflex is certainly closer to it than Airtable though.

chrisdone

hace 5 añosdiscuss

I see that it supports units in terms of scale - does it also prevent units that measure different things from being combined? E.g. 2 kg + 3cm (units mismatch) or 3$ * 7$ (two monies can’t be multiplied).

chrisdone

hace 5 añosdiscuss

Airtable is strongly typed in the fields of the tables, but the expression language is not. It is my conclusion based on researching Airtable, that the decision to have well typed tables is so that relational operations work nicely, and so that they can implement interfaces on top of these tables easily, such as calendars and work planning things etc. I don’t think that there is an underlying motivation to fix the ill-type code of the world, so to speak. Any non-trivial code work is done in JavaScript, anyway.

chrisdone

hace 5 añosdiscuss

I commented elsewhere in this submission that I am working on a strongly typed spreadsheet. (Don’t want to spam my product link.)

I do think that bringing new syntax to the table is justifiable if it brings new concepts with it.

I agree, power query is essentially a separate product and doesn’t feel first class. I think that probably explains its relative obscurity, despite being highly powerful.

chrisdone

hace 5 añosdiscuss

I am working on a product which is pretty much exactly what you describe. I love spreadsheets but I wanted something that I wanted to actually program in right from the beginning to the end of my work process.

It’s called Inflex: https://inflex.io/

And it is a pure functional programming language, with cells, which are reactive, and with real data structures like lists and records. We have a work in progress beta. Sign up requires a paid subscription, but only because I wanted to make sure that the infrastructure was working. To try the work in progress product, you can just hit Try which lets you play in a sandbox. It doesn’t save or remember any of your work, and also doesn’t even hit our databases. (Safe from the hug of death.)

It’s pretty bare-bones right now but it’s based on ideas from Haskell, and Unison which is a content addressable language. (Every cell has a SHA512 hash of its content.) That makes versioning very easy, but this is not seen in the UI yet.

The table editing and what not is a little cumbersome right now, as there are a lot of things to come together and I wanted to demonstrate at least some of them.

Speaking of clean separation between data and display, The plan is to build for example reports using a simple HTML like DSL. Also, things like time and external data sources will be treated in the type system as explicit streams, which is an architecture that has been fully explored in Haskell under the guise of FRP.

But I’m working on this in my spare time and therefore progress is turtle pace rather than silicon valley pace. :)

chrisdone

hace 5 añosdiscuss

I like your work on Mito, and I feel like it’s the python answer to a project that I’m working on which is the equivalent but with Haskell, or rather a riff on Haskell to be more amenable to spreadsheets-like programming.

One thing that you can do when you have a pure functional programming language is rather than generating separate cells for modifications, you can go into the code and modify it directly fairly reliably.

I’ve linked my project elsewhere, don’t want to spam the thread.

chrisdone

hace 5 añosdiscuss

SPJ has been coming at this from the angle of let’s add things to Excel because Excel itself is already established.

This, in my opinion, is putting lipstick on a pig. The inputs and outputs work represents a very stretched contortion of trying to do real programming in a limited environment.

I am coming at it (commented elsewhere in the submission my project, avoiding spam) from the other end: start with a fresh, language take all the tried and tested programming language research useful to this way of working and connect it to a UI which fully comprehends this language. Throw out the grid and coordinates.

Row types, polymorphic variants, FRP for time/streams/events, type classes for arithmetic, CAS for cells, etc. We really do know what works, and therefore we can actually start from scratch and have some thing that is actually nice to use.

chrisdone

hace 5 añosdiscuss

It’s my understanding that the main selling feature of AirTable is the hard coded views that they offer; calendars, kanban style planners, things like that. The slightly more structured nature of relational tables over spreadsheets lets you implement those fairly reliably.

chrisdone

hace 5 añosdiscuss

Someone said the problem of WhatsApp is network effects. Network effects are fine.

Email benefits from network effects. The difference is that email is designed to be decentralized and from the beginning had many clients with open protocols. IRC similar. And of course, the web browser itself. DNS.

Back when these were invented, people had many different operating systems and architectures, so the protocol was more important than the client/server. Today, we have about three platforms: web, iOS and Android, meaning you can reach millions of users with software rapidly, rather than the slow way of pushing a protocol. There’s less incentive to have decentralization and there’s money to be made. Protocols require cooperation and therefore move slower. SMS and IRC and email don’t feel modern because they move at glacial pace of cooperation.

I think therefore it’s harder today to push a decentralized, more free protocol than it was when we had more OS/arch diversity. When in a quasi-mono-culture, protocols take a back seat. People don’t ask about it or know what they are. The ratios are flipped: we have basically three OSes and a very large diversity of app/services all incompatible and each locking you in.

chrisdone

hace 6 añosdiscuss

Not that, but Unison is one direct inspiration. I wrote a small overview here https://community.inflex.io/t/the-inflex-language/20

chrisdone

hace 6 añosdiscuss

A paper that profoundly influenced my language design: “Programming with Polymorphic Variants” https://caml.inria.fr/pub/papers/garrigue-polymorphic_varian...

And the earlier paper “A Polymorphic Type System for Extensible Records and Variants” https://web.cecs.pdx.edu/~mpj/pubs/96-3.pdf

Row types are magically good: they serve either records or variants (aka sum types aka enums) equally well and both polymorphically. They’re duals. Here’s a diagram.

              Construction                Inspection

    Records   {x:1} : {x:Int}             r.x — r : {x:Int|r}
              [closed]                    [open; note the row variable r]
    
    Variants  ‘Just 1 : <Just Int|v>      case v of ‘Just 0 -> ...
              [open; note the row var v]  v : <Just Int>
                                          [closed]

Neither have to be declared ahead of time, making them a perfect fit in the balance between play and serious work on my programming language.

chrisdone

hace 6 añosdiscuss

That may be a cultural difference. You may see the EU as having a "very lax work ethic", but in my experience working in the EU, they see America (and Britain) as having an unhealthy work obsession.

(Work to live vs live to work, perhaps.)

chrisdone

hace 6 añosdiscuss

The recent Unison language uses the effect system described in the Frank language https://www.unisonweb.org/

chrisdone

hace 6 añosdiscuss

I agree. I read the same passage and had the same complaint.

I just finished a Great Courses lecture series on the Norman conquest of England, and the professor makes this very comment. And also argues that the melding of Norman--not 'French', Norman was a sister to Old French that looks more like Vulgar Latin--and Old English is what gives modern English its vast vocabulary, roughly twice the size of Spanish; as many words have the Germanic and Romance varieties. You can 'meet' someone or 'encounter' someone, etc.

Ironically, "Norman" comes from "north men", as Normandy was settled by Scandinavian invaders who "went native" in France. Then they "went native" again in England, forgetting their original Norman.

chrisdone

hace 6 añosdiscuss

There's a StrangeLoop talk about teaching programming by Felienne Hermans (https://www.youtube.com/watch?v=g1ib43q3uXQ) that claims that all fields have an "exploration vs instruction" debate on how to teach their field, but this debate is apparently absent from the field of programming for the most part, wherein the "mess around and figure it out" exploration style of LOGO and Papert ("every time you teach something, you deprive a [student] of the pleasure and benefit of discovery") is the predominant unquestioned wisdom. Felienne wants more pedagogy fights. It's a worthwhile talk. I love LOGO and I think our generation of programmers are very sympathetic Papert's philosophy due to most of us being self-taught to some degree (you can see the fond nostalgia already on display in the comments here), but Felienne made me think about it more critically.

chrisdone

hace 6 añosdiscuss

Reiki does not involve touch.

chrisdone

hace 6 añosdiscuss

I think Decision Fatigue has a long and rich treatment in the Buddhist and specifically Zen tradition. One of the true practical daily takeaways from Zen teachings I can share is that dithering and hesitation are acute forms of suffering and akin to a broken record repeating.

A zen master may deliberate on a question, but will never dither. When presented with a choice, do the thinking it deserves but no more.

A simple example: you're looking at a menu and they all look good. Pick the first one or the one closest to your finger. It doesn't matter.

Also, don't cheat and be deferential; "I don't know, which would _you_ like?" Practice actively choosing. It'll do wonders in your daily life.

chrisdone

hace 7 añosdiscuss

That's an interesting angle. Another way of saying it might be that GoDP on the face of it can make one-off proofs for a value. Proofs for a function requires making proofs about all possible inputs, which is where your property test comes in handy. I could have `Named a (List x -> List x -> List x)` as the function I'm proving things about.

With some template-haskell you could run the property test at compile-time, and then use that proof later (e.g. for an instance of Semigroup which would require a argument proof of associativity), in languages like Unison that never run the same test suite twice (due to Content addressable code), this would be feasible. Or just run the property in your test suite and hope that the developer runs the test suite often. GHC erases data types that aren't actually evaluated in many contexts, so we even have erasure too.

I like your angle!

chrisdone

hace 7 añosdiscuss

Techniques like Ghost of Departed Proofs are the most exciting thing to me as a casual correctness enthusiast. It acts as a means of combining static types with contracts.

Types are sound mostly because they are a stupid mini language, so easily enforced, like you said. Contracts are practical and convenient because you tend to write them in the language or a subset thereof that you’re checking. That’s hard to ignore.

GODP has you write a runtime check in regular code, and return as a result a proof value. Put that code in a module boundary. Then you have upstream functions expect a proof argument along with the value the proof is about. They’re tied together with a unique type variable (rank n or existential are the mechanisms of delivery for Haskell, but may differ in other languages).

head :: NonEmpty n -> Named n (List a) -> a

In this way you started from a dynamic, runtime piece of code, and ended up using a static type system to just ensure everything is passed around correctly which is trivial.

A single proof in this technique is nominal in the type (e.g. not null or positive or sorted ascending/descending), but combining them is done at the value level so there’s flexibility.

The bang for buck potential is large. I’m more interested in stuff like this than the dependent types direction that people are pushing for in GHC. If I wanted dependent types I have Agda, Coq, Isabelle, Idris, etc. to play with.

Submissions

Finally, dynamically typed programming in Haskell made easy

Fast Haskell: Competing with C at Parsing XML

FP Complete's online Haskell IDE is now free for community use (try it)

Try Haskell: An interactive tutorial in your browser

comments