Seems like most people aren't seeing the "bigger picture" and therefore just achieve local maxima. At Google IO yesterday they showed that their new smart speaker thing can pause music when you make a certain gesture (). In the video, the woman gets called on her smartphone and then uses a gesture to pause the music. Probably better than a voice command, but they won't get my applause until they either forward the call to the smart speaker or reduce music volume automatically when the smartphone gets called. It's 2019 and two devices used by the same person in the same room still can't cooperate on something like this. That's kind of embarrassing, isn't it? Anyway, the crowd seemed to love it...

This article is an interesting overview https://www.nature.com/articles/d41586-018-05588-x

I have this book. I know I’m sounding like yet another entitled dev, but the main turnoff for TLA+ (for me anyway) is the editor.

One of the features of some next-gen projects is to eliminate the need for techniques like TLA+ and UML. The concept is to make the specification the final code, and skip the implementation phase. Since TLA+ and UML do not produce a final product you have then the errors related to mapping those into executable code. In my own work i go from sketch, to data structure design, to executable spec which is the final product. I believe that is the shortest way to the goal.

yeah, we ended up with explicit watches where you told us what you wanted

@ogadaki Good to know. Will prioritize that one.

@ogadaki Basically, we struggled at the intersection of “how does this language actually work” and “can people understand this”. An example of the former was “what is the lifecycle of a HTTP request that touches a DB”, and of the latter “can we make

if (x % 5 == 0)

easy to read, understand, and edit”

With the latter, @Peter van Hardenberg told us (paraphrased) “ive never felt so stupid when coding”, which is a strong indication that your language is on the wrong track 🙂

I will remind people that the Luna people are going for a very hard target, which is having dual graphical + textual representation, freely convertible. Also, i added info on Jonathan Blow's Jai language, which i estimate will release in 2020. It is an extremely thorough implementation, designed for building games, and is already greatly superior to C++ IMHO in its current state. Of course we can only see videos at this point, but you can tell it is real, and coming.

Unicode exemplifies the tyranny of committees staffed with people who don't care how much damage they do as they erect their perfectly hypercomplex edifice. It started out nice, hey, let's stop overloading code points in the 256 char range. They quickly add a bunch of characters and things are okay, but then they continue to add more and more obscure alphabets, then they go off the rails are add the "astral" set of characters beyond UTF16, and turn it into an icon database, which changes every year, sure to break on older operating systems. Unicode was not designed to be an art database, yet that is their current intention, with multiple flavors of coloration as they make it more and more ridiculously complicated. I wish they would stop, or at least only revise it once every 10 years like the census.

Or you could see Unicode as a case study of how to build and maintain an international, cultural, technological building block that enables communication across cultures and deals with the challenges that come with it. Including complexities introduced when actively trying to deal with diversity and taking cultural bias out of a technology.

Really easy and fascinating study on internet voting in Estonia. As is often the case with our wacky community, I imagine the platform/medium that this paper is hosted on will be of equal or more interest to many of you then the content/message itself. It’s a way to collaboratively annotate papers. This paper has like a dozen or so comments all from the same guy, and I found them quite helpful https://fermatslibrary.com/s/security-analysis-of-the-estonian-internet-voting-system

https://www.devever.net/~hl/objectworld Rethinking files In Unix, everything is a file. This is often viewed as a positive, but it's often a poor abstraction for many things. This discussion goes into some of the issues.

