mechazoidal + facme   43

oakes comments on Paravim - A parasitic editor for Clojure
"Since then they have focused in a client server model where the client basically renders whatever neovim tells it to render.

The problem with the client server model is that there is a surprisingly amount of latency even in a local tcp connection, when you are expecting results every keystroke.

The other problem is that neovim clients have to ask their users to install neovim, which is a bad user experience. And worse, they have to hope their users have an up to date version of neovim that supports the apis they want to use. To me it seems like a modern version of DLL hell...

I want a direct in-memory connection to vim, and I think the async changes that neovim made actually made this more difficult.

The onivim 2 folks have it right. Vim should just be a state machine that you access with a stupid simple api that takes input and gives you new output."
reddit  comment  neovim  facme  piperesearch 
4 days ago by mechazoidal
Basically embedded libvim, with deep magic to connect it in clojure
clojure  editor  vim  facme 
4 days ago by mechazoidal
Nvim documentation: ui
Showing how vim's internal state is available over a defined protocol
piperesearch  facme  vim  neovim 
4 days ago by mechazoidal
TUI · letoram/arcan Wiki · GitHub
Arcan dev: "Its purpose is to provide a middle ground between the common high-level UI frameworks (HTML5, GTK, QT, ...) and glyph-based NCurses/Turbo-Vision like "character-stream" APIs."
This was a WIP, but he wants to revisit it eventually
arcan  gui  tui  piperesearch  facme 
22 days ago by mechazoidal
Free Software Needs Free Tools :: Benjamin Mako Hill
"First, the use of nonfree tools sends an unacceptable message to users of the free software produced. “Software freedom is important for you as users,” developers seem to say, “but not for us.” Such behavior undermines the basic effectiveness of the strong ethical commitment at the heart of the free software movement."

"Secondly, we should realize that, going forward, the software we produce is only as free as the software it depends on for its continued use, distribution, and evolution."
2010  pmz  gpl  opensource  piperesearch  facme  essay  software_development 
4 weeks ago by mechazoidal
GitHub - letoram/arcan: Arcan - [Display Server, Multimedia Framework, Game Engine] -> "Desktop Engine"
by crazyloglad:
"a powerful development framework for creating virtually anything from user interfaces for specialized embedded applications all the way to full-blown standalone desktop environments.

At its heart lies a robust and portable multimedia engine, with a well-tested and well-documented Lua scripting interface. The development emphasizes security, debuggability and performance -- guided by a principle of least surprise in terms of API design."
repo:github  piperesearch  arcan  gamedev  library  pmz  facme  gui 
5 weeks ago by mechazoidal
"Relentlessly optimized for speed and minimalism over the years, the editor consists of less than 2000 lines of C code and less than 4000 lines of Lua code. "
facme  lua  editor  tools 
6 weeks ago by mechazoidal
GitHub - makepad/makepad: Code your design. Rust based authoring tool for 2D design and animation using code.
@trishume: "It’s a work-in-progress editor that uses an imgui-esque custom UI toolkit to render everything, making heavy use of the GPU. Layout and highlighting for the entire file is calculated every single frame by highly optimized code. This will drop frames on rare 10k line files, but for all other files allows fancy things other editors couldn’t easily do like pressing alt to smoothly animate into an overlay of the functions in the whole file."

