HNHacker News
TopNewBestAskShowJobs

shalabhc

711 karma · joined May 31, 2016

[ my public key: https://keybase.io/shalabh; my proof: https://keybase.io/shalabh/sigs/NgDeILkzoEofkUNT-I5VjMhFDAAlXGMy0M8L6k4v5C8 ]

http://shalabh.com

shalabh at shalabh.com

works at dagsterlabs.com

submissionscomments
shalabhc··on Programs are a prison: Rethinking the building blocks of computing interfaces
A lot of replies are missing the point.

It's not "apps integrate better with each other".

It is "there are no apps".

So what would Adobe sell, if not the "Photoshop app"? It would sell the Photoshop "menu of filters", the "selector toolbox", the "color histogram view" and such. But the workspace where you see the image and apply the selectors or filters would be outside Photoshop itself. It would be a standard part of the system, where the image could come from and go into another organizing system (possibly provided by another vendor). You could mix organizing systems, sharing/versioning systems and filters/selectors/menus/views from various vendors, commercial or free or open source.

This would apply not just to images, but to all kinds of media - movies, documents, including "code".

shalabhc··on Programs are a prison: Rethinking the building blocks of computing interfaces
Agree. I'm usually very frustrated with the app boundaries, poor system wide integration and so much duplication of work.

Another essay about computing without apps is https://humane.computer/killing-apps/

shalabhc··on Self-Contained Development Environments (2018) [pdf]
Thank you. How much of this problem do you think is solved by Monticello, if you've used it?
shalabhc··on Self-Contained Development Environments (2018) [pdf]
What do you think it would take to make such systems suitable for deployment? Do you have to give up the productivity?
shalabhc··on Orca: an esolang for audio-visual live coding
There's a two part podcast on futureofcoding.org with the creator of Orca, Devine Lu Linvega:

https://futureofcoding.org/episodes/044

https://futureofcoding.org/episodes/045

shalabhc··on Malleable Systems: Software must be as easy to change as it is to use it
This isn't about building software similar to what we currently have and just making it more end user configurable. This is about rethinking software so that end user malleability makes sense.

What does such software even look like? We want some kind of end user modifiable artifacts, still contained within some constrained substrate. Think Minecraft or Excel - I can give you a spreadsheet to calculate some taxes, but you can then dig in, change the formulae, remix with other sheets, and so on. Most software is not like this - typically you get some pre canned views and switches, not a canvas of composition.

shalabhc··on Talkyard: Open-Source forum software – a StackOverflow, Reddit, Disqus hybrid
I've been using the hosted version of this (https://www.talkyard.io) on a blog for a while and have been very satisfied. I like how the threaded discussion looks, and also like the live preview edit box which works well for long form comments.
shalabhc··on Where's my simulator? Simulated effect absent from the programming experience
Thank you for the implicit praise!

Seems like this would be an interesting list of essays - is it publicly shared?

shalabhc··on On Composition (2019)
Seems so. Also this twitter thread: https://twitter.com/RainerJoswig/status/1213484071952752640

- all commands have uniform introspection - console contains 'live views', not dead text - embedded REPL inside apps with commands that mirror the menus and buttons - seamless jump to source, live edit

shalabhc··on On Composition (2019)
(Author here)

It's not about interfaces being an impediment but there being too many composition models, none of which seem to scale very well. A composition model is more than an interface. E.g. the way you compose a C program is you write the pieces (functions, structs) that are designed to fit together in certain ways, and then run the compiler which binds these together. The way you compose a web application is you invoke multiple processes that have a pre-shared notion of the protocols and they bind with each other. We're inventing model upon model, stacking them up like an wall of rocks. I'm saying we should look for models that are powerful but compact and can scale up. It should also be something that leads to less reimplementation because composition within it becomes easier. I don't think we have such models and I believe this needs deeper study.

shalabhc··on On Composition (2019)
(Author here)

Your comment about scaling is on point. We're building on a system that not just enables but encourages a large amount of duplicated work because the substrate we've settled on is bytearray oriented. So all PLs and programs map their structures to 'bytes'. Could be worse - we could have different kinds of bytes (8-bit, 12-bit, etc.). But also could be better - the different processes could map their internal structures onto shared symbols or trees, and the substrate could provide a higher level of abstraction instead of clumps-of-bytes.

The interesting question to me is what kinds of composition models should a substrate provide? If we pre-share the notion of bytes, we end up share files and writing over sockets. If we pre-share more structured notion (e.g. graph) and share that it's another way. But there's more to it - how does meaning get transmitted via a message to a receiver? If we pre-share a grammar language, perhaps we can send a message that programs the receiver to extract useful info from itself? Whatever the structure of the message, there needs to be some sharing of 'tags' or 'identifiers' within the message for it to be usefully absorbed. How do we share these? Should this also be provided by the substrate?

shalabhc··on Show HN: Lucidity – an interactive program-state visualizer
Perhaps a combination of cultural and technical feedback loops?

Technology selects folks that like 'playing computer in your head' as Victor said [1]. This grows a culture where tools that help you avoid mentally simulating the computer are devalued. This selects more people even better at playing computer in their heads, etc.

[1] https://www.theatlantic.com/technology/archive/2017/09/savin...

shalabhc··on Is Git Irreplaceable? (2019)
For comments, fully agree that we don't need several isolated systems (source files, docs, commit messages, ...)

How about one system which is a hypermedia system and can hold many different kind of objects. So annotation objects can reference 'code objects' such as types, fields, functions or even blocks directly. Not sure if Dark gives each of these an identity (it should) which will make it possible to refer to them via hard links rather than text snippets. Once you have all code and comment objects in one hypermedia system, creating views from that is about multiple projections of the interconnected objects.

Wouldn't it be great if I can use a query to refer to 'all functions that reference this type' inside some docs? Or list all annotations that reference a function? These could be embedded inside annotations as well. Gtoolkit does something similar.

Perhaps even a 'branch' can be thought of as a subset of the hypermedia graph. E.g. using a code block X2 instead of a code block X1 within the same function.

shalabhc··on Lisp Symbolics Macivory 3 with loaded software
Here's another Lisp Machine demo showing some of these ideas in action: https://www.youtube.com/watch?v=o4-YnLpLgtk
shalabhc··on How to annotate everything
hypothes.is does exactly this, except it uses pdf.js

It doesn't matter where you load a PDF from (locally or any online source) the public annotations are overlaid.

shalabhc··on Let's Write an LLVM Specializer for Python (2015)
If you like this you might also like http://terralang.org
shalabhc··on Show HN: Darklang
One more for ya.

- DB/field annotations for privacy - given it's 'one integrated system', can we attach a privacy attributes to fields or db and automatically hide them everywhere (even in the dev view?)

shalabhc··on Show HN: Darklang
Great analysis. I also think you have 'small operators' and 'large operators' in middle and right. Consider a large number of small consultants building small-ish websites with some interactivity and state for small clients. They might use RoR, Django, but have to manage and run the operations and a database, even if they use cloud services. Wouldn't they be better with a integrated solution across coding, building, deploying, etc?
shalabhc··on Show HN: Darklang
Great stuff! My suggestion is to really leverage the possibilities opened up by the design choices that make Dark different - the structural editing and db/infra/editor integration. E.g.:

- Have multiple projectional views of the system, triggered on keypress, e.g. caller context, database context, handler context. So if I'm editing a function I should be able to see the handlers that are affected, also the call stacks up and down, even show function calls inlined, current live errors overlaid, etc.

- Easy example based testing. Can I just click on a function, type input values at the top, then dark shows my intermediate values and output, and then I mark a 'check' on this trace to stamp it as a test case? Then every related change (or a special button) runs affected tests and I can see what's failing. I didn't see any testing in the demo.

- History of each function, each handler, each table - absolutely need this, with 'blame'.

- Immediately live is nice but really you want to roll out some related changes together, and a 'diff' of a snapshot against another one is great. I should be able to see the db diff, the function diff and handler diff in one integrated view. Should be able to 'label current version', in addition to auto-save.

- Annotations - these should be allowed everywhere. I assume functions, AST nodes, tables, columns etc are already reified, so I should be able to link to them in free form annotation comments that I may put in the code or just floating around by themselves. Documentation needs to be integrated as well. At the very least I should be able to link to a function or table via an external hyperlink.

- A standard CRUD UI for DBs should be available.

shalabhc··on Alan Kay Did Not Invent Objects
I'm not sure the article is implying anything about Alan. Hard to tell, there seems to be something missing in the piece.

But one thing the article does argue about is what can and cannot be called OOP. It seems completely reasonable to me to refer to Java, Python and similar languages as OOP languages. That is the current widely accepted meaning of the term (even though these languages might be more like Simula than Smalltalk).

It also seems reasonable to say that Kay's original ideas around OOP and their evolution and refinement (not sure if we can call it a definition) overlapped with these, but were on a different trajectory. One that perhaps has not been explored extensively.

shalabhc··on Alan Kay Did Not Invent Objects
I think more interesting than 'who made X first' is 'what did X mean to A vs B'. So irrespective of whether Simula had objects first or Smalltalk did, the debate should be how Kay's perspective of objects was different than Simula's.

E.g. Kay wrote:

> Simula can't be praised too highly, and it was a huge influence. But if you take the care to check, you will find out that what I termed "Object Oriented" was quite different from Simula in (what I thought were) important ways. And if you are looking for the earliest inventions of ideas like these, there are several that predate Simula (take a look at that HOPL II chapter mentioned above)

(via https://news.ycombinator.com/item?id=15580308)

Some of the context is covered in the write-up, but there's more. E.g. one thing I hear from Kay is that objects are some kind of replacement for thinking about computing as procedures + data structures. And perhaps that we're still exploring the objects idea stuck into the old context (of procedures) rather than a new context of objects-only.

shalabhc··on Lisp Operating System (2015)
Great write-up and I agree with many points. I don't think the 'Lisp language' is the key point here though, but the other OS properties like a single level store and composition methods richer than byte arrays.

Would be nice if the author referenced historical systems that overlap these ideas.

One is the Symbolics Genera system with 'data level integration' so apps shared rich data structures instead of uninterpreted bits. https://www.ifis.uni-luebeck.de/~moeller/symbolics-info/gene...

Another is Appolo Domain/OS which had a single level store: http://bitsavers.org/pdf/apollo/014962-A00_Domain_OS_Design_...

shalabhc··on Flutter desktop shells
Random Dart question - how is the standalone Dart VM implemented? What is it written in, is there a bytecode, etc?

And is there a place where more details are available?

shalabhc··on Project Xanadu
Ted Nelson recently did a series of videos on the important ideas in Xanadu. Start here: https://www.youtube.com/watch?v=hMKy52Intac

Also you can buy his classic 'Computer Lib' book here: https://computerlibbook.com/

shalabhc··on What Is Dark?
I think operation level consistency policies are more useful than DB level. For instance, saying bounded stale reads are OK for some operation could be useful for the high read scenarios and hopefully the system will materialize a cache.
shalabhc··on What Is Dark?
Looks promising! Since this subsumes the database - what kind of transnational data consistency is provided? How do upgrades to your data model work?
shalabhc··on Nim in 2018: A short recap
How does Nim prevent modifying an object after it has been added to a Table? (Or is it always copied?)
shalabhc··on Systems, not Programs
I'm aware of extended attributes and it definitely seems like a step above the completely opaque byte arrays that are the status quo. I suppose we could call it db as a file system.

Another interesting idea is the data types in Amiga OS (http://www.mfischer.com/legacy/amosaic-paper/datatypes.html). I believe it lets applications be generic enough so that as new media formats are added, the applications automatically work with them, without rebuilding or restarting.

Lisp machines were mentioned in another thread here. They also had a better story around sharing data - you shared rich structures (rather than blobs of bytes that are encoded and decoded at every boundary) - and they would update live, etc.

In the end it seems today we're entrenched in something that's reasonable, but many good ideas could be explored more.

shalabhc··on Systems, not Programs
That ST video is great.

Yes, apps are silos - why? Making non-siloed apps is harder, and integration across these is harder still. Is it possible to design the underlying system/substrate such that siloed apps are not the structures grow easily, and integration is not something that has to be 'added on', but emerges automatically?

shalabhc··on Systems, not Programs
> The big difference is, you instrument a program, but you do not instrument a system.

We do instrument systems, consider strace or https://zipkin.io/

> A comparison would be a computer system is like a biological ecosystem.

Excellent analogy and one that I really like. What are the 'programs of biology'? One way of decomposing this is 'spacial' - e.g. a cell is a program, a limb or an organ is another larger one etc. But what about the nervous system, circulatory system, etc.? Aren't they useful perspectives but they span different units in the spacial decomposition. Can I view and modify them directly? What about updates - consider attaching another limb vs changing the electrical conductivity of neurons - while preserving some consistency and enforcing constraints.

← PreviousPage 2 of 10Next →