Intellectual property is broken — the idea isn't necessarily bad but the implementation sucks. This is the opinion both I and many other people in the online nerd circles I inhabit hold. The reasons behind it are well known:

• Copyright lasts for way longer than it should — 50-70 years after the author's death (in most parts of the world).
• Copyright disproportionately benefits large corporations rather than regular people.
• Current wave of generative AI was built on the works stolen from millions of individual creators with the express purpose of replacing them without compensation, and AI companies were allowed to redefine what "fair use" means in their favor in order to get away with it.
• Software patents are rife with abuse by patent trolls, serve no practical purpose, and stifle innovation by preventing projects from using mathematically superior algorithms.
• Hardware patents, alongside trade secrets, stifle silicon innovation and limit the number of CPU/GPU vendors, making them great tools for geopolitical trade wars.
• Firmware DRM takes away the user's autonomy over the hardware that they bought, locks them away from choosing which software to run, and in some cases, effectively destroys their hardware by turning it into a useless piece of plastic if the user tries to resist.
• DRM on creative works takes away the user's ownership over the works that they "bought", allowing the publisher to do a rugpull at any moment and to take away the user's "purchases" without returning them their money.
• Copyright and especially DRM make it much harder to preserve works for future generations, which corporations aren't interested in doing themselves since it's not profitable, leading to more lost media.

A reasonable conclusion many people draw from this is "maybe we should get rid of intellectual property laws?" My opinion on this is, well, complicated. In order to understand it better, let's remind ourselves what caused the implementation to suck in the first place.

There are 3 main reasons why intellectual property is in the state that it is right now:

Consolidation

Most important intellectual property is owned by a few extremely large, extremely wealthy, and extremely influential corporations that own unimaginable numbers of assets. The operating systems most people use are owned by Google, Microsoft, and Apple. Most of the music is owned by Sony, Universal, and Warner Bros. Most of the movies are owned by Disney, Paramount, and the same 3 that own most of the music.

Incentives

Large corporations in the form they exist today are de facto monarchies which have one goal — make as much money as humanly possible, spend as little as possible, give as much of the earned money to the CEO and as little to tax agencies. This gives them a direct financial incentive to do things like:

• Make their employees work as much as possible in order to maximize the output
• Pay their employees as little as possible, since salaries are a major source of expenditure
• Prevent their employees from unionizing in order to establish a firm top-to-bottom chain of command and eliminate as much responsibility as possible from the upper layers
• Own the tools (e.g. software) and the output (e.g. creative works) of their employees in order to make them as interchangeable as possible so they can always hire new ones if the current ones are unsatisfied with the corporate decisions
• Continue owning as many intellectual property assets as possible in order to remain being hard to replace and near impossible to effectively boycott
• Continue getting royalties from their intellectual property for as long as possible in order to make money without doing anything
• Continue not letting their users truly own copies of their employees' works in order to extract as much money as possible from the former by making them pay more than once
• Use their wealth and influence to align the law with their incentives, making their business easier
• If the law doesn't want to align in a specific country, make a compromise there but keep doing the same as before in the countries where it does align
• If the law is a huge inconvenience, break it in secret, burn the evidence, and don't get caught
• When get caught, buy their way out of it

Of course, not all of these things happen all of the time because opposing forces exist. Once they weaken, however, cracks start to show.

Litigative power

For you as an individual who isn't a billionaire, it's pretty much impossible to win a case against a large corporation. They have orders of magnitude more money than you, they don't have to worry about burning out because they have armies of lawyers, and they don't have to worry about losing everything and having their life ruined because the greatest damage you can do to them is negligible.

If you try, you'll either settle out of court or get buried in paperwork, as they'll do their best to stretch the litigation for as long as possible. That is if you can even sue them in the first place — many companies nowadays include a binding arbitration clause in their terms of service, making you settle out of court by default. If a corporation wants you to lose, you lose.

You see where this is going, right? Removal of intellectual property laws isn't enough on its own, as it doesn't directly address any of the above. The incentive to extract maximum money from appropriated works remains, and so do most of the tools large corporations have at their disposal.

So my argument is: If you get rid of the bad laws but keep the incentives, the system will eventually adapt and perpetuate the bad practices by whatever means necessary. All you'd be doing is shuffling cards around, trading an explicit law for an implicit one.

In order to drive the point home, I'd like to present a hypothetical nightmare scenario of what'd happen if all you did was get rid of intellectual property laws and highlight just how disastrous the consequences would be.

United States, early future — In an unprecedented act of unanimous support by both parties, a law has passed that'll soon eliminate all forms of intellectual property in the US, and it'll come in effect in only a few short months. Allied countries are considering such a law as well.

Fearing huge losses in profits, major hardware manufacturers, software producers, and art publishers swiftly form an alliance. The alliance has a single job — figure out how to keep money going. After struggling to coordinate for a couple months, they unearth a goldmine of a solution, just in time before the law takes effect.

Since they can't rely on the government to enforce intellectual property anymore, they resort to the only lever they have left to pull — their terms of service. The members agree to only share their IP with other members. In order to become a member, one must agree to terminate their service for any user found to be in violation of a member's IP. If a user crosses the line, all the members terminate their service with them. If a member refuses to comply, they lose membership.

In order to make such enforcement feasible, considerable effort is poured into hardware-level DRM. Since breaking DRM is now legal, it gets implemented at the lowest level, where it's near impossible to crack, and starts being used for everything, even the tiniest text files. Since patents are no longer a thing, every invention becomes a trade secret, never shared with anyone but a select few people. Any attempt at reverse engineering becomes a violation.

People are reasonably outraged. As a compromise, the duration of "copyright" is shortened to a more reasonable value — 50 years after the work's first publication. Old movies become public domain, and people rejoice. The alliance is here to stay.

Time passes. More countries adopt similar laws. More companies join the alliance.

More time passes. As most people have already got used to the new order, the duration of "copyright" slowly gets raised back up.

Even more time passes.

The year is now 2060. You're a 40 year old Gen Alpha salary man, one of the lucky few who has a job that pays a livable salary. You have a big extended family, and your Millennial grandma is on life support.

"Copyright" is now perpetual. All of the knowledge in the world is either secret or behind a paywall. If you're one of the few remaining artists, you pay more in royalties than your parents did, as AI systems scan your works for every potential influence. Writing about historical events? You better pay a cut to history textbook publishers.

You visit your long gone great grandparents' old house. The attic has many of their antique belongings, including a cartridge with a video game for an almost 80 year old console. A game that can't be bought anymore due to the licensing issues that occurred before you were even born. You bring that cartridge home, dump it, and decide to play it in an emulator.

The moment you hit play, the company that inherited the rights to the video game discovers your actions. You lose all of your accounts, lose your job, and they pull the plug on your grandma's life support. Your grandma is dead, and you're next.

Will this actually happen? Probably not. But I hope it illustrates my point — you need to address the reasons why intellectual property is bad first and foremost. This implies stopping companies from being irreplaceable monstrosities, putting their ownership and control in the hands of their employees, and making it realistic to go court against them. Removing intellectual property laws is secondary.

The idea of AI systems scanning your works for influences was suggested by Juniper Stone on Discord while we were discussing this topic.

A major reason why this is possible is Hugo's template engine of choice — Go templates. They let you simply hook up a bunch of structures and functions to it and make Go's runtime reflection magic handle the rest. In no uncertain terms, they turn Go, a compiled language with a rich package ecosystem, into a scripting language — all you need to do is expose the things you want to the user. As a basic concept, this is groundbreaking, and Hugo takes full advantage of it, giving you nice stuff like image processing capabilities, filesystem traversal capabilities, the ability to read image Exif metadata.

Unfortunately, Go templates are also full of design flaws and missed opportunities that hold it back from its true potential, which I slowly discovered while using Hugo for my websites over the course of the past few years. Here they are, roughly in the order of egregiousness:

{{/* Throws no error, prints false. */}}
{{ eq 0 0.0 }}

Now, I know how bad this looks at first glance — it truly feels like Go's authors are trolling you. Especially if your first glance at this issue is after hours of debugging why your if statement fails to catch if a variable is equal to 0, like what happened to me. But hold on with me for a moment, there's actually a technical reason for it. Sort of.

Go is a strongly typed programming language, meaning that if you try to perform an arithmetic operation on 2 different types or pass one type where another one is expected, it'll scream at you instead of coercing your value to the right type. When it comes to numbers, it's even stronger than other strongly typed languages like Python, and it won't coerce an integer to a float. Take the following code, for instance:

a := 0
b := 0.0

fmt.Println(a == b)

If you tried to compile it, Go would notice that the variable a is an integer and the variable b is a float, and rightfully tell you that you can't do it:

invalid operation: a == b (mismatched types int and float64)

Go templates inherit this property of being strongly typed. Unlike Go, however, which is statically typed, Go templates are dynamically typed, meaning that the same variable can be reassigned to a value of a different type, which makes sense for a tiny template language. As such, instead of reporting an error, like a strong static language would, or coercing the values, like a weak language would, it silently returns a false because the types don't match.

Except it's not quite that simple. Go does, in fact, coerce the values, but only if both operands are literals, not variable identifiers:

// Prints true
fmt.Println(0 == 0.0)

Go templates, on the other hand, don't perform coercion even in this case and always treat the operands like Go would treat variable identifiers, leading to complete chaos where Go templates' behavior doesn't match Go's behavior.

This is another case where Go templates do what Go does but in an inconvenient way. As far as variables go in Go (pun intended), it's about as follows:

• Variables can be declared with var identifier = value. There's also syntactic sugar for this — identifier := value — and since it saves you 3 whole key presses, everyone is using it instead.
• You can assign a new value to the variable with identifier = value.
• Variables are block scoped, meaning that if you enter a block like the body of an if statement, you can declare a variable with the same identifier as another variable without affecting the latter in any way because your variable will only ever stay within that block.

On its own, := used for variable declaration and = used for variable assignment sounds like a bad idea — it'd be really easy to mix up the two of them and end declaring a new scoped variable instead of assigning to an existing one, and you wouldn't use the var identifier = value syntax out of the need to conform to the agreed upon code style.

But fear not! Go has us covered here. If you do mess up, you'll most likely create a variable that's declared and then never used, which Go will scream at you about and not let you compile your project:

declared and not used: identifier

What do Go templates do in this case? Nothing:

{{ $meal := .PotatoChips }}

{{ if $isBeforeMidnight }}
    {{/* Throws no error. */}}
    {{ $meal := .BuyFood "healthy" }}
{{ end }}

{{/* Always .PotatoChips */}}
{{ $meal }}

And you can't even use the var identifier = value syntax here because it doesn't exist in Go templates.

This one is self-explanatory: In Go templates, nil exists as a keyword but doesn't exist as a literal. You can compare values to nil but can't assign a variable to it without resorting to hacks:

{{ $dict := dict }}
{{ $nil := index $dict "non-existent key" }}

{{/* Prints <nil>. */}}
{{ print $nil }}

{{/* Prints <nil>. */}}
{{ if eq $nil nil }}
    {{ print $nil }}
{{ end }}

{{/* Throws an error. */}}
{{ $notNil := nil }}

To be completely fair, the practical impact of this is negligible — it's at most a nuisance that you can't set a variable to an undefined value in the few cases where you need it. But from a language design standpoint, this is extremely cursed. An unrepresentable primitive is not a thing you see often in other languages.

Let's say you want to have a variable that has 1 of 2 possible values, picked depending on whether a certain condition is satisfied. In Hugo, you can do it like this:

{{ $meal := cond $isBeforeMidnight
    (.BuyFood "healthy")
    .Fridge.Contents.Extract
}}

There are 2 problems with this: First, you can only do it in Hugo. cond is not a thing in Go templates by default. Second, there's a bug in this code. Since Hugo couldn't add a new keyword to the language, they had to make cond a function. And since functions don't do short circuit evaluation like, say, an and keyword, cond will evaluate both possible values regardless of the condition, leading to hard to diagnose side effects.

There's only one way to work around this — use an if statement:

{{/* No nil, baby! */}}
{{ $meal := false }}

{{ if $isBeforeMidnight }}
    {{ $meal = .BuyFood "healthy" }}
{{ else }}
    {{ $meal = .Fridge.Contents.Extract }}
{{ end }}

The difference in the number of braces speaks for itself.

Go templates have a nifty feature that lets you chain function calls without having to wrap everything in a million parentheses or making a variable for every intermediate value:

{{ $meal := $potatoes | boil | mash | stickIn $stew }}

Is syntactic sugar for:

{{ $meal := stickIn $stew (mash (boil $potatoes)) }}

You may already see a problem with this: It always passes the value as the last argument to the function. Let's say that it turns out the function stickIn accepts the arguments in the opposite order. Now you have to change the code above to:

{{ $meal := stickIn ($potatoes | mash | boil) $stew }}

And if you then want to call a method on the resulting value, it gets even worse:

{{ $meal := (stickIn ($potatoes | mash | boil) $stew).Serve }}

Compare this to the ES proposal for pipes in JavaScript that uses placeholders for argument placement instead:

const meal = potatoes
    |> mash(%)
    |> boil(%)
    |> stickIn(%, stew)
    |> %.serve();

Much better. This is how pipes should be done, if you ask me.

Go templates let you define and call inline templates in your code, and I can't overstate how awesome this is. For example, if your template host provides you with some rudimentary reflection capabilities, which Hugo does, you can use it to print lists with recursion:

{{ define "print-slice" }}
    [

    {{ range . }}
        {{ if reflect.IsSlice . }}
            {{ template "print-slice" . }}
        {{ else }}
            {{ . }}
        {{ end }}
    {{ end }}

    ]
{{ end }}

{{ template "print-slice" (slice 9 8 7 (slice 7 6 5) 4 32 true) }}

But unfortunately, printing is the only way you can output values in vanilla Go templates. Hugo does have a workaround for this — inline partials — but it's not without its flaws. Let's say you want to make a function that calculates the factorial of a number:

{{ define "partials/factorial" }}
    {{ return (math.Product (seq 1 .)) }}
{{ end }}

{{ partial "factorial" 5 }}

This works correctly but only for positive values because seq will start iterating backwards for negative values. If you try to fix it the naive way:

{{ if gt . 1 }}
    {{ return (math.Product (seq 1 .)) }}
{{ else }}
    {{ return 1 }}
{{ end }}

You'll get an inscrutable error like this:

execute of template failed at <return>: wrong number of args for return: want 0 got 1

Because it doesn't work for the same reason cond can't short circuit evaluate its arguments — return is just a function. Since it's not a keyword, it can't preemptively stop the execution of a function. All it can do is set a value somewhere and tell Hugo to later put it in the right place. So instead, you have to do this:

{{ $result := 1 }}

{{ if gt . 0 }}
    {{ $result = math.Product (seq 1 .) }}
{{ end }}

{{ return $result }}

Go templates were this close to having user definable functions, but they didn't add a return keyword. What a shame.

If you're writing a new template engine, it'd be really cool if you added the things Go templates do right without adding the things they do wrong. Just sayin'.

• InterestGroupBiddingAndScoringScriptRunnerGlobalScope
• WEBGL_multi_draw_instanced_base_vertex_base_instance

• WEBGL_draw_instanced_base_vertex_base_instance
• RunFunctionForSharedStorageSelectURLOperation
• InterestGroupReportingScriptRunnerGlobalScope
• WindowControlsOverlayGeometryChangeEventInit
• InterestGroupBiddingScriptRunnerGlobalScope
• InterestGroupScoringScriptRunnerGlobalScope
• ContentVisibilityAutoStateChangeEventInit
• TopLevelStorageAccessPermissionDescriptor
• ProtectedAudiencePrivateAggregationConfig
• AuthenticationExtensionsClientOutputsJSON
• PresentationConnectionAvailableEventInit
• PrivateNetworkAccessPermissionDescriptor
• AuthenticationExtensionsClientInputsJSON
• AuthenticationExtensionsLargeBlobOutputs
• WindowControlsOverlayGeometryChangeEvent

