for both access and persistent identity

a URI is like a proper name and baptism is given by the registration of the domain name, which gives a legally binding owner to a URI

Before asking the question, how do I build AGI, you first must ask the question, what would I recognize as AGI?

If you're not 100% sure whether you know how compilers work, then you don't know how they work.

In some cases, it is not straightforward to write links to the HTTP "Link" header field from an application. This can, for example, be the case because not all required link information is available to the application or because the application does not have the capability to directly write HTTP fields.

The answer is simple – stop using these services and look for privacy respecting alternatives where possible.

If someone came up to you in the street, said they’re from an online service provider and requested you store all of the above data about you with them, I imagine for many the answer would be a resounding NO!

I’ll read through a dependency, start refactoring, and realize that it’s going to be simpler to write it myself

a bigger source tree

Vendoring means that you aren’t going to get automatic bugfixes, or new bugs, from dependencies

If the program provides accurate real-time feedback about how user manipulations affect program state, it reduces user errors and surprises. A good GUI provides this service.

The LISP part, though, is not going well. Porting clever 1970s Stanford AI Lab macros written on the original SAIL machine to modern Common LISP is hard. Anybody with a knowledge of MACLISP want to help?

Performance. Running a research project in a browser isslower than running it natively. Fortunately, performanceis not generally critical for evaluating usability. Thus weprioritize compatibility and ease-of-use over performance.

There are several issues to consider when translating re-search projects into JavaScript and running in a browser

We propose building an infrastructure that makes it easy tocompile existing projects to JavaScript and optionally collectusage data. We plan to leverage existing tools to translateprograms into JavaScript. One such tool is Emscripten [15],which compiles C/C++ code and LLVM [14] bitcode toJavaScript.

the tools can be distributed within static web-pages, which can easily be hosted on any number of exter-nal services, so researchers need not run servers themselves

We propose helping researchers compile their tools toJavaScript

not designed to be secure

Many research projects are publicly available but rarely useddue to the difficulty of building and installing them

Ringer is a low-level programming language for web automation tasks. Many statements in the high-level Helena language are implemented with Ringer. Ringer comes with a record and replay tool; when a user demonstrates how to complete an interaction in a normal browser, the tool writes a straight-line Ringer program that completes the same interaction on the same pages. GitHub

wehave found instances of people using relatively heavy-weightJavascript frameworks like Exhibit [11] just for the compar-atively minuscule feature of sortable HTML tables

Despite the social nature of h., discovery is very difficult. Purposefully ‘finding the others’ is mostly impossible.

H.’s marketing director has 1348 public annotations over almost 6 years, its founder 1200 in a decade.

If you need a site that’s just a single page I think I would use a word processor and do a “save as html”.

Over in the IndieWeb community we were having a conversation about how easy it should be for people to create their own websites (also for small local businesses etc.) Where making the site is basically the same as writing the text you want to put on it. Social media silos do that for you, but out on the open web?

Begin premium services directly to students

The program iswritten in Java, but it is pretty clear that it was translated from a language like ML

When a person uses a tool to achieve some goal, they quickly learn how towork around the short-comings of the tool in order to get their job done. As a result, the personbecomes desensitized to problems in the tool.

I find C++ quite ugly

When I go to use some software it takes an inordinate amount of time to set things up.

Some of my ruby, nodejs and python projects no longer run due to dependencies not being pinned at creation time.

why I am doing this

XBL is a proprietary technology developed by Mozilla

use-cases such as representing a 410 Gone deleted resource on static hosting that often disallow setting HTTP headers directly

1) get an extra 'search' attribute on to the <a> tag in HTML so that we have: e.g. <a href='...' search='...'>link text</a> 2) If there's take-up, then later on push for adding a date-time of creation attribute to <a>. This will add link history to the internet. The way (1) works is someone sticks the basic href to a page in the href attribute, and then sticks the text they want to link to in the search attr. The browser fetches the page, and as a secondary action (at user option) searches for the text.

Documents may be retrieved by URL: by sending mail to listserv@info.cern.ch with a line containing the command SEND followed by the URL of the document

If you refer to a particular place in a node, how does one follow it in a new version, if that place ceases to exist?

Linking by context In this case, the annotater refers to a part of the document by the context: for example, he quotes the first and last pieces. See for, example, the section "In this case...". This method is clearly heuristic and prone to failures just as is the automatic generation of differences above..

The solution set is as follows: take your pick.

A disadvantage seemed to me to be that it is not obvious which words take one to particularly important new material, but I imagine that one could indicate that in the text.

A feature of Microcosm is that links are made using keywords in the following way. Within a certain region (for example, a set of documents), a keyword is connected to a particular destination. This means that a large number of links may be declared rapidly, and markup in the document itself is not needed.

