summary refs log blame commit diff stats
path: root/article/the-old-web-was-better.html
blob: d0b881fa3ce73a36d1dabed57be4854fb79904d4 (plain) (tree) 
da29ebc ^










8363f1e ^



























da29ebc ^






1
2
3
4
5
6
7
8
9
10

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

38
39
40
41
42
43










                                                                                                             


























                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           





                                                                  
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
	<head>
		<title>The Old Web Was Better</title>
		<link rel="stylesheet" href="/plain.css" />
		<link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
		<meta charset="utf-8" />
	</head>
	<body class="indent">
		<h1>The Old Web Was Better</h1>
		<p>Article ID: 9</p>
		<p>
		When I go to an average ``modern'' World Wide Web site with the default configuration of Lynx, a wonderful plain text Web browser, I am usually greeted with things like <code>example.com cookie: some jibberish Allow? (Y/N/Always/neVer)</code> for which I'd press V a couple times.  Then, I would press C-f or page-down a couple times to scroll past a giant navigation bar full of nested lists, a few HTML login forms, multiple search bars.  Then I'd see the actual text of the article I'm looking for.  Or sometimes, the site would show ``Please enable JavaScript to view this page.'' or some Cloudflare prompt saying that I need to enable JavaScript to solve a proprietary CAPTCHA to view the page because they have detected ``unusual activity from my network''.  Or I would be met with a blank page.  If I decide to visit the modern Web with a ``normal'' Web browser such as Firefox or Chromium, with a default install, I'd get a ten-megabyte load of a bunch of fancy advertisements at the top of the page, a giant navigation bar that's really colorful to distract me from what I actually want to see, some pop-ups wanting me to fill in my email address to sign up for their newsletter (which as people say would usually be weekly HTML email spam), flashy advertisements on the side bar, and when I finally scrolled past the header part of the page, a few hasty paragraphs with large paragraph seperations unreadably wrapped in a narrow column.  All to display a few kilobytes of actual text, and rarely a few hundred kilobytes of useful images.
		</p>
		<p>
		The Web, which people often refer to as the aggregate of human knowledge and high-speed distribution of information, has turned into a degenerate mess of advertisements, JavaScript, slugishness, tracking and profiling, security holes, and slowness.  In summary, the modern Web is <em>painful</em>.
		</p>
		<p>
		I'm looking back towards the 1990s, where Websites would be like this one.  Simple (X)HTML, plain text, or another lightweight markup language.  No ads, trackers, JavaScript, popups, <a href="https://www.gnu.org/philosophy/who-does-that-server-really-serve.en.html">Software as a Service Substitute</a> etc.  Just distribution of information and ideas, as gophertext, plain text, or simple (X)HTML.  As simple as that---basically ``use the simple defaults of your Web server program and don't bother with huge management systems''.
		</p>
		<p>
		Though, some semi-modern things are good.  MediaWikis, for example, while their behind-the-back workings of mulplitudes of PHP mountains, SQL databases, and recently JavaScript-infested visual editors are extremely unelegant, they do provide a consistent simple user interface, without many browser requirements, for users to distribute useful information with.  Just not loads of JavaScript and margins and paddings and ads, please.
		</p>
		<p>
		It would also be better if more people were to have personal Websites to express themselves with, rather than relying on centralized social media giants, who once again display a bunch of ads and wraps articles/``posts'' at 30 columns to make people uncomfortable reading comprehensive ideas and get them inclined to write short illogical rants and personal attacks.  <a href="https://learn.tuxiversity.org/">Tuxiversity</a> and <a href="https://landchad.net/">LandChad.net</a> are useful resources to get started with.
		</p>
		<p>
		The same applies to the Internet more generally.  Don't send huge, clunky HTML emails.  Simple chat protocols like IRC.  Whatever.
		</p>
		<p>
		Further reading:
		</p>
		<ul>
			<li>
				<a href="https://bunbun.de/posts/blog3.xhtml">The Internet of Bloat</a>
			</li>
		</ul>
		<div id="footer">
			<hr />
			<p><a href="/">Andrew Yu's Website</a></p>
		</div>
	</body>
