And then you can also use the FFI functionalities provided by the particular Lisp implementation (i.e. SBCL, LispWorks, ABCL, etc.)
However, the use of a portable library like CFFI means that you can take your code that runs correctly in SBCL, and then run the very same code in CLISP (other Lisp implementation) with no change at all.
CFFI works for the following Lisp implementations or "compilers": ABCL, Allegro CL, Clasp, CLISP, Clozure CL, CMUCL, Corman CL, ECL, GCL, LispWorks, MCL, SBCL and the Scieneer CL.
There can be, but they mostly have to do with moving things around in memory and garbage collection. An FFI has to marshall in-memory data structures from Lisp into the form C expects, and then move C's results back into Lisp's world. Sometimes your program will have to do this manually but the FFI usually takes care of simple cases like pointers and atomic types. Still, it's not cost-free because at minimum the removal and insertion of tags has to happen.
A related problem is word alignment; getting this right is important for passing data from Lisp to vector processors (and to a GPU I presume, but I haven't done that).
The other issue is GC: When the C function is running, it's important that Lisp's garbage collector not move the memory C is using. Some Lisp implementations do the laziest thing and just stop Lisp until C returns. Others are more sophisticated and keep C's heap separate -- but that requires more copying. Still others mark the memory C uses in a way that tells the GC "don't touch" but that can lead to pathological fragmentation in extreme cases.
The above makes it sound worse than it is. 99% of my use of a Lisp FFI has resulted in a performance increase because C is in general about twice as fast as CL for low-level stuff--which is one of the reasons to use an FFI in the first place.
In that case though, why claim to be "decentralized"? That to me means one large, interconnected network, which one can access through any of its members. Mastodon is decentralized; you can make an account on any server and search and follow users on any other server without leaving. Bittorrent is decentralized, you can grab info from the DHT then connect to peers and download stuff.
If it depends on an index/searching service, how is the network itself any more decentralized than say an FTP server? I wouldn't call FTP decentralized.
This is the right answer, at least for visual dataflow. It should be done by diff/merge of graphs, displayed visually, not by converting it into a text-based format and using something like git, Perforce, or cvs. Dataflow can be expressed textually, but you'd have a hard time following the code.
I'd be in favor of having some standard "code review markup language", which could contain review comments and workflows. Then you would be able to put these in files and make those files part of your repository (ie commit/push).
Then, you could build various frontends to handle these in a user friendly way if you like. But also, would be accessible and editable in your favorite text editor.
As long as the tools and processes don't get in the way of communication because they require comments to be written in a particular format or in a precise place. Too often, such tools end up in discouraging the very thing they're supposed to help.
This is something I've been thinking about quite a lot lately – I considered extending our git-flow a bit to contain review branches (or something comparable). If you'd like to chat a bit about potential solutions for your approach just drop me a line!
We solve this via gatekeeper rules (repository administrator defines rules such as who needs to review which part of code, or whose code needs to be reviewed (intern team for instance needs to be reviewed by core team etc), or what commit message rule should be followed etc.
Personally, I NOP-ed all arrow keys _and_ hjkl also, after I found myself keeping j pressed to get to an area at the bottom of the window. Which would be an L. Then NOP-ed, bit by bit, many other things which could be done faster. 90% of my movements are search, BWtf{} and some scrolling with zt zz zb. The only case I found the lack of hjkl problematic so far is in block visual mode.
Another anti-pattern I did was Da and dWi, NOP-ed them and forced myself to start using C and cW respectively. Not much of an achievement, but feels better :) Same for x, I deleted whole words with x, then pressed i, I removed the mapping of x.
Conclusion: in case you think you have an anti-pattern, just NOP the mappings. In case one or two turns out to be too much of restriction, you could always remove the NOP mapping later.
I started combining {} with zt zz zb. I feel like it mimics physical handling of a scroll. This requires some empty lines though. In case I work with dense text, I usually switch to H/M/L also (combined with zt zz zb).
I have to mention that for navigation purposes, f/F is only useful with ;, otherwise you could find yourself looking through the line for a suitable character which slows you down. With ; it's enough to pick a "rare" character on the line which is near to/in the desired object.
Next to c2f, ci" (and ci) etc) could be really useful when you end up being in the middle of a string literal and just want to change the whole thing. Or in the middle of an expression in parens - http://fuckyeahvim.tumblr.com/image/122373002741
In FastMail you could already search based on some of the email headers, like from:thatpurplecompany.com (or has:attachment, https://www.fastmail.fm/help/receive/search.html) and then you could save the search.. It's visually not that rich, but it solves your problem.
Tagging (for me) is more about ad-hoc grouping. As giving it a thought right now it's even hard for me to come up with a realistic use case.
