dokyun

> Windows has turned itself into spyware

Has?

The ancient Romans had far less of a problem with all of those things than many people do now; would you consider them uncivilized?

If you hate nesting, just do this

    (defun foo (&aux bar baz)
      (setq bar (quux)
            baz (xyzzy))
      ...)

    (the number (+ 35 7))

is a lot less clunky than

    (+ 35 7)@Numeric

No point in placing your hope in people you don't even know. You couldn't figure an eight, with the way you're going.

Since I don't consider it my job to provide context or be constructive, I let other people like you do it for me. I might follow up on it, as is my freedom of choice, but since I can't guarantee that happening I tend to do things that way. See, isn't that a fun system? I've augmented my own freedom with yours!

I was aware of the story beforehand. The context you've pasted here hasn't changed the intent of my statement, but I'm glad you took the time to type it.

> Third, emails weren't handed over

That they weren't, however the information that was handed over was enough to identify the target.

> Why parrot half of a story disparaging one of the only large email providers that fights in court to protect the privacy of its users?

Because despite their apparent and commendable work in trying to preserve the privacy of their users, they have regretfully failed to do so in the past, and it will more than likely proceed that way in the future.

It's not that I want to badmouth their efforts, but it has tainted them so I think it would be wrong not to bring it up. An email provider that has never divulged info (of which several exist) isn't tainted the same way as one that has. It may only be a difference of time and scale, but it's your freedom of choice, and I think freedom of choice is a very important thing. Email is decentralized, and the more email providers that exist and hold themselves to high standards the better. If more people moved between or started smaller email providers, it would help relieve these kinds of issues.

So that is why I would recommend against it.

You probably still don't want one, given they've been known to divulge user info to various authorities in the past.

That's what makes it come off as stupid and kneejerk to me. This guy wrote "The Wii homebrew community was all built on top of a pile of lies and copyright infringement" like it's some kind of shocking revelation. The guy writes it in a way that makes me think it's fueled by some years-long grudge rather than an intent to unravel some kind of conspiracy. It's kinda pathetic, really.

signed, "I have had more money than I will ever need for the last decade". Get fucked.

> Lisp is so powerful, but <tired old shit from someone who's never used Lisp>.

You use defmethod for overloading. Types check themselves.

So Open Source is like a dark mirror version of Free Software. Open Source thinks that there's benefit in programs being free, but also that defending their freedom is actually a bad thing.

Ironic since the Chinese already banned facial recognition.

Paint.net isn't free software, it's proprietary freeware. It used to be free a long time ago, but the author is a tool and made it closed source because people were creating other versions of it.

I think working with a ready-made Unix isn't as friendly to the idea of 'hobbying' an OS. For studying how Unix works, it's great. But if I wanted to make experimenting with my own bespoke system worth it, I would try to not have preconceived notions about how it should work, or copy an entire design. There are dime-a-dozen Unix-workalike hobby OSes out there, and in the shoes of an experimentalist there's a lot to weigh you down in the Unix ecosystem, and a lot of things worth trying that break from the way Unix does things.

If you really did want to work with an existing OS for actual research/experimentation purposes, and you're a fan of C, I would go with Plan 9/9front. There's a reason Bell Labs ditched Unix--because it wasn't a worthy research platform anymore.

Yeah this is cool.

It would be great if there were more hobby OS resources targetting something other than X86. It is common and everything, but all the bootstrapping and device cruft involved isn't something you should need to get in your head, and 386 assembly by itself is terribly frustrating and obtuse to write by hand. I think most people might be better off starting out with a RISC microcontroller. There isn't nearly as much bullshit involved between getting a running kernel and talking some simple serial, and you can get an instruction set reference, assembler manual, and processor datasheet that will tell you everything you need to know. And it's easy to have fun hardware hacking that way too, making your own peripherals and such.

Seems like Visual Studio rots the mind so bad nowadays that people would rather clamor support for useless garbage like LSP in their editors, and if it can't be supported very well it's foremost the editor's fault, not the fault of the crap they want to tack on to an otherwise fine product. People have been doing this with Emacs, saying Emacs is slow because its LSP implementations are slow and unresponsive, not that LSP is badly designed, or that an editor shouldn't need an asynchronous network protocol to provide IDE features. It also demonstrates the mentality that people find it increasingly preferable to have their computing served to them on a silver platter by a third party than being able to control it locally.

A shitpost doesn't have to be low effort, rather I'd argue the greatest ones are often quite high effort, and invoke a sense of poetry and lucidity that makes you question what could've gone on inside the head of the person that made it. That style of shitposting was part of the culture of 4chan's now-defunct textboards, and even back then it was markedly different from (and for the most part ignored by) the rest of the site.

For what it's worth, copypastas are the highest (and likely the oldest) form of meme.

An issue I have with imageboards is that use of images invites low-effort posting because it makes it easy to be as annoying as possible, whereas with pure text making inflammatory remarks at least takes some forethought, and it invites unique forms of creative writing. Anonymous textboards I think have the best forms of banter, but they're dying out these days. Over here people have incentives to appease others by gathering upvotes, so they feign this type of altruism that keeps them from being too inflammatory and makes them resort to stupid shit like tone indicators instead of being clever enough to write it that way.

implying hacker news is highbrow

Why is it that square pegs are easy to fit in a square hole, but not so in a round hole?

It's the only Macsyma anyone's running these days, so maybe if Symbolics hadn't killed it off there'd be another version more deserving of the title.

I got a lightly used copy off Amazon, along with "The UNIX programming environment" a year or two ago, probably. They're both fine with only a bit of wear, but I don't think they were ever of a super sturdy binding that would hold up well under heavy abuse.

You'll lose first.

God forbid any of that corrosive communist ``free software'' touch our pure American companies.

I don't disagree with you there. The only thing CL really misses out on is that its type system isn't specced out enough to be as powerful as it could be. Since they're just macros you can write all kinds of crazy types, but non-terminating ones just might not work if your implementation doesn't handle them a certain way. This was actually a disputed issue: https://www.lispworks.com/documentation/HyperSpec/Issues/iss....

Someone had proposed reifying types to be first-class objects, which might be a good thing. I haven't thought about it enough to decide. https://gist.github.com/Bike/e405cc49a64fed0752b524c292bd715...

I don't believe it's not intrinsic. A lot of the reason why Lispers may be averse to static types is because of the perceived inflexibility it can induce into the system. Lisp programmers don't want to be told what to do, especially by the compiler. Some CLs like SBCL have allowed some form of inference through the standard type declarations in the language. This leads me to believe that the 'right thing' in the case of Lisp is a combination of dynamicity and some stronger typing features that can be applied during the optimization stage. The dynamic nature and ease of use of Lisp relative to its performance is one of its greatest assets: it would be nearsighted to try and sacrifice that--a good Lisp programmer can optimize the important parts of his programs such that they're comparable to or even outperform their equivalents in other more ``high-performance'' languages. With that being said, these developments might bring us closer to a ``sufficiently smart compiler'' that could make that latter stage mostly unnecessary.

Aren't people using GNUboot nowadays?

Considering intellectual property doesn't exist, I wouldn't fault him for not knowing anything about its fundamentals.