</html>
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-25 04:32:36 +0000
Current_routine->calls.pop_front(); // just in case 'main' returns a value, drop it for now if (Current_routine->calls.empty()) goto stop_running_current_routine; for (int i = 0; i < SIZE(ingredients); ++i) trace(9998, "run") << "result " << i << " is " << to_string(ingredients.at(i)) << end(); // make return products available to caller copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin())); // End Reply break; // continue to process rest of *caller* instruction } //: Types in return instructions are checked ahead of time. :(before "End Checks") Transform.push_back(check_types_of_return_instructions); // idempotent :(code) void check_types_of_return_instructions(const recipe_ordinal r) { const recipe& caller = get(Recipe, r); trace(9991, "transform") << "--- check types of return instructions in recipe " << caller.name << end(); for (int i = 0; i < SIZE(caller.steps); ++i) { const instruction& caller_instruction = caller.steps.at(i); if (caller_instruction.is_label) continue; if (caller_instruction.products.empty()) continue; if (is_primitive(caller_instruction.operation)) continue; const recipe& callee = get(Recipe, caller_instruction.operation); for (int i = 0; i < SIZE(callee.steps); ++i) { const instruction& return_inst = callee.steps.at(i); if (return_inst.operation != RETURN) continue; // check types with the caller if (SIZE(caller_instruction.products) > SIZE(return_inst.ingredients)) { raise << maybe(caller.name) << "too few values returned from " << callee.name << '\n' << end(); break; } for (int i = 0; i < SIZE(caller_instruction.products); ++i) { reagent/*copy*/ lhs = return_inst.ingredients.at(i); reagent/*copy*/ rhs = caller_instruction.products.at(i); // End Check RETURN Copy(lhs, rhs) if (!types_coercible(rhs, lhs)) { raise << maybe(callee.name) << return_inst.name << " ingredient '" << lhs.original_string << "' can't be saved in '" << rhs.original_string << "'\n" << end(); raise << " ['" << to_string(lhs.type) << "' vs '" << to_string(rhs.type) << "']\n" << end(); goto finish_return_check; } } // check that any return ingredients with /same-as-ingredient connect up // the corresponding ingredient and product in the caller. for (int i = 0; i < SIZE(caller_instruction.products); ++i) { if (has_property(return_inst.ingredients.at(i), "same-as-ingredient")) { string_tree* tmp = property(return_inst.ingredients.at(i), "same-as-ingredient"); if (!tmp || !tmp->atom) { raise << maybe(caller.name) << "'same-as-ingredient' metadata should take exactly one value in '" << to_original_string(return_inst) << "'\n" << end(); goto finish_return_check; } int ingredient_index = to_integer(tmp->value); if (ingredient_index >= SIZE(caller_instruction.ingredients)) { raise << maybe(caller.name) << "too few ingredients in '" << to_original_string(caller_instruction) << "'\n" << end(); goto finish_return_check; } if (!is_dummy(caller_instruction.products.at(i)) && !is_literal(caller_instruction.ingredients.at(ingredient_index)) && caller_instruction.products.at(i).name != caller_instruction.ingredients.at(ingredient_index).name) { raise << maybe(caller.name) << "'" << to_original_string(caller_instruction) << "' should write to '" << caller_instruction.ingredients.at(ingredient_index).original_string << "' rather than '" << caller_instruction.products.at(i).original_string << "'\n" << end(); } } } finish_return_check:; } } } bool is_primitive(recipe_ordinal r) { return r < MAX_PRIMITIVE_RECIPES; } :(scenario return_type_mismatch) % Hide_errors = true; def main [ 3:num <- f 2 ] def f [ 12:num <- next-ingredient 13:num <- copy 35 14:point <- copy 12:point/raw return 14:point ] +error: f: return ingredient '14:point' can't be saved in '3:num' //: In Mu we'd like to assume that any instruction doesn't modify its //: ingredients unless they're also products. The /same-as-ingredient inside //: the recipe's 'return' indicates that an ingredient is intended to be //: modified in place, and will help catch accidental misuse of such //: 'ingredient-products' (sometimes called in-out parameters in other //: languages). :(scenario return_same_as_ingredient) % Hide_errors = true; def main [ 1:num <- copy 0 2:num <- test1 1:num # call with different ingredient and product ] def test1 [ 10:num <- next-ingredient return 10:num/same-as-ingredient:0 ] +error: main: '2:num <- test1 1:num' should write to '1:num' rather than '2:num' :(scenario return_same_as_ingredient_dummy) def main [ 1:num <- copy 0 _ <- test1 1:num # call with different ingredient and product ] def test1 [ 10:num <- next-ingredient return 10:num/same-as-ingredient:0 ] $error: 0 :(code) string to_string(const vector<double>& in) { if (in.empty()) return "[]"; ostringstream out; if (SIZE(in) == 1) { out << no_scientific(in.at(0)); return out.str(); } out << "["; for (int i = 0; i < SIZE(in); ++i) { if (i > 0) out << ", "; out << no_scientific(in.at(i)); } out << "]"; return out.str(); }
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-25 04:32:33 +0000