Some other good points in here to read PR. Note however they reserve the right to take it private due to money reasons.
rust  facme  piperesearch  repo:github  gui  editor 
6 weeks ago by mechazoidal
Emacs users are like Terry Pratchett’s Igors
PR/facme: "Emacs is built upon this principle; the Lisp principle. Make some small kernel of features. A substrate. Take care to make this substrate programmable (in any language, Emacs chooses Lisp), and then build the system upon it. Let users worry about future features. Some 359,000 lines of C code comprise its kernel, and 1,637,000 lines of Emacs Lisp take the rest of it."
Compare to Acme not needing programmability since the OS+shell handle it all.
Or consider that those 359k lines of code _are_ an OS, one that's portable to any other as a guest.
Emacs  piperesearch  facme  lisp 
7 weeks ago by mechazoidal
GitHub - basecamp/trix: A rich text editor for everyday writing
basecamp's rich-text editor, using the latest Modern Standards!
"sidesteps these inconsistencies by treating 'contenteditable' as an I/O device: when input makes its way to the editor, Trix converts that input into an editing operation on its internal document model, then re-renders that document back into the editor. This gives Trix complete control over what happens after every keystroke, and avoids the need to use 'execCommand' at all."
repo:github  editor  web  webdev  library  javascript  facme 
8 weeks ago by mechazoidal
GitHub - lotabout/skim: Fuzzy Finder in rust!
A clone of fzf in Rust. Available through cargo: either use the binary directly, or use it as a crate to give your rust program a fuzzy-finder(via BufRead)!
rust  repo:github  CLI  tools  library  facme  fzf 
april 2019 by mechazoidal
Vimways ~ Vim's social life
"I’ve always wondered why these vi/ex love-letters never mention the use-case of using vi in a shell pipeline, which seems to me a natural and reasonable. But this use-case is never discussed, never featured in breathless one-liners. Anyways I wrote some notes here: (and yes, I know about vipe"
piperesearch  facme  vim  shell  neovim 
april 2019 by mechazoidal
Acmeish for vscode
"Acmeish, inspired by the acme text editor from plan9.

The general idea of the plugin is to allow you to use system commands to manipulate text in your editor buffers in a convenient way, so the IDE blends better with the host system."

It basically provides two functions: capture, and run, which duplicate the mouse-button clicks of Acme.
plugin  facme  vscode 
march 2019 by mechazoidal
Notes from the Architect – Varnish
"Stop programming like it's 1975": don't worry about moving data between disk and memory. Reserve a block of memory and use it as a backing store. Let the kernel sort it out!

See also this for a 2019 note:
varnish  programming  optimization  2006  facme 
march 2019 by mechazoidal
Notes on Text Editing: Why Modality and Chording?
An interesting comparison between emacs and vim style, along with praise for vim's specific modal editing (and an unexpected & interesting argument against Kakoune's use of combined visual+normal modes AND reversal of verb object grammar)

"People may prefer to mainly stick to one style or the other, but normal vs. visual vs. insert vs. etc. mode is not the only type of modality. A lot of the benefits of modality can be had without using Vim’s style of having multiple editing modes by default. Some Emacs users prefer to not use evil but still make uses of hydras for grouping related keybindings. Some Vim users rely on chords for one-off navigational/editing tasks in insert mode. The best system is not one or the other but a compromise between the two."
repo:github  vim  emacs  ui  kakoune  piperesearch  facme 
february 2019 by mechazoidal
React as a UI Runtime — Overreacted
An excellent deep dive into React's rendering system. The two bets it makes are "stability" and "consistency" of the rendering tree: it works for most desktop-style UI, it won't help with games or constantly changing controls.

See the lobsters discussion for some other thoughts, including how Clojure Reagent works by taking the data-driven approach
programming  javascript  reactjs  piperesearch  facme  ui  gui  webdev 
february 2019 by mechazoidal
For the Love of Pipes | Lobsters
Note deadpixi notes about improving parts of sam where OS has gotten better:
"In the background I’m slowly rewriting the terminal side of things in a more modern way. The host part of sam is pretty much static, though I’ve made some modifications there (switching to a much simpler gap buffer implementation since modern OS’s have trustworthy virtual memory implementations). The host part is also getting an automatically-compacting journal that works better in some edge cases (again possible due to better OS support these days)."

(Later in the discussion object streams(PowerShell) are brought up, and I note that CMS pipelines were really the only close comparison)
lobsters  comment  facme  sam  discussion 
january 2019 by mechazoidal
What is the difference between the vim snippets plugins? | StackOverflow
Author of mu-template, one of the oldest vim snippets plugins. Note that it is one of the few that allows templates to include other templates, along with allowing the use of "StakeHolders" plugin to enable "tied placeholders"(modifying one named placeholder modifies other placeholders with the same name)