• SecurityPolicyViolationEventDisposition
• IdentityCredentialRequestOptionsContext
• MediaCapabilitiesKeySystemConfiguration
• SanitizerElementNamespaceWithAttributes
• AuthenticationExtensionsLargeBlobInputs
• MLQuantizeDequantizeLinearSupportLimits
• WEBGL_blend_equation_advanced_coherent
• OrientationSensorLocalCoordinateSystem
• SharedStorageRunOperationMethodOptions
• PublicKeyCredentialCreationOptionsJSON
• XRSessionSupportedPermissionDescriptor
• ContentVisibilityAutoStateChangeEvent
• AuthenticationExtensionsClientOutputs
• NavigationCurrentEntryChangeEventInit
• PrivateAttributionAggregationServices
• SecurePaymentConfirmationAvailability
• AuthenticationExtensionsPaymentInputs
• SharedStoragePrivateAggregationConfig
• HTMLSharedStorageWritableElementUtils
• PublicKeyCredentialClientCapabilities
• PublicKeyCredentialRequestOptionsJSON
• IdentityCredentialRequestOptionsMode
• AuthenticationExtensionsClientInputs
• FileSystemHandlePermissionDescriptor
• SVGFilterPrimitiveStandardAttributes
• MockCapturePromptResultConfiguration
• PermissionsPolicyViolationReportBody
• PrivateAttributionAggregationService
• PresentationConnectionAvailableEvent
• PresentationConnectionCloseEventInit
• CollectedClientAdditionalPaymentData
• InterestGroupScriptRunnerGlobalScope
• AuthenticatorAttestationResponseJSON
• MLConvTranspose2dFilterOperandLayout
• IdentityCredentialDisconnectOptions
• SVGComponentTransferFunctionElement
• ImageBitmapRenderingContextSettings
• NavigationUpdateCurrentEntryOptions
• PerformanceLongAnimationFrameTiming
• PrivateAttributionImpressionOptions
• PrivateAttributionConversionOptions
• ReadableStreamBYOBReaderReadOptions
• BluetoothLEScanPermissionDescriptor
• BluetoothManufacturerDataFilterInit
• GPURenderPassDepthStencilAttachment
• WEBGL_compressed_texture_s3tc_srgb
• AccelerometerLocalCoordinateSystem
• AttributionReportingRequestOptions
• PerformanceObserverCallbackOptions
• PrivateAttributionConversionResult
• RemotePlaybackAvailabilityCallback
• SharedStorageModifierMethodOptions
• MediaStreamTrackAudioSourceOptions
• AuthenticatorAssertionResponseJSON
• PublicKeyCredentialCreationOptions
• AuthenticationExtensionsPRFOutputs
• RTCPeerConnectionIceErrorEventInit
• XRTransientInputHitTestOptionsInit
• FederatedCredentialRequestOptions
• DocumentPictureInPictureEventInit
• OffscreenCanvasRenderingContext2D
• NavigationCurrentEntryChangeEvent
• OnBeforeUnloadEventHandlerNonNull
• MagnetometerLocalCoordinateSystem
• DeviceMotionEventAccelerationInit
• DeviceMotionEventRotationRateInit
• PresentationConnectionCloseReason
• AuctionReportBuyerDebugModeConfig
• BluetoothRemoteGATTCharacteristic
• BluetoothCharacteristicProperties
• PublicKeyCredentialUserEntityJSON
• PublicKeyCredentialDescriptorJSON
• PublicKeyCredentialRequestOptions
• AuthenticationExtensionsPRFValues
• AuthenticationExtensionsPRFInputs
• MLBatchNormalizationSupportLimits
• SecurityPolicyViolationEventInit
• IdentityCredentialRequestOptions
• HandwritingRecognizerQueryResult
• CanvasRenderingContext2DSettings
• CameraDevicePermissionDescriptor
• PresentationConnectionCloseEvent
• SecurePaymentConfirmationRequest
• TransformStreamDefaultController
• DirectFromSellerSignalsForSeller
• AudioWorkletProcessorConstructor
• AuthenticatorAttestationResponse
• VideoEncoderEncodeOptionsForHevc
• GPURenderBundleEncoderDescriptor
• WebTransportDatagramDuplexStream
• EXT_disjoint_timer_query_webgl2
• ExtendableCookieChangeEventInit
• PaintRenderingContext2DSettings
• DigitalCredentialRequestOptions
• DocumentPictureInPictureOptions
• FileSystemCreateWritableOptions
• ObservableInspectorAbortHandler
• PushSubscriptionChangeEventInit
• SharedStorageWorkletGlobalScope
• SpeechRecognitionErrorEventInit
• ReadableStreamDefaultController
• WritableStreamDefaultController
• PAExtendedHistogramContribution
• DirectFromSellerSignalsForBuyer
• BluetoothManufacturerDataFilter
• BluetoothLEScanPermissionResult
• OfflineAudioCompletionEventInit
• MediaStreamAudioDestinationNode
• MediaStreamTrackAudioSourceNode
• AttestationConveyancePreference
• VideoEncoderEncodeOptionsForAv1
• VideoEncoderEncodeOptionsForAvc
• VideoEncoderEncodeOptionsForVp9
• EncodedAudioChunkOutputCallback
• EncodedVideoChunkOutputCallback
• WebGL2RenderingContextOverloads
• GPUExternalTextureBindingLayout
• RTCRemoteOutboundRtpStreamStats
• RTCRtpHeaderExtensionParameters
• RTCRtpHeaderExtensionCapability
• WebTransportBidirectionalStream
• USBIsochronousOutTransferPacket
• USBIsochronousOutTransferResult
• EXT_texture_filter_anisotropic
• SVGAnimatedPreserveAspectRatio
• WEBGL_compressed_texture_pvrtc
• HTMLAttributionSrcElementUtils
• CredentialMediationRequirement
• SpatialNavigationSearchOptions
• CharacterBoundsUpdateEventInit
• BrowserCaptureMediaStreamTrack
• IdentityProviderRequestOptions
• IdentityProviderClientMetadata
• FileSystemPermissionDescriptor
• GyroscopeLocalCoordinateSystem
• MediaTrackSupportedConstraints
• MockCaptureDeviceConfiguration
• NotificationPermissionCallback
• ObservableSubscriptionCallback
• ObservableEventListenerOptions
• SanitizerElementWithAttributes
• SurfaceSwitchingPreferenceEnum
• ReadableStreamGetReaderOptions
• UnderlyingSourceCancelCallback
• AuctionRealTimeReportingConfig
• BluetoothServiceDataFilterInit
• AudioContextRenderSizeCategory
• MediaElementAudioSourceOptions
• AuthenticatorAssertionResponse
• AuthenticatorSelectionCriteria
• NavigatorAutomationInformation
• WebGLRenderingContextOverloads
• GPUStorageTextureBindingLayout
• GPUShaderModuleCompilationHint
• GPUCopyExternalImageSourceInfo
• MLInstanceNormalizationOptions
• RTCIdentityProviderGlobalScope
• RTCRemoteInboundRtpStreamStats
• RTCPeerConnectionErrorCallback
• RTCLocalSessionDescriptionInit
• RTCPeerConnectionIceErrorEvent
• WebTransportReceiveStreamStats
• USBIsochronousInTransferPacket
• USBIsochronousInTransferResult

• OES_texture_half_float_linear
• WEBGL_compressed_texture_astc
• WEBGL_compressed_texture_etc1
• WEBGL_compressed_texture_s3tc
• ClipboardPermissionDescriptor
• CaretPositionFromPointOptions
• DocumentPictureInPictureEvent
• MediaKeySystemMediaCapability
• SVGFEComponentTransferElement
• FileSystemGetDirectoryOptions
• IntersectionObserverEntryInit
• MediaCapabilitiesDecodingInfo
• MediaCapabilitiesEncodingInfo
• CanvasCaptureMediaStreamTrack
• MediaStreamTrackProcessorInit
• DeviceMotionEventAcceleration
• DeviceMotionEventRotationRate
• PaymentRequestUpdateEventInit
• SharedStorageSetMethodOptions
• SharedStorageWorkletNavigator
• SpeechSynthesisErrorEventInit
• ReadableStreamIteratorOptions
• UnderlyingSourceStartCallback
• WebAssemblyInstantiatedSource
• BluetoothPermissionDescriptor
• BluetoothAdvertisingEventInit
• BluetoothRemoteGATTDescriptor
• MediaStreamAudioSourceOptions
• AllAcceptedCredentialsOptions
• PublicKeyCredentialParameters
• PublicKeyCredentialUserEntity
• PublicKeyCredentialDescriptor
• GPUComputePassTimestampWrites
• SFrameTransformErrorEventType
• SFrameTransformErrorEventInit
• RTCStatsIceCandidatePairState
• RTCSessionDescriptionCallback
• RTCIceServerTransportProtocol
• RTCPeerConnectionIceEventInit
• WebTransportDatagramsWritable
• WebTransportCongestionControl
• WebTransportSendStreamOptions
• XRTransientInputHitTestSource
• XRTransientInputHitTestResult
• XRInputSourcesChangeEventInit
• SecurityPolicyViolationEvent
• EXT_texture_compression_bptc
• EXT_texture_compression_rgtc
• WEBGL_compressed_texture_etc
• BackgroundFetchFailureReason
• BackgroundFetchUpdateUIEvent
• ScriptingPolicyViolationType
• ViewTransitionUpdateCallback
• SVGFESpecularLightingElement
• FileSystemWritableFileStream
• IntersectionObserverCallback
• ConstrainDOMStringParameters
• PaymentMethodChangeEventInit
• PerformanceObserverEntryList
• GenerateTestReportParameters
• SharedStorageUrlWithMetadata
• SpeechRecognitionAlternative
• UnderlyingSourcePullCallback
• ReadableByteStreamController
• TransformerTransformCallback
• BluetoothManufacturerDataMap
• BluetoothDeviceEventHandlers
• VideoTransferCharacteristics
• GPUExternalTextureDescriptor
• GPUBindGroupLayoutDescriptor
• GPUComputePipelineDescriptor
• GPUCopyExternalImageDestInfo
• GPURenderPassTimestampWrites
• GPURenderPassColorAttachment
• MLRecurrentNetworkActivation
• MLNormalizationSupportLimits
• RTCEncodedVideoFrameMetadata
• RTCEncodedAudioFrameMetadata
• RTCIdentityProviderRegistrar
• USBControlTransferParameters
• EXT_color_buffer_half_float
• KHR_parallel_shader_compile
• BackgroundFetchRegistration
• ClipboardUnsanitizedFormats
• ExtendableCookieChangeEvent
• AnimationWorkletGlobalScope
• AnimatorInstanceConstructor
• IntrinsicSizesResultOptions
• TextEncoderEncodeIntoResult
• MediaKeySystemConfiguration
• MediaKeySessionClosedReason
• IdentityProviderAccountList
• SVGFEDiffuseLightingElement
• SVGFEDisplacementMapElement
• HandwritingHintsQueryResult
• ImageBitmapRenderingContext
• OffscreenRenderingContextId
• NavigatorConcurrentHardware
• InputDeviceCapabilitiesInit
• KeySystemTrackConfiguration
• MockMicrophoneConfiguration
• PerformanceNavigationTiming
• NavigatorNetworkInformation
• PaymentRequestDetailsUpdate
• PerformanceObserverCallback
• PresentationConnectionState
• PushSubscriptionOptionsInit
• PushSubscriptionChangeEvent
• SanitizerAttributeNamespace
• TaskPriorityChangeEventInit
• PaymentCredentialInstrument
• ServiceWorkerUpdateViaCache
• SharedStorageModifierMethod
• SharedStorageWorkletOptions
• SpeechRecognitionErrorEvent
• SpeechRecognitionResultList
• SpeechRecognitionPhraseList
• ReadableStreamGenericReader
• ReadableStreamDefaultReader
• UnderlyingSinkStartCallback
• UnderlyingSinkWriteCallback
• UnderlyingSinkCloseCallback
• UnderlyingSinkAbortCallback
• WritableStreamDefaultWriter
• IterationCompositeOperation
• BasePropertyIndexedKeyframe
• CharacteristicEventHandlers
• BluetoothCharacteristicUUID
• OTPCredentialRequestOptions
• AudioContextLatencyCategory
• OfflineAudioCompletionEvent
• MediaElementAudioSourceNode
• AudioWorkletProcessCallback
• PublicKeyCredentialRpEntity
• UserVerificationRequirement
• GPUPipelineLayoutDescriptor
• GPURenderPipelineDescriptor
• GPUCommandEncoderDescriptor
• GPUUncapturedErrorEventInit
• MLBatchNormalizationOptions
• MLConv2dFilterOperandLayout
• MLRecurrentNetworkDirection
• MLLayerNormalizationOptions
• RTCEncodedVideoFrameOptions
• RTCEncodedAudioFrameOptions
• RTCIdentityValidationResult
• RTCRtpSynchronizationSource
• WebTransportReliabilityMode
• WebTransportConnectionStats
• WebTransportSendStreamStats
• SummarizerCreateCoreOptions
• AccelerometerSensorOptions
• HighlightsFromPointOptions
• SpatialNavigationDirection
• StartViewTransitionOptions
• CharacterBoundsUpdateEvent
• SVGFEConvolveMatrixElement
• FileSystemReadWriteOptions
• FileSystemSyncAccessHandle
• HandwritingModelConstraint
• HandwritingRecognitionType
• HTMLFormControlsCollection
• NavigationInterceptOptions
• NavigationInterceptHandler
• OnErrorEventHandlerNonNull
• OnBeforeUnloadEventHandler
• StructuredSerializeOptions
• DedicatedWorkerGlobalScope
• ConstrainPoint2DParameters
• DelegatedInkTrailPresenter
• MediaDecodingConfiguration
• MediaEncodingConfiguration
• ConstrainBooleanParameters
• DeviceOrientationEventInit
• MemoryAttributionContainer
• PrivateAttributionProtocol
• PresentationConnectionList
• NetworkInformationSaveData
• CollectedClientPaymentData
• ExtendableMessageEventInit
• SpeechRecognitionErrorCode
• SpeechRecognitionEventInit
• SVGAnimateTransformElement
• AuctionAdInterestGroupSize
• ProtectedAudienceUtilities
• ReportResultBrowserSignals
• VideoFrameCallbackMetadata
• AnimationPlaybackEventInit
• BluetoothServiceDataFilter
• BluetoothPermissionStorage
• WatchAdvertisementsOptions
• BluetoothRemoteGATTService
• OTPCredentialTransportType
• OfflineAudioContextOptions
• MediaStreamAudioSourceNode
• AuthenticationResponseJSON
• CredentialPropertiesOutput
• WebGLShaderPrecisionFormat
• WebGL2RenderingContextBase
• GPUCopyExternalImageSource
• GPUCommandBufferDescriptor
• MLSingleInputSupportLimits
• RTCIdentityAssertionResult
• RTCIdentityProviderDetails
• RTCIdentityProviderOptions
• RTCQualityLimitationReason
• RTCRtpTransceiverDirection
• RTCDTMFToneChangeEventInit
• SummarizerSummarizeOptions
• XMLHttpRequestResponseType
• IDBVersionChangeEventInit
• WindowOrWorkerGlobalScope
• WebGLVertexArrayObjectOES
• SVGTextPositioningElement
• WEBGL_debug_renderer_info
• ServiceWorkerRegistration
• CredentialCreationOptions
• ScriptingPolicyReportBody
• CSSPositionTryDescriptors
• CSSVariableReferenceValue
• CSSMatrixComponentOptions
• TextFormatUpdateEventInit
• FileSystemDirectoryReader
• FileSystemEntriesCallback
• IdentityProviderWellKnown
• IdentityProviderAPIConfig
• IdentityAssertionResponse
• FenceReportingDestination
• FileSystemDirectoryHandle
• HandwritingDrawingSegment
• HTMLHyperlinkElementUtils
• OffscreenRenderingContext
• NavigationNavigateOptions
• NavigationHistoryBehavior
• PromiseRejectionEventInit
• IntersectionObserverEntry
• PerformanceLongTaskTiming
• MagnetometerSensorOptions
• MediaStreamTrackEventInit
• MediaStreamTrackProcessor
• MediaSessionPlaybackState
• MediaSessionActionHandler
• MediaSessionActionDetails
• AbsoluteOrientationSensor
• RelativeOrientationSensor
• PaymentRequestUpdateEvent
• PictureInPictureEventInit
• ReportingObserverCallback
• PerformanceResourceTiming
• SanitizerElementNamespace
• SchedulerPostTaskCallback
• CaptureStartFocusBehavior
• SelfCapturePreferenceEnum
• SystemAudioPreferenceEnum
• DisplayMediaStreamOptions
• DisplayCaptureSurfaceType
• SharedStorageAppendMethod
• SharedStorageDeleteMethod
• SpeechSynthesisErrorEvent
• ReadableStreamBYOBRequest
• TransformerCancelCallback
• ByteLengthQueuingStrategy
• AuctionAdInterestGroupKey
• AuctionReportBuyersConfig
• URLPatternComponentResult
• PerformanceMeasureOptions
• VideoFrameRequestCallback
• BluetoothLEScanFilterInit
• BluetoothPermissionResult
• BluetoothAdvertisingEvent
• BluetoothRemoteGATTServer
• DynamicsCompressorOptions
• CurrentUserDetailsOptions
• PublicKeyCredentialEntity
• VideoEncoderEncodeOptions
• EncodedAudioChunkMetadata
• EncodedVideoChunkMetadata
• WebGLRenderingContextBase
• GPUShaderModuleDescriptor
• GPUCompilationMessageType
• GPUPipelineDescriptorBase
• GPURenderBundleDescriptor
• MLLogicalNotSupportLimits
• SFrameTransformErrorEvent
• GenerateAssertionCallback
• ValidateAssertionCallback
• RTCReceivedRtpStreamStats
• RTCOutboundRtpStreamStats
• RTCSessionDescriptionInit
• RTCPeerConnectionIceEvent
• WebTransportDatagramStats
• WebTransportReceiveStream
• XRInputSourcesChangeEvent
• XRReferenceSpaceEventInit
• RewriterCreateCoreOptions
• XMLHttpRequestEventTarget

Use the following Node script. It uses the WebIDL definitions from every Web standard to do its job. And yes, I am as surprised as you that they not only have a JavaScript API for this, but it's also all in one place and easy to use.

import idl from "@webref/idl";

const specs = await idl.parseAll();
const asts = Object.values(specs);
const definitions = asts.flat();

const allNames = definitions
    .map(definition => definition.name)
    .filter(name => name != undefined);

const uniqueNames = Array.from(new Set(allNames))
    .toSorted((a, b) => b.length - a.length);

const THRESHOLD = 25;
const longNames = uniqueNames.filter(name => name.length >= THRESHOLD);

const byCharacters = name => Math.floor(name.length / 10) * 10;
const namesByCharacters =
    Object.entries(Object.groupBy(longNames, byCharacters))
    .map(entry => ({characters: entry[0], names: entry[1]}))
    .toSorted((a, b) => b.characters - a.characters);

for (const group of namesByCharacters) {
    const characters = group == namesByCharacters.at(-1)
        ? THRESHOLD
        : group.characters;

    console.log(`### ${characters}+ characters\n`);

    for (const name of group.names) {
        console.log(`* \`${name}\``);
    }

    console.log();
}

One of these codes is RS (= Serbia). Either by a sheer coincidence or someone playing 5D chess, .rs is also the file extension for the Rust programming language, which is why the domain name of every other Rust project now belongs to Serbia. This made me curious about other cases like this, so here's an incomplete list of programming languages, domain-specific languages, markup languages, etc which file extensions match a country code. If you think something is missing, let me know!

Sometimes, it isn't on the Internet:

• Because your question is so hard, that science doesn't yet have a good answer to it.
• Because you're looking for something so specific and inconsequential, that no one's simply bothered to deal with it yet.
• Because you're looking for something that shouldn't exist, guided by a fundamental misunderstanding in your research.
• Because whoever made it lived a long time ago, and their work didn't survive.
• Because no one preserved it while it was on the Internet.
• Because whoever made it isn't on the Internet. Yes, such people still exist.
• Because whoever made it thought it was too trivial to share.
• Because it's only somewhere in a book no one's put on the Internet yet.
• Because something close to it is. Too bad it isn't a perfect substitute.

