Ted Blackman (one of the Urbit developers) recently posted a puzzle on Twitter, asking people to describe what a piece of code (written in this phonetic representation) does. [1]

I was delighted to find that I still remembered the phonetic names after first reading of them back in 2013, though I got the exact result wrong.

[1] https://twitter.com/rovnys/status/1199958608483684352

Velvia makes people look far too red in the face.

You should use Provia for portraits, not Velvia. Velvia, as you note, has a strong magenta cast.

Whoa, do you have a link to that Atkinson talk?

Server-side??? Apple requires apps use the Apple WebKit framework only for web content, which runs only on the client-side. The point of Puffin is to run Flash and other desktop crapware websites that don’t work on Mobile Safari (Apple WebKit) properly.

Puffin isn’t a native or local web browser; it’s an optimized, virtual, remote browser viewer. If they sell it as a “Citrix for the web,” they might have a shot.

Ah, I didn't realise that was Puffin's use case.

Opera Mini does the same thing as Puffin. Puffin wasn't denied access because it rendered on a server.

Imagine if we nationalised Uber.

Not every 'socialist' proposal has to mean 'big, bad government', as some political circles like to portray it. Look at the success of free/open-source software. It didn't involve any nationalisation, government protection etc. No, it beat the competition in the free market, many times even in a market that wasn't really 'free' because of vendor lock-in, lobbying etc. I don't see why this could not work elsewhere as well.

Free software does not extend from socialist thought.

Stallman's initial realisation was a reaction to crony capitalism: he could not modify the printer due to IP rules. Essentially, a deal is done between government and big business (the manufacturer and possibly the university), at the expense of hackers (individuals).

The justifications for copyright are rooted in common-good arguments. The state limits individual freedom, claiming that it should because of (undemonstrated) common-good advantages. Hayek explores this, and takes a position against IP in _The Fatal Conceit: The Errors of Socialism_.

A better political analogy for free software is a conflict from early US history: between landowner and state rights advocates (Jefferson) vs big-business visions (Hamilton).

Open-source is socialist, really? I just thought it was a fancy way of showcasing skills and did it for fatter invoices it leads to, not public approval. An investment which requires capital in the form of skill. How on Earth is this socialist?

That's a great idea, because:

1. A government regulating a market is one thing while a company regulating a market is yet another thing.

2. As Stallman puts it: "We should not allow a company to have a share over around 10% of any market. If in a certain field a single dominant company is beneficial for society, that means it is a natural monopoly, and should be served by a regulated utility."

It also seems like they were trying to abuse/repurpose OS level functionality (the power button). I imagine that was difficult on Android, and the article completely fails to acknowledge that this is actually impossible on iOS.

We ran some casual benchmarks on this at work once, and it's important to note that the performance of AutoLayout dramatically improves based on the degree of nesting you employ.

If you have sixteen views on a cell and their locations all depend upon each other, it's going to take a long time to solve those constraints. But if you can break up the cell, say into four subviews with four elements inside them, it's likely to be faster (no guarantees, though)

Yup, it's easiest if you understand what the solver is doing and help point it towards solutions/find them trivially.

Unfortunately, i had to write my own constraint system and practice with it a lot to use AutoLayout with high performance where i was confident i was not introducing significant re-layout performance problems.

A long time ago I put my Snapper Card (NZ equivalent) in a cup of acetone to get the chip out. I then stuck the chip in the back of my Nokia bar phone.

> It’s no secret that I really like Clojure and as a lisp, it was the easiest language for me to start the prototype with, but there’s no reason this couldn’t be done for any language with a dynamic runtime. The rest is mostly simple analysis of an AST and some clever inference.

I have looked into this. It is kind of criminal that for most real world languages (Ruby[1], C[2] etc), it's not possible to just define a grammar and throw it at a standard parser generator for them - they generally have one or two quirks which make this infeasible.

In my ideal alternate universe it would be considered unthinkable to publish a language without also publishing a grammar in a standard format for said language, which can then be plugged into your favourite text/semantic/tree editor. Our tools should dictate our languages, not the other way around.

[1] http://programmingisterrible.com/post/42432568185/how-to-par...

[2] https://en.wikipedia.org/wiki/The_lexer_hack

Most programming languages are context-sensitive [1] (at least with unbounded nesting), so parsing them correctly and efficiently is mathematically impossible. All practical implementations have to take shortcuts.

[1] Mainly due to begin..end blocks, curly braces or indentation (as in Python)

Are most programming languages really context-sensitive? or aren't they mostly context-free?

My days of fiddling with writing parsers are long ago (https://www.codeproject.com/Articles/7035/A-Java-Language-ID...) but if I remember correctly most languages aim for at most a LL(2) grammar, meaning they are designed so the parser doesn't have to peek more than two tokens ahead before being able to make a correct determination.

C has some fun ones:

a * b;

Is either: a times b if a is a var, or declare a varible b with type a. If a is a typedef.

Also:

some_type b = {a, b, c, d};

Is only valid if some_type is an array or a struct. Which is possibly defined elsewhere in the source.

(I tend to see this syntax in some code bases (some_type) { a, b, c, d }, which is a bit better).

Context free grammars are perfectly capable of expressing matched curly braces, even with unbounded nesting. Am I missing something?

Yes, thinking about it that alone is not sufficient. Still, I'd claim that most languages are not context free.

CPP (Pre-processor) aside, C is not context free due to typedef making identifiers ambiguous. Also if-then-else? Since C++ templates are turing-complete, the grammar is probably unrestricted.

Python is not context free due to

    if ...:
        stmt1
        if ...:
           stmt2
        stmt3

stmt3 and stmt1 have to share the same level of indentation to form a valid Python program, but they might contain arbitrary indentation within brackets.