facme: is there any sort of CLI-based snippet generator? like if you called it from acme or a ":!" command: the goal is not to tie it to the editor. OTOH, if you want to visually step through each snippet item(like neosnippet/deoplete), how could you do that with a unix command?
(of course, consider that sam might be able to do something like this with its command-language and structural regular expressions)
vim  facme  stackoverflow 
january 2019 by mechazoidal
RFC: Parameter hints popup menu - Github
"This RFC proposes introducing a second popup menu in insert mode to display method argument hints, current parameter, etc. similar to a number of IDEs and editors. The proposal is to allow scripts to control this (such as on insert of ( and ) characters) and for it to be non-interractive and not to interfere with insert-mode completion."

reddit comment to go with: "Currently Bram is working on "text properties". That will allow you to define that, from line X1, column Y1 to line X2, column Y2 the text is a function declaration. Then you can set highlighting or something similar for that text property. This is how semantic highlighting can be implemented instead of the potentially much slower regex based syntax highlighting.

Then Bram plans to make it possible to spawn a window (something like the completion menu, again, take a look at the link) that has a few lines of text and reuse the text properties on that window - and you get a really nice UI capabilities for function signature help/argument hints."
gist  vim  facme 
january 2019 by mechazoidal
Programmer as wizard, programmer as engineer
"I think one of the overarching goals of compute science is to make more programming like wizarding. We want our computers to be human-amplifiers.

But we have different design goals and constraints when we’re doing one or the other. With engineering, we’re tasked with the long term maintenance of a piece of software, and we also become concerned with many lower-priority properties, such as its performance. With wizarding, we’re often best served by designing for ease of throwing code away rather than maintaining it. Well-engineered code is irreplaceable, but well-cast spells should be transient."

"The Problem is that we’re really, really terrible at transitioning from the bottom-right to the bottom-left. That is, at initially creating a quick and dirty prototype/MVP, and then evolving it into a well-engineered product."

"Getting to an MVP as fast as possible will probably always be the first priority. After all, who knows if what we’re building is even a good idea. And once there, we’re almost always going to start shipping that as a product, and thus wanting to maintain and evolve it from there. We can’t throw it away, no do-overs, too expensive.

So really, we need to get better at making this transition."