Or sometimes, it is on the Internet:

• But only in someone's private archive.
• But not indexed by search engines at all.
• But will soon no longer be because whoever is responsible stopped caring.
• But impossible to find due to being drowned by endless amounts of SEO slop.
• But behind a paywall you can't climb over.
• But not in your country.
• But unusable on your hardware/software.
• But doesn't accommodate your disability.
• But not in a form you understand.
• But it fucking sucks.
• But not all in one place.

And sometimes, you have a genuine original thought.

Don't let the notion of the Internet being a vast sea with everything in it stop you from sharing — it's not even true.

• A wide range of people telling me that I "act weird".
• Struggling with expressing my thoughts, especially when not given an opportunity to write everything down in advance.
• Taking a long time to adapt to a new group of people.
• Being scared shitless of interacting with people for the first time, even if it's something inconsequential like posting online.
• Revealing too many details about my private life after I've adapted.
• Struggling with eye contact.

• Getting upset to the point of a mental breakdown when suddenly reminded of a currently worrying topic.
• Recalling negative events related to that topic and getting angry that I let them happen.
• Punching myself, usually in the thighs, sometimes causing bruises, to stop myself from recalling them.

• Punishing myself for merely thinking of something bad, like performing an act of extreme violence, "because if I don't make it stop, it'll get worse" or "because I'm not a bad person, and I need to prove it to myself".
• Blowing a minor setback, like a health issue, out of proportion "because what if it's more serious than it looks" and thinking through every unrealistic way it could result in my slow and painful death.
• Punishing myself for doing nothing about that setback "because I'm responsible for it, so I have to do something" when there's nothing that can be done about it anymore.
• Punishing myself for doing something which makes sense right now but which would probably look awkward if someone else was around "because what if someone notices it somehow" when there's no good reason to suspect that.

• Complete lack of motivation by things that I'm not currently obsessed over, even when they're crucial for survival.
• Getting stuck and not being able to think of what to do when finally trying to start doing something.
• Spending too much time trying to come up with all possible failure options "because what if I haven't thought it through well enough, and I'm gonna make another stupid mistake that can be prevented right now".
• Spending too much time trying to find out whether I should be doing tasks in this specific order "because what if I'm wasting my time when I could be doing something more important first".

• Not doing difficult tasks when I absolutely should, even at the cost of catastrophic failure, "so I don't have to deal with the consequences of fucking up" or "because I'm worthless and I shouldn't bother trying".
• Trying to find any excuse to stop doing the task after having already started "because I'll fuck it up in the end, and it's better to give up now" or "because it's not worth doing anyway".
• Asking for help and making up bullshit excuses to avoid doing anything "because I deserve to suffer" or "because I want to give up".
• Postponing tasks for way too long, regardless of how little effort they require, "because they require doing something".
• Refusing to do anything meaningful when completely bored "because I want to keep wasting time" while still constantly thinking about it.

• (Childhood) Knocking on things a certain number of times "or I'm going to die".
• (Circa 2022) Pretending I don't know something in order to trick people into explaining it to me "to see if they actually know about it" or "to find new information about it without making an awkward question".
• (Semi-ongoing) Trying to suppress invasive thoughts by either ridiculing them or thinking something worse. Makes the thoughts stay for even longer.
• (Semi-ongoing) Repeating my todo list for today in my head over and over "or I'm going to forget to do something again".
• (Semi-ongoing) Purposefully involving myself in arguments with idiots online or imagining arguments with an exaggerated version of them that dodges all attempts at reasoning "because they're wrong and I need to always be ready to debate them".
• (Ongoing) Checking something way more times than necessary, particularly when it's not obvious whether it's true (e.g. "is this photo blurry?"), "so I know it for certain" or "so I'm sure I'm not making it up".
• (Ongoing) Obsessing over whether I really like a certain piece of media and avoiding it "so I don't get tired of it" or purposefully subjecting myself to it more times than necessary "so people don't think I'm a poser". Causes me to develop a negative association with that piece of media, even though I like it, which fucks with my brain.
• (Ongoing) Reading things I'd written to someone over and over "because I did a such good job phrasing them".
• (Very ongoing) Listening to the same song on repeat for hours.
• Random fidgeting, like tapping or beatboxing, that pops out once in a while but which doesn't take so much time as to be harmful.

It isn't about website "structure". No attention will be paid to what a webmaster thinks their website is structured like. Only how a user moves between pages will be considered.

It isn't about in-text hyperlinks. Every website has those — it's the main feature of the Web. My definition of "navigation" will be limited to strictly lists of links that serve no purpose other than guiding the user.

It isn't a prescription on which type you should use in which situation. You can use any. Don't let a random blog post stop you from exploring your creativity.

It isn't about "search engine optimization". If you think SEO is a good thing, knowing full well the extent of the damage it's done to the Web, you should seriously reconsider your life choices.

Now that I pissed off the only people who'd be interested in reading this, let's cut to the chase.

Not in any particular order.

This is the most straightforward type and one of the easiest to implement — it requires little effort as long as you have any template engine. You put a bunch of links to the most important places on every single page, usually in the header, and that's it. If you want to go somewhere less important, you deal with it somehow™, usually by resorting to a different navigation type for a specific section.

Due to being the first thing anyone thinks when hearing the word "navigation", it's hard to give an example of where exactly it's used. Let's just say it's used pretty much everywhere.

In this type, pages represent nodes in a hierarchy. Like with an actual tree, navigation is done by descending to a child or ascending to a parent, except you do it with links and not by scraping your ass against the bark. Descent is implemented as a list of children pages, and ascent can be implemented either as a "go up" link or as breadcrumbs, depending on how much effort you want to put into it.

As you can tell, this is some weird computer sciency shit that doesn't reflect how normal people organize stuff. For this reason, it's vanishingly rare to see it used for an entire website. It's also, however, the perfect way to represent a filesystem on the Web, which is why it's used in many file directories and indices. And this website too for some reason.

As the name suggests (or so I hope), this is a combination of the previous 2 types. There's still a hierarchy, but instead of pages only having links to their neighbors, they have an entire copy of the hierarchy. Since hierarchies take a lot of space, the links are almost always put in a sidebar, or a header but in a collapsed form.

A typical consumer of this type nowadays is documentation websites, which makes sense because it lets you jump between lots of topics while staying organized. Another place you could've encountered it in is many websites from the late 2000s. They specifically used the "collapsed links in the header" variety which fell out of use, likely as it's unusable on smartphones.

You can consider this one a subtype of the comb navigation where the number of important places is 1. The place in question being, of course, the homepage which contains a map of everything there is on the website. Return to the homepage is implemented as a simple "go home" link unless you're applying it to an existing template made for comb navigation, in which case you end up with an ugly header with a single menu item.

Since you don't need a template engine to implement this type, it's used on a lot of personal websites, especially ones hosted on fully static providers like Neocities. It was common in the '90s as well, for the same reason, among people who didn't want to use frames.

This type can be summarized as "no navigation". There are only in-text hyperlinks, no dedicated navigation sections. As such, you don't "navigate" it, you instead either search or open a funny article like 23 skidoo, start clicking on related terms, and then 5 hours later, realize you dug all the way down to flashbulb memory, arche-writing, and pseudo-Kufic in 3 separate tabs.

Most wikis and some note taking/personal knowledge base websites use this type. Completely understandable because trying to force a single hierarchy of any sort onto hundreds or thousands of pages generally doesn't end up well. It's additionally not totally uncommon to see it on indie websites, especially artsy ones.

The most limiting type. The pages are arranged sequentially and shown one at a time, with an action required to progress to the next one. That action can be anything from swiping to pretending to be neurotypical so you can get your minimal wage job from a company that really wants to know your personality type. Most of the time, you can go back to the previous page with another action.

TikTok and similar microvlogging (not to be confused with microblogging) platforms use this type to fuel your addiction to Family Guy clips. It's also the go-to for quizzes and authorization forms, but can you truly call these last 2 examples "navigation"? I don't know.

This one also involves no actual navigation, but this time, due to the thing you're looking for already being right there in your face. The pages, if you can still call them that, are all embedded into a single page and seamlessly scrolled through by the user. Like a literal meat grinder, it keeps on working forever as long as you have the meat. Computers and infinities don't mix though, so "forever" is faked with endless scrolling or good ol' pagination.

Image-oriented social media and microblogging platforms, most notably Reddit and the no longer existent Twitter, (ab)use this type extensively. This is the only example needed here as their sheer mass alone accounts for most of the Web.

Something I missed? Your thoughts are welcome.

Videos and video games aside, the thing that truly sells 4K to me is fonts. This glyph rendering is incredible. No amount of antialiasing or bullshit like subpixel rendering can compare to having 4 times as many pixels. Considering I can't tell those pixels apart, this resolution is comparable to printed books for me — something people in the '80s could only dream of when they conceived the idea of WYSIWYG. Needless to say, I'm not going back.

My legs have been cursed with thick and dense hair that's impossible to shave. You can try, but it regrows in a matter of literal hours, turning into an irritated bloody mess in the process. I've always suspected that an epilator could fix this, and guess what, I was right. It absolutely did — it takes the hair a couple weeks, not hours, to regrow now, and even then it's not as thick.

If you're thinking about buying yourself one, here are some tips: First of all, yes it is painful, but it gets less painful when hair is not as dense. Unless you wait, like, a month for it to regrow completely, your second time won't be nearly as painful. For your first time, the trick is to go slowly, as slow as you can, and put up with the unbearable pain. It may take forever, but going one row of hairs at a time is better than experiencing pain that's even less bearable.

I hate wearing gloves. They limit my fine motor skills, so I have to either constantly take them off or suffer each time I want to take my keys or money out of the pocket. They also don't work with touchscreens, and I know I'm not supposed to use my phone while walking, especially when it's cold outside, but fuck you, I'm gonna do it anyway.

My hands hate the cold. Every time the temperature drops below, like, 10°C, they turn into a red dry desert that only spreads farther and gets drier and redder the more I go outside. When it gets real bad, they start bleeding. The problem doesn't completely go away until it's warm outside again, no matter how much moisturizer I use.

Did I, at some point, consider these facts, accept that wearing gloves is a necessity for survival, and go on with my life? No, of course not. Instead, I did nothing up until this year when I realized that fingerless gloves have none of the issues of regular gloves and are almost as good at keeping my hands warm. Once in a while, being a stubborn idiot has its upsides.

I've recently gotten into cooking, and having a scale has been a lifesaver, even more so than measuring spoons or a measuring cup. I'm notoriously bad at eyeballing things, so if I don't have a concrete measurement of something, I can and do mess it up. But not anymore — my inconsistent hands now manage to consistently make identical pizza dough each time I try. All I needed was a mass produced piece of equipment you can buy for $5 and actually bothering to write down the recipes.

I grew up in a household without a microwave. I don't know why we didn't have one because it's an awesome tool for reheating and unfreezing food. Additionally, it's more reliable and requires a lot less effort when it comes to boiling macaroni and grains, which is a good thing because I'm really lazy. It's a shame it took me so long to discover that, but at least I know why I shouldn't repeat my parents' mistake.

Plastic bags suck. They're harmful for the environment, cost a lot of money to buy each time you go shopping, and are practically not reusable. You use them a couple times, and they already start falling apart. You can use them as glorified trash bags, I guess, if you don't mind the price, but why would you? I wish I'd been asked this question before because it took me way too long to realize that I could buy a real shopping bag, made out of cloth, and forget about ever dealing with plastic bags again.

Okay, that's a weird one. I understand this is a very specific problem that most people likely don't have, but I struggle with doing things that don't have one obvious order of steps. One of these things is my morning routine.

I've tried hard to stick to a specific order but couldn't until I bought a plastic storage thingy with 3 drawers in it. I put the stuff I need for brushing my teeth on the top, the stuff I need for shaving in the middle, the stuff I need for skincare on the bottom, and the whole thing in my bathroom. The issue is no more — I go from top to bottom, no thinking required.

This is a story similar to the one with gloves. I have an utterly dysfunctional immune system, so I get sick all the time. Does this mean I've always worn a scarf to protect my neck and not get sick even more often? Nope! Not only did I not learn how to wear one, I'd never bothered to get one in the first place until last year. Sometimes, I'm surprised that I'm still alive in spite of my recklessness.

Before we get to the praise, there's one thing you need to keep in mind: Xiaomi is not your friend. It's a company whose primary business is selling you a shitty Android reskin with an extensive history of spyware built into it, that they don't want you to get rid of, making you jump through hoops of increasing insanity to unlock the bootloader and taking their sweet fucking time to release the kernel source code and comply with GNU GPL.

With that said however, their hardware is pretty damn good for its price. My Redmi Note 8 was $150 when I bought it, and it's been the most reliable phone I've ever had so far. There's a rich custom ROM ecosystem, so I'm able to run a somewhat maintained copy of Android 14, with all of the useless crap cut out, even though it's been 5 years since the initial release.

It's also worth pointing out that the camera in this phone is outstanding — as long as you disable edge enhancement, which you should as it's the worst thing that's ever happened to photography, it performs as well as early 2000s digital camera, except it fits in your pocket and can record video in a non-potato resolution. The battery is just as great and lasts long enough for it not to be annoying. That is unless your ROM gets a mysterious battery drain issue which has happened to me once.

