dmux

Is their core technology ads or search?

Wouldn't a snapshot mechanism plus load-balancer handle this case and still keep the architecture simple?

As I've gotten older (about a decade's worth of professional experience at this point), I've started feeling the same way. It's so tempting to build up these abstractions and pipelines and introduce new tools but at the end of the day, what is it we're trying to achieve? It's often the case that the abstractions chosen were the wrong ones for the job and staying at a lower "layer" of abstraction results in more benefits in the longer term (i.e. lower layers are move at a slower pace). If a project's lifetime is longer than 2 hype cycles, it may be worth considering digging down a layer and doing things there.

Whenever a subject like this comes up, I'm always reminded of Stewart Brand's "pace layering" [0].

[0] https://imgur.com/V5oL5WZ

There are several examples of small applications in the Wapp repository: https://wapp.tcl.tk/home/file?name=examples/

I especially like the shoplist one. Such a simple application that's immediately useful.

I've been having a wonderful time spinning up small projects using Tcl, Wapp, and Sqlite. Tcl's quoting rules makes it really easy to embed HTML (or anything else, really) inline within a procedure. Simple example:

    # available at /style.css
    proc wapp-page-style.css {} {
        wapp-mimetype text/css
        wapp-cache-control max-age=3600
        
        wapp-trim {
            body {
                background: aliceblue;
            }
        }


    }

    # available at /hello
    proc wapp-page-hello {} {
        wapp-trim {
            <html>
            <head>
                <link href="%url(style.css)" rel="stylesheet">
            </head>
                <body>
                    <h1>Hello HN!</h1>
                </body>
            </html>
        }
    }

I'd put a caveat on this. If you already suffer from panic attacks, have schizophrenia or have suffered psychosis, meditation may _not_ be for you.

One problem I've never seen mentioned regarding microservices is what happens when the organization that produced them has moved from growing to stagnating and finally into decline. If microservices ship the org-chart, what happens when that organization fails to attract engineers?

I worked for a company that microserviced themselves into a pit. We had a huge layoff which completely killed the morale of the remaining engineering staff. Over the next 3 years, more and more engineers left and the company refused to replace them. What started out as teams (~5 people) responsible for ~3 microservices ended up as teams of ~3 people responsible for ~6 microservices.

It was kind of cool to be responsible for more architecture and see how it all fit together, but the sad reality was that too many of the microservices that had been stood up were stitching together disparate data from other microservices to then perform what a single SQL query against a RDBMS was doing.

I've always been partial to "Introduction to Computing: Explorations in Language, Logic, and Machines" [0] by David Evans of the University of Virginia.

[0] https://computingbook.org/

>Tcl is too much like shell script programming.

How so? Tcl has namespaces, a standard lib, runtime introspection, an OO system, threads, asynchronous programming capabilities via event loop, a GUI framework and is cross platform. Have you actually used it?

> Enumerated errors. Some part of the tooling should be able to tell me all the errors that a function could raise.

I don't know if I'm missing the mark here, but aren't you describing Checked Exceptions?

I've only just started learning Common Lisp and never used Clojure, but what are the implications or trade-offs of

>Symbols are not storage locations (see Var)

I thought the way symbols worked in CL are one of the three big ideas (s-exps and macros being the other two).

I'm not sure if this is the plant you're describing, but in New England, Monarchs are really attracted to Milkweed. The White Swamp [0] variety may be what you're describing.

[0] https://www.fs.fed.us/wildflowers/plant-of-the-week/asclepia...

Ever since I came across a Tcl programming book in my college library I've always been fascinated with it. I return to it every couple of years to play around with meta-programming ideas that I've come up with.

For example, here is a really naive example of implementing a DSL that allows you to write something like

    SELECT name age FROM person INTO name age

and have the values of the selected columns be placed in variables specified after the INTO keyword.

Implementing that isn't too difficult:

    # a pretend database

    set language(name)           Tcl
    set language(created)        1988
    set language(created_by)   "John Ousterhout"
    set language(stable_release) 8.6.11


    proc SELECT {args} {
 
     ### Lowercase all the args to make things easy
     set args   [string tolower $args]
 
     set from_index  [lsearch $args from]
 
     set cols   [lrange $args 0 [incr from_index -1]]
     set table   [lindex $args [expr $from_index + 2]]
 
     # Get access to the global variable with the value contained in $table
     global $table
 
     set into_index  [lsearch $args into]
     set vars   [lrange $args [incr into_index] end]
 
     foreach c $cols v $vars {
      upvar $v local_var
      set val [lindex [array get $table $c] 1]
      set local_var $val
     }
    }

After that, you could "SELECT created name created_by FROM language INTO x y z" and then

    puts "$y was created by $z in $x"
    >Tcl was created by John Ousterhout in 1988

>Big Objects was the idea that in the future, basic doing stuff level code would be fully replaced by bought or open source objects that would plug in in standard ways to industry wide interfaces.

Isn't this the same as API's as a service?

And microplastics in _everything_.

I've never gone further than thinking about it, but I've always been curious as to how simple it would be to use Awk as an interpreter for a really simple Tcl-like language:

    set a 1
    set b 2

    define add (n,m) $n + $m

    set result [add a b]

I think it would be simple enough to come up with some Awk pattern/actions to parse the above and execute the commands.

Sounds like something I'd really enjoy. Observing one particular space over time is the concept behind the graphic novel** "Here" by Richard McGuire.

** It's really light on dialogue (and characters for that matter). Way more emphasis on the Graphic part than the Novel part.

I don't follow this subject matter too closely, but I have read Marvin Minksy's "Society of Mind." Doesn't this "multiple demand" concept mirror what Minksy described back in the late 1980's as conflict and compromise between individual "agents"?

We've reached https://en.wikipedia.org/wiki/Godwin%27s_law

I see that this site gets posted quite a bit, but isn't this particular post just blog spam? 70% of the post is a quote from the linked Smithsonian article.

I wonder if it's due to the Play Framework which could be used in either Scala or Java.

I just encountered this first hand. I know someone who's just entering college and was asking how they go about saving a file in Microsoft Word! Up to this point in time, they had always used a school appointed Chromebook where they never even had to save things to their local computer :|

I've spent way more time with Racket than Common Lisp (just picked it up over the last month) and Racket just doesn't have the same development experience as Common Lisp. There's no iterative / interactive development in Racket, by design [0]. That means you have to stop-and-reload-the-world every time you make a change.

[0] https://blog.racket-lang.org/2009/03/the-drscheme-repl-isnt-...

>there is a bit of fatigue and companies are a bit more wary than they were 5-10 years ago

This reminded me of a really disheartening (and probably 100% accurate) thread on Reddit recently. A developer was asking how to go about validating an idea for a SaaS that was catered towards small businesses. Most, if not all of the comments were along the lines of "no thanks, we've already dealt with a startup trying to 'solve' our problem."

Plain old HTML + forms can go a long way when accessed through the Lynx or w3 web browsers. I think the first time I encountered a system where this was the preferred path was in Kannel [0].

https://kannel.org/download/1.4.5/userguide-1.4.5/userguide....

>He seems to be saying that TypeScript leads to faster code execution as TypeScript has types, but fails to understand that TypeScript still compiles to JS and the browsers run JS without types...

I'm not saying this is the case, but isn't there a greater opportunity to optimize TypeScript code over JavaScript due to the presence of types? Isn't this the same thing as a statically typed program being compiled into assembly (untyped) ?

I've reread the quote you posted and think I may understand, although I'm probably misusing some terminology: since the call to call/cc is the only thing in the lambda definition, the continuation captured at that point is kind of the termination/return point of the function. If there was something after the call/cc, e.g. a

    (display "Done with looping")

then invoking the continuation would break out of the loop and display "Done with looping."

Can anyone explain in a little more detail what's going on in the definition of the Scheme version of sum-of-squares? The previous example where the continuation of 2 + 1 + N is captured makes sense to me, but I'm having a hard time wrapping my head around the resulting continuation when a lambda is involved.

To make it a little cleaner, I've replaced the "receiver" definition with a function reference instead. What's the continuation here?

    (define sum-of-squares
      (lambda (bound)                        
          (call/cc the-receiver)))

I wouldn't say they're responsible for maintaining it. But I think it's fair to question their decisions. As I mentioned above, one of their principles specifically calls out that the internet depends on interoperability and various protocols.

I don't really understand the argument that if everyone else drops support that Firefox should too. Firefox could champion themselves as continuing to support various protocols and live the principles they set out for themselves.

I'm not sure if you're trying to be antagonistic with this reply or not. I also didn't feel it was important for me to outline the entirety of the data pipeline -- I merely wanted to point out that FTP is still in heavy use in some industries.

To address your concerns though: meter data is not ingested via FTP. That's done using other protocols. It's transferred b2b via FTP over private tunnels. And you're correct Firefox is not used for uploading data. If it were possible it wouldn't even be a good choice given the volume of data we deal with. It is, however, used heavily for accessing the uploaded data by Operations and other teams.