alexpana

const std = @import("std");

// const input = @embedFile("18.test.input");

const Operator = enum {
    l_paren,
    r_paren,
    add,
    sub,
    mul,

alexpana

WPM = 200; m = Array.from(document.getElementsByTagName("p")).reduce((acc, t) => acc + t.innerHTML, "").split(" ").length / WPM; h = Math.floor(m / 60); m = Math.floor(m % 60); msg = h > 0 ? h+"h "+m+"m" : m+"m";alert("Estimated read time: " + msg)

alexpana

float FParticleRibbonEmitterInstance::Spawn(float DeltaTime)
{
	bool bProcessSpawnRate = Spawn_Source(DeltaTime);
	if (bProcessSpawnRate == false)
	{
		return SpawnFraction;
	}

	UParticleLODLevel* LODLevel = SpriteTemplate->LODLevels[0];
	check(LODLevel);

alexpana

import bpy
import os
from time import time
from bpy.props import BoolProperty, IntProperty, PointerProperty

bl_info = {
    "name": "Image Auto Reload",
    "description": "",
    "author": "[email protected]",
    "version": (0, 0, 1),

alexpana

using UnityEngine;

namespace Camera
{
    public class OrbitCameraController : MonoBehaviour
    {
        private const float MIN_DISTANCE = 0.5f;

        private const float MAX_DISTANCE = 50f;

alexpana

PostRock

• Alcest
• Circadian Eyes
• Explosions in the Sky
• Eluvium
• Tides from Nebula
• Break my fucking sky
• Her name is Calla
• Nyctalgia
• God is an Astronaut

alexpana

Various 'features' of C++ that show the hacky / inconsistent way in which the language was constructed. This is a work in progress, and currently contains some of the reasons I can remember why I've given up on C++. If you want to contribute, leave your favourite "hack" in the comments.

1. (in)Visibility: C++ allows changing the access modifier of a virtual function in the derived class. Not only does C++ have no notion of interfaces, it actually allows subclasses to hide methods declared public in the superclass.

2. Operator over-overloading: One of the increment operators takes a dummy int parameter in order to allow overloading. Can you tell which without googling? (hint: its postfix).

3. Exception unspecifiers: C++ has two types of exception specifiers: throw() and nothrow. The first is deprecated (because 'we screwed up, sorry, let's forget about this terrible mess'). The second one guarantees it's contract by terminating the application when violated. That's because functions declared

alexpana

class Point {

    private final int x, y;

    private final String name; // Cached at construction time

    Point(int x, int y) {
        this.x = x;
        this.y = y;
        name = makeName();

alexpana

#include <memory>
#include <vector>
using namespace std;

class Test {
public:
    // vector of unique pointers to int
    vector<unique_ptr<int>> intVector;

    // moves a unique pointer into the vector

alexpana

{
	"caret_style": "phase",
	"fade_fold_buttons": false,
	"font_face": "Consolas",
	"font_size": 9,
	"highlight_line": true,
	"ignored_packages":
	[
		"Vintage"
	],