dmux

I wonder if something like an inverse Ishikawa ("fish bone") diagram could be used.

>Many things can be learnt from simulating real world systems.

This reminded me of the book "Business Engineering with Object Technology" by David A Taylor. In one chapter he goes about identifying "objects" in a manufacturing business and goes down to the level of modeling employees and the machines that they'd be using on the production line. I've never found the need to model things that granular, but it's definitely an interesting concept of "reifying" _everything_.

Does this not work in Firefox? Upon running the code I get the prompt and a blank grid drawn, but no colors or anything to indicate what's being drawn.

The pattern-action paradigm is really simple to understand and I suspect it's what made Sinatra style web frameworks stand out.

Any particular videos you'd recommend?

Not included as part of the subset linked above, but D's Contract Programming piqued my interest: https://dlang.org/spec/contracts.html

Wapp is a great piece of software. The entire "framework" (including the HTTP server) is just under 1000 lines of code (and that's including comments).

I'm guessing Nodd has a lot of bookkeepers!

>Every year there is more and more tooling and configuration to do before actually coding anything.

I've become increasingly worn-out from this as well. It's strange that as an industry we parrot the "premature optimization is the root of all evil" line, yet we build out our tech stacks as if we were all part of FAANG.

>It's just bizarre to watch how once unassailable Intel is totally floundering in multiple aspects of their main business.

Isn't this just history repeating itself though? We could easily replace "Intel" with any number of previous market leaders that have fallen by the wayside.

It works just fine for web-backend development.

Nearly everything in Tcl can be inspected at runtime: the source code for procedures (and their arguments), classes that have been defined, methods, etc. Tcl can be made to appear as if it was "image" based rather than file based. This project taps into that.

I've been interested in the Tcl language since 2010 or so but have only written small scripts up to this point in time. I decided it was finally time to dive in so I've been working my way through "The Tcl Programming Language: A Comprehensive Guide" by Ashok P. Nadkarni as well as learning about the Naviserver ecosystem.

I came across a reference to Althttpd while reading through some of the Fossil [0] documentation. I'm always amazed at how robust and simple SQLite and its related technologies are.

From the page:

> As of 2018, the althttpd instance for sqlite.org answers about 500,000 HTTP requests per day (about 5 or 6 per second) delivering about 50GB of content per day (about 4.6 megabits/second) on a $40/month Linode. The load average on this machine normally stays around 0.1 or 0.2. About 19% of the HTTP requests are CGI to various Fossil source-code repositories.

[0] http://fossil-scm.org/home/doc/trunk/www/index.wiki

>There is something of the DIY, can-do, participatory side of 90s computer culture in there.

I've really enjoyed reading Greenspun's stuff and this is a great way to describe his writing style.

Great to see some discussion about this ecosystem. I literally started playing around with NaviServer just 9 days ago. It's definitely worth a glance. There are a lot of great utilities built right in: database connection pooling, a key-value cache, and more [0]

Tangentially related, I've been making my way through Greenspun's Software Engineering for Internet Applications [1] and have especially found the metadata section to be enlightening [2]. I like to think of myself as a competent engineer, but this quote hit too close to home

If you're programming one Web page at a time, you can switch to the language du jour in search of higher productivity. But you won't achieve significant gains unless you quit writing code for one page at a time. Think about ways to write down a machine-readable description of the application and user experience, then let the computer generate the application automatically.

[0] https://naviserver.sourceforge.io/n/toc.html

[1] https://philip.greenspun.com/seia/

[2] https://philip.greenspun.com/seia/metadata

>...and in what order functions are applied to modify that data.

Is this solved in a better way using other paradigms?

>That's an abstraction more easily and succinctly solved by higher-order functions.

Definitely a legitimate approach. In my mind, it seems to be describing Dependency Injection or some type of Strategy Pattern. The activity is defined using "roles" (interfaces) in some use-case class and then implementations of those interfaces are injected.

I've been enjoying going through the OOP literature from the 90's (and earlier) and have especially enjoyed Trygve Reenskaug's view on things. I came across the OORam methodology in Trygve's book, "Working with Objects" [0] which I found after reading about Ivar Jacobson's "Use case driven design."

I found the idea of reifying use-cases into explicit code constructs interesting.

https://heim.ifi.uio.no/~trygver/1996/book/WorkingWithObject...

>The C layer should be as thin as possible and have logic in it that pertains to routing and whatever kinds of transforms your "wire"/"transport" layer needs while the Services do all the heavy lifting and contain most of the business logic.

I believe Trygve Reenskaug (the inventor of MVC) would agree with this point. After MVC he went on to invent "Data, Context, Interaction" (DCI) [0], which aligns with what you're describing.

[0] https://en.wikipedia.org/wiki/Data,_context_and_interaction

Groovy also has a great HTML DSL: http://groovy-lang.org/processing-xml.html#_markupbuilder

Implementing your own DSL is fairly trivial too: http://docs.groovy-lang.org/docs/latest/html/documentation/c...

Is DAG in this context "Directed acyclic graph"?

>We don't live in a vacuum, conjuring thoughts on our own. The things we do have a huge impact on the things we think, whether we realize that or not.

Do you give any credence to the claim that playing violent video games makes people violent?

Previous discussion 2 years ago: https://news.ycombinator.com/item?id=17529987

>Basically use the least level of abstraction that can reasonably get the job done.

There is a great section of John Ousterhout's "A Philosophy of Software Design" that goes into this. He mentions that moving code to functions / methods doesn't eliminate complexity, it nuat kind of shifts it: it adds complexity to the "interface" of the module.

Sometimes leaving code inline with its original context is better.

How have you achieved a balance between too little and too much testing? I worked on a project that had a ton of tests, but they seemed to be "over fitted."

Any language that has an "eval" mechanism makes this really easy. I've used Groovy's GroovyScriptEngine to build something like what you're describing. These scripts are provided with a "Binding" that gives the script access to the HttpRequest and HttpResponse.

Isn't passing @_ around similar to a concatenative language pushing and popping things off the stack?

If you want to download all of the pdfs:

  wget --no-parent --accept pdf http://worrydream.com/refs/

I've had similar thoughts, but wouldn't giant companies like Amazon be taking this into consideration if it were really an issue?