(Okay, technically, this isn't a complete list because there's a bunch of iterations where I didn't do anything except recompressing the images or renaming them, but why would want to know about those?)

Date: 2020-02-29

My social media profile picture at that moment was a solid square of Slapper Pink, my favorite color. Since I'm a very original person, I did the same to the button for my website.

This was my attempt at ripping off the Neocities.org, the web is yours button. I think I did a decent enough job because no one noticed.

The font is Liberation Serif Bold Italic. The planet in the background was taken from Public Domain Vectors. If I remember correctly, the space behind the planet is a heavily downscaled version of that picture from NASA I used in my dream journal.

This was an attempt at ripping off another button, coincidentally also made by A.N. Lucas. In retrospect, I did a shitty job. This looks nothing but cheesy.

The picture of the planet was, once again, taken from Public Domain Vectors. The font is GNU Unifont.

In the '90s, there were many buttons like "Made with Notepad", so I decided to make a parody of that with the software I used. I think I got the motivation to do that from a button that said something like "Best viewed in Firefox".

The Tux was, of course, taken directly from Larry Ewing. The font on the top is GNU Unifont, and the one on the bottom is Liberation Serif Bold Italic.

Same thing as with the GNU/Linux one.

The logo was taken directly off the website of Neovim. The font on the top is, once again, GNU Unifont, and the one on the bottom is Nimbus Roman Italic, half of which is bold. I used the same colors for it as they did on the website.

Without going too deep into the history of my website: on this date, I decided to make an alternative retro-looking version on my website and upload it to Neocities. As part of that effort, I decided to add some buttons for extra points. A lot has changed since then, and now the "retro version" is the only version of my website, and the Neocities version is simply a mirror.

Like with every other artwork on this website, I used GIMP as my image editing software and made heavy use of the nearest-neighbor downscaling because that's what they did in the '90s too. Additionally, I used no font antialising because that was completely unheard of back then.

Since I'm a fancy fellow, I drew the borders with the NeXTSTEP/Windows 98 palette with 2 colors on each side instead of the one with 1 color on each side, which almost every genuine '90s button used. Unfortunately, this ended up biting me in the ass later because, guess what, they did it for a reason — these colors are not Web-safe.

Date: 2020-03-01

Oh boy, that's a weird one. So first of all, your eyes aren't deceiving you — there were no visual changes in this iteration. Or well, I guess your ears if you're using a screen reader. Either way, the only change was that I converted everything to GIF (pronounced "GIF") so when people download them, they see the .gif extension and think "ah yes, a genuine '90s website". I abandoned this idea 6 days later because, you know, fuck it, PNG is fine.

Initially, I was going to write that this was, perplexingly, the iteration that spread, despite being the shortest living one, but it seems actually not to be the case. The only clue I have as to why any of them spread at all is this button wall which picked up the GNU/Linux button sometime between 2020 and 2021. My theory before was that since it has a .gif extension on that wall, its author/their scanner must've picked the button from my website when it was still in GIF. But now that I look at it, the button on that wall ain't the 2020-03-01 iteration, it's the 2020-03-07 iteration. Did it end up there for some other reason, and the .gif extension is just a byproduct of a conversion the author of the wall did? I'm even more clueless now than before.

But regardless, by sheer luck, the GNU/Linux button, presumably downloaded from that wall, ended up in a video by Michael MJD. Truly a surreal experience.

Date: 2020-03-07

The main difference in this iteration is, as you've probably guessed already, the fact that I switched from using an automatically generated, for each button, palette to a 216 color Web-safe palette because that's more authentic. The fancy borders had to be sacrificed in the process. I used Floyd-Steinberg dithering because, while I was experimenting with background images, it turned out ordered dithering sucks really bad. Since the planet on World Wide Web button was already dithered, I remastered it to use Floyd-Steinberg too so it doesn't look out of place.

Date: 2020-03-13

I think I added this one so there are 6 of them total and they all align into one nice 2 row rectangle. In case you're wondering, it linked to my Neocities profile page, and the phrase itself was stolen from Davie504. Also it's sort of a parody of the famous "Netscape Now!" button.

The thumbs up emoji was stolen from Twemoji. Unfortunately, by "stolen" I actually mean stolen because I don't think I've ever credited them for that on the licensing information page. Oh well, I guess better late than never:

Copyright 2019 Twitter, Inc and other contributors. Graphics licensed under CC-BY 4.0

The fonts are the same as in the GNU/Linux and the Neovim buttons — GNU Unifont on the top and Liberation Serif Bold Italic on the bottom.

Date: 2020-12-27

I got bored of using a solid color to represent myself, so I put the initials I used back then near a folder icon and called it a day. The folder, if that even requires an explanation, was inspired by Windows 95.

The font is Liberation Serif Bold Italic but a bit bigger.

Date: 2021-12-09

The main version of my website had been moved from Neocities, but I still used the latter as a mirror. In order not to accidentally gaslight people into thinking it didn't happen, I wrote a "(kinda)" under this button using the pencil tool. I could've done a better job drawing the letters, but whatever, the idea was questionable anyway.

Date: 2021-12-29

The shadow on top is shorter by 1 pixel. That's it, that's the difference.

Date: 2022-01-02

I realized how ridiculous "NeoCities (kinda)" looked and replaced it with a button I quickly made for Bruh, Ltd.

The bear was drawn by my friend in Paint.NET. Since nearest neighbor downscaling ruined its eyes, I manually touched them up a bit. The background image was taken from Public Domain Pictures. I don't remember what font I used, but it was probably either Liberation Sans or Nimbus Sans.

Date: 2022-04-21

I decided that a Windows 95 aesthetic was boring, so I started looking for inspiration in Unix desktop environments, one of which was GNOME 1. Then I realized this gray looks ugly and remembered that Classic MacOS used purple as the accent color. My favorite color is pink, and that's close to purple, so I connected the dots and made the folder pink. Best decision I've ever made. It looks awesome.

By the way, the third version of the button is different — the folder was moved to the right by 1 pixel. I also centered my profile picture by using this awesome tool. And yeah, the darker border is now slightly pink too.

Date: 2022-09-10

My initials are no longer K.K., so here's that. Since my new name is shorter, I made the home page layout narrower. 3 rows of buttons looked way too big, so I got rid of the World Wide Web and the Slap like NOW! buttons. Not a big loss, to be fair.

The phrase "Yours truly" was taken from the Super Mario 64 cutscene where Princess Peach invites Mario over to a dinner. I've never played that game, but the scene looks really cool. I even used it as the inspiration for my email page which I eventually moved to Bruh, Ltd.

I drew the letters by myself because Comic Neue Italic didn't look good at this resolution.

If you see any of these buttons online, now you know what time interval they initially came from.

There are 2 main issues with it, and my brain can't comprehend how they can possibly happen at the same time:

First, they ask you to give them your passport data. Yes, this is not a joke. It's supposedly optional, but they really want you to do it because they take away your ability to do a bunch of stuff like withdrawing your money back or transferring account ownership if you don't. This point will also become relevant later.

Second, there's no TOTP two-factor authentication. The only option is SMS-based two-factor authentication, using 4-digit codes if that wasn't bad enough already. Not giving the user a choice to avoid SIM swapping attacks is a pretty shitty thing to do, if you ask me, especially when you're dealing with sensitive data.

Before you enter your card credentials, you'll notice the elephant in the room: everything is roughly twice as expensive as you'd expect. Don't believe me? Let's compare the prices (transfer only, without the discounts) at the time of writing:

Reg.ru (the transfer/renewal price is only shown when you hover over a TLD):

• .com: $22.67
• .online: $50.65
• .zone: $63.20
• .co: $71.85
• .ru: $10.98

Porkbun:

• .com: $10.37
• .online: $26.24
• .zone: $26.24
• .co: $22.97
• .ru: N/A

Hover:

• .com: $17.99
• .online: $34.99
• .zone: $39.99
• .co: $27.99
• .ru: N/A

So yeah, unless you want a .ru domain, this isn't good.

In addition to that, however, they charge you for WHOIS privacy for non-Russian domains. It's not much — $2.2 a year — but I can't emphasize enough how fucking braindead this decision is in the modern world. WHOIS privacy is absolutely essential for individual people, so you don't have much choice. This is effectively a "fuck you, give us even more money".

Now, the last thing I want to point out here is sort of my fault. Reg.ru apparently doesn't support DNSSEC for anything but a handful of TLDs, and I forgot to disable it before transferring my domain name to them, making my website stuck in a limbo. It took the support 4 days to resolve this, and the wait was infuriating, but oh well. I guess now I know that this is an issue that can happen.

There are none. They offer stuff unrelated to domain names, like VPSes and website hosting, but virtually everyone offers these, so it's not anything special. I myself haven't used any of them, so I won't comment on it.

In terms of domain names, they offer exactly the same things as everyone else, like a DNS server and paid TLS certificates that you don't need because you can get them for free from Let's Encrypt, ZeroSSL, or a million other places. Hilariously, they also offer printed "domain ownership certificates" which, as far as I can tell, serve zero useful purpose.

If you ever decide that their service isn't worth your money, oh boy, you're in for a treat. You can't just enable domain transfer and copy the authinfo key. No-no, instead you have to leave a request to get it emailed to you. Lost the email? Tough shit, now you have to wait a month for your next attempt. Didn't get the email in the first place? Guess what, you have to wait for them to "process" your request. They don't specify how long it should take for international domains, but for .ru it may take up to 3 motherfucking days. For me, it took a day.

But what if you don't want to transfer anything? Can you just painlessly disown a domain? No, you have to contact the support and attach your passport data. That's right, you can buy a domain without giving them your passport but you can't get rid of it. How convenient, you assholes! My eyes couldn't believe it when I discovered that.

None of this should be necessary. It achieves nothing but making the process of leaving them as tedious as possible so you don't bother and pay up. This is the domain name equivalent of gym subscriptions that you can buy online but can't cancel without several unholy rituals.

On 2024-09-19, I was contacted by someone claiming to be a backlink specialist for Internet companies. I don't know if they were a Reg.ru employee, but judging by their question, I tend to believe they were: They were asking if they could get a "link on my blog", likely hinting at a sponsored post, while asking about this post. No, you can't. I have not and will not accept money or any other kind of favors to put anything on my website.

Commercialization has already ruined the Web in the past 2 decades, filling search results with slop generated by dishonest people (sponsored posts), slop generated by people who value money over everything else ("search engine optimized" posts), and recently, slop generated by machines that can't think but can speak well enough to imitate the other 2 groups (AI-generated posts). Regardless of how well you're paid, your decision to contribute to complete erosion of trust on the Internet is never admirable. You deserve better than that. Go home and rethink your life.

Reg.ru offers nothing that makes them worth it and treats you like a money cow, not a customer. Don't buy from them.

Let's say we have a few computers and we want to connect them together to share information between them. Create a network, if you will. In the history of computing, there have been countless ways to do it. Smart people who developed them called these ways protocol suites. Pretty much all of them are now dead, with the exception of TCP/IP which is a fancy way of saying "protocols that the Internet uses, 2 of which are TCP and IP".

If we want to fully admire the beauty of these protocols, we need to first understand their underlying principles that may not be that obvious at a glance:

• Plug and play: For the most part, computers get along without announcing their presence or being aware that anyone is present. They send stuff and hope for the best.
• Peer to peer: There’s no client and no server. Everything is just a computer.
• Unencrypted and untrusted: No one has to obey each other's wishes, and everyone can do wild shit on every step of the process. As you'll see soon, this is not a bug but a feature.

These principles always stay true, and when they don't, it's purely by convention. Computers can agree to follow conventions, but it's not mandatory.

Now here is where your teacher would show you a chart of the "OSI model" to explain what different protocols on different layers do. The chart in question looks something like this:

• Layer 1: Physical
• Layer 2: Link
• Layer 3: Network
• Layer 4: Transport
• Layer 5: Session
• Layer 6: Presentation
• Layer 7: Application

That's nice and all, but there's one detail missing here: This model wasn't decided for TCP/IP. It was designed, as the name suggests, for the OSI protocols which is a completely unrelated suite that competed with TCP/IP in the '80s but which no one uses today. It simply happens that this abstract model sort of works for describing any network, including TCP/IP if you pretend Layers 5 to 7 don't exist (most of the time, they're covered by a single protocol — HTTP) and Layer 3 includes IP and nothing else.

For the sake of simplicity, I'm going to pick 1 most common protocol from each layer, one that you're likely using at home, and describe how things would work for an average person. There are, of course, more protocols but they mostly follow the same principles.

Before we can create a network by wiring several computers together, we should wire at least two. In order to get connected, computers have a piece of hardware called a network interface, also known as a network card or a network adapter. All the network interface does is send and receive bits over some medium. That medium is usually a cable for wired transmission or air for wireless transmission. When 2 computers are physically in contact with each other via either of them, this connection is called a network segment.

The type of cable we're interested in is called Category 5e, usually shortened to Cat 5e. Since virtually every Ethernet network that people usually encounter uses it, it's sometimes also called an "Ethernet cable". The cable itself is 8 copper wires, all wrapped in plastic and connected to a head that can be easily inserted into an interface. When you send data, the interface uses a technique called amplitude modulation which is basically picking 2 voltages and saying that one of them is 1 and the other is 0.

So now we have 2 computers wired together. They can send and receive data, but as you can tell, this won't quite scale well. If we want to have more than 1 segment, we need to agree on what to send over that cable.

The most straightforward way to connect a lot of computers together is by using a device called a switch, which is called this way because it does packet switching — going through every packet of data it receives, one at a time, and resending it wherever it belongs. The device itself isn't anything out of ordinary — it's a computer, usually underpowered, with a fuckton of network interfaces which is all you need for this job. Your "home router" is really a switch and a router wearing a trenchcoat.

Also the switch is not the only thing you can use here. After all, if you don't want your device to even think where to send what, you can use a hub which will happily broadcast packets indiscriminately to everyone connected. You can even go one step back and wire your computers in a circle or wire every computer to every other computer. You can then call your masterpiece a network topology so you sound like a true nerd to your friends. Sky is the only limit here!

How does the switch understand which computer is trying to talk to which? Using a protocol called Ethernet that gives the bits in the stream of data a meaning. The data is sent in chunks called frames that can have a payload of any size from 46 to 1500 bytes + a bunch of metadata. There are multiple ways to encode all of this, but the only one that actually matters is called Ethernet II. Apart from a funny series of ones and zeroes used to synchronize the transmission, the metadata has stuff like the checksum (that isn't perfect), which Layer 3 protocol is being sent, and the source and destination MAC addresses.

As you've probably guessed, the MAC address is the bit we're interested in, as network interfaces use them to identify themselves to each other. The address itself is usually built into the network interface and is allocated to its manufacturer by the company called IEEE, who manages them. There are also 2 special addresses: a loopback (00:00:00:00:00:00) which is like sending a letter to yourself and a broadcast (FF:FF:FF:FF:FF:FF) which is like asking your switch to become a hub for a moment.

At this point, you may already see a potential issue with this: If computers self-identify themselves, what's stopping them from claiming to be someone else? The answer is absolutely nothing! In fact, Android and iOS devices do exactly that when discovering Wi-Fi networks. (Wi-Fi is unrelated to Ethernet but both use MAC addresses.) Additionally, this adds a bonus that there could be several computers, called nodes in this context, behind a segment, which allows tricks like wiring 2 switches together and making it just work™ with no effort.

But wait, how does a switch figure out which port corresponds to which node? Why, of course, by analyzing the traffic! Since every frame contains its source address, the switch can look at which addresses come from which port and dynamically build a switching table. If the table doesn't have the needed address yet, no problem — it'll broadcast the frame instead. Or I suppose you could configure the table manually if your switch is advanced enough.

Now we have several computers, all connected to a switch. One sends a frame to another, and it's successfully received. What can it do with that frame? Theoretically, anything, but realistically, if it sees the destination address is wrong, it'll discard it. But you can't always be 100% sure — a node could be malicious and listening to everything.

For obvious reasons, we can't connect every computer in the world to a single network. We can, however, connect all of the networks between each other and create a big network that consists of networks. An Internet, if you will. IP is the protocol that makes it possible by not only specifying which computer to send data to, but also which network.

The same way switches connect computers, routers, also called gateways in some contexts, connect networks. They usually do it by being part of several of them at once and relaying the packets they receive to the right one. But it's important to remember — they don't really have to do that. Like it happens with governments in real life, all it means to be a router is that other computers recognize you as one. Instead of sending packets to the right network, a router can, for example, purposefully send them to the wrong one, do what you expect but record the data, send the right payload but change the metadata, or even do nothing. "Gaslight, gatekeep, girlboss" truly is the moral imperative here.

And as a fun consequence of that — there may not necessarily be exactly 1 router on a network. There may be 0, in which case you're stuck with a single network, or there may be multiple routers, which is vanishingly unlikely for you to encounter and yet not technically impossible.

Communication over IP is done by sending packets, this time not called something weird like "frames", over whatever Layer 2 protocol is being used, which for us, is Ethernet. Packets can be up to 65535 bytes in size (including all of the metadata), and since that's bigger than an Ethernet frame, they sometimes have to be either fragmented among several of them (IPv4) or just not be that big (IPv6). In order for fragmented packets to be properly reassembled, each one gets a matching Identification field.

As you probably know, there are 2 versions of IP: IPv4, the older one that stuck with us for way too long, and IPv6, the objectively better newer one that, at the time of writing, still only has 38% adoption. For your convenience, I'll be covering both of them. Their packets have quite different layouts, but they both encode pretty much the same stuff like the version of the protocol, how long the headers and the payload are, a few hints to assist delivery, and a thing called time to live (renamed to hop limit in IPv6). The last one instructs routers to drop the packet after it's been resent too many times and accidentally makes traceroute possible. Oh yeah, and also the source and destination IP addresses.

The main difference between the addresses in the 2 versions is their size. IPv4 addresses are 32 bits and are usually written down as 4 decimal numbers, one for each byte, separated by dots — for example, 192.0.2.23. IPv6 addresses are 128 bits which is 4 times as big, so they're instead written down as 8 hexadecimal numbers, one for each 2 bytes, separated by colons — for example, 2001:db8:0:0:0:0:0:23. If you have several zeroes in a row, you can collapse them — the example above becomes 2001:db8::23. And yes, this doesn't only work in the middle:

1:0:0:0:0:0:0:0 = 1::
0:0:0:0:0:0:0:1 = ::1
0:0:0:0:0:0:0:0 = ::

In general, there are 2 kinds of addresses: globally-routable and reserved. Globally-routable addresses can, as the name suggests, be routed to from anywhere as long as it's on the Internet, if things go according to the plan. But again, they don't have to. Reserved addresses, on the other hand, are used for stuff that isn't on the Internet, like private networks, documentation (hey, I used a couple of them above), denoting the same machine (127.0.0.0/8 and ::1), denoting that we don't know the address (0.0.0.0 and ::), and black magic like translating IPv6 to IPv4. You can read the full list of reserved addresses if you want.

If you've ever noticed how every IPv4 address on a home network starts with 192.168., reserved addresses are the reason why. What's even cooler, however, is that every IPv4 address that starts with 10. is also reserved, which means you can set your home router's address to 10.69.4.20. Now that's what I call a party trick.

In case you're wondering who controls who gets which addresses: IANA does. How is it different from ICANN, its parent company? God fucking knows, but as far as I understand, IANA manages IP addresses and DNS names that aren't gTLDs (stuff like .com) or ccTLDs (stuff like .uk) while ICANN manages gTLDs and gives money and people to IANA so they can do their job. Except IANA doesn't really "control" IP addresses, it gives them to regional registries, and actual control is done via BGP, but let's not get into that.

Alright, say we know which IP address to send data to. There are 2 things we can do (apart from doing nothing): If we know for a fact that wherever that address points to is physically on the same network, then we can send the packets there ourselves. After all, if we know the destination MAC address, we have no use for a router. If we know for a fact it isn't on the same network, then we send it to a router. Assuming everything goes right, the router will be able to send the packets either directly to the destination or another router, and the process will repeat until the data arrives. If the destination isn't valid or any router along the way decides not to cooperate, the data will obviously never arrive.

Keeping in mind that a router is merely a computer with a role: Like with Ethernet frames, a computer is free to do whatever it wants with IP packets it receives, but realistically, it'll look at the destination address and give up trying to process the packet if it doesn't match any of the addresses it's interested in. That is unless it decides to route that packet somewhere else. Linux calls this process "IP forwarding" and lets you enable it per network interface. So if you enable it for, say, enp1s0, all packets received there, that weren't sent directly to your computer, will be routed.

All you really need to know about routing is that it's basically resending packets from one network interface to another. Preferably unchanged, but no one is there to stop the opposite from happening. In order to figure out where to resend, or well, send stuff at all, computers use a thing called a routing table. The table consists of entries that say which network corresponds to which interface and which router to send packets to if the network isn't directly reachable. The router that's used for packets that don't have anywhere else to go is called the default gateway.

Wait, but what the hell does "network" even mean in this context? It's a long story: Since having a separate entry for every single address would be insane, ranges of addresses are used instead. These ranges are formulated by slicing an address in 2 and calling the 2 resulting parts the network, also known as the subnet if it's inside a bigger network, and the host. The number of bits given to the network is called a prefix and is usually written down separated from the address with a slash. This way of writing it is called the CIDR notation. For example, 192.0.2.23/24 means that we should slice the address into a 24 bit network — 192.0.2.x — and an 8 bit host — x.x.x.23 — and think "huh okay, we're referring to the host 23 inside 192.0.2.0/24".

What's the difference between 192.0.2.23/24 and 192.0.2.23/23? There isn't any if neither network is in our routing table. For all we know, they're the same address. What does an address with an all-zeroes host like 192.0.2.0/24 mean? It means we're referring to the network as a whole and not any computer inside it. That's the kind of range I was talking about. What does an address with an all-ones host like 192.0.2.255/24 mean? It means if you send a packet there, the router of that network will broadcast it. What does IPv4 mean by a "subnet mask"? It's a fancy way of writing down the prefix as a binary mask with N ones in the beginning. So a /24 prefix and a 255.255.255.0 mask are the same thing. Why was I forced to manually calculate this shit on paper in college? Because they're sadists.

Got it? Great. So given an address, we look through every entry in the routing table and try to find matching networks. If the network is 192.0.2.0/24, then the IP matches if its lowest 24 bits match with the network's. If there are multiple matches, then we find out whether that damn 192.0.2.23 is 192.0.2.23/24 or 192.0.2.23/23 by picking the network with the longest prefix and sending packets to the corresponding interface. Finally.

Or do we? We know the destination address but not the source address. So uhhhhh…

Well, you don’t really get the IP address, you get an IP address. Not only can a computer have several interfaces connected to different networks, but it can also have more than a single address on the same network. Also remember what I said about having multiple routers on the same network? So yeah, chances are you'll get a couple more of them than you expect.

Anyway, let's get the most obvious solution out of our way beforehand: If you know exactly what network your computer always connects to and how it behaves, you can set your static address and default gateway manually. There's nothing stopping you from doing that, and if your computer is a server that lives in the same datacenter for years at a time, this is your most rational choice. Whether your router is going to like that is a different matter.

If your computer is a phone, however, or you can't ever be bothered configuring anything, then it'd be really nice if it could negotiate a dynamic address for itself. Luckily, that's exactly what DHCP does, and it does that for both IPv4 and IPv6. That is unless you use Android because Google decided you don't need it for IPv6. Read this 11 year old bug report they closed as "won't fix" for more info.

The way DHCP functions is quite simple: There's a client — your computer that wants an address — and a server — usually a program running on your router, but it can be on a separate machine. The client sends a discover message to the server via UDP (more on that later) with stuff like "hey, this is my MAC address and I'd really like to have an IP address, preferably that one", and after a bunch of back and forth offers from the server and requests from the client, they hopefully arrive at an acknowledgement. The client receives the information it needs to send stuff: its own address, how long it can have that address for, the address of the gateway, the prefix/subnet mask so it can populate the routing table with its own network, the address of the DNS server, and possibly other things.

But hold on. The client sends how and where? It knows neither the address of the server nor its own address. Does it send messages to a fixed location? No, it instead screams to everyone on the network with a broadcast frame and hopes someone replies. What does it use as the source/destination addresses? 0.0.0.0 and 255.255.255.255, which is like saying "I don't know" and "anyone who can hear me". The IPv6 version of the protocol does it slightly differently by using a multicast address which is practically the same thing, except the client is only screaming to the computers that are explicitly listening for DHCP messages. Also yes, your intuition is completely right here. A malicious third party can absolutely spoof this.

And this is all fine and dandy, but DHCP still has a fundamental flaw despite being this simple — it requires a centralized server. Doesn't sound quite "plug and play", does it? Understandably, IPv6 has a solution for that, called SLAAC. That's one hell of a funny name. The way this protocol works is somehow even more straightforward, if you can believe that. In fact, it's so straightforward that IPv4 had its own version of it called IRDP that unfortunately went nowhere. Oh well.

When using SLAAC, your computer starts with outright making up a link-local address for itself by taking a fe80::/64 network prefix and shoving some random bytes into it. The address is already being used by someone else? Eh, just make up a new one. "Link-local", by the way, means that it's a reserved address that can only be used on the current network and which is always present, even if you're completely isolated from the Internet. If you've ever noticed that your computer has an IPv6 address but no IPv6 Internet connectivity, this is why.

After getting a link-local address, your computer, similarly to what it does with DHCP, uses multicast to discover routers, but this time using ICMP Router Solicitation (more on that also later) instead of UDP. In response, the routers on the network, if they feel like it, respond with a Router Advertisement. If the response isn't "fuck off and use DHCP", your computer picks up their addresses, DNS server configuration, and globally-routable prefixes they send back. Now we have everything we need for real.

As you can see, this time, we got a whole prefix instead of one specific globally-routable address. Does this mean your computer can shove some random bytes into it too? Yes, that's exactly what it means! Or well, it can also shove its MAC address, but that's a poor practice since then the Internet servers you connect to will be able to see your MAC address. Fortunately, modern operating systems, including Linux if you use NetworkManager, don't do that anymore. If you're unsure about yours, look for "IPv6 interface identifier generation" or something like that in your network daemon's settings.

There's only one piece of the puzzle left: How do you find if an IP address is used by someone on the network? Or for that matter, how do you find the MAC address of the router from its IP address? The answer for both questions is ARP for IPv4 and NDP for IPv6, both of which are stupidly simple protocols.

Their entire principle of operation is broadcasting "anyone know this IP address?" and seeing if anyone sends "yeah, here's the MAC address" back. The only major difference between the two is that ARP is sent directly over, in our case, Ethernet, effectively displacing an IP packet, while NDP is sent via ICMP. And yes, once again, both can be and are spoofed by hackers.

Let's address the elephant in the room: ICMP is not a Layer 4 protocol, even though it's sent on top of an IP packet as payload. Actually, the same applies to ARP — it's not Layer 3, even though it's sent on top Ethernet. Yes, this makes no fucking sense and is clear evidence that computer people should never be allowed to categorize stuff, but it is technically consistent with the OSI model: ICMP doesn't transport and ARP doesn't network. This fact, however, is completely irrelevant because real protocols don't care. This is the exact kind of OSI and TCP/IP mismatch I was talking about. To make our lives easier, let's pretend it's Layer 4.

ICMP, to put it short, is an error reporting mechanism for IP. Pretty much all it does is send a code to identify what happened to a packet and maybe some additional data. How does it identify the packet? By sending the first bytes of it as the payload, duh! What can it say about the packet? A lot of things, including "I don't want to accept your packets", "your packet was way too big", and "you didn't send any packet, but thanks for making sure I'm still alive; here's your data back". The last one is known as Echo or, more commonly, ping. Plus, as I mentioned before, NDP uses it for MAC address and router discovery while traceroute uses it to trace which addresses a packet travels through.

If you want to send proper data, you aren't going to use ICMP unless you're this guy. You're going to use TCP or UDP. I'll only be covering UDP since it's more relevant to the whole routing aspect of TCP/IP, and its basic principles also apply to TCP. But the gist is: TCP is not connectionless, i.e. the client and the server have to shake their hands before sending stuff, and it tries really hard not to lose or reorder anything along the way. UDP doesn't do that. Why would you use it then? It's a lot faster, which is good for stuff like video games.

Compared to a plain IP packet, UDP provides 2 additional features: Rudimentary error checking (a checksum) and multiplexing, i.e. letting you send multiple streams of data over one address. As you can probably tell, packets being identified by their address alone doesn't let you do that. UDP does this by providing 2 additional 16 bit port numbers with every packet, one for the source address and one for the destination address.

What you need to keep in mind here is that every port is duplex which is a smart way of saying "sends data both ways", so you only need one for two-way communication. In other words, there aren't really "source ports" and "destination ports", strictly speaking. Your computer has 65536 ports total, so whatever port it picks as the source will also be used as the destination by whoever replies. For this reason, if it needs to send something as a client, it'll use a random, ephemeral port.

However, you're running server, it's certainly a good idea for it to accept requests on a stable, well-known port. Usually, those ports have a number below 1024 and require root to bind to, but not always. A few examples of such ports are 80 for HTTP, 443 for HTTPS, 53 for DNS, 123 for NTP, and 25565 for Minecraft: Java Edition, the most important piece of networking software. If you want to look through all the standard ports, IANA has got a nice big list for you.

Wait, bind? Yup, it means assign a program on your computer to a port and an address, so it and only it is able to send and receive stuff over it. A security mechanism of sorts. When you send an HTTP request, you bind to a port, preferably an ephemeral one, and when you listen to these requests, you also bind to a port, preferably 443 because not using TLS in the year of our Lord 2024 is a crime.

As you surely know, there are 8 billion people on the planet and only 4.2 billion IPv4 addresses, which is really bad. Well, guess what, you're wrong! There aren't 4.2 billion globally-routable addresses. Remember — reserved addresses exist. If we exclude those, including a mysterious 268 million address hole in 240.0.0.0/4 that was reserved for "future use" but never actually used, we only get 3.9 billion addresses. On top of that, most of them are allocated to multinational corporations with big datacenters and big bucks, not residential areas. Now that's bad.

Obviously, you're reading this article on the Internet right now and you're likely using IPv4. Okay, maybe you printed it, but someone had to get it from the Internet before that. And that someone didn't have to wait in a queue for a week to get a turn at using their IP address (hopefully). How come? The answer is a good dose of unholy rituals that your ISP performs, also known as CGNAT or, more generally, NAT.

Here's a few fun observations: You probably aren't hosting your own Internet services at home. Almost everything that you send is either TCP or UDP. You probably aren't using all 65536 ports of either protocol at once. See where I'm going with this? What if I give you and your friends reserved addresses, then track the port numbers you're using, send your stuff as my own using my single globally-routable address with different ports, and then give you the stuff that comes back as if it'd been sent to you. Trust me, bro, you won't notice it™.

Yes, this is pretty much what NAT subjects you to. Lies and deception. You think you have an entire address for yourself, but all you get is a port per connection, which NAT is desperately waiting for you to forget about for a few minutes so it can give it to someone else. You think you can let people send packets to you, but NAT's grim ghostly hand points to a sign that reads "your packet shall go out first" and doesn't even give you a port. Your existence is reduced to nothing but being a pawn in NAT's master plan to conquer the world.

Oh yeah, also it spoofs the Identification field. These aren't aware of ports, after all.

Be a good boy/girl/bunny and use IPv6. Please :)

• Your brain amplifies worries and uncertainty.
• Your thoughts are separate from who you are.
• There's no need to blame yourself for your thoughts.
• Your actions matter more than your thoughts.
• Sometimes doing nothing is better than desperately trying to find what to do.
• Accept your thoughts as background noise that doesn't need to be interacted with.
• Mocking, rebutting, agreeing with, or trying to stop your thoughts will only make them worse.
• Don't make a big deal out of it — it's okay if you slip up.
• Change the atmosphere in a healthy way (touch grass).

• By "Choco Pie" I mean the brands of candy called "Choco Pie" by Orion and Lotte. The candy with the same name from other companies, like Tondi, are specifically excluded because they're all garbage.
• By "every flavor" I mean every flavor that was sold in retail in Russia at the time of writing. There are more flavors, but they're only sold in other countries like India, and I don't live there.

In order to not repeat the same stuff more than necessary, here are the things that are common to all flavors of the given brand. Keep them in mind when trying to picture what a flavor would taste like to you:

• Orion flavors are generally softer and rounder. This, however, doesn't mean that they fall apart easier.
• Lotte flavors are generally more sweet but not terribly so.
• Orion flavors generally have more, well, flavor. For example, you can actually taste the vanilla in the vanilla flavor.
• Lotte flavors are usually cheaper and easier to find, especially in smaller quantities. In contrast to Orion flavors, with the notable exception being Original, which are almost exclusively sold in 12-packs, Lotte flavors are trivial to find in 6-packs.
• Orion has more flavors. Many more flavors.
• They're both a waste of your money if you can eat something better. Don't repeat my mistake of eating all 12 of them from a 12-pack on a semi-regular basis. This is neither healthy nor wise financially.

From best to worst, split into categories.

1. Black Currant, Orion
2. Cranberry, Orion

A vanilla purist may condemn my decision to rank these two the highest, but I genuinely think they deserve it. They both have lots of jam inside, taste like the actual fruit they're supposed to represent, and are just right amount of sweet. I also love black currant as a berry (it's probably second to my favorite), so I'm bit biased here anyway.

3. Original, Orion

If you're picking a Choco Pie for the first time, this is likely your safest bet, which you could probably already tell by the number of flavors ranked lower. Also let's be real, it should've been called "Vanilla". "Original" is way too fancy of a name.

4. Vienna Cake, Orion
5. Cherry, Orion
6. Raspberry, Orion

These are about as well produced as the fruit flavors ranked higher, but in my opinion, don't taste as good. Vienna Cake (what even is this name) hits the right spot even though it uses Dark as its base which I'm not that big of a fan of. The peach jam tastes more like orange jam, but I still have to say the combination of the two works really well. Raspberry, on the other hand, is my favorite berry, but for some reason, I'm not a fan of raspberry jam. The Choco Pie unfortunately doesn't manage to make me a fan of it. It's still good but I'd very much rather eat strawberry jam.

7. Vanilla, Lotte

If your only choices are this and a fruit flavor you haven't tried yet, this is likely your safest bet. It's not quite as good, in my opinion, as Original but it's not much worse. By the way, it's not really called "Vanilla" since the box doesn't name any flavor.

8. Apple-Cinnamon, Orion
9. Chocochip & Orange, Orion
10. Mango, Orion
11. Dark, Orion
12. Caramel, Orion
13. Poppy, Orion

These are generally not that great in my opinion. Well, except for Caramel which is simply indistinguishable from Dark. Maybe I got unlucky and mine happened to have little to no caramel in it. Dark itself, by the way, is uhh... Well, don't get me wrong, it's fine and has its unique flavor, but I would very much rather eat an Original. I just don't vibe with it. In fact, I don't vibe with it exactly the same way I don't vibe with the poppy seeds in Poppy. In this case, however, the additional flavor is more weird and less interesting.

Either way, the other 3 flavors are not that noteworthy. Apple-Cinnamon tastes like an actual apple and I can sorta get behind it. I'm not sure if I can taste the cinnamon, but to be fair, I haven't ever tried actual cinnamon. The chocolate chips in the Chocochip & Orange are a bit gimmicky but don't hurt. Mango is decent but that's about it. But hey, at least it's already miles ahead of the mango flavor of Bounty.

14. Strawberry, Orion
15. Strawberry, Lotte
16. Banana, Lotte

These are not worth your money. They don't have any actual jam inside but instead have a bit of food coloring and a flavoring agent that tastes vaguely like fruit. And yes, this includes Strawberry by Orion, which is incredibly underwhelming. It's supposed to have strawberry jam, but I swear couldn't taste any. I would've loved it otherwise.

17. Cacao, Lotte
18. Coconut, Orion

Do not buy these flavors. Cacao is a disgusting bitter piece of shit that's nowhere near being comparable to Dark. This is strange, considering Lotte flavors are generally more sweet which should help, but it fucking doesn't. Coconut is Original that tastes like it had cum diluted in its marshmallow. It may not sound that bad (okay, maybe it does) but remember: this is considered a "premium" flavor, making it a third more expensive. I regret paying for it. No wonder no one else wants to buy them.

Just buy vanilla.

But first, a little disclaimer: As you can probably tell, I'm not a low-level development guru. There's probably a better way to do it, so take everything with a grain of salt.

In order to build the test cases (or well, any native RISC-V software), you need a toolchain. The 2 most popular options you have are GCC and LLVM, and I recommend using the former since that's what the test suite was written in mind. LLVM is likely possible to use with a minor makefile modification, but I didn't bother.

The easiest way to get the whole GCC toolchain is to either get it from your Linux distro (if it offers a riscv64-unknown-elf one) or build it manually using the official repo. For obvious reasons, I'm going to cover the second scenario.

Install the build dependencies for your specific distro using the command in the readme and clone the git repo. You don't really need --recursive here since there are more submodule dependencies than most targets need, and it's going to fetch everything at the build time anyway:

git clone https://github.com/riscv-collab/riscv-gnu-toolchain.git

Next, you need to build the Newlib flavor. I personally prefer using ~/.local as the prefix, so the whole thing is installed for my user only and requires no black magic other than putting ~/.local/bin in my $PATH:

./configure --prefix=$HOME/.local
make

Depending on how slow your hardware is, the whole process will take an hour or two. In the meanwhile, you can ensure that you're properly hydrated, your dishes are washed, and your laundry has been done.

First of all, you need to clone the thing. Note that --recursive is needed here since the repo has a submodule that it doesn't fetch by itself:

git clone --recursive https://github.com/riscv-software-src/riscv-tests.git

In contrast to what I do with the toolchain, I prefer using a prefix pointing to a folder near the test suite itself. Since it doesn't install any executables native to your host, this shouldn't be an issue. Let's say you have the following file hierarchy in your project:

• output
• riscv-tests

In order to build the tests and install them into output, you need to run the following:

cd riscv-tests

autoconf
./configure --prefix="$(realpath '../output')"

make
make install

As you can probably see, you now have a bunch of tests cases themselves:

• output/share/riscv-tests/isa/
  • Makefile
  • rv32mi-p-breakpoint
  • rv32mi-p-breakpoint.dump
  • rv32mi-p-csr
  • rv32mi-p-csr.dump

The object of your interest here is the files with no extension (not counting Makefile, obviously). They're the native RISC-V binaries in the ELF format. .dump files are their disassembled versions, generated with objdump, that are actually quite handy because they let you quickly debug why a test case fails without having with manually objdump everything or rolling out your own full-fledged debugger.

Before even touching any of them, you should consider: does your emulator frontend support ELF? If not, you should first dump the contents of the test cases into a flat binary file:

riscv64-unknown-elf-objcopy -O binary test-case test-case.bin

Next, you need to pick the test cases that are actually relevant for your specific emulator (or "TVM" as the test suite calls them) by looking at their filenames. For example, here's what different parts of rv32mi-p-breakpoint mean:

32

XLEN bits. Self-explanatory — pick 32 or 64 depending on which one you're emulating. There's no need to use both.

m

Privilege mode. Depends on which ones your emulator is capable to operate in, except for u that you're going to need anyway because it tests the instructions common to all privilege modes. So for example, if you're implementing the:

• Unprivileged spec only — use u.
• Unprivileged spec + privileged spec (machine mode only) — use u and m.
• Unprivileged spec + privileged spec (machine mode and supervisor mode) — use u, m, and s.

i

Extension/base instruction set. Depends on which ones you care about. So for example, if you're making an RV64IMAC emulator, you need to pick i, m, a, and c.

p

Target environment. A bit weird to define, so just consult the table in the test suite's readme. But in short, if you're making a simple single-hart emulator with no virtual memory support, you need p.

breakpoint

Tested instructions. Easy to choose — just pick all of them. Or well, I guess you can omit ma_data if you don't implement misaligned loads/stores.

For this I'm going to recommend you the approach used by Max Nurzia's rv — make a tiny wrapper around your emulator's core and shove the unmodified test cases into it.

As test cases are just executables that do stuff and make an ecall when they're done, all you need to do is load them into memory, jump to the first instruction, and run until you encounter an ecall. In order to verify if the test passed, you need to look at the RVTEST_PASS/RVTEST_FAIL macros inside the riscv_test.h header file of your target environment. For example, here's what they look like for p:

TESTNUM: gp

