Felienne Hermans

If there is a specific discussion direction you have in mind, you should put it forth. That clip helps add more context, for sure.

I don't have much to add, but I'll state that I adore Papert's vision, and that even those who disagree about "what we should do on Monday" should keep an eye on the vision. If it does not directly inform what steps to take in the short term, at least it should have an indirect influence. By a similar token, tearing everything down and trying to rebuilding it from scratch carefully is famously tempting and notoriously ineffective for software systems. Even with software it's hard to make that claim flat out, and I shouldn't dare try to draw an analogy to social systems, since, you know, revolutions happen and for good reason. But I am glad there are at least some people (though maybe there are relatively too many) with an eye toward incrementalism.

There are many similar ideas to Papert's and Kay's that could perhaps be organized under a theme of being visionary or radical or in stark contrast to the status quo. Coming to mind are: A Mathematician's Lament by Paul Lockhart [1] (2002) or much more narrowly Ten Lessons I Wish I Had Learned Before Teaching Differential Equations by Gian-Carlo Rota [2] (1997).

I'm also reminded of some work by Felienne that questions the idea that computer programming in particular is not amenable to traditional instruction. This idea is popular with this era's programmers (perhaps because for the most part, at…

> it's the quantity of it that makes the difference.

But as many people have pointed out, quantity can have, well, quantitative reasons. I remember a blog post stating that being the only woman among 100 men at conferences, the author always got at least one stupid comment/question.

She even turned it into a formula:

#(women at a conference) = inversely proportional to #(times I talk about women in tech) [1]

Of course, that formula has simple quantitative reasons. Let's say that constant 1% of the 100 men there want to talk about women in tech. If there is 1 woman, you're it. If there are 2 women, 50% chance, 3 women 33% chance etc.

Same with rude people. Let's say there's an even 1% of women and men who are rude to the opposite gender and they are equally prolific. If there are 10% women at the conference/company/..., a woman has a roughly 100x greater chance of encountering that type of behaviour. Even though the level of rudeness is exactly the same.

Approximately: 1100 people, 1000 males, 100 females. 1% rude makes 10 rude males per 100 females, roughly 10% chance; 1 rude female / 1000 males, 0.1% chance, 100x difference.

Considering that "badness" of rude behaviour is likely going to be on a bell curve, you not only get more bad behaviour, you also get worse behaviour. Just from he numbers.

So you can have outcomes that look subjectively sexist (women encounter much worse and/or much more bad behaviour) without there actually being any sexism.

[1]…

DRAKON represents programs as flowcharts, and there's no reason why the underlying representation couldn't just be C, Python, or some other imperative language, and there's no reason why C or Python originally written in vi couldn't be represented in DRAKON.

I'm not a fan of flowcharts but DRAKON is of historical significance. The same would apply to GRAIL.

Other imperative visual programming languages such as Scratch could also be stored in a form resembling a textual imperative language. In other words, the visual element is largely "syntactic sugar".

Dataflow programs can also be stored as text rather than binary, but due to the nature of dataflow, this would be inconvenient to program directly in. This is because dataflow programs are graphs with only a partial order rather than ordered lists like programs in C or Lisp. This means that visual dataflow languages, such as LabVIEW and my own Full Metal Jacket (http://web.onetel.com/~hibou/fmj/FMJ.html) aren't simply syntactic sugar.

There are textual dataflow languages such as SISAL, but these require a compilation step before code is actually dataflow.

You should not be surprised to find that version control systems designed for text in which lines of code are executed sequentially by default is less useful for stored visual dataflow programs. You could still use diff/merge on the stored representation at the function level, but not easily at the line level, because the visual representation doesn't have…

I'm jus going to name-drop Felienne Hermans, who did an entire PhD on bringing proper software tools and best practices to Excel:

http://www.felienne.com/publications

Here is one of her more recent versions of the talk she gives on the topic:

https://vimeo.com/162206549

I think she raises especially important points when she mentions that Excel is used everywhere, that it suffers from all the technical debt problems that regular software development suffers from, and that buggy Excel sheets have big consequences (the austerity paper bug comes to mind[0]). So even if "real" programmers don't want to program in it, it still should be taken seriously given its place in the world.

https://www.bloomberg.com/news/articles/2013-04-18/faq-reinhart-rogoff-and-the-excel-error-that-changed-history

Felienne Hermans has done some very interesting work examining how to refactor spreadsheets. (http://www.felienne.com/publications)

Her PhD dissertation on the subject "Analyzing and Visualizing Spreadsheets" (http://www.felienne.com/archives/2534) is particularly detailed.

Much though some people might think that spreadsheets are not for serious work, they're being used for that right now, and that is unlikely to change. Better to figure out how to improve the tooling, rather than undertake the quixotic quest to get business people to abandon their perfectly viable programming tool.

There is an excellent video with her on InfoQ, explaining her spreadsheet formula refactoring tool Bumblebee (and the F# code behind it): http://www.infoq.com/presentations/spreadsheet-refactoring

Parsing shell-like syntax using turning complete excel to be able to parse shell-like syntax is step up from asci programming, but certainly drives home why would want to use a lexer.

IMHO, Fortran language implienter has nicer real world experience on why would want to use things like lex/yacc.

Suggest grouping associate shell command to excel function name that calls the turning tape that does the requested shell command (perhaps one excell spreadsheet per turning tape?). aka turing shell recursive decent parser.

https://www.felienne.com/archives/2974 &&
https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/

Although, IMHO, might want to upgrade the turning complete excel stuff to support a less verbose grammer type 1 or type 2 first.