mechazoidal + piperesearch   1971

Quadrilateral demo - Cassowary Javascript
"The below is a new (as of May 2011) all-javascript implementation of the bounded quadrilateral demonstration that was first released as part of the Cassowary constraint solving toolkit. In addition to Javascript, there are also C++, Java, and Smalltalk implementations, and the C++ implementation is wrapped for use with Guile Scheme (see also Scwm) and Python."
solver  javascript  interactive  piperesearch 
yesterday by mechazoidal
.blend file format of Blender format spec for Kaitai Struct
"Internally, .blend format is a hybrid semi-self-descriptive format. On top level, it contains a simple header and a sequence of file blocks, which more or less follow typical TLV pattern. Pre-last block would be a structure with code DNA1, which is a essentially a machine-readable schema of all other structures used in this file."
blender  reference  format  piperesearch 
yesterday by mechazoidal
Experiments in Constraint-based Graphic Design · cat /var/log/life
"Basalt is implemented as a domain-specific language (DSL), and it’s quite different from GUI-based design tools like Illustrator and Keynote. It’s also pretty different from libraries/languages like D3.js, TikZ, and diagrams. At its core, Basalt is based on constraints: the designer specifies figures in terms of relationships, which compile down to constraints that are solved automatically using an SMT solver to produce the final output. This allows the designer to specify drawings in terms of relationships like 'these objects are distributed horizontally, with a 1:2:3 ratio of space between them.'"