One might want to make a private annotation to something which is visible world-wide but unwritable. The annotation would be invisible to another reader

In practice, a system in which different parts of the web have different capabilities cannot insist on bidirectional links. Imagine, for example the publisher of a large and famous book to which many people refer but who has no interest in maintaining his end of their links or indeed in knowing who has refered to the book.

Best of all, there is no software to install, it just works from the Web!

To increase the granularity of vcontrol, HTML elements can be subclasssed

It seems the Web is still in a primitive state of formation: loose bands of individuals hunting and gathering. I look forward to great nations in this new medium.

Especially if CouchDB were an integrated part of the browser

Of the two, the html version is the one where I've spent a bunch of time trying to understand and improve the performance. In the dear imgui version I've done the easiest possible thing at every step and the performance is still fine.

So what’s wrong with all the different languages? Nothing, if you enjoy the mental exercise of creating and/or learning new languages. But usually that’s all they are: a mental exercise.

Editorial: The real reason I wanted Cmm to succeed: to democratize programming. It wouldn’t belong in any business plan, and I seldom mentioned to anyone, but the real reason I wanted Cmm to succeed was not about making money (although paying the mortgage was always important). The real reason was because of the feeling I had when I programmed a computer to perform work for me

Another thing I’ll do when I’m King of the World is declare that executable code will always be inseparable from it’s source code. Using a script language solves that, of course, because a script is it’s source. For compiled code a second-best solution is the executable always contain pointers to where the source originated, but since that source may disappear the better solution is for language compilers to simply tack the original source code (and related make files and resources) onto the end of the executable in a way that can be commonly extracted. The law will be known as the “All boots shall contain their own bootstraps” decree.

lack of a common powerful hi-level language available on every computer remains. You still cannot write a script file and send it to everyone and expect them to be able to run it without installing something first. The closest we probably have is HTML with JS embedded, since everyone has an HTML browser installed

It's often a good idea to replace common primitives, such as strings, with appropriate value objects.

You can use terribly slow scripting and techniques and get something working, not because the tooling is genius, but because the hardware is so incredibly fast.

I think we can define an "archival virtual machine" specification that is efficient enough to be usable but simple enough that it never needs to be updated and is easy to implement on any platform; then we can compile our explorable explanations into binaries for that machine. Thenceforth we only need to write new implementations of the archival virtual machine platform as new platforms come along

software collapse

browsers aren’t magic! All the information browsers send to your backend is just HTTP requests. So if I copy all of the HTTP headers that my browser is sending, I think there’s literally no way for the backend to tell that the request isn’t sent by my browser and is actually being sent by a random Python program

And it’s like, no, no, you know? This is an adaptation thing. You know, computers are almost as old as television now, and we’re still treating them like, “ooh, mysterious technology thing.” And it’s like, no, no, no! Okay, we’re manipulating information. And everybody knows what information is. When you bleach out any technical stuff about computers, everybody understands the social dynamics of telling this person this and not telling that person that, and the kinds of decorum and how you comport yourself in public and so on and so forth. Everybody kind of understands how information works innately, but then you like you try it in the computer and they just go blank and you know, like 50 IQ points go out the window and they’re like, “doh, I don’t get it?” And it’s the same thing, it’s just mediated by a machine.

:

or a not very significant change is made to an existing feature in a way which probably won’t cause anybody problems

The git repositories for Inform

a MIT style license, which does not require the notices to be reproduced anywhere outside of the actual library code.

his ostensible real life (which is actually staged)

The more the reimplementation differs from the original authors’ code, the better it is as a verification aid

the published journal article, or some supplementary material to that article, contains a precise enough human-readable description of the algorithms that a scientist competent in the field can write a new implementation from scratch

The lack of CPU power in those days also meant there was deep skepticism about the performance of interpreters in general, and in the user interface in particular. Mention "interpreted language" and what sprung to mind was BASIC or UCSD Pascal, neither regarded as fast.

symmetric

The JS that is being run is essentially IE6 or IE5-level, so none of the modern features introduced in IE8

It should be dead simple to distribute content (eg. static content).It should be easy to build apps.It should be not too hard to build a platform.

Dynamic typing makes that harder

The point is to write bug-free code.

Easier than C? Really? Since all that crap ends up calling C libraries anyway? This is about hard real time as it gets.

If you’re still worried, do note that the Space Telescope Science Institute’s document mentions that the script processor itself is written in C++, which is known for being... well, the type of language you’d want to use if you were programming a spacecraft.

written in arcane code that you’d have to recompile

therefore likely less error-prone

what’s the point of going with web-like scripts instead of more traditional code

Usually the philosophy is akin to turning an antique coffee-grinder into the base for a lamp: it's there, so why not find a way to put it to some use.