(The diagram in the middle is worth the cost of admission, there are some observations on type systems but nothing I haven't seen before)
software_development  design  pmz  facme  piperesearch  asspad 
january 2019 by mechazoidal
(repo: )
"Interim is, as the name implies, an experiment of combining the homoiconicity of Lisp (manipulation of symbols), the genericity of Plan 9 (everything is a file system) with the minimalism and hackability of home computers. New languages like Rust [Rust2015], Unikernel systems like Mirage OS [Mirage2015] and hardware designs like lowRISC or the Novena laptop [Novena2015] show that it is absolutely possible to build simpler, more open and safer systems than we take for granted today."

facme: note the "list of 'buffers'" and "list of rectangular 'views'": "the same buffer can be interpreted in different ways: listen to an image, look at graphic structure of text, paint into an audio sample."
But of course contrast that with his view on emacs: it wouldn't need to exist if the OS provided the building blocks for integration.
"I argue that an operating system can be designed as a database of well-formed functions that each do one thing well. The functions can then be composed to form ad-hoc "applications". A requirement for this is that unlike in proprietary/closed/binary designs, all source code must be open and all functions reusable in new contexts. Interim OS includes functional building blocks for text display and editing, and an example development environment written in the Interim language:"
plan9  lisp  osdev  research  facme  pmz  2015 
september 2018 by mechazoidal
Xft but for XCB
On using the font-for-xcb library to make it a little easier
x11  facme  rendering  fonts  unix 
september 2018 by mechazoidal
On the road to pure Go X11 GUIs
THis is mostly trying to avoid writing wrappers to the big toolkits(along with avoiding cgo), and a running research log of plugging into Wayland/X11 with Golang
Golang  x11  facme  programming 
september 2018 by mechazoidal
"a uniform, search-based interface for quickly accessing your digital information, regardless of “where” it is"
facme  osx  tools  productivity 
august 2018 by mechazoidal
☭🚀🐕 Bodil 🐕🚀☭ on Twitter: "And we need to stop copying Notepad's interaction design. It's easy to learn but awful to grow with. Emacs and vim offer tremendous UX at the cost of a steep learning curve, but you're going to be writing code fo
"There seem to be three main schools of thought:

* the IDE school: editors should be like Visual Studio except lighter (Code)
* the Notepad school: editors should be like Notepad except better (TextMate, Sublime)
* the ed(1) school: we solved editors last century (Emacs, vim)
"And we need to stop copying Notepad's interaction design. It's easy to learn but awful to grow with. Emacs and vim offer tremendous UX at the cost of a steep learning curve, but you're going to be writing code for a long, long time, you need an editor that can grow with you."
"It might be the bias of my circle but the sam/ssam editor family seem to be a common one to derive designs from" ('ssam' is a plan9 rc script that allows using sam language on streams)
tweets  editor  programming  emacs  vim  sam  facme 
may 2018 by mechazoidal
GitHub - driusan/de: A Programmer's Text Editor
"It's kind of like a bastard child of vim and Plan 9's acme editor, because vim feels inadequate on a computer with a mouse after using acme, and acme feels inadequate on a computer with a keyboard after using vi. Like vim, it's a modal editor with syntax highlighting that uses hjkl for movement. Like acme, it attempts to exploit your current OS environment instead of replacing it and tries to make the mouse useful"
editor  golang  software  tools  acme  vim  repo:github  facme 
may 2018 by mechazoidal
Announcing duit: developer ui toolkit
From mjl! Uses devdraw! Could this be adapted anywhere else?
Golang  gui  library  plan9  facme 
april 2018 by mechazoidal
Structural Regular Expressions
Showing how to implement in Perl with existing regex operators
perl  regex  plan9  presentation  transcript  sam  facme 
november 2017 by mechazoidal
google/xi-editor/rope_science · GitHub
Explanation and outlining the evolution of xi's internals: accidentally discovers monoids are useful while parallelizing, ends up with CRDTs for async and undo(with the caveat that network undo is indeed a very tricky problem)
piperesearch  programming  xi_editor  computerscience  math  text  editor  repo:github  facme 
april 2017 by mechazoidal
Phil Hagelberg / polywell · GitLab
"A highly-configurable text editor / coding tool written in Lua that runs on the LÖVE game engine. [...] But you can build many kinds of text-centric interfaces using Polywell buffers; for instance the game Bussard includes a mail reading interface as well as a simulated SSH client. The ideal means of user empowerment is to give your users the same tools inside the program that you used to create the program yourself; this is the vision behind Polywell.
piperesearch  editor  lua  gamedev  repo:gitlab  facme 
august 2016 by mechazoidal
Phil Hagelberg / jeejah · GitLab
"The nREPL protocol allows developers to embed a server in their programs to which external programs can connect for development, debugging, etc. The original implementation of the protocol was written in Clojure, and many clients assume they will connect to a Clojure server; however the protocol is quite agnostic about what language is being evaluated. It supports evaluating snippets of code or whole files with print and io.write redirected back to the connected client."
piperesearch  repl  lua  protocol  repo:gitlab  facme 
june 2016 by mechazoidal
"It extends vim's modal editing with built-in support for multiple cursors/selections and combines it with sam's structural regular expression based command language." @Screwtape: "it takes the “structural regular expressions” idea from Sam and melds it with the “multiple cursors” idea from Sublime Text, and it turns out the two go very well together." "Anybody developing a modern, native editor today should memory map files - modern OS'es are really good at it."
pmz: implementing something like this for inferno might be easier to work with on a laptop than acme
sam  vim  editor  repo:github  pmz  facme 
april 2016 by mechazoidal
GitHub - mawww/kakoune: mawww's experiment for a better code editor
"a code editor heavily inspired by Vim, as such most of its commands are similar to vi’s ones, and it shares Vi’s "keystrokes as a text editing language" model."
piperesearch  vim  repo:github  editor  software  facme 
february 2016 by mechazoidal
CMS/TSO Pipelines Runtime Library Distribution
note that wikipedia calls it "an example of an executable specification language" PR: a simple version of the language would be good for a first step ,and any extra stages/operators listed here should be mined for ideas
piperesearch  pipes  facme  dataflow  IBM  reference 
january 2014 by mechazoidal

Copy this bookmark: