It’s not obvious to me how to do this completely properly. OO is the wrong approach IMHO, as you don’t want to be passing behaviour downstream. Something like algebraic data types might be promising, but then you have to send a description of the data down the pipe before any data itself?

    Erlang’s a bit on my mind today (RIP Joe), but maybe something like its pattern-matching system would work well here?


      PowerShell Core is even available for Linux, complete with installation instructions. I haven’t yet taken time to get my head around PowerShell, even on Windows, but maybe I should.


        In the second link, the horses metaphor is hilarious. All I’m saying to keep from spoiling it.


          UNIX people can’t. I’m sure you could since you regularly work with a hardware/software architecture that was superior in some ways. ;)


            what if we could pass more than text - but arbitrary structured, typed data. This is not science-fiction, it’s really simple to implement. We know things about programming that weren’t really known or understood back in the early UNIX times.

            Wasn’t that done back in UNIX times on Lisp machines? And then, given it’s dynamic, maybe a bit later on Smalltalk systems?

            If not arbitrary, Flex Machine seems like it fit. That was late 1970’s to 1980’s. Fewer people knew about it, though. There was also people like Hansen doing OS’s in Pascal. A brief skim of Solo paper led me to this statement: “Pascal programs can call one another recursively and pass arbitrary parameters among themselves… Solo is the first major example of a hierarchical concurrent program implemented in terms of abstract data types (classes, monitors and processes) with compile-time control of most access rights.”

            Clearly, there were already ideas there for people to build on for doing something other than text. They just couldn’t be or weren’t applied. Then, the UNIX authors and others continued building on their ideas with minimal adoption of alternatives. Eventually, Linux ecosystem started adopting pieces of many ideas kind of bolted into and on top of it the existing system. Although it’s a legacy system, a clean-slate project could certainly do things differently. We’re seeing that start to happen with virtual machines and unikernels that reuse hosts’ drivers.


              Good call! I’d like to see more discussion about Floyd. I like the idea of giving the compiler a lot of freedom, i.e. not forcing the programmer to overspecify the solution. I think that is the way to fast programs

              Scala has some of this with “late data layout” but I’d like to see it in more languages.


              There are some problems I have in Oil that could use this kind of program transformation, i.e. encoding lots of tiny nodes and object compactly. Although right now I plan to do it by hand for expedience.

              I was also hugely impressed by Reason / Recycle about 20 years ago!!!


                I let the author know about this discussion and offered to send him an invite.


                  If I delete the meta viewport tag entirely, it renders pretty much exactly the same.

                  Running without a viewport tag is essentially a “legacy mode” for Mobile Safari and its clones. It’s designed to make pages that assume everyone’s using a 1024x768 computer screen render without producing completely broken layouts. at the cost of requiring the user to zoom and pan. By running Safari in that mode while trying to make a site that’s mobile-friendly, you are using the browser in a way that is contrary to Apple’s design intent. And it don’t work too well, do it?

                  In contrast, look at https://notriddle-more-interesting.herokuapp.com/ and https://notriddle-more-interesting.herokuapp.com/assets/style.css. Notice how the style sheet contains no media queries at all, and how it does not perform user agent sniffing. Most of the stuff in that stylesheet is done in multiples of em, relying entirely on the browser’s defaults to be sensible, and when you run Mobile Safari with viewport width=device-width, they are. All I have to do beyond that is implement my margins using margin:auto and max-width.

                  If you want a simpler and cleaner example, and one that I didn’t write, look at http://bettermotherfuckingwebsite.com/. Notice, once again, that it contains no iphone-specific stylesheet (no media queries, no user agent stiffing) and it still looks great on an iphone. The magic incantations are:

                  • viewport with width=device-width
                  • the content margins are implemented using max-width, rather than setting specifc margins, so the margins grow and shrink as the browser grows and shrinks and the content is never forced into a tiny sliver

                    Why would brute force only be associated with Caesar cipher, as the diagram implies?

                    1. 5

                      The light-grey on light-grey is too hard for me to read, I had to stop :/


                        Well, I tried again and I guess it works. As you said, I was trying to render to a smallish desktop sized canvas, then scale to phone screen. It’s easier for me to see what that looks like with my own desktop browser without resizing it down to actual phone size. I’m generally dissatisfied with special mobile styling and wish it did just work more like a tiny desktop. But no point fighting the whole world. Thanks.


                            I think the reason is that in general you’d want to avoid GC when doing soft real-time?

                            RC doesn’t help with that as such. Calling malloc can take an indeterminate amount of time, just like a GC pass can, so the actual fix is to avoid allocations entirely…which you can also do in a full GC system. (A common optimization in languages like Java is indeed to pre-allocate in tight loops, reusing the same data structures over and over.)


                              There are different ways - it’s just Unix has lodged itself into our heads to the point we can’t think of anything else, and if we do, the first thing to correct that is a POSIX compatibility layer.


                                Do you have any suggestions for using tiddlywiki on mobile?

                                The save workflow is already pretty terrible now on modern browsers, and I never figured out syncing. I really liked the idea of it, and am always curious how people use it.


                                  I’ve been thinking this a lot in the last few years, just about the industry in general. The ease & cheapness of “fixing” software is nice, but it effectively disincentivizes doing it right in the first place, so we just end up shipping enormous amounts of absolute garbage software. And it only seems to be getting worse, as far as I can tell.


                                    The nodes are “things to discuss”, and everything you mention there fall into that category.

                                    But it’s interesting that you say that - I’m developing a larger version of this diagram where the different types of nodes are distinguished, and the nature of the relationship is made explicit. I share your disquiet, and it’s part of what’s driving the design.


                                      I don’t know how Boeing dropped the ball on communications when Airbus (seemingly) didn’t.

                                      There’s a longer, darker rant about the politics of the aviation industry that I’m not going to uncork today, including how much an aircraft manufacturer can benefit from a “home turf” investigation of an accident.

                                      But I do think there’s a qualitative difference between coverage today and coverage a decade ago, and vastly increased audience for outrage-bait, which feasts upon incidents like these. And that’s the biggest thing that annoys me about the 737 MAX case, because so many of the things people are getting outraged about are not just precedented but normal practice (like trying to design the new generation of a plane to minimize retraining and recertification from the old generation).


                                        Nice! Do you have any idea how slow you are compared to the standard Self VM or the same code on Python?

                                        Also does RPython give you multiple OS threads or goes it have a GIL like CPython?

                                        I found your notes on general differences between tinySelf and the original Self - they look very much like changes I’ve thought about before which probably means they’re genuine pain points in the current Self syntax.

                                        When you talk about using ; as a cascade operator do you mean like in Smalltalk 80, ie

                                        a b: 2; c: 4.           ==>.       a b: 2.  a c: 4.

                                        or a true cascade ie

                                        a b: 2; c: 4.           ==>.       (a b: 2) c: 4.

                                        Which is what Tim Budd did for his Little Smalltalk and is IMO much better ;)


                                          Had me at “arbitrary structured, typed data.” - immediately thought of PowerShell, which - while just one tool of many - meets your requirement of “be(ing) common to the user space binaries we work with…”