(it's a python DSL for now and very much WIP, but the power of this is amazingly illustrated: replicating hand-made inkscape, Tikz diagrams)
Uses the Z3 solver, but there are some other options discussed towards the end.
lobsters: https://lobste.rs/s/ut5gb7/experiments_constraint_based_graphic
piperesearch  2d  graphics  python  dsl  2019 
2 days ago by mechazoidal
CI/CD pipelines: Monad, Arrow or Dart? - Thomas Leonard's blog
"In this post I describe three approaches to building a language for writing CI/CD pipelines."
PR: "It’s convenient to write CI/CD pipelines as if they were single-shot scripts that run the steps once, in series, and always succeed, and then with only minor changes have the pipeline run the steps whenever the input changes, in parallel, with logging, error reporting, cancellation and rebuild support. [...] We can get the same benefits of static analysis by using a monad in an unusual way, here referred to as a 'dart'. Instead of functions that take plain values and return wrapped values, our functions both take and return wrapped values. This results in a syntax that looks identical to plain programming, but allows static analysis (at the cost of not being able to manipulate the wrapped values directly)."
(example ocaml library is at: https://github.com/ocurrent/ocurrent )
ocaml  build  piperesearch  programming  functional 
2 days ago by mechazoidal
VFX Reference Platform
"a set of tool and library versions to be used as a common target platform for building software for the VFX industry. Its purpose is to minimise incompatibilities between different software packages, ease the support burden for Linux-based pipelines and encourage further adoption of Linux by software vendors. The Reference Platform is updated annually by a group of software vendors in collaboration with the Visual Effects Society Technology Committee."
(major technologies covered: gcc/glibc, python, qt, numpy, openexr, ptex, opensubdiv, openvdb, alembic, FBX, OpenColorIO, ACES, boost, Intel TBB/MKL, and C++ revision)
piperesearch  standards  programming  reference  linux 
3 days ago by mechazoidal
forsyth / styx-n-9p — Bitbucket
"In Inferno and Plan 9, the client-side interface is provided through ordinary system calls: mount, open/create, read/write, close. Outside those systems, library support is needed, and this project is intended to distribute and maintain some of those. The first is a Java client, allowing concurrent access to a remote Styx server, including the use of Inferno public-key authentication. (Secure key storage must be provided separately.)"

note: "We sometimes use the different names to distinguish the authentication scheme: public-key (Styx) or shared-secret (9P) but the scheme is actually separate from the protocol."
java  piperesearch  pmz  repo:bitbucket  9p  inferno  plan9 
4 days ago by mechazoidal
In-memory databases
landley is basically summing up the in-memory + log-structured DB stuff(this is from a few years ago)
"For persistence, all you need is an on-disk snapshot of the initial state, plus an append-only log of transactions that change that state. When your database needs to be restarted, you re-read the snapshot and replay the log to update the snapshot. Most of your atomicity and persistence guarantees center around making sure the log entries are committed to disk, but it's all fast streaming writes instead of having to seek all over the disk, and thus has no impact on reads."
[...]
pr: "The obvious way to design an in-memory database is thus in two parts: a direct layer providing function access to the data store with transactions and searching and persistence and such, and the other providing an SQL layer on top of that. Whether the database is in shared memory or not is an implementation detail."
database  piperesearch  sql 
9 days ago by mechazoidal
Re: [9fans] There is no fork
> I struggle to understand how version control is not more actively used.

It's not particularly necessary when you have global state with snapshots provided by a shared WORM fs. DVCS adds a lot of complexity for questionable gain, in that environment. 9front's adoption of mercurial is a historical accident rather than a desired outcome. But, I understand that most people just want to use the tools they already know. It's much easier than learning a new paradigm.
piperesearch  dvcs  plan9  comment 
10 days ago by mechazoidal
9front usage | Lobsters
josuah's comment is great: "It is surprising how well [remoting into a VM running plan9] works in practice since drawterm got resizing support : all the windows inside it will be resized equally well due to how plan9 handles resizes."
plan9  discussion  pmz  lobsters  piperesearch 
10 days ago by mechazoidal
moxie: incremental declarative UI in Rust
note that despite the lobsters discussion, this isn't in Electron, but it does use the DOM and webrender.

there's some great discussion/thinking based on raph's earlier reactive UI post! "my main goal is to identify the technology needed for the analogous ecosystem niche for Rust. Well, that, and I quite like the Hooks API. I have described moxie a few times as "what if a React in Rust but built out of context and hooks?"
piperesearch  rust  ui  gui  dom  optimization  reactjs 
11 days ago by mechazoidal
Mergeable replicated data types – Part I – the morning paper
Mergeable Replicated Data Types (MRDTs) are in the same spirit as CRDTs but with the very interesting property that they compose. Furthermore, a principled approach for deriving MRDTs is provided, allowing a wide range of data-types to be lifted to their mergeable, replicated counterparts with very little effort on the part of the programmer. The paper sets the discussion in the context of geo-replicated distributed systems, but of course the same mechanisms could be equally useful in the context of local-first applications.

There’s a lot of material in this paper’s 29 pages, and to make sure I have the space to properly understand the ideas (the process of summary writing is a critical part of that for me), I’m going to spread my coverage over two posts.
crdt  algorithms  distributed  from:morningpaper  piperesearch  multipart 
17 days ago by mechazoidal
Dragney Taggart on Twitter: "my kingdom for a monitoring system that lets you visualize ~10K points per second of production latencies in a live, pausable, zoomable graph"
Tweet from @aphyr: Like this is not *impossible* to think about. Riemann has pushed 10M events/sec. I don't think browsers could keep up, but you could imagine doing some sort of weird hybrid rendering thing where you render graph chunks on the server and stream them down to the client as images
piperesearch  visualization  tweets  monitoring 
17 days ago by mechazoidal
Amplify Creations
@sinbad recommends the Shader Editor
plugin  unity3d  piperesearch  gamedev 
18 days ago by mechazoidal
[zeromq-dev] FFmpeg Adds ZeroMQ Support To Let Multiple Clients Connect To A Single Instance
links to a phoronix story: "improves the streaming options by allowing multiple clients to connect to a single FFmpeg instance without a separate server or multi-cast destination address setup as previously required."
2019  zmq  ffmpeg  piperesearch 
22 days ago by mechazoidal
Nvim documentation: api
On nvim's API: discoverability, channels, etc.
neovim  piperesearch  api  lua 
24 days ago by mechazoidal
We Can Have Nice Things: Neovim and the state of text editor art in 2019
I admit, neovim is looking pretty tempting at this point, with lua+easy GUI+vim mentality.
PR: "Nvim audience is "people who want more potential + less entropy". YMMV."
"IOW: ecosystems tend to be winner-takes all (80% of users will use the top few, the rest is "long tail") cf. textmate grammars, javascript, Vim plugins, ..."

"- Ship half of the Right Thing so that it spreads like a virus.
- Then take the time to improve it to 90% of the Right Thing."
(getting an idea for for "mimic the good parts of Blender script/function interfaces")

also, rebuilding their own terminal/GUI since they can't depend on the OS anymore for GUI
"Writing a GUI with Neovim is crazy easy. It took me about 4 hours, including learning a GPU framework."
"Lua's lack of "batteries included" is a benefit. Nvim is the "stdlib"."
facme: vim.treesitter: query the syntax tree
neovim  presentation  slides  pdf  vim  lua  piperesearch  facme 
24 days ago by mechazoidal
The Concurrent 2-Trie - Chris Vest - Medium
"The concurrent 2-trie is a dictionary-like data structure that is designed and optimized specifically to be used for translation tables in file buffer pools. When the concurrent 2-trie replaced the lock-striped hop-scotch hash tables in the Neo4j file buffer pool, file buffer accesses became 30% faster."
"As simple as this data structure is, I have not yet found a description of it in literature. Hence I decided to do this write-up. If this reminds you of a paper you have read, then feel free to send me a link."
database  piperesearch  datastructures 
26 days ago by mechazoidal
Safespaces: An Open Source VR Desktop | Arcan
"the current stages of work on a 3D and (optionally) VR desktop for the Arcan display server. It is tentatively called safespaces as an ironic remark on the 'anything but safe' state of what is waiting inside. For the impatient, here is a video of it being used "
arcan  vr  gui  2018  piperesearch 
28 days ago by mechazoidal
An interview on what makes Postgres unique (extensions) - Craig Kerstiens
PR: not so much for postgres, but this quote: "Extensions have allowed Postgres to extend beyond a traditional relational database to much more of a data platform. [...] Extensions allow the core to move at a slower pace, which makes sense. Each new feature in core means it has to be thoroughly tested and safe. That’s not to say that extensions don’t, but extensions that can exist outside core, then become part of the contrib provide a great on ramp for things to move much faster."
postgres  interview  piperesearch  2019 
29 days ago by mechazoidal
Announcing Bastion 0.3 - Highly-available Distributed Fault-tolerant Runtime | Lobsters
PR: "With supervision trees, you gain the ability to manage how some groups of processes are managed. With links and monitors, you gain the building blocks on which Erlang’s supervision trees are built, and much more."
erlang  rust  lobsters  comment  piperesearch 
4 weeks ago by mechazoidal
SRFI 167: Ordered Key Value Store
"This library describes an interface for an ordered key-value store that is suitable for implementing a storage engine for the generic tuple-store SRFI. It maps cleanly to existing ordered key-value databases that may or may not provide transactions."
PR: "The author argues that getting started with data management systems with ordered key-value stores is easier to the mind and also reflects the modern industrial practice that builds (distributed) databases systems possibly with SQL support on top of ordered key-value stores. Otherwise said, this SRFI should offer grounds for apprentices to learn about data storage. It will also offer a better story (the best?) for data durability in Scheme implementations. [complements SRFI 168: Generic Tuple Store]"
scheme  reference  piperesearch  database 
4 weeks ago by mechazoidal
version control - What does Linus Torvalds mean when he says that Git "never ever" tracks a file? - Stack Overflow
PR: "In my taxonomy the term for what we're interested here is the 'atomicity' of the version control system. [...] When a VCS has file-level atomicity, there is in fact a history for each file. The VCS must remember the name of the file and what occurred to it at each point. Git doesn't do that. Git has only a history of commits—the commit is its unit of atomicity, and the history is the set of commits in the repository. "
"Note that a VCS can be commit-oriented, yet still store data file-by-file. That's an implementation detail, though sometimes an important one, and Git does not do that either. Instead, each commit records a tree, with the tree object encoding file names, modes (i.e., is this file executable or not?), and a pointer to the actual file content. [and contents in blobs]"
"The file history you see [with 'git log'] does not exactly exist in the repository, in some sense: instead, it's just a synthetic subset of the real history. You'll get a different "file history" if you use different git log options!"
(there's also his VCS book linked)
piperesearch  git  stackoverflow  answer  dvcs 
4 weeks ago by mechazoidal
File systems unfit as distributed storage backends: lessons from ten years of Ceph evolution – the morning paper
"Ten years of hard-won lessons packed into just 17 pages (13 if you don’t count the references!) makes this paper extremely good value for your time. It’s also a fabulous example of recognising and challenging implicit assumptions. In this case, the assumption that a distributed storage backend should clearly be layered on top of a local file system. Breaking that assumption allowed Ceph to introduce a new storage backend called 'BlueStore' with much better performance and predictability, and the ability to support the changing storage hardware landscape. "
from:morningpaper  ceph  piperesearch  distributed  filesystems 
5 weeks ago by mechazoidal
call-with-current-continuation.org: Strand
"an open-source implementation of the identically named parallel Prolog dialect as described in the book "Strand: New Concepts for Parallel Programming" by Ian Foster and Stephen Taylor. Strand represents a very elegant and concise notation for expressing concurrent and distributed algorithms using very few fundamental language constructs."

"This implementation of Strand is written in Forth and runs on Linux x86-64/ARM, Mac OS X x86-64 and OpenBSD amd64 systems, has no dependencies and is entirely self-contained."

PR: it could almost be thought of as Erlang's long-lost junior sibling(prolog syntax, automatic vm communcation(albeit via shared-memory/files). Confirmed on lobsters!: https://lobste.rs/s/04vqwy/implementation_strand_parallel_prolog#c_9fynpo

Might be useful to look at for the prolog concepts and automatic topology(rings, torus), but the software itself is probably too young.
prolog  forth  piperesearch  language  programming 
5 weeks ago by mechazoidal
c++ - The actor model: Why is erlang special? Or, why do you need another language for it? - Stack Overflow
"Erlang enforces rules that an OS simply can't without major kernel overhauls -- kernel overhauls that would probably not be beneficial overall. "
"the Erlang runtime guarantees delivery of messages. This is something sorely missed in an environment where you must communicate purely over unmanaged ports, pipes, shared memory and common files which the OS kernel is the only one managing (and OS kernel management of these resources is necessarily extremely minimal compared to what the Erlang runtime provides). " (note that it's NOT RPC or method invocation, just "I got this message")

"Built on this promise is the promise that monitors and links are accurate. And based on that the Erlang runtime makes the entire concept of "network cluster" sort of melt away once you grasp what is going on with the system (and how to use erl_connect...). This permits you to hop over a set of tricky concurrency cases already, which gives one a big head start on coding for the successful case instead of getting mired in the swamp of defensive techniques required for naked concurrent programming."
erlang  piperesearch  stackoverflow  answer  comment  actor_model 
6 weeks ago by mechazoidal
Ulf Wiger » What is Erlang-Style Concurrency?
- Fast process creation/destruction
- Ability to support >> 10,000 concurrent processes with largely unchanged characteristics.
- Fast asynchronous message passing.
- Copying message-passing semantics (share-nothing concurrency).
- Process monitoring.
- Selective message reception.

PR: "If there is any single defining characteristic of Erlang-style Concurrency, it is that you should be able to model your application after the natural concurrency patterns present in your problem. If creating a process is perceived as expensive, programmers will reuse existing processes instead; if message passing is perceived to be expensive, various techniques will be invented to avoid sending messages. These workarounds are nearly always detrimental."
piperesearch  erlang  concurrency  2008  asynchronous 
6 weeks ago by mechazoidal
jake_morrison comments on Erlang + Java for an audio streaming server project?
"in telecom, the traditional model is "signaling" vs "media". So you have protocols which do call setup, e.g. ringing the phone. After the call is set up, it allocates resources on physical hardware or another server process which handles the media streaming. So you could say that people have been doing audio streaming applications in Erlang for decades "
PR: so then it might be "erlang does the networking, and hands off to C/Rust NIFs or host OS for cpu-heavy work"
erlang  reddit  comment  piperesearch 
6 weeks ago by mechazoidal
GitHub - processone/ejabberd: Robust, Ubiquitous and Massively Scalable Messaging Platform (XMPP, MQTT, SIP Server)
stackoverflow: "one of the most well know erlang application and the one I learnt erlang with. I think it's the one of most interesting project for learning erlang because it is really building on erlang's strength. (However some will argue that it's not OTP, but don't worry there's still a trove of great code inside...)"
erlang  xmpp  repo:github  reference  piperesearch 
6 weeks ago by mechazoidal
Interprocess Locks | Squadrick
"ROS uses a publish-subscribe paradigm for communicating between messages, and internally it uses either TCP/IP or UDP, which are both quite slow compared to using, say, the system’s shared memory. I decided to build a small simple IPC library that uses the same pub sub pattern, but using shared memory instead."

https://github.com/Squadrick/shadesmar/blob/master/include/shadesmar/ipc_lock.h

PR: "memory copies from GPU to shared memory and vice-versa, without the need to do an intermediate copy to the process’ memory space." He used Boost/C++, but it should be able to do this in Rust as well?
piperesearch  ipc  concurrency  ros  c++ 
6 weeks ago by mechazoidal
shawn comments on: What are you working on this week? | Lobsters
"Our app is called Faceweave. It’s similar to Faceapp in that you can make yourself look older or younger, but the key distinction is that you can apply multiple effects simultaneously. You use sliders and machine learning to morph your face over time."
"Most of our alpha testers came from the dota 2 subreddit. They turned out to be very interested in transforming dota 2 heroes into 'real life' people!"
machine_learning  graphics  piperesearch  lobsters  comment 
6 weeks ago by mechazoidal
Kubernetes and the Erlang VM: orchestration on the large and the small « Plataformatec Blog
"If you are using Erlang/Elixir and you wonder how Kubernetes applies compared to other languages, you can use Kubernetes for the Erlang VM as you would with any other technology. Given that Erlang/Elixir software can typically scale both horizontally and vertically, it gives you many options on how you want to allocate your resources within K8s. On other areas, Kubernetes and the Erlang VM can nicely complement each other, such as using K8s Service Discovery to connect Erlang VM instances. Of course, Distributed Erlang is not a requirement and Erlang/Elixir are great languages even for stateless apps, thanks to its scalability and reliability."
PR: "As users connect and disconnect and as nodes are brought up and down, you could somehow update the database or communicate via a complex RPC mechanism, while carefully watching the cluster for topology changes. With the Erlang VM, you can just broadcast or exchange this information directly, without having to worry about serialization protocols, connection management, etc, as everything is provided by the VM. All without external dependencies. "
erlang  k8s  distributed  piperesearch  devops 
6 weeks ago by mechazoidal
Generative Artistry
Tutorials and podcasts about generative art, including history. Tutorials are fully interactive(usually using the canvas element) and include Hypnotic Squares, Piet Mondrian, Vera Molnár, and more!
webdev  css  art  javascript  interactive  tutorials  podcast  piperesearch  graphics 
7 weeks ago by mechazoidal
Pipecut Project Home
"Pipecut tries to facilitate the development of pipelines by letting you see your data and your shell commands at the same time, eliminating the back and forth editing cycle of entering and quitting more(or less), then recalling and editing the command line. Since pipecut has an AST view of the Unix command line, it can provide shortcuts, optimizations, and do code generation that would not be possible otherwise."
last updated 2015, see https://github.com/akavel/up for a modern (accidental) reinvention
piperesearch  unix  pipes  tools  visualization  shell 
7 weeks ago by mechazoidal
Blobs in Games: Verb-noun vs noun-verb
Starts with interesting stuff in the Ultima games, then goes into vim and auto-complete.
"In games it seems like it'd be better for players to first choose an object from the environment and then choose from a small set of actions, than to first choose from a large set of actions and then choose from a set of objects. However I haven't surveyed enough games to see what's more common. The next time you're playing a game, look at the structure of commands to see if it's verb-noun or noun-verb. "
gamedev  vim  facme  piperesearch 
8 weeks ago by mechazoidal
Plan 9 admittedly sucks in many ways. It has limited hardware support, a weird u... | Hacker News
"To draw to the screen there is one function: draw(). You pass it two rasters and some coordinates and it draws one on top of the other. That's it. Everything works across networks and architectures."

"The thread library is wonderful. Threads in Plan 9 are non-preemptive and run in a round-robin fashion. They communicate using CSP channels. CSP can greatly simplify the design of many programs."

"In a few of the programs I wrote would access the mouse and keyboard in seperate threads. You could use the regular open() and read() calls from each thread and there was no need to worry about locks. When I wanted something to run on both cpus I forked a process, which is very cheap."

PR: "In linux and windows programs are islands. These islands are expected to provide everything the program does in one executable. Acme is not an island. It does not have a builtin spell checker or word counter. What it does have is a namespace that allows you to access its resources."
pmz  piperesearch  plan9  hn  comment 
9 weeks ago by mechazoidal
Pointer Based Data-Structures in SPARK - The AdaCore Blog
"The specification and verification of pointer-based data-structures is a challenge in deductive verification whether the 'pointer' part is implemented as a machine pointer or as an array index (as an example, see our previous post about verifying insertion inside a red-black tree). In addition, SPARK has a strict ownership policy which will prevent completely the use of some (doubly-linked) data-structures, and complicate the writing of usual algorithms on others. However, I think I have demonstrated in this post that is still feasible to write and verify in SPARK some of these algorithms, with comparatively few user-supplied annotations."
Note how they're borrowing some ideas from Rust.

See also: https://lobste.rs/s/tj7bom/pointer_based_data_structures_spark
ada_language  ada  programming  verification  pmz  piperesearch 
9 weeks ago by mechazoidal
An Introduction To Real-Time Subsurface Scattering
'If you were to ask me right now to choose between the 3 techniques that I discussed, I would probably go with the screen-space option. In general it seems to have the least corner cases to handle, and most closely resembles a ray-tracing approach. But that could also be a bit of "the grass is always greener" syndrome on my part. I also fully expect a few games to start using ray-traced SSS on high-end hardware at some point in the near future, since you can use that for high-quality results while keeping a screen-space path as a fallback for weaker hardware'
gamedev  rendering  raytracing  piperesearch  textures  shaders  2019 
9 weeks ago by mechazoidal
The Fascinating Influence of Cyclone
The history of Cyclone, what it influenced, and who was involved. Covers Ada, Midori, M#, Pony, Rust, and others

PR: "For all their benefits, unique (linear) references have a significant limitation. Using only unique references, only hierarchical (tree) data structures can be built. Nearly all data structures with cycles need to allow multiple references to the same object, which unique references cannot do. This limitation, as well as the disruptive constraints of move semantics, should stay top-of-mind when touting the virtues of single-owner memory management and unique references."
programming  safety  history  c  c++  piperesearch  memory 
10 weeks ago by mechazoidal
GitHub - crawshaw/sqlite: Go SQLite3 driver
Not actually a DB driver, but an attempt to bring some of the SQlite non-db features into the interface via C linking.

See also: https://crawshaw.io/blog/go-and-sqlite
sqlite  golang  repo:github  database  piperesearch 
10 weeks ago by mechazoidal
Modern C for C++ Peeps
Good stuff for C99:
- compound literals, designated initialization
- don't be afraid to pass-by-value!
- named optional arguments
- easier ways to avoid pointers for data blobs: use tagged index handles, embrace "dumb data, smart functions"!

see also: https://lobste.rs/s/ktl6cs/modern_c_for_c_peeps
archive_it  c  programming  reference  piperesearch  pmz 
11 weeks ago by mechazoidal
Autodesk Graveyard - cad nauseam
"This page lists some of the Autodesk products that are no longer sold or for which end-of-life or no-more-development have been announced. This is provided as-is for historical interest and with no guarantee of accuracy. "
(last updated 2018?)
autodesk  inspiration  piperesearch  reference  software 
11 weeks ago by mechazoidal
Latacora - Cryptographic Right Answers
"There are, in the literature and in the most sophisticated modern systems, “better” answers for many of these items. If you’re building for low-footprint embedded systems, you can use STROBE and a sound, modern, authenticated encryption stack entirely out of a single SHA-3 like sponge constructions. You can use NOISE to build a secure transport protocol with its own AKE. Speaking of AKEs, there are, like, 30 different password AKEs you could choose from.

But if you’re a developer and not a cryptography engineer, you shouldn’t do any of that. You should keep things simple and conventional and easy to analyze; “boring”, as the Google TLS people would say."
cryptography  reference  2018  piperesearch  security 
11 weeks ago by mechazoidal
oil/regex-manual.md at master · oilshell/oil · GitHub
"Egg Expressions (Oil Regexes)"
"The language is designed for "dumb", one-to-one, syntactic translations. That is, translation doesn't rely on understanding the semantics of regexes. This is because regex implementations have many corner cases and incompatibilities, with regard to Unicode, NUL bytes, etc."
"Eggexes are meant to be used with existing regex engines. For example, you translate them to a POSIX ERE, which is executed by egrep or awk. Or you translate them to a Perl-like syntax and use them in Python, JavaScript, Java, or C++ programs."
regex  oil_shell  piperesearch  repo:github 
11 weeks ago by mechazoidal
So you want to write a package manager - sam boyer - Medium
Most of the article is about package managers general, the Go stuff is only at the end.
PR: note the "project specific manager", and then think about not only user scripts being part of the"project", but also textures and any other external files. Versioning as well: the Armstrong method of using a hash of the source code is an approach, but that's tricky for mere mortals to grok!
Golang  packaging  build  piperesearch 
12 weeks ago by mechazoidal
The Power of “Yes, if”: Iterating on our RFC Process — Squarespace / Engineering
"We took three steps, each of which incrementally improved our process: we wrote an opinionated RFC template, created Infrastructure Council, and introduced Architecture Review."
(PR: "list why existing solutions didn't work for you")
collaboration  software_development  piperesearch 
12 weeks ago by mechazoidal
I'd recommend people interested in learning formal methods *do not* start with t... | Hacker News
nickpsecurity on his general formal methods advice: try starting with Alloy or TLA/Pluscal, not Coq/Isabelle/HOL.
formal_methods  hn  comment  piperesearch  pmz 
12 weeks ago by mechazoidal
GitHub - spacejam/tla-rust: writing correct lock-free and distributed stateful systems in Rust, assisted by TLA+
However, it needs to be noted that when creating lock-free high-performance algorithms, we are going to need to sidestep the safety guarantees of the compiler. Our goal is to create data structures that are mutated using atomic compare-and-swap (CAS) operations by multiple threads simultaneously, and also supporting reads at the same time. We choose not to sacrifice performance by using Mutexes. This means using Rust's Box::into_raw/from_raw, AtomicPtr, unsafe pointers and mem::forget. We are giving up a significant benefit of Rust for certain very high-performance chunks of this system. In place of Rust's compiler, we use the TLA+ model checker to gain confidence in the correctness of our system!
rust  tla  repo:github  formal_methods  piperesearch 
12 weeks ago by mechazoidal
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 
september 2019 by mechazoidal
Nvim documentation: ui
Showing how vim's internal state is available over a defined protocol
piperesearch  facme  vim  neovim 
september 2019 by mechazoidal
Interview with Dask’s creator: Scale your Python from one computer to a thousand
Note:
- ability to combine other python libraries to make them distributed
- central scheduler+distributed worker architecture isn't complicated, just not interesting unless you're actually building one
- data frames again!
piperesearch  python  distribution  interview  scalability 
september 2019 by mechazoidal
Mindstorms
Papert's book, not the toy: "So the core insight I got from the book: Kids benefit from computers by having simulations (microworlds) where they can play (no predefined goals!) around with concepts. The challenge is to find or design the right simulation such that they have close relationships to concepts we want to teach."
learning  piperesearch 
august 2019 by mechazoidal
index - mapmaking
Lots of good resources and tools.
TODO: I'd really like to check out ViewingDale, but all the links are dead: "Its built for mapping worlds where you have images as nodes and multiple child nodes each having more nodes etc as many as you want. You can zoom into it where it will render out all of the images as a large tree by compositing it spatially. So its not text based. But otherwise its a generalized 2D pan and zoom image compositing engine. The tree is stored as text files that reference more text files so if one definition changes then all the other references to them change. In this way you can build a 2D world map by linking branches of grouped up images. Best to see the videos on the site. Though it can do worlds as a map I also use it for code documentation, PCB design etc since they can also be spatially mapped in a tree fashion."
todo  mapping  maps  gamedev  piperesearch  reddit  reference 
august 2019 by mechazoidal
Less is exponentially more
Rob Pike: "My late friend Alain Fournier once told me that he considered the lowest form of academic work to be taxonomy. And you know what? Type hierarchies are just taxonomy. You need to decide what piece goes in what box, every type's parent, whether A inherits from B or B from A.  Is a sortable array an array that sorts or a sorter represented by an array? If you believe that types address all design issues you must make that decision.

I believe that's a preposterous way to think about programming. What matters isn't the ancestor relations between things but what they can do for you.

That, of course, is where interfaces come into Go. But they're part of a bigger picture, the true Go philosophy.

If C++ and Java are about type hierarchies and the taxonomy of types, Go is about composition."

(of course, draw your own conclusions)
transcript  Golang  design  programming  piperesearch 
august 2019 by mechazoidal
par_shapes.h
"When tinkering with a new graphics API or raytracing kernel, I often want to use procedurally-generated shapes to avoid worrying about loading art assets.

Hence my motivation for authoring a single-file, zero-dependency, C99 library that can generate simple shapes and perform basic operations on them:
- Applying affine transformations
- Computing surface normals
- Welding colocated vertices"
library  piperesearch  mesh  models  procedural  graphics  c 
august 2019 by mechazoidal
Rolling my own scene graph - Game Development Stack Exchange
A good overall answer (topological, not spatial, and does not include render data)
scenegraph  answer  stackoverflow  piperesearch  graph 
august 2019 by mechazoidal
Unix Tools · oilshell/oil Wiki · GitHub
Oil shell author notes how much duplication of functions(starting processes, expression languages, formatting) there is in historical Unix commands.
piperesearch  pmz  repo:github  shell 
august 2019 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 
august 2019 by mechazoidal
4 Rules for Intuitive UX – Learn UI Design
It's mostly webdev but can apply anywhere:
- Obey the Law of Locality
- ABD: Anything But Dropdowns
- Pass the Squint Test
- Teach by example
design  ui  ux  tips  piperesearch  interface 
august 2019 by mechazoidal
BubRoss's Epic Counterpoint to "Users Don't Care About Software Bloat" | Lobsters
vfoley: "As BubRoss said, if a program is slow and there are alternatives, people will use the alternatives. And if the fast alternative program enables new behaviours, then the old program will likely die out." Examples are git, Gmail, go's compiler, SQlite(as an ETL tool)
piperesearch  lobsters  comment 
august 2019 by mechazoidal
libxo - A Library for Generating Text, XML, JSON, and HTML Output — libxo 0.8.4 documentation
Contrast with nushell: "the library aims to minimize the cost of migrating code to libxo".
PR: maybe a lib to ease emitting PR messages(cbor/yang, structured text, etc)?
freebsd  library  piperesearch  unix 
august 2019 by mechazoidal
Wiki - ActuallyUsingCrev
It's got some rough spots, but he likes crev. Like magic-wormhole, this should really be a standard system for non-tech people:
- "The infrastructure in terms of proofs and such is all language-agnostic"
- "if people want to make their own proofs, just doing one crev code review a week will add up fast."
- proofs are generated plaintext, stored in git
rust  signatures  piperesearch  pmz  2019  security  review 
august 2019 by mechazoidal
z0mbie42 / rust_gui_ecosystem_overview · GitLab
"the principal criterion being get the shit done": current (2019/08) winners are Electron+Neon, and QT
rust  reference  gui  piperesearch  repo:gitlab 
august 2019 by mechazoidal
Fossil: TH1 Scripts
"a custom minimal Tcl dialect called TH1, which is embedded into Fossil itself. Fossil's build system and test suite are largely based on Tcl."
"The original Tcl language after when TH1 is modeled has a very rich repertoire of commands. TH1, as it is designed to be minimalist and embedded has a greatly reduced command set. "
tcl  piperesearch  fossil  language  programming  pmz 
august 2019 by mechazoidal
Gregory Szorc's Digital Home | The Mercurial Revlog
PR: "In theory, Mercurial revlogs can be backed by anything. This is the extensibility of Mercurial at work. There's just a Mercurial extension sitting between using SQL, S3, Cassandra, or any other storage backend for revlogs."
Note that he warns that there can be impedance mismatch with using alternate revlog backing(bundles are the linchpin), but I think this may have been fixed with bundle format v2
2014  dvcs  hg  datastructures  version_control  piperesearch 
august 2019 by mechazoidal
« earlier      
per page:    204080120160

related tags

2d  3d  3ds  3dsmax  3d_printing  9p  9slice  abi  abstract  abstraction  acm  acme  activitypub  actor  actors  actor_model  ada  ada_language  addressing  adobe  adt  advice  advocacy  aesthetics  afl  agile  ai  alf_language  algebra  algol  algorithims  algorithms  aliceml  alloy  ama  amazon  ampl_language  analysis  analytics  anatomy  android  animation  anime  answer  antifragile  antipattern  apache  api  apl  app  apple  applescript  ar  arcan  architecture  archive  archived  archive_it  array  array_language  arrows  art  article  articles  arxiv  asm.js  asn1  assembly  assimp  asspad  async  asynchronous  audio  autodesk  automation  avisynth  awk  aws  backup  bash  basis_codec  beaker  beos  bestpractices  bezier  bibliography  big-data  bioinformatics  bitcoin  blender  blockchain  blog  bloom  bluetooth  book  books  brep  bret_victor  browser  build  burnout  business  c  c#  c++  cache  cad  calculator  calculus  calm  camera  canvas  cap  capitalism  capnproto  cartoons  cbor  celshading  cel_shading  ceph  certificate  cg  cgal  chat  chrome  cinematography  citeseer  class  cli  climate_change  clipstudio  clock  clojure  clojurescript  cloud  cmake  code  codec  codepen  cola  collaboration  color  comics  comment  comments  communication  community  comparison  compilers  completion  complexity  components  compression  computation  computers  computerscience  computer_vision  computing  concept  concurrency  concurrent_ml  confidentiality  config  configuration  consistency  constraint  constraints  containers  contract  controller  converter  coordination  corba  cqrs  crafts  crdt  creativity  crev  criticism  critique  cryptography  csg  csp  css  culture  curves  customization  d3  d3d  dadgum  dance  danluu  darcs  data  database  dataflow  datalog  datascience  datasets  datastructure  datastructures  data_frame  data_source  datomic  dat_project  DAW  dbms  dead_link  debugging  decentralized  deconstruct  demo  demoscene  dependencies  deprecated  design  designer  design_patterns  desktop  development  devops  dht  diff  direct3d  directx  disassembler  discussion  distributed  distribution  djb  documentation  docuverse  dom  dotnet  drawing  drdobbs  dreamcast  dropbox  dsec  dsl  dsp  dvcs  ebook  eclipse  ecs  ed  editor  editors  edn  education  ef-12  electronics  elixir  elm  elm_language  emacs  email  embedded  emulation  emulator  encryption  engine  engineering  erlang  essay  ethernet  etoile  eureka  events  event_sourcing  event_streams  eve_language  example  excel  exokernel  explanation  exploit  f#  facebook  facerig  faces  facme  faq  Farbrausch  fbx  federation  fediverse  fedwiki  ffmpeg  fightman  figure_drawing  file  files  filesystems  filmmaking  flash  flash_memory  flickr  fonts  formal_methods  format  forth  fortran  forum  fossil  fp  fpga  fractal  framework  free  freebsd  freedom  french  frep  from:acm  from:ann  from:aosa  from:cgworld  from:citeseer  from:eff  from:gamasutra  from:hackaday  from:ltu  from:medium  from:morningpaper  from:msresearch  from:nodontdie  from:stackoverflow  from:techcrunch  from:wikipedia  frontend  frp  fsm  functional  futurism  ga  gadt  gallery  gamasutra  game  gamedesign  gamedev  games  gdc  generation  generator  geography  geometry  gist  git  github  glitch  glsl  gltf  gnome  golang  google  googledocs  gpgpu  gpl  gpu  grammar  graph  graphics  graphql  graphviz  graph_theory  gsl  gstreamer  gui  guitktk  h264  hack  hadoop  hahaonlyserious  hardware  haskell  HATEOAS  hex  hg  history  hlsl  hlvm  hmd  hn  hosting  howto  html  html5  http  humor  hypercard  hypermedia  hypertext  ibm  identification  identity  ietf  illustration  imgur  immutability  impromptu  indie  inferno  infoq  innovation  input  inspiration  integration  interaction  interactive  interface  internet  interpreter  interview  ios  IoT  ipc  ipfs  iso  itch  izware  japan  japanese  java  javascript  jit  jobs  journalism  json  julia_language  jvm  j_language  k8s  kafka  kakoune  kdb  kernel  khronos  kinect  kotaku  kragen  k_language  lab  labor  landscape  lang:jp  langsec  language  languages  lasp  latency  layout  learning  lecture  legal  lego  lens  leveldb  libraries  library  licensing  lighttable  lightwave  linda  linear_algebra  linkedin  linux  lisp  list  literature  live2d  livecoding  llvm  lmdb  lobsters  logging  logic  logo  longread  lotus_notes  lua  luajit  machine_learning  machinima  macros  macross  make  makefile  management  manga  manifesto  mapping  maps  marx  mastodon  math  mathematics  matrix  maya  mdns  meander  mecha  media  medium  memcached  meme  memory  mercury_language  merge  mesh  messaging  metadata  methodology  metrics  microservices  microsoft  midi  midori  mindmap  minikanren  minix  misfeature  mixer  ml  mmd  mmo  mobile  model  modelchecker  modeling  models  monitoring  motion  motion_capture  mouse  movies  mozilla  ms_research  mud  multimedia  multipart  music  mvc  nanomsg  nanovg  nasa  neovim  network  networking  networks  newton  nintendo  nix  nlp  node  nodejs  notation  notes  npr  ntp  oats  objective-c  ocaml  occam  ogg  ohm  oil_shell  om  ometa  oop  openbsd  opencl  opencv  openfl  openframeworks  opengl  openmirage  openscad  opensource  operational_transform  optimization  orchestration  orc_language  org-mode  organization  organizing  os  osc  osdev  osl  osresearch  osx  owasp  p2p  packaging  painting  paper  paperman  papers  parallelism  parallelization  parinfer  parser  parsing  particles  patch  patents  pattern  patterns  paxos  pdf  performance  peripherals  perl  perspective  philosophy  photography  photoshop  physics  pinboard  pipe  pipeline  piperesearch  pipes  pixar  pixelart  pixiv  plan9  planning  platform  playlist  plugin  plugins  pmz  podcast  polycount  polygon  polygons  polymer.js  posix  post  postgres  postgresql  postmortem  postscript  powershell  practices  presentation  previz  printing  privacy  procedural  processes  production  productivity  programming  project  prolog  proof  proofs  propagator  protocol  protocols  psx  psyc  pulseaudio  pwa  pws  python  qmail  qnx  quaternion  query  queue  quickcheck  quote  q_language  racket  radio  ragel  rails  random  rant  raytracer  raytracing  reactjs  readability  rebol  reddit  redis  redlanguage  redo  refactoring  reference  regex  relational  reliablility  renderer  rendering  repl  replication  repo  repo:bitbucket  repo:github  repo:gitlab  repo:googlecode  repo:sourceforge  report  research  resource  rest  retopo  retrocomputing  retrogaming  review  rfc  riak  riemann  rigging  robotics  ros  rotoscoping  rpc  rtos  ruby  rule  rules  runtime  rust  r_language  safety  sakuga  sam  sample  scala  scalability  scaling  scenegraph  scheduler  schema  scheme  science  script  scripting  sculpting  sculptris  sdf  sdn  secondlife  security  sega  semantics  semanticweb  semver  serialization  server  service  servicediscovery  services  sexp  sgi  shaders  shading  sharing  shell  siggraph  signatures  signed-distance  simulation  sisal  sketchup  slack  slides  slideshare  smalltalk  sml  snobol  society  softimage  software  software_development  solver  sorting  source  spec  specification  spir-v  spki  spreadsheet  spreadsheets  sprite  sprites  sql  sqlite  squeak  ssb  ssd  sse  ssh  ssl  stackoverflow  standards  startups  star_language  state  statecharts  statemachine  statement  steam  stellar_protocol  stop_motion  storage  story  storywriting  strangeloop  stream  streaming  streams  strings  style  subversion  summary  surf  svg  swift  sync  synchronization  syntax  synthesizer  sysadmin  system  systemd  tactics  talk  tcl  teaching  technique  technology  terminal  terminology  terrain  terra_language  testing  text  texture  textures  texture_mapping  texturing  text_processing  theory  threads  threejs  time  timeline  tip  tips  tla  to-get  to-read  to-watch  todo  tools  toot  toots  transactions  transcript  transducers  tree  tui  tumblr  tutorial  tutorials  tvpaint  tweet  tweets  twitter  types  typography  ubf  ui  uml  unhosted  unicode  unikernel  unity3d  unix  unreal  upspin  url  usability  uv  ux  vcs  vector  verification  verse  versioning  version_control  vfx  vgc  vi  via:popular  video  video:embedded  video:niconico  video:reddit  video:twitter  video:vimeo  video:youtube  videos  video_editing  video_editor  video_software  vim  virtualization  vision  visual  visualization  vm  voice  voxel  voxels  vpri  vr  vroid  vst  vsxu  vulkan  vvvv  w-hat  w3c  watches  wearable  web  webapp  webassembly  webcam  webclip  webdesign  webdev  webgl  webrtc  websockets  webvr  weird  wiki  wikipedia  win32  windows  wired  workflow  writing  x11  x86  xanadu  xen  xi_editor  xml  xmpp  xr  yang  zbrush  zeromq  zfs  zmq  zookeeper 

Copy this bookmark:



description:


tags: