Hacker News Reader

While it is only a design concept, Mercury OS [1] might interest you. When I first came across it, I was blown away by the idea. It basically makes the user intent first class rather than the application/program. What I mean is that instead of finding a program or application to execute your intention indirectly, you declare your intent to the OS. Then the OS maps your intent to a series of actions which are executed by hooked-in pseudo-functions. It erases the boundary between applications by being almost like an interactive visual version of a declarative programming language. You should read the article rather than trouble yourself with my explanation though...

[1] “Introducing Mercury OS” by Jason Yuan https://link.medium.com/USD9Pj6svX

Thanks, I'll take a look!

The workspace concept (Eclipse, VSCode, Visual Studio solution etc.) works well, but is often hated because it is at odds with the OS file system hierarchy.

Making workspaces a first class OS citizen would be great, but the problem is with mutually referential hierarchical projects, having to include shared network folders in a corporate workflow etc., which break the metaphor again. Maybe an n-ary taggable workspace association flag on FS entries would work (Reiser FS?).

what do you mean by "at odds with the OS file system hierarchy"?

the file organization in a VS project can be totally abstracted from the underlying file structure, or it can be a 1-1 mapping. if I'm using a supported version control system, I might never need to care where the files live on disk. on the flip side, the fact that every file has a physical location mean I can also use whatever unsupported version control I want.

the OS filesystem is a pretty stable and relatively simple interface. I'm not sure how it could be made more intuitive without sacrificing flexibility.

Personally I am a big fan of haveing file system hierarchy dictate workspace heirarchy. I understand that there are cases where it might be nice to have a separate structure defined for an IDE, but that often comes with the cost of not being able to seamlessly use filesystem operations to edit the project directly. It feels more *nix-y to use the filesystem for this.

I thought it one of the really interesting parts of the Sets experiments that the Windows team was working on (and ultimately seem to have cancelled). They fell straight into this rabbit hole of "sessions" and defining what they mean to a user as soon as they tried adding (heterogeneous) Tabs as a native UI element to every window title bar. A lot of the dev talk on what to expect with Sets was on trying to surface user-meaningful activities to the Microsoft Graph and thus to the Windows Timeline thus making those groups of tabs meaningfully relevant to a user ("these are the tabs I used to file my expense report").

It is definitely a hard problem to solve, especially if you are hoping for software to do a lot of that aggregation automagically "reading people's minds". It was really cool seeing some very smart people on the Windows team trying to build it with Sets, and maybe all the more disappointing that the idea didn't make it "out of the lab" for its grand attempts at trying to build a more complicated/nuanced/powerful model of how people interact with groups applications at a time.

I like the idea that the job of the OS (or really, the DE) is to respond to why we're using our computers. Each application should have its own job, but the DE's job is to help us achieve our intentions.

    > For my ideal work desktop, I want to have tools assigned per task that I can easily assemble until that task is achieved.

Funny you should say that – I'm currently working on an application that does just this (on macOS). Beta/MVP should hopefully be out this summer.

For my ideal work desktop, I want to have tools assigned per task that I can easily assemble until that task is achieved. As a spitball idea: Cmd-space, type in "research open sourcing my kindle", and get given a browser and some sort of note collector. Collect the various things from the session into my note, refile the entire stack as a project, and move on to the next task. In the future, I can access the actual project and receive a workspace with terminals, an IDE or whatever else I need to Get the Thing Done, archived versions of the sites I opened, etc. Ideally, the environment would be designed to reduce distractability.

I'd willing to donate money, work, or both. Is anyone working on something like that?

Have you tried https://workona.com/? Is a chrome plugin so limited to web tools and resources, but for me and the use case you describe, it’s a total game changer.

That's exactly the point of using HyperLook as a window manager, which we were discussing at Sun in 1991 before they canceled NeWS.

HyperLook, which was inspired by HyperCard, but written in PostScript for the NeWS window system, let you build specialized task-oriented user interface by assembling and customizing and scripting together components and applets into their own "stacks".

The Psychedelic Inspiration For Hypercard:

https://www.mondo2000.com/2018/06/18/the-inspiration-for-hyp...

Bill Atkinson interview about HyperCard:

https://twit.tv/shows/triangulation/episodes/247?autostart=f...

SimCity, Cellular Automata, and Happy Tool for HyperLook (nee HyperNeWS (nee GoodNeWS)):

https://medium.com/@donhopkins/hyperlook-nee-hypernews-nee-g...

>HyperLook was like HyperCard for NeWS, with PostScript graphics and scripting plus networking. Here are three unique and wacky examples that plug together to show what HyperNeWS was all about, and where we could go in the future!

HyperLook and window management:

https://news.ycombinator.com/item?id=19007885

>HyperLook (which ran on NeWS, and was like a networked version of Hypercard based on PostScript) was kind of like looking outwards through windows, in the way Rob Pike described the Blit (although it was architecturally quite different).

>I think his point was that window frames should be like dynamically typed polymorphic collections possibly containing multiple differently typed components that can change over time (like JavaScript arrays), not statically typed single-element containers that are permanently bound to the same component type which can't ever change (like C variables).

>With X11, the client comes first, and the window manager simply slaps a generic window frame around it, subject to some pre-defined client-specified customizations like ICCCM properties to control the window dressing, but not much more, and not under the control of the user.

>With HyperLook, the "stack/background/card" or window frame came first, and you (the user at runtime, not just the developer at design time) could compose any other components and applications together in your own stacks, by copying and pasting them out of other stacks or warehouses of pre-configured components. [...]

Here are some ideas about HyperLook and other systems, that could be applied to Sugar:

https://libarynth.org/hyperlook

>[...] My ultimate fantasy gui environment would support plugging in different script editors, with not only easy-to-use but also advanced visual programming interfaces, tailored to specific tasks and skill levels (like handling and sending events, solving constraints, processing signals, playing music, controlling robots, blinking lights, dancing bears, etc). [...]

Thanks, this is really interesting. I'll have a read through :).