Apple just announced a new framework SwiftUI that uses a "declarative syntax", and includes features in Xcode that allow editing source code and seeing the user interface changes live (it's not clear to me yet whether that can be done while the application is running, or only with a non-interactive preview of the UI) https://developer.apple.com/xcode/swiftui/

One of the things that hit me in the SwiftUI XCode demo (in the opening keynote, not PSOTU): at the very beginning, he clicks the rendered “Hello world” widget in the simulator panel; XCode focuses the editor panel and highlights the code for the widget instance in question. It’s blink-and-you’ll-miss-it fast, and the audience don’t react at all. I’d like to know: which existing web framework + IDE combos currently do this? Specifically: click a rendered component in a page (in a browser, or browser preview panel) and be taken to the code that instantiates that component?

terminology bikeshedding: I find this view taken by tiddlywiki to be kind of charming, as I often find generic terms get overloaded with overlapping definitions and implications from other applications of the same word. any opinions?

Adding to @yoz earlier point, here is a full video of SwiftUI, it looks quite impressive https://developer.apple.com/videos/play/wwdc2019/204/

The just announced new Dropbox is potentially interesting to this group https://www.dropbox.com/features/new Mainly as an attempt to improve the file system.

Quietly living inside file managers built by operating-system companies “served us well,” says Dropbox CEO and cofounder Drew Houston.

A separate thread based on @Daniel Hines’s comment https://futureofcoding.slack.com/archives/C5U3SEW6A/p1560278279045900?thread_ts=1560278176.045100&cid=C5U3SEW6A I’ve thought about WinFS on and off for years, often hearing the same refrain from others who yearn for what WinFS might have been. And now I’m turning on it: if a filesystem-level database was that good an idea, we’d have it already. I’m being deliberately provocative here because I genuinely want to know what problems WinFS could have solved that 1. aren’t just as solvable at app/userspace level (sorry, I’m not an OS expert) 2. are based on what we know of WinFS’s actual API and capabilities, rather than capabilities of other databases that we wish a filesystem would have. (I’m also interested in apps using other databasey filesystem features, but it’s a slightly different discussion)

How would you try to get developers on board with a FoC solution (eg. VPL), that is turning into a product? Let's say the product can be shown to perform better from a technical point of view than its mainstream alternatives, integrates well with conventional code, and also has a kind of "coolness" quality to it. How and through what channels would you approach developers to try it / use it?

https://suhr.github.io/wcpl/intro.html additional info

apparently my favorite type of PL content is half-finished stuff from outsiders lol

>> Enter TurboEditor. Because of this one simple little thing (not so little actually) that my friend found, we were able to decompile the entire CanDo program and figure out how it worked. Remember that important thing? Yes, that’s right, CanDo is actually written in itself and it could actually modify pieces that are currently executing. Let me clarify this just a little. One card could modify another card, then pull that card into focus. The actual card wasn’t currently executing, but the deck was. In fact, we came to find that CanDo was merely a facade. We also found that there was a very powerful object oriented, fully reentrant, self-modifying, programming language under that facade of a UI. In fact, this is how CanDo’s UI worked. Internally, it could take an element, decompile it, modify it and then recompile it right away and make it go live, immediately adding the updated functionality to a button or slider.

While CanDo could modify itself, it never did this. Instead, it utilized a parent-child relationship. It always created a child sandbox for user-created decks. This sandbox area is where the user built new CanDo Decks. Using this sandbox approach, this is how CanDo built and displayed a preview of your deck’s window. The sandbox would then be saved to a deck file and then executed as necessary.

YouTube recommended a video about Arrow Types to me.

I think a lot of y'alls might like Matt Parker's stuff (aka standupmaths) on YouTube, if you're a math person at all

A young aspiring programmer asks you as an expert and mentor:

"I want to understand the most important programming paradigms and learn about the broadest set of language features out there. What is the minimal set of programming languages I should look at? Popularity and how widely used these languages are doesn't matter, I just want the highest 🤯:🤓 ratio to maximize my learning."

Here's what I think: • C — for a simple, pragmatic, influential, and still widely used procedural language and to understand memory management • Smalltalk — for a highly dynamic language and environment, message passing and the origins of OOP • Lisp — because you wouldn't take me seriously if I left it off such a list • Haskell — for a pure functional, strongly typed language with laziness and strong compiler support (error checking, synthesis, etc.) • Forth — for an even simpler, but still highly expressive, extensible, and dynamic language • Datalog — for logic programming and constraint solvers (or maybe Prolog instead?) • Erlang — for actor model and concurrent programming What would you respond?

https://gist.github.com/halgari/f431b2d1094e4ec1e933969969489854 Blurb titled "What I want from a Type System".