Most notably missing from the discussion is inheritance.

if (property === 'firstName')

This became a serious practical issue as version control was adopted as a tool for collaboration, with members of a team communicating through commit messages. Git therefore introduced the approach of “rewriting history”.

this basic wisdom was lost with the adoption of computers. Computers make it very easy to modify information, to the point that version control had to be invented to prevent massive information loss by careless editing.

Since facts and narratives live in different universes, we should avoid mixing them carelessly. Crossing the boundary between the two universes should always be explicit. A narrative should not include copies of pieces of facts, but references to locations in a fact universe. And facts should not refer to narratives at all.

I decided to start with a fresh install of Python 2.7. First surprise: no C compiler.

I add mass to each of these… mental clusters? planetary bodies in the Mindscape? by hyperlinking the phrase as I type.

The linear structure of a notebook that forces the narrative to follow the order of the computation.

It comes to the conclusion that the closest existing approximation to a good platform is the Java virtual machine.

we need to think about what the required platform is for each variety of canned computation

The fundamental problem is that VirtualBox emulates arcane details of PC hardware in order to work with existing operating systems, and then the installed operating system recognizes that arcane hardware and installs drivers etc. that rely on it. That means we have to emulate the same arcane hardware 20 years from now just to be able to boot the old virtual system.

around in 10 years

no matter how ill-adapted it is to our needs

perhaps we will end up compiling our software to asm.js and run in the browser

Note however that it’s not “any of today’s virtual machine managers”

For the 2013 Web platform, you may hope that its sheer popularity will motivate someone to keep it alive, but I wouldn’t bet on it either. The Web platform is too complex and too ill-defined to be kept alive reliably when no one uses it in daily life any more.

if you want to use an archived copy of a 2013 Web site, you need the 2013 Web platform

we can’t know what trivial change to the environment might stop the experiment working, or (worse) make it appear to work but actually have a major change in it

The more I think about it, the less I think there is a meaningful definition of the one true run time. I have put significant effort into making sure that runtimes are consistent but, however we do this, it makes our experiments less realistic. With rare exceptions (perhaps some safety critical systems) our algorithms will not be used in highly controlled situations, moderated to reduce variability between runs or to maximise speed of this particular process. Algorithms will be run as part of a larger system, in a computer sometimes with many other processes and sometimes with few and, because of the way that computing has developed, sometimes in raw silicon and sometimes in virtual machines. So the more I think about it, the more I think that what matters is the distribution of run times. For this, your experiment on your hardware is important, but so are future recomputations on a wide variety of VMs running on a variety of different hardware.

If I can’t run your experiment at all, then I can’t reproduce your times.

We are not asking people to send us VMs, but to send us what they think we need to get the experiment to run. This is usually a few megabytes of code and maybe executables. Assuming we can run it in a standard environment, we can make our own VM without one ever being sent to us.

Code you make available today can be built with only minor pain by many people on current computers

Before running it you need two free tools, Vagrant and Virtual Box.

There has been significant pressure for scientists to make their code open, but this is not enough. Even if I hired the only postdoc who can get the code to work, she might have forgotten the exact details of how an experiment was run. Or she might not know about a critical dependency on an obsolete version of a library.

Other examples of tech stacks that are very stable are C, C++, and Fortran.

sometimes, the system thecustomer wants and the system that should be built are quitedifferent.

Error establishing a database connection

the reason a lot of studies are made of these price and volume variables is that now, in the age of computers, there are almost endless data available about them. It isn’t necessarily because such studies have any utility; it’s simply that the data are there and academicians have worked hard to learn the mathematical skills needed to manipulate them. Once these skills are acquired, it seems sinful not to use them, even if the usage has no utility or negative utility.

there is an intended reading order

In a world where all scientifically relevant information is stored in stable and well-defined open file formats, software tools can evolve much more freely without disturbing ongoing work or harming reproducibility.

David Cournape made the interesting observation that no technology less than 20 years old is better than Python in terms of stability.

Every beginner-level tutorial for scientists should state during the first five minutes that you cannot expect stability and that you should either use Python only for throw-away code or else

The technical solutions proposed all depend on yet more infrastructure whose longevity is uncertain.

Finally, in anticipation of an argument that I expect to see, let me stress that this is not a technical issue. Computing technology moves at a fast pace, but that doesn’t mean that lack of stability is a fatality. My last Fortran code, published in 1994, still works without changing a single line. Banks have been running Cobol code unchanged for decades. Today’s Java implementations will run the very first Java code from 1995 without changes, and even much faster thanks to JIT technology. This last example also shows that stability is not in contradiction with progress. You can have both if that’s a design goal. It’s all a matter of policy, not technology.