RVTEST_PASS:
    fence
    li TESTNUM, 1
    li a7, 93
    li a0, 0
    ecall

RVTEST_FAIL:
    fence
1:  beqz TESTNUM, 1b
    sll TESTNUM, TESTNUM, 1
    or TESTNUM, TESTNUM, 1
    li a7, 93
    addi a0, TESTNUM, 0
    ecall

Which basically means that if a test passed, gp (aka x3) should be 1 and a0 (aka x10) should be 0, and if they aren't, the test failed.

The easiest way to provide feedback for test coverage is to repeat this process for each test case, one at a time, and either print the result or return it as an exit code and let a separate script do the printing for you. Here's a simplified version of the script I used in my emulator:

#!/bin/sh

set -ue

RUNNER=your-wrapper

RED='\033[0;31m'
GREEN='\033[0;32m'
NORMAL='\033[0m'

for CASE in relevant/cases/*
do
    if "${RUNNER}" "${CASE}"
    then
        echo -e "${GREEN}$(basename "${CASE}"): PASS${NORMAL}"
    else
        echo -e "${RED}$(basename "${CASE}"): FAIL${NORMAL}"
    fi
done

• Calculator
• Calendar/daily planner
• Clock/timer/alarm
• Contact browser
• Dictionary browser
• Map/navigation utility
• Notes editor
• Presentation utility
• Spreadsheet utility
• Todo/checklist editor
• Translation utility
• Weather forecast utility
• Word processor

• Audio editor
• Audio player
• Bitmap image editor
• Font editor
• Font viewer
• Hex editor
• Image viewer
• PDF/E-book viewer
• Text editor
• Unicode character browser
• Vector image editor
• Video editor
• Video player

• BitTorrent client
• Email client
• Fax utility
• Password manager
• Phone dialer
• SMS messenger
• Two factor authentication utility
• Web browser

• Audio recorder
• Camera capture utility
• Paper scanner utility
• Printer utility
• QR code/barcode scanner
• Step counter/fitness assistant

• Antivirus utility
• Application log viewer
• Backup utility
• Bulk rename utility
• Checksum utility
• Data recovery utility
• Disk cleanup utility
• Disk image browser
• Disk image writer
• Disk partitioning utility
• Disk usage analyzer
• File archiver
• File browser
• File transfer utility
• File/disk encryption utility
• Hardware information utility
• Hardware resource monitor
• Help browser
• Network analyzer
• Process browser
• Process scheduler
• Remote desktop client
• Screen capture utility
• Software repository browser
• System configuration utility
• Terminal emulator
• Virtualization/emulation utility

Note: you can safely skip this section.

Houses usually have a lot of things in them. Especially houses in not quite the richest regions of Russia. The house I was raised in happened to be possibly one of the worst offenders when it comes to hoarding useless garbage.

Human brains have limited memory capacity. Especially neurodivergent brains powering an extremely lazy person. Unfortunately, I'm this exact kind of person.

As you've probably already guessed where I'm going with this, these 2 things put me in a perpetual loop of losing stuff, mismanaging stuff, and not doing stuff due to the sheer volume of shit I had to keep in my head to get through the day. Upon my gradual realization of that, I also realized the core problem.

Having too much choice discourages actually making a good choice. Or in other words, if you limit the number of ways you can fuck up, you'll fuck up less.

This principle is one of the core design decisions in many software products like the Python programming language or virtually any UI design guideline set released in the last 10 years (or well, at least on paper). As it turns out, for me, it's also applicable to housekeeping. I'm probably not the first person to realize that, and it also probably doesn't work for normal people, but I guess it shouldn't stop you from attempting it as well.

Now with theoretical bullshit out of the way, let's get into attempting to solve it. Basically speaking, The Rule of Two entails the following: don't have more than 2 sets of something, and use the placement of items in your house to encourage yourself to actually put effort into something.

Here are the ways I used this rule in everyday life:

I've always sucked at it, and I still do. To avoid that, I always just used more dishes to cook/eat food instead of cleaning the dirty ones. This created many weird situations where I'd used 5 different knives to cut something and made me wash literal mountains of stuff afterwards.

Don't fucking do that. The easiest way to actually make yourself wash dishes and avoid this mistake is to have no choice but to wash dishes. In other words, get yourself 1 plate, 1 fork, 1 spoon, and 1 knife. Get yourself another set of these items, but hide it away from your sight in a way that's difficult to undo. This way, you'll have only one set of usable dishes that need to be washed after use + an additional set of redundant dishes in case you accidentally break yet another plate.

I've always been known for always wearing the same kind of clothes, so this one came naturally to me. If you have only one set of clothes, you rarely wash them and end up wearing dirty clothes. If you have a ton of sets of clothes, you either accumulate mountains of laundry or pick one set and get the same problem.

There's an easy way out of this: have 2 sets of identical clothes and swap them weekly, doing laundry right after. You can do it at the same time as your other weekly routines like cleaning up your house (which you hopefully do). Let's call this day the Maintenance Day. Mine is on Friday.

You can also apply the same solution to managing your bathroom and kitchen towels, bedroom fabrics, etc. It's not like you really need more than 2 sets of each.

Don't. Carpets and rugs can both go fuck themselves. The aesthetic value and marginal warmth they provide is nothing compared to having to regularly vacuum them or breathe dust all day long.

Limit the number of places you can put your things into. It doesn't have to be 2, but it's a reasonable number. Avoid buying furniture that gives you additional storage space, and especially desks with shelves. This doesn't mean you shouldn't partition your stuff into meaningful categories, however. Just make it so the things you don't want to see are right in your face so you don't lose them at the most inappropriate moment.

Obviously, this solution implies you don't have tons of stuff that requires the aforementioned storage space. If you do, it may be a wise decision to reconsider your life choices and eliminate some of them one way or another.

The same thing can be applied to the management of consumables, electronics, papers, and probably something I couldn't have thought of. Use your imagination.

While this principle worked for me, I should warn you that it does require some determination not to give up and some commitment to routine. I don't know how to help you with that, but I do know that this approach will ease your efforts somewhat.

It's a piece of fucking garbage. Don't get me wrong, it wasn't disgusting to eat it, and it didn't look that unappealing. As a piece of food, it was a totally acceptable thing you could eat to get some calories. But as a shawarma, or in other words, a piece of art, it was a fucking dumpster fire. This taste was definitely worse than anything I've tried yet with the only exception being that one grill place in Krasnodar Krai. So in the end, there's only conclusion I can make: buying a shawarma here is like going to a school canteen for your birthday party. Don't fucking do it.

👎 Rating: Bad

Regular high-quality shawarma comparable to an expensive one in my city. I was actually pleasantly surprised by it. Can recommend, I guess?

🏅 Rating: Important

This shawarma claimed to be Syrian. The cook probably was Syrian, but I'm not sure if I can say that about the shawarma itself. It was... okay? The one I tried yesterday was heaven compared to this one, but it was also miles ahead of the one from Omsk. I'd say it's about of the same quality as, like, a mediocre shawarma from my city. The same quality I'd expect from picking a random eatery I've never been to.

👍 Rating: Good

Okay, this was really fucking weird. The place I bought it at is called Big Shawarma. The name didn't lie; it was indeed big. And I don't mean big as in falls apart in your hands, but actually big and manageable. It had a good selection of ingredients, including my favorite Korean carrot salad, and 3 sauces. As an icing on the cake, it was also masterfully assembled. And yet, despite all of that, it tastes like shit. I don't know how it's even possible. The only explanation I can find to it is that they used the cheapest ingredients or something. Anyway, it still tastes better than the one from Omsk, but can't really match the one from Ufa.

👎 Rating: Bad

Just pretend I put the same review as for the one from Ufa. It's the same shit.

👍 Rating: Good

You should answer the questions in this section without looking up the answers.

• Is airplane food bad?
• What is Obama's last name?
• What is the capital of Switzerland?
• Who was the first female president of the United States?
• When did World War II start?
• How many letters are there in the Russian alphabet?
• What is the name of Jotaro Kujo's Stand from JoJo's Bizarre Adventure?
• Does the sentence "James while John had had had had had had had had had had had a better effect on the teacher." make sense to you?
• Does the sentence "The complex houses married and single soldiers and their families." make sense to you?
• Is the word "folk" pronounced with an "l" sound?
• How many days did 1752 have?
• What are the colors of the flag of the Seychelles?

• Can you pronounce such words as "thick" and "that" as they're pronounced in the British/American English?
• Are the words "wine" and "whine" pronounced the same?
• Are the words "pour" and "poor" pronounced the same?
• Are the words "ferry" and "fairy" pronounced the same?
• Are the words "caught" and "cot" pronounced the same?
• Does the word "father" rhyme with "bother"?
• Are the words "Mary", "marry", and "merry" pronounced the same?
• Do the words "trap" and "bath" have the same vowel?
• Does the word "bird" have the sound the word "rock" begins with?
• Are the words "metal" and "medal" pronounced very similarly?
• Does the word "hurry" rhyme with "furry"?
• Does the word "about" rhyme with "kaput"?
• Does the word "bag" rhyme with "vague"?
• Are the words "bath" and "barf" pronounced the same?
• Are the words "kin" and "king" pronounced the same?
• Are the words "fill" and "feel" pronounced the same?
• Are the words "full" and "fool" pronounced the same?
• Are the words "back" and "bag" pronounced the same?
• Are the words "back" and "buck" pronounced the same?

• How do you pronounce the word "data"?
• How do you pronounce the word "exactly"?
• How do you pronounce the word "lmao"?
• How do you pronounce the word "lol"?
• How do you pronounce the word "GIF"?
• How do you pronounce the word "PNG"?
• How do you pronounce the word "WAV"?
• How do you pronounce the word "gzip"?
• How do you pronounce the word "char" as in char letter = 'a';?
• How do you pronounce the word "lib" as in "libinput"?
• How do you pronounce the word "src" as in src/main.c?
• How do you pronounce the word "var" as in var number = 3;
• How do you pronounce the word "GNOME"?
• How do you pronounce the word "GUI" as in "graphical user interface"?
• How do you pronounce the word "Kdenlive"?
• How do you pronounce the word "RHEL" as in "Red Hat Enterprise Linux"?
• How do you pronounce the word "bin" as in /bin/bash?
• How do you pronounce the word "etc" as in /etc/sudo.conf?
• How do you pronounce the word "mnt" as in /mnt/usb?
• How do you pronounce the word "proc" as in /proc/uptime?
• How do you pronounce the word "chmod" as in chmod +x prg?
• How do you pronounce the word "env" as in env python?
• How do you pronounce the word "grep" as in grep -rl "hello"?
• How do you pronounce the word "ls" as in ls /etc?

• Are you good at telling apart your emotions?
• What languages do you know?
• What language do you think in?
• Do you have an internal monologue?
• Does your internal monologue use your own voice or someone else's?
• When you read other people's messages in your head, do you read them with your internal monologue's voice or the sender's voice?
• Do you think you have more than one person in your head?
• Do you think you're human?

• Can you visualize your own past?
• Can you imagine 60 dB of bass being pumped right into your ears?
• Imagine a cube.
  • What color is it?
  • Where is it located?
  • How is it lit?
• Can you imagine the smell of a rotten egg?
• Can you imagine the taste of coffee without milk or sugar?
• Can you imagine someone cutting the tip of your finger?
• Can you imagine someone uncomfortably touching your arm?
• Can you imagine being extremely hungry?
• Can you imagine being extremely thirsty?
• Can you imagine losing balance?
• Can you imagine wanting to vomit?

• What color is the letter E?
• What color is the note C#?
• What gender is the number 6?
• When you see someone being kicked, do you feel being kicked too?
• What does the word "quizzaciously" taste like?
• What does soul music taste like?

Note: don't try to do the actions listed if you either don't know the answer or the answer is "no."

• Can you put your foot behind your head?
• Does looking at the Sun not damage your eyes?
• Can you see infrared or ultraviolet light?
• Can you survive in extreme heat or cold?
• Can you multiply two 4 digit numbers in your head without a calculator?
• Can you break a concrete wall with your own hands only?
• Can you draw a panorama of a city after only seeing it once?
• Can you survive a whole month without sleep?
• Can you imagine a 4D object rotating in 4 dimensions?
• Can you imagine a color that doesn't exist?
• Can you survive getting 10000 volts of electricity applied to your body?

• Are you good at telling apart different forms of attraction?
• On a scale from 1 to 10, how attracted are you to feminine/masculine people:
  • Sexually?
  • Romantically?
  • Aesthetically?

Since the dawn of time, humanitarian activities has been the major obstacle for climate change. However, a solution might have been found in the most unexpected place possible. Bee sex. Improperly implemented, destruction of the habitats caused the colossal impedance in the event chain.

While the validity of the theory is yet to be proven, its mere presence highlights the fact that spiders has been dying one by one for a very long time. A certain director blaming her customers for poor reception can be classified as the most important step in mammal evolution. Monkeys' menstrual cycle is quite an unusual thing to witness. Every single one of them is already dead. And the thing is that no one can prove whether such a hurdle is worth being put in place or not.

The ocean has been quite unstable since 1982, which is what scientists usually prefer to call "the building escalation process", which has been used for our advantage for a long time. The profitability of human kidneys has been disputed for a very long time, however, the president of Iraq, John Malkovsy, has called this "utter bullshit." Your opinion doesn't matter, everything has already been put into place and reinforced by the law. The introduction of the locomotive in 1473 caused a great deal of pain; the mix of sodium and potassium chloride produces a peculiar fire, rigorously enforced, which effects can be controlled by humming the anthem.

Very specific methods of transportation has been implemented by Adobe, which caused a major displacement of terrestrial biomes. The princess has anxiety, but that doesn't seem to affect his consciousness in the process of killing his favorite ice cream. One way, you can find certain death; the other way, you can find your own ass. Run away. By doing that, he took a big shit on the entire oil industry, which I approve, but no one else acknowledges that there could be better ways of doing that.

If he decides to uncover the truth, the people would be delighted to fill in the missing holes (which sort of sounds illegal, but it's actually not; trust me). Read my previous article if you have a need to protect your point of view. Giant meteorites from outer space sound like a good Easter egg, which is completely true, but Microsoft would be quite unhappy if it was to ever come true. (Okay I actually lied, but there's no need to retell her statement; all of these expressions stay hierarchically sound.)

What seems to sound like nonsense actually has deep implications for the computer industry, which is actively talked about in the media, but keep in mind it's still all in vein; email as a means of communication was discontinued in 2046, and it's quite sad. Young people disregard the law and stay gay, and it's not something Poland is proud of. Ethnic diversity has been a hot topic in China, which caused her to write an article about his experience with abortions and how disabled people are actually quite nice. But keep in mind, that doesn't mean you should overengineer your code even though it's written in Rust. He almost beat me to death after I said that, which I painstakingly recorded in our timetable, which affection was seen as "sexual harassment" of the whole liberal church industry.

"You shall slurp your own semen", Arial Destruction Project Association (A.D.P.A) said to their shareholders. Our company manufactures the majority of the female fetuses that are later distributed to the majority (384) of the pirates in the Josephine Sea (located near the Isle of Woman). Acknowledging our ass is likely to be kicked, we decide to ignore your offer and shame your own employees, even though they're totally correct and we're not; the imagery of the movie was quite impressive for 2024, and the most impressive thing about it is the depiction of the following:

I have no fucking clue who George Washington is. He has only ever witnessed how well his entrepreneurship was going. Such an attractive woman should never have been involved in sex work, but it was her decision, and we must respect that. Such a prediction made the entire future of the city crumble, which shattered our hopes. I absolutely despise this man and I wish them all the worst. It is our moral responsibility to reject all attempts at destroying what we've built with our hard work. Tho I'm not sure if it's actually the right decision, but it doesn't matter. Shall you keep doing political work in this area, make sure people are satisfied, and pretty please, don't get into the dirty business.

It's truly terrifying how far the plastic has spread. If you enforce such a rule at its fullest power, even though no one else wants it, we're basically screwed over; all of the decisions we made and observations we collected will be lost. Even if they tell us to spy on you, we will never give up the hope of rejection to apply the best practices, track how many steps you have walked in your entire life, search for the best grocery store, or even record the documentary about wild life in Brazil.

git commit is a particularly useless command since no one ever uses it, but we do use it here at Poop Toilet, Inc. Absolutely no one, not even Fox Industries, cares what you look like, but we're required by the law to track such data, and that can mean no one from France will ever get true satisfaction from their life. The only way to free yourself of suffering is to sacrifice your soul to the devil.

NFTs, while looking like a scam at first glance, actually are, which opens a great variety of opportunities to control the market; this hopefully should make our lives easier by eliminating the middle man between you and your chair. Once upon a time, this was considered a fair play, but it no longer is; come to think about it, this is completely ridiculous, but that's just the world we live in. Old technologies must be abandoned in favor of more abusive factors of the environment, however God says you to do. Federalization is the only way out of this paradise.

It's completely useless to try to resist the urge, let the porridge in my head surround us nonetheless, giving birth to whole galaxies while destroying the very nature of being a responsible citizen, and all that was required was a piece of plastic with no cuts. What? I honestly don't remember, but it was between 7"5' and 47 km/KiB. You can do a similar thing by performing a simple life hack: The trick is to basically ignore everything I've said earlier (which Japanese people usually call 환영하다 — the rise of the dead). The usage of the black material called "dirg" managed to hide the very fact that the drawings has never been shown to anyone. There's no way I can demonstrate it to you, but trust the spirit, framing several people as communists will do no good for the foreground scenery.

Fuck you, James Cook. Your achievements have been nothing but a pain in the ass for the entire human race.

As you can tell by one of the rules I live by, I'm really into cutting edge technology. This is why I use Arch Lin... Okay I actually don't. And there are a few reasons for that:

• Rolling release distros are not stable enough for me. They tend to break once in a while. And "once in a while" just happens to happen at the most unexpected and inappropriate moment possible. With fixed release distros, you can easily tell when the things are going to break — at the moment of an upgrade.
• Fedora has enough packages for me. It doesn't have as much as Ubuntu or as a diverse range of them as Arch, but it has the exact packages I need, and they're just fresh enough.
• It's supposed to work out of the box, so it's easier to install and work with. In other words, even though it's not a DIY distro, it works well for me as one because it's DIY enough for me.
• I'm a big Red Hat fan. The community around Red Hat has quite a few cool and shiny technologies that I like. These include systemd, GNOME, Wayland, Flatpak, PipeWire, and others. Fedora always has the latest versions of them and supports them better, so there's no reason not to use it for me.

Void Linux

What I used to use before Fedora. Not as stable and mainstream but I guess still usable.

CentOS Stream

"Fedora LTS." I use it on my server.

Yes, I use GNOME. It goes without saying that GNOME is a weird kid on the block. It's extremely aesthetically minimalist, and the developers are defending this minimalism as much as possible, which makes a lot of people angry. In other words, this DE is as far away from Windows as possible, and people are not used to it.

I, however, really like this minimalism, and this is why I not only use it but also use it without any extensions. The default GNOME workflow fits my needs pretty well and requires minimal customization compared to other desktop environments. The main thing I like about GNOME is how distraction-free it is. It shows you only so many elements at once, which works well with my brain that can't handle too many things at a time. If you're like me in this regard, you'll like GNOME.

KDE

Good desktop environment for people who like the Windows-like workflow more.

Sway

Solid window manager that can be just as good as GNOME for me but requires a lot of configuration.

Well, I wrote it myself as an exercise in writing software without knowing how it works. I guess that says something.

XFCE Terminal

Good alternative if you don't want to use code written by a Russian shitcoder.

GNOME Terminal

Good alternative if you don't mind it being slightly "bloated" and lacking a few customization options.

Truth be told, I fucking hate shell as a language. It looks like complete shit, makes it extremely easy to shoot yourself in the foot (even easier than C does), and makes you produce unreadable code if you're trying to do something complex. fish sort of fixes those issues at the cost of not being POSIX-compatible. Luckily though, I don't give a single damn about POSIX compatibility, so I'm perfectly fine writing my scripts in it.

Yeah, and it also works out of the box. I still customize it a bit, but at least it doesn't require me to install 12000 packages to get basic functionality.

Python

Not a shell but still a good language to write your scripts in.

Zsh

POSIX-compatible shell that can be customized to work just as well as fish.

When it comes to text editing, I have very specific requirements that no text editor can achieve out of the box while not being bloated. Therefore, I have to put myself through the torture of using Neovim, which is highly customizable but a pain in the ass to get used to. Luckily, I'm a masochist, so it's absolutely not an issue for me.

Nano

A minimalist text editor that doesn't require you to be a masochist to use it.

Vim

Neovim but not neo.

Let's be honest. I have no idea how it works nor do I know how to use it properly. Still, it somehow manages to be extremely helpful to me. For me as a programmer wannabe, version control is critical since it allows me to effectively introduce changes into the code base without breaking everything. It's a complete miracle that git works so well despite being so complex and that it managed to become so popular despite being decentralized and open source. Let's hope it doesn't go away.

Controlling your versions manually

Sure, why not?

rclone is a Swiss army knife utility that allows you to sync from any cloud storage and to any cloud storage. The fact that such a utility exists and it's completely open source is a miracle, and I'm so glad that it does. Now that I know about it, I no longer have to use any crappy proprietary client for my cloud storage provider and can just use one little tool for everything, and it just works. Which means that I get better user experience than even Windows users. Isn't that wonderful?

rsync

For the cases when you need to sync up with your own server.

GVfs

Similar to rclone but made for slightly different purposes.

As you have probably noticed, my website is quite complex. And to handle such complexity, I have to use a static site generator. Hugo is the one I randomly chose to be the one I use. So far, it's been quite a pleasant experience. The template language it uses, while being slightly weird, allows me to pull off quite a few interesting tricks like a breadcrumb navigation and anchored headings. Another nice thing about it is that it's statically linked and written in Go, which means it's just one binary file with no dependencies.

Not using an SSG

Good idea if you have a small website and/or don't mind editing every single one of your pages after a slight change in the template.

Writing your own custom SSG

Good idea if you're unsatisfied with other options and also extremely smart unlike me.

Yes, Mozilla is not doing well as a company, but Firefox still remains the one browser that's reasonably private, has enough features, and supports Linux well enough. If it dies someday, I'll jump to the second best option, but while it's alive, I'll keep using it. Giving up and allowing Google to have a monopoly to decide what the Web is going to be is a bad idea.

Brave

Second best option? I'm not sure.

Ungoogled Chromium

Another good option, I guess, but lacks a few useful features.

Bitwarden combines the best of the 2 password manager worlds. On one hand, it's open source, which means you can actually trust it. On the other hand, it's cloud-based, which allows you to sync your passwords between devices in a comfortable way without any magic. On top of that, it also offers a generous free plan that barely has any limitations and allows you to self-host your own server. For these reasons, Bitwarden is what I recommend to an average person.

KeepassXC

Better option for paranoid people who can sync their stuff manually.

pass

Better option for extreme minimalists who use the command line in addition to being able to manually sync stuff.

Oh, what's this? A proprietary app? By Microsoft? Yes, it is. I'd gladly use something else but this app satisfies my note taking needs perfectly despite being proprietary:

• It's extremely simple. All I need is an ability to write stuff and a checkbox near the stuff I wrote. Also maybe an ability to organize stuff into lists and folders. Nothing else.
• It has both an Android app and a web app, which I absolutely 100% need because I often take notes on my phone.
• It syncs my stuff with the cloud, so I never have to do it manually.

If you know any other app that is open source and satisfies all of the 3 requirements, feel free to contact me.

Notion

Another proprietary app that allows you to organize quite some complex stuff.

A plain text file

What I used to use. Doesn't work that bad but doesn't satisfy any of the 3 requirements.

GIMP is by far not the best graphical editor in the world, but there isn't much choice. It's a bit technologically outdated and not the most powerful, but hey it's open source and actually somewhat works. In addition to that, it's the only editor I'm good at, so abandoning it would be not the smartest idea.

ImageMagick

Another way to do magic on images but without a GUI.

Microsoft Paint

Where it all started.

I hate WYSIWYG editors but still have to use this one for my college stuff. Someday, the good times will come, and I'll no longer have to use it.

Markdown

Use it when you want to write stuff without subjecting yourself to rectal pain.

Microsoft Office

Proprietary garbage that works better for some edge cases.

Just like git, OBS is a good example of a software miracle. It's open source, and everyone uses it. The latter is especially weird, considering it's targeted for gamers, and 99.9% of the video games are proprietary. Once again, I'm so glad that it exists because otherwise I'd have to rely on something less professional like CLI-based hacks.

GNOME built-in screen recorder

Works well when you need to quickly capture something to show to other people.

FFmpeg

For the cases when you need to do some magic on the recorded video/audio.

As you probably know, I'm a law-abiding citizen, and I never pirate any video games, especially ones by Nintendo®. Thus, in order to abide the law and not pirate the games, I need software that would allow me to play the legally obtained video games by emulating the console those game would be legally played on. Luckily, RetroArch does exactly that for a wide range of consoles. It does sacrifice a bit of overall quality and is prone to bugs, but eh, it's good enough for me.

Not playing legally obtained video games

For people who don't have free time (not me).

Installing emulators separately

For people who have free time (not me).

As you can see by the "ISO" part in the format's name, it's an actual standard written by the International Organization for Standardization. It defines many cool things like a way to write time intervals, which can be useful for writing portable software, and a calendar where the year is separated not by months but by weeks, which is used in finances, but here we're only interested in the basics. Simplified, the core date format looks like this:

yyyy-mm-ddThh:mm:ss

RFC 3339, a commonly used profile of ISO 8601, also allows you to replace the T in the middle with a space, for better readability:

yyyy-mm-dd hh:mm:ss

Yup, that's about it. You write the year, the month, the day, and then the time exactly like it's done in other date formats. There's nothing extraordinary, so you can learn it in 2 minutes.

This is the main reason the standard was written and why people still use it. Other date formats can be difficult to tell apart. For example, consider this date:

02-03-04

When you read it out of context, you have absolutely no idea what's going on there. Is 02 here the day or the month? You just can't know unless the day in the date is greater than 12, in which case it just can't be a month:

30-03-04

This day-month ambiguity is a really common problem, which often occurs online. People just write down their dates in whatever date format they know without even thinking that other people can interpret it in different ways.

ISO 8601 doesn't have this problem as it's always obvious which part is the day and which is the month because of the uniqueness of the format:

2004-03-02

While other date formats usually don't provide strict requirements on how to write something, ISO 8601 is an exception. Apart from few edge cases, here, there's only one correct way to write a date, which is not only useful for computers to parse, but also helpful for humans to avoid confusion with other formats and improve readability. Here are some of the restrictions:

• The elements in the date are always separated by a hyphen. Not many date formats use this delimiter, and this also can be useful when using dates inside filenames as slashes are usually not accepted in them.
• The elements are always padded to the maximum number of digits. This not only makes all of the dates look equally nice, but also, coupled with other quirks of this format, allows the files with the date in the name to be sorted just by the filename.
• The year is always written in the full form. This makes the format unique when written down and eliminates the year 2000 problem in any forms that it can take. For example, when writing down birthdays, it always makes it obvious which century we're talking about.
• The time is always written in the 24 hour format, so there can be no confusion about what half of the day something happened in.

On the first glance, it seems like the European format is about as logical as it can get — days go into months and months go into years:

18.12.2002
---------> Elements

However, this ignores a very important characteristic of numbers — endianness. Consider a regular number, for example:

69420
<---- Digits

As you can see the digits here do the opposite of what elements do in the European format. When the leftmost element of something is the most valuable, we call it big endian.

Thus, the European format is little endian while the numbers in it are big endian:

18.12.2002
<- <- <--- Digits
---------> Elements

And the American format just makes no sense:

12/18/2002
<- <- <--- Digits
?????????? Elements

And, as you can see, ISO 8601 is completely consistent in this regard as everything is big endian:

2002-12-18
<--- <- <- Digits
<--------- Elements

The situation becomes even worse if you consider time because it is big endian, like ISO 8601, thus doesn't work with any other date format:

18.12.2002 23:03:59
<- <- <--- <- <- <- Digits
---------> <------- Elements

12/18/2002 23:03:59
<- <- <--- <- <- <- Digits
?????????? <------- Elements

2002-12-18 23:03:59
<--- <- <- <- <- <- Digits
<--------- <------- Elements

If you're still having trouble visualizing all of this in your head, look at this Reddit post.

If you think that ISO 8601 is a silly thing that someone in their basement made up and no one actually uses, think again because that can't be further from the truth:

• The fact that it's standardized says at least something. Does your favorite format has a neat several hundred page document where it's described in extreme detail and that is internationally recognized? Also the standard is quite far from being dead — after being published in 1988 it was updated in 1991, 2000, 2004, and 2019.
• As I already mentioned, the standard is actively used in IT. Almost everything that is used by software and somehow involves a written numerical date format already speaks ISO 8601.
• yyyy-mm-dd has been adapted or used since the beginning as a national date format by many countries such as Canada, Sweden, and Japan. See this article for more details.

It doesn't have any of the nice features ISO 8601 has and doesn't work well internationally (i.e. assumes the person you're communicating with knows English). If you think the latter is not a problem, imagine how you would feel if you had to read a date someone wrote in their native language that you don't understand:

01-Янв-2020

The only reason why it does to you is because you're not used to it. After a little bit of practice, it'll be even less weird than your favorite date format.

First of all, the claim that the order of relevance is little endian is quite questionable. The only situation when you can say that for certain is when we're talking about events occurring on a day-to-day basis, however I can think of numerous cases when the year and the month are more relevant:

• Article publication date
• Historical event
• Personal event that happened a long time ago
• Someone's birthday
• Random database entry

Second, the order of relevance is actually irrelevant. Even if the order of relevance was this way, you're not reading the dates out loud, so there's no need for them to be ordered a certain way. If you're not interested in the year, you just skip it and read the end of the date just like you would do when reading time while not being interested in the hour.

In my opinion, ISO 8601 seems clearly superior to other date formats when it comes to international communication (such as posting things online), and as you can see, I have enough reasons to say so. While the format certainly has an audience, it's unfortunate that it's not as big as it could be. By writing this article, I hope I made you at least think about different date formats and be more careful when it comes to making people understand what date you're talking about.

Yes, I'm making a comment on an actual political issue despite being far from an expert in it. I know it may not turn too well, but I'd rather be transparent to you.

First, let's clear up a couple of things:

• I do support free speech, but I acknowledge that it’s not free of consequences and doesn’t mean a guarantee of a certain way of it to be presented.
• I do still support decentralization despite it making harder to moderate things as it’s highly beneficial for the democracy and resisting monopolization.
• I think content moderation only makes sense on social media and not things like cloud providers and DNS registrars as that's too excessive.
• I think the world would be better if social media didn't exist at all and everyone had their own websites instead as that'd make this problem much less prevalent and limit the scope of platforms where content moderation is needed.
• While I think offending posts shouldn't be shown, I don't think they should be deleted forever. Instead, they should be just hidden in a way that makes it possible to preserve them for future generations so the history is not lost.

So the basic idea of content moderation is that companies employ their ability to restrict their platform and remove the content they deem inappropriate. This is allowed to happen because free speech doesn't apply to private companies, and the people who don't support it are arguing that it should so the companies are not able to censor any ideas. I, however, don't support this idea for one simple reason: it'll do much more harm than benefit us. Aside from being necessary to limit the conversation from offtopic content, moderation is extremely useful for eliminating toxicity on the platforms. Even when done poorly, moderation prevents everything going completely apeshit because of overflowing by loud hateful vocal minorities. Should you remove the ability of private companies to do it, every platform will turn extremely toxic. There would be just no place for a normal conversation, which will affect the crime rate and will further propel the spreading of extremist ideologies. This should not be allowed to happen.

One argument that I've heard against it is "I would rather accept hateful groups on the platform and let their ideas be challenged by facts and logic", however it wouldn't work. No one will give a shit about facts and logic when they have an advantage of being popular. There's no other way to get rid of them other than isolate them to their own platforms, where their ideas slowly decade and die in peace.

First of all, if you don't like systemd, I have nothing against either you or your choice. Just please don't blame me for a choice different from yours more than I blame you.

In my opinion, systemd is a prime example of a software controversy made for little to no reason, and it's pretty funny. Here are some of the common arguments that are used against systemd and why I think they're wrong:

• It's monolithic? I have no idea why some people believe it, but basically they think that systemd is one big fat binary that encompasses all the features. It's not. The project consists of several dozen of standalone services that, by the most part, work independently of each other and can easily be disabled or replaced. It's quite far away from "all or nothing" and is similar in this aspect to the Linux kernel.
• It's bloated? I'd say that's pretty far from the truth, which can be proven by looking at the systemd services and the features they provide. For example, take a look at timesyncd or networkd. That, in my opinion, is quite minimalist and even feature lacking in some aspects. Projects like chrony and NetworkManager are much more feature complete, but no one has any complaints to them. And here I'm not even talking about services like localed or hostnamed that barely even count as services because they're like 3 lines of code that don't even sit in the background.
• It's complex? Yes, it is technically more complex than previous projects, but its complexity is justified by its helpful features, just like for many other software. That's how the modern world works.
• It doesn't follow the Unix way? It uses plain text for configuration and consists of many small programs that can be used together to do the job. Sounds pretty Unix to me. But even if it didn't follow it, let's just admit to ourselves that Unix is dead for good. What we have now is Linux and we should make the best out of it and not just blindly follow the principles from a prehistoric operating system.
• It's a feature creep? systemd promises to provide a set of low-level basic building blocks for a Linux system that allows it to run and be administered. As you can see, it does what it promises and nothing more. Just because all those tools are under a single name doesn't mean it's a feature creep. BSD does the same thing, but no one complains there.
• It forces people to use it? It does but by using the fair technique of being so useful that people actually use it. No one is technically holding a gun near your head and forces you to use it, and you're free to make a systemd-free distro. Just, please, don't complain when people don't want to support you because they have no obligation to do so for you.

And here are the reasons why I really like it:

• It's so much more convenient. systemd makes it much easier to do many things like, for example, reading logs of everything and analyzing your system. Every instrument is systemd's toolbox has a uniform well-documented interface that's not that big of a pain to use.
• It's more robust. systemd employs a declarative system for its configuration, which is more resistant to errors than executing arbitrary shell commands.
• It allows for more clever techniques. One of them, for example, is socket activation, which allows to launch services on demand instead just letting them sit in the background forever. Another one is containerization, which allows you to limit the capabilities of the services, making them less vulnerable.
• It unifies the ecosystem. Now when almost every distro uses systemd you don't have to worry about making a certain thing just work across all the systems, because it now just does.

Yes, I am not kidding. Just bear with me.

Wiping your ass with toilet paper is basically the worst thing you can do to it. Instead of actually getting rid of the feces, you just smear them while irritating your skin. Considering how people usually wipe, in the end you're just left with a barely cleaned ass. What's the solution to this, you might ask? Well, it's obvious — washing it instead. I've been doing it since I was a child, and I've had absolutely no problems so far. My ass is about as clean as it can get and my anal hygiene is incredibly simple while yielding great results.

Disclaimer: I've only ever flown cheap Russian airlines, so I have no idea about the situation in the rest of the world, but it's probably even better.

This one is kind of hard to explain because tastes are personal, but basically I think airplane food is not only good but also superior to regular food you can get in a restaurant or cook at home. Here are my extremely subjective reasons:

• It has a unique taste you can't get anywhere else. Apparently, because of the high altitude, and dry air the food doesn't taste as prominent as regular food. You may not like it, but I absolutely love it. It makes the food taste just so much better for me, and I would be incredibly happy if there was a way to recreate it at home.
• It's given to you in a small portion that's just enough to make you feel satisfied. You have to make the best out of little things you have and enjoy them.
• It's presented at the best time possible. After you've gone through all of the nightmare that is modern airport and waited through a portion of the flight, you get hungry and sad, but then you're given a little nice present in form of some interesting food. Isn't that nice?

By modern UIs, which I like, I mean the current state of app and web design, where minimalism rules, and by old UIs, which I dislike, I mean 90s utilitarian WIMP design. The best examples I can give of them is GNOME and Windows 95 respectively. In my opinion the principles of modern UI design do a much better job in the following aspects:

• Being eye candy. In contrast to old UIs, where everything is composed of ugly static gray uniform blocks, modern UIs greatly emphasize looking epic. One of the ways this is being done is by using animations. To me personally, they make using the apps more smooth and comfortable and create an illusion of the app being something more than just a couple of pixel surfaces on your screen.
• Reduced complexity. In contrast to old UIs, where you can have as many features as possible, making your menus grow arbitrarily long, in modern UIs you have to think about making everything fit on the phone screen. As a result, the designs have to be pretty minimalist with features abstracted in logical ways. This makes the already simple apps even less complex and hides the complexity of complex ones in a clever way.
• User friendliness. The days of needing to read a manual to use software are long gone. Professional software still requires you to learn it, but it's at least not so bad. Making software accessible by being obvious is a great thing, and we shouldn't go back.
• Less clutter. Modern UIs put a much greater emphasis on whitespace while old UIs tried to make the interface as compact as possible. In my opinion, this is a great thing because it makes it much easier to visually scan the information and makes everything look even nicer.

First of all, let's get one thing out of the way: I don't think there is such a thing as "bad music." Any music has an audience, and as long as it satisfies someone, it's good. You may not personally like modern music, but that doesn't make it bad. Yes, even if the music is getting less complex, you can't call it "objectively bad" because it still serves its purpose of being listened to.

Second, I think we truly live in a wonderful time in terms of music. We still have all of the nice genres from the past but we also have people making new stuff, including in those old genres. The new stuff does a great favor to the music by exploring the boundaries of what's possible to do with sounds. So in the end, I think if try hard enough you'll be able to enjoy some modern music too. For example, I'm a big jazz fan, but I also like dubstep.

It's widely known that the Star Wars prequels turned out to be not what was expected from the franchise, but in my opinion, it's not necessarily a bad thing. First, let's be honest, the quality of the movies wasn't that bad. Yes, the Episode 1 was a kind of rough start, but it gets much better in the end, and overall the quality of the film isn't low. Relatively speaking, you can't call the trilogy "bad." It surely isn't as classical as the original trilogy but still is interesting to watch. Second, this trilogy has a very nice thing that it shares with the original trilogy — originality. It introduced so many different characters, places, and concepts, but it still felt like a Star Wars movie series. The same can't be said about the sequels though. They lack absolutely any originality and basically copy the original trilogy in a quite shitty way. For this reason, I can say that the prequels are not that bad, especially compared to the sequels.

You may think that it's the fact that it was decided to move from the "there's only 1 display server" idea. You're wrong, as that would invalidate the core goals of the project — to be just a protocol that requires implementations.

What can't be denied, however, is the fact that instead of creating a full-featured "batteries included" set of protocols and a reference implementation of a library, compositors based on which could compete with X by being just as feature complete, there was created only a simple compositor, which can only satisfy the needs of a kiosk and not a modern desktop environment. An unofficial version of such a library didn't even appear until 2017.

After 12 years of development, the implementations of the protocol still have a series of features incompletely implemented:

• (Fixed by 2025) Color management
  Protocol, wlroots, Mutter, KWin
• (Fixed by 2024) Variable refresh rate support
  wlroots, Mutter, KWin
• (Fixed by 2024) DRM leasing
  Protocol, wlroots, Mutter, KWin
• Input emulation
  libei, wlroots (won't fix), Mutter, KWin
• (Fixed by 2023) High bit depth display support
  wlroots, Mutter, KWin
• (Fixed by 2021) Screencasting
  OBS Studio
• Client-side global hotkey binding
  xdg-desktop-portal, wlroots (stuck in limbo), GNOME, KDE
• Nvidia GPU support:
  • (Fixed by 2022) Nvidia not being assholes
  • (Fixed by 2021) GBM support by the proprietary driver
  • (Fixed by 2024) Explicit synchronization support
    Protocol, wlroots, Mutter, KWin

As you can see, it's not so many, and the partial fault here is on clients rather than servers.

On the server side, while it's true that Wayland makes implementing a display server much easier, implementing a window manager is still a nightmare. For example, even using a library, you need to write a thousand lines of code to implement the absolute bare bones compositor, which won't even support such critical things as damage tracking, hi-DPI, graphical tablets, multiseat, and any input/output configuration. X, on the other hand, allows you to write as few as 50 lines of code because it handles most of things such as the ones listed itself.

Wayland's core set of protocols while covering a wide range things, doesn't provide ones needed to build a modern desktop environment such as a desktop shell protocol (to build such things as panels and launchers), a protocol to simulate input and control windows, a protocol to control the clipboard, and others, leaving that to the compositors. While such a set of protocols does exist, it's not adopted by the majority of the compositors. A similar problem is happening to the set of protocols required to screenshot, screencast and remote desktop — the adoption by clients is extremely low. This makes working with Wayland and debugging it much less flexible and compositor-dependable than X, and makes developing clients even harder.

In contrast to X.org, which has a unified config system, each Wayland compositor has to implement configuration separately. This results in not only inconvenience when trying to move the config from one compositor to another or describing how to configure something, but also different feature coverage by different compositors. For example, a compositor may not implement an input configuration such as scrolling speed or graphical tablet mapping or an output configuration such as display bit depth. In some cases the compositor may not even implement any input configuration, which makes using it extremely problematic, especially considering such a problem doesn't exist when using X.

Considering the listed problems, the Wayland's future doesn't look that bright. But don't give up hope just yet, as long as we have projects like wlroots pushing the innovation, not everything is lost!

For obvious reasons, the OS would be open source, 100% DRM and spyware free, actively developed, and actually useful in its area. It would also probably follow some of the common software standards (like, for example, JSON for IPC and command line utilities), use consistent naming and versioning schemes, and be written in a memory-safe language.

• Most of Linux and BSD systems (partially)
• Some of hobbyist systems (partially)

Both of the 2 most popular file hierarchies, the Windows NT one and the Unix one (including whatever is built on top of it), are quite complicated due to historical reasons. Many of the directories are no longer used for their intended functionality, and some are practically duplicated.

A good one would look something like this:

• /
  • system/
    • Stuff
  • users/
    • username/
      • Stuff

Where Stuff is:

• apps
  • appname
    • Whatever resources the app is supposed to be installed with
• resources
  • binaries
  • libraries
  • themes
  • Whatever else can be shared between apps
• data
  • appname
    • cache
    • config
    • Whatever else state or configuration the app can have
• documents, downloads, music, videos, etc

• macOS (kind of)
• Flatpak (partially)

Having a shitton of protocols, for which you often don't have enough tools to easily explore, is terrible for discoverability. Everything is a file was supposed to fix that, but the solution was awkward and hard to deal with. So, instead of pretending that everything is a file, it'd make sense to accept that some "files" are not actually files and implement a universal way to explore them.

For example, a scheme could be created for each subsystem of the OS, allowing access to its objects via a URL like file:/system/apps/. Here's an example of what schemes could be created:

• file for the root file system and disk for any
• http{,s}, {quic,tcp,udp}, ip for different levels of network access
• process for signals, process information, and some IPC
• network, settings, audio, video, etc for high-level configuration/IO
• tty, desktop, window, notification, etc for UI
• device for low-level IO
• A custom scheme registered by its (in-library or standalone) handler

• Redox
• D-Bus (kind of)

For obvious security reasons, no app should be ever accepted as 100% trustworthy and bug-free, and sandboxing never lets that happen. That is unless there's a way to disable the sandbox or let some apps act outside of it, which will unavoidably get used, defeating the whole purpose of sandboxing.

Considering the file hierarchy from the previous point, it'd look something like this:

• By default, an app only has access to the file protocol and can only access its own files (read only), data, and (shared) resources it needs.
• It can ask for access to an additional protocol, resource, or files/data of another app.
• An app can be given a temporary or a permanent permission for such access.
• Each permission request must be approved or disapproved by the user.
• File dialogs are used to acquire permission to files that the user needs to open.

• Android
• Flatpak
• OpenBSD

It seems to be reasonable to just improve Linux instead of creating a whole new OS, and some progress is currently being made.

As usual, the elephant in the room. Fonts in Microsoft Windows don't look as good as they do everywhere else. I know the difference is not that big, it's all just a matter of preference, and if you're used to them, they'll look great, but who gives a shit. I'm no font expert, but here are the problems I can see:

• The default fonts are not cute enough. Specifically, in my opinion, the default UI font, Segoe UI, looks like an absolute ass compared to Roboto, San Francisco, and even Cantarell.
• As far as I understand, the fonts are extremely hinted, pushing every glyph into the pixel boundaries and deforming the intended design. As far as I know, by default, no other operating system does that.
• Subpixel rendering is used, which while slightly improving the resolution of the rendered glyphs, distorts their color. In addition to that, it makes it an absolute pain in the ass to edit the screenshots and is technically more difficult to implement and display properly. Most of other modern operating systems don't do that by default.

Many cancerous proprietary apps nowadays are guilty for this one, and, holy fuck, I hate it so much. Usually this problem manifests itself in form of:

• The app just straight up refusing to switch to the landscape orientation
• The app showing an unclosable error message if you're using it in the wrong orientation or on the desktop/mobile
• The app going apeshit or refusing to work on low resolutions

I can kinda understand the last 2 — the developers may be lazy or greedy as fuck or using some overengineered garbage to build the UI. An ability to use the app somehow in any case would be nice, but whatever. The first one, however, just doesn't make any goddamn sense. If you've built your shit with a modern UI toolkit, there's no way it can break completely after an orientation switch. Some minor things can occur if you're building something really complex, but, come on, you're not that lazy.

Or, quite often, the complete lack of it. I'm talking here mostly about variables in programming languages, but it can also apply to many other things. Here are some examples:

UNIX shell and classical PHP

Everything is just dumped into the global namespace and requires careful naming.

C

In addition to the problems of shell/PHP, careful naming is needed even more due to libraries, and the standard is fucked up (not only in terms of naming) and extremely long names can (theoretically) just not work on some compilers.

UNIX file hierarchy

A lot of not the best naming and duplicated functionality; not that bad overall, but needs to be simplified.

JavaScript

Despite opportunities to properly separate everything into modules, the global namespace is fucking enormous and contains things you probably don't even know existed.

DNS

It should've been in reverse.

Ink problems aside, we live in the 21st century, so you have no excuse for not using PDFs instead. Just stop wasting resources.

I don't know, they just won't work for me. Complex ones like {Microsoft ,Libre}Office break everything if you're trying to do something really sophisticated, while simple ones like your favorite note taking app are much less useful and rarely compatible with each other. They also often produce horrendous and barely human-readable plain text (or even worse, binary) markup, which is a pain in the ass to correct by hand. It's easier to just use a plain text editor and type Markdown if you need something simple and HTML+CSS if you need something cool, which I do.

Let's just start with the elephant in the room, as this website was heavily inspired by various lightweight ones like Best Motherfucking Website. At least in my opinion, statically generated and manually written website show that it's still possible to stay modern or stay funky without making the browser and server process all of the unnecessary crap. This website has in total one page that uses JavaScript, the credits, which is not even a text page but an art project, and those 10 lines are only used to show a fade-out animation.

So, yeah, people suck and fuck up everything, including the web, but I also want to talk about 2 specific websites: The New York Times and Medium. Those may be not the best examples, but you get the point: why the fuck does a website, which sole purpose is to serve text documents, make my browser have a stroke each time I visit it? This is just beyond me.

Unexpected error happened. Contact us or something.

I hate when this happens so much. The anger that I'm experiencing each time is absolutely indescribable. Look, I understand that your app aims at the largest audience possible, but is there any specific reason to not tell me the error message? Don't you think there are power users that happen to be using your goddamn app? What if the problem is on my side, how am I supposed to fix it if you don't tell me anything?

Quite often this problem exist in a form like this:

Unexpected error 0x0002b375

Just why? Tell me the motherfucking error message, don't make me browse your error code listing, which probably won't even help a bit in the end. It's okay to just print a little bit more text on the screen, we're not living in the 70s or something, where literally each bit is precious and must be saved no matter what.

From technical things, let's get more into casual ones. Voice messages really annoy me, especially when they're received at the worst moment possible. I know that you're a lazy piece of shit, and you don't even want to touch your keyboard, but do you really think I'm always ready to listen to your garbage no matter what? What if, in contrast to you, I don't want to annoy people in public places with random voices? And I'm not even talking about voice messages being impossible to search by their contents, taking more bandwidth, and being more difficult to archive.

The future would be really better if we had built-in transcription services in our messengers. That would not only fix all of this shit but also make them more accessible. Someone, of course, is going to fuck everything up by putting the whole process in the cloud, sacrificing users' privacy, instead of doing that locally, but let's just hope there will be adequate solutions.

I just walked my dog... That was a good walk... I'm so happy...

Or even better

WARNING!!!! Very important information!!!! Don't touch this file!!

Many of older people (or at least so I think) do that, and I really want them to stop. I know you may actually be such a slow talker or scream the whole time, but punctuation exists for a reason. Exclamation marks and ellipses are made to reflect a change in intonation to emphasize something. If your whole sentence is emphasized, then none of it is. Just use periods for fuck's sake.

And if you thought that was bad, wait until you see this:

Haha)) What a funny joke))))))))))))))))

You may think that the person has problems with their keyboard, but it's actually a Russian truncated smiley. So if you have

Hello :)

it becomes

Hello)

And if you're a complete moron, it becomes

Hello)))))))))))

Come on, is it really that hard to just type a singular regular smiley? No, it's not :) If you use this shit unironically and don't feel bad about it, I have no faith in you.

This problem became apparent almost instantly, as it was visible as early as the OS starts to boot up. It manifested itself in form of washed out colors, especially black. The problem was caused by improper display color range detection and, according to the bug tracker, was apparently fixed 2 times, but the fix still didn't work on my machine until very recently with kernel version 5.6.0-rc5. And I'm still not sure if the fix will last.

Update: it didn't.

In any case, after I acknowledged the existence of the problem, the solution was quickly found on Arch wiki:

xrandr --output OUTPUT-DEVICE --set 'Broadcast RGB' 'Full'

And it worked fine until I decided to switch to Wayland. No Wayland utility I know of provides an ability to set an "output property" yet, so it took me quite some time to figure out how to do that, and I had to launch an X server just to fix the problem after each reboot. Luckily, I bumped into this post. The required utility was called proptest, and it acted on DRM itself without touching the display server, so it had to be launched in the framebuffer console. I used the one from the drm-utils Fedora package and launched it manually at first but (after failing to make a dracut module) wrapped it in a systemd service later:

/usr/local/lib/systemd/system/broadcast-rgb-workaround.service:

[Unit]
Description=Work around the broken Broadcast RGB detection

[Service]
Type=oneshot
ExecStart=/usr/local/bin/broadcast-rgb-workaround

[Install]
WantedBy=basic.target

/usr/local/bin/broadcast-rgb-workaround:

#!/bin/sh

chvt 12

proptest CONNECTOR-NUMBER connector 97 1

chvt 1

(The numbers may alternate, and they did one time, so they have to be looked up manually by just launching proptest.)

The solution to this was found almost instantly by searching the kernel error message. I just had to copy this random firmware file to /usr/lib/firmware/brcm/.

The sound card on this machine is called bytcr-rt5651, and it was a huge pain in the ass to fix. First off, I just refused to use PulseAudio for quite some time. I'm not entirely sure what my motives were, but I just accepted having no sound at all. Why it didn't work with just bare ALSA is a whole other question. When I decided that there's actually nothing wrong with PulseAudio, the problems didn't end and it took me some time to find this set of files and apply it properly. One problem was that some UCM files were already included by default, but they were less correct than the ones in the set.

But that fixed only the software problems, and the hardware problems were much more ridiculous. The 4.5 mm audio jack on this machine acts as a headphone jack and a microphone jack at the same time. Literally at the same. Plugging the headphones there almost made me shit my pants the first time as I heard my own movement sounds amplified. But before I even thought of plugging the headphones directly, I used a female-to-male jack adapter, which I didn't even realize was dead. How stupid could I be to not check it for such a long time. In any case, I just found another one and plugged my headphones with it.

But then my headphones died. The only options available were the full-blown speakers and the Bluetooth headphones. The first option wasn't actually an option because the machine doesn't have enough horsepower to power them, so I went for the second one and failed. Bluetooth is supported by this machine and I could even detect the headphones and connect them, but no audio played whatever I tried. I didn't have much time to do anything with it, so I gave up for some time and had no sound once again.

After some time, I suddenly remembered that I had another, very big compared to the machine itself, speakers with amplification. The idea looked kinda silly because the speakers are literally, like, ten times the volume of the PC, and my setup was already fucked up through the roof, so introducing another cable didn't sound too great. I didn't have much choice, so I went for it in any case, and everything's been (mostly) okay since.

Intel Atom x5-Z8350 used on this machine, in addition to being a slow piece of shit and having graphical problems, is vulnerable to freezing on certain C-State transitions (see this bug report). And it seems like other operating systems like Windows are also affected by this, but I couldn't test that because I didn't use Windows on this machine for longer than 10 minutes.

The most common solution for this kind of problem is to use this script, but it doesn't work. Adding intel_idle.max_cstate=1 to the kernel boot parameters also doesn't help, but adding intel_idle.max_cstate=0 (which disables intel_idle as a whole and switches to acpi_idle) appears to work. It seems like it doesn't completely eliminate freezing, but it happens less often, and permanent freezing almost doesn't happen. Overall, this issue is not solved yet, and I'm still looking for updates.

I hugely fucked up by buying this computer, and I hope you won't repeat my mistakes. Everything, however, is not that bad after all because of the incredible work of the developers of the Linux kernel, wl-roots, GTK, Firefox, and others, and things are probably going to get even better. I'm still going to use this machine for some time, but I will choose my next one more carefully.