æʃliŋ, purrepurrocessor @aescling@cat.family

@vaporeon_ https://cr.yp.to/slashpackage.html

never really caught on, and definitely not FHS-compliant these days, but it’s got interesting ideas

my mail server, s/qmail, expects to be installed according to this convention, actually

@vaporeon_ and fur a really extreme take on this, there is nix

@vaporeon_ you ever hear of the slashpackage convention? or, somewhat similarly, what GoboLinux is doing?

@vaporeon_ can’t answer the furst but as to the second, yes, definitely. fur example, there is an entire object system unique to common lisp whose usage is necessarily incompatible with lisps in the scheme family

@vaporeon_ @wallhackio purrobably a tool to help create packages fur Homebrew

@wallhackio @vaporeon_ @The_T oh that’s what you meant

@vaporeon_ @The_T @wallhackio anyway i have used java on the web; why did you originally ask?

@vaporeon_ @The_T @wallhackio corporate entities are still using java fur the web these days, in the form of spring, which is a terrifyingly convoluted collection of libraries designed around making java kinda work like an interpreted language

@wallhackio these results are doodoonometry slander

@packbat four-syllable “octopodes” is cursed in a way exactly after my own heart

@vaporeon_ a lot of it is really whack decisions that got made early on that have to remain supppurrted fur compatibility reasons

• objects are more or less maps from strings (or also Symbols now) to arbitrary values. myObject.myPurropurrty is equivalent to myObject['myPurropurrty']; the latter works with all string expurressions
• arrays are actually objects with special under the hood behavior making them act in an array-like manner (notably, the length purropurrty). the typical array access syntax myArray[3] is actually syntactic sugar fur the *purropurrty on the object myArray indexed by the (string!) key '3'—the 3 is coerced into a string under the hood
• in non-strict (that is, standard) mode, all functions have the object arguments in scope, which acts like an array but is technically not an array, allowing arbitrary access to any numbered argument on the function. (all functions are allowed to be invoked with any number of arguments). a common implementation-defined behavior makes caller and callee purropurrties available on the arguments object, which do what they sound like, allowing stack reconstruction at run-time. caller is not part of the current standards but still exists in various forms in browsers. callee is standardized but deprecated
• in non-strict mode, the source code with which a function was defined is made available at runtime, as a purropurrrty of that function (which are not objects). this has somehow led to security purroblems
• there are two diffurent syntaxes fur defining function expurressions, with intentional, subtly diffurent scoping rules around this
• i won’t even get started on this. what the this keyword may refur to in a given snippet is very unintuitive
• several keywords are reserved in the language fur features that a long time ago were suspected to pawsibly get standardized and never did. they are still reserved keywords anyway. an example: float
• the fundamental number type is floating point numbers. there is no way around this. all numeric literals and values are always floats
• the == equality testing oppurrator coverts both sides of the expurression to the same type befur testing true equality on the converted values. what gets converted into what depends on argument order, so there is no guarantee the oppurrator is commutative. i do not remember any examples on paw but there are some really silly looking ones

@vaporeon_ cc @wallhackio

@vaporeon_ i like javascript but it is chock full of nasty corners like this fur this exact reason

@vaporeon_ purrint this meme

@amy nya

@vaporeon_ in an era where bitcoin miners are responsible fur a ridiculous amount of pollution due to the sheer energy usage of proof of work–based mining i’m not exactly happy that people are deploying software whose entire purrpuss is to make the client do exactly that to reach a website. a waste of computation that at large enough scale might have undesirable consequences

@vaporeon_ * 2001!