What is not OK is what I perceive as the dominant attitude today: sell SciPy as a great easy-to-use tool for all scientists, and then, when people get bitten by breaking changes, tell them that it’s their fault for not having a solid maintenance plan for their code.

coding-intensive research

the poor reproducibility of Python-based computer-aided research

What I find surprising in the frequent heated debates is that the nature of the type system is rarely even discussed. People talk about static vs. dynamic types as if there were only one static and one dynamic type system.

The closest technology I am aware of in this space is F# type providers

every computation on a modern computing system is actually a staged computation, with reproducibility of the last stage (the one we most care about) requires the reproducibility of all prior stages

explicit documentation of both the execution environment used to run the software and all requirements and dependencies of systems, software, and libraries should be clearly noted in the code and/or readme file (Benureau and Rougier 2018). While time passing can make software obsolete, it also fades the memories of researchers. For that reason alone, it is important to annotate source code to explain the intended operations, which supports reproducibility for the original research team while also supporting future reusers (Benureau and Rougier 2018)

Most developers know and love github pages

An ActivePaper is, by defini-tion, a package combining the code, data, and documentationthat describe together a computational scientific study.

today’s notebook implementations require note-book authors to take various precautions to ensure repro-ducibility, which are exactly the same as required for makingscripts reproducible: a detailed documentation of the soft-ware environment that was used, listing all dependencieswith detailed version information

A recent study [25]of more than a million notebooks in public GitHub reposito-ries found many indicators of poor quality, some of whichsupport earlier criticisms of notebooks encouraging bad soft-ware engineering habits

C, Fortran, BLAS, and Unix

over the seven years of the project, I ended upspending a lot of time catching up with dependencies. Newreleases of NumPy and matplotlib made my code collapse,and the increasing complexity of Python installations addedanother dose of instability. When I got a new computer in2013 and installed the then-current versions of everything,some of my scripts no longer worked and, worse, oneof them produced different results. Since then, softwarecollapse has become an increasingly serious issue for mywork. NumPy 1.9 caused the collapse of my MolecularModelling Toolkit, and it seems hardly worth doing muchabout it because the upcoming end of support for Python 2in 2020 will be the final death blow.

perhaps the mostfrequent motivation for adding dependencies in layer-3 soft-ware is the desire to write less code oneself

Accept that your construction is short-lived. In caseof collapse, start from scratch

a blog post

There is a good chance that you have never heard ofsoftware collapse before, for the simple reason that it’s aterm I have made up myself two years ago in a blog post.

What I call software collapse is what is more commonly referred to as software rot: the fact that software stops working eventually if is not actively maintained. The rot/maintenance metaphor is not appropriate in my opinion because it blames the phenomenon on the wrong part. Software does not disintegrate with time. It stops working because the foundations on which it was built start to move.

“on a decadal time scale, wecannot rely on software to run repeatably.

even if the code has been made available, it cannotbe easily run because of changes in the underlyinglibraries, operating systems, and other dependen-cies

Finally, software is hard to work with. Forgetmaking research reproducible, it is hard enough touse it 6 months later.

The “work around” was to detect users in an IAB and display a message on first navigation attempt to prompt them to click the “open in browser” button early.

Roughly stated, my overarching career mission is to design, build, and deploy software platforms that put end users in control of their computing and data, in part by making it easy and natural for programmers to create software that honors user desire.

The idea here is to emulate the hardware platform WordPerfect ran on

We also see the usual conceit of totalizing systems like Microsoft Word: plain ASCII text files are accepted, as input files, but only “for compatibility reasons”. Ugh.

in Oberon (as in Python, but very much not as in C or Pascal) a character is a string of length 1

I can't possibly keep updating software to deal with new JavaScript versions

A complete description on implementing eventhe simple IMGUI would take too much space. Iinvite you instead to watch Casey’s video lecturemirrored on my web site, and look at the samplecode I’ve posted. I’d like to thank Casey Muratori, JonathanBlow, and Atman Binstock for feedback on thisarticle, some of which you can read on Casey’sweb site forum.

a “global variable” which identifies whichwidget is active

Instead, we simplydescribe them from scratch every frame, whichdoesn’t actually result in more code. It’s more likewe run the “create” code every frame.

This is less efficient than the previousapproach, but it’s less likely to have bugs.If we have CPU speed to spare, we can get rid ofall the bugs.

I like to organize all the state in a program so that it's reachable from some root pointer. This makes it easy for the reader to understand all the resources allocated by the program by just following the tree of types. It also makes it easy to find any piece of state from within a debugger, or to write little debugging helpers that eg check global invariants or print queue lengths.

I've gotten to where "if I can't make sense of it and be productive in it with just vim, grep, and find, your code is too complex".