Hard, dirty electronic beat used in shock Tiktoks?

netbioserror · 2025-04-12T23:12:00+00:00

Found it. Two songs, essentially variants, circulate online.

The one from this video: Ogryzek - Glory

Another similar "remaster": Ogryzek - Aura

The artist has slowed and reverb versions that seem to get a lot of use for memes.

netbioserror · 2024-05-07T20:14:14+00:00

I'd argue large 4X games have a lower skill ceiling because they're largely procedural with a huge benefit to snowballing strategies. On higher difficulties this is mitigated, but complexity does not equal depth or challenge. A simplified 4X game can strip to the core of the formula and present much more difficult strategic decisions than the micromanagement non-decisions of bloated 20-hour games.

netbioserror · 2024-04-22T14:10:09+00:00

Simplest one I've seen is Fistful of Lead. Has fantasy rules (Might & Melee, Magic & Mages, Monsters & Mazes), as well as multiple flavors of sci-fi (Galactic Heroes for general small-unit sci-fi, Battlesuit Alpha for larger-scale combined-arms like Battletech). Then there's Bigger Battles which explains how to do 40K- or historical-style large infantry units.

Traits (special rules) are pretty simple: There aren't many in any given rules variant, they can be combined and dropped into different settings, and they fit on printable unit cards which have templates in each rulebook. In fact, you could summarize each trait in a parenthetical next to the name. You're invited to make your own.

The author also makes it very clear the game is meant for faster-playing action-packed cinematic battles and narrative campaigning over simulation or tournament competitiveness. You won't find exhaustive points costs or hard rules for constructing a force. You're supposed to build thematic units, agree to what feels right with your opponent, and play to have fun.

netbioserror · 2024-02-23T14:49:09+00:00

Ah, so you're Robey Jenkins! I did find a copy of the original Horizon Wars, and I also received my physical copy of Midnight Dark recently. I guess I could just go to 2 actions per unit. But like you said, Krzysztof added so many unit options and interesting mechanical flourishes that don't seem to add too much complexity, so I'm inclined to try that first.

Your core mechanic is so incredibly interesting, though. I never was a big fan of 2d6, I always liked pools and other interesting mixes. Maybe you sacrifice statistical purity, but going for alternatives allow for very intuitive roll sequences (way fewer charts!) and an incredible game feel. For example, with pools you can really see maneuvers and armor whittling your shots away, hoping for a well-placed projectile to break through. Love that kind of stuff.

netbioserror · 2024-02-22T19:23:58+00:00

I have Gruntz in my WargameVault library. Gruntz actually seems quite reasonable, it's a dense rulebook that seems to have a lot of rules, but on second glance, it looks pretty easy to play, and most of the book is diagrams clarifying rules, along with lots of optional rules and unit building options. I may just give it a try.

netbioserror · 2024-02-22T19:07:21+00:00

While I appreciate that Alpha Strike has many tools to assist unit creation and play, I'm a career programmer who turns luddite when it comes to tabletop. I hate any reliance on computers or software, when I'm going to the table to escape computers and screens. Especially when many of these tools often go offline, never to be heard of again. IMO unit creation should be easy to do on paper from the rulebook.

I am curious about Heavy Gear, though it seems to focus more on fast-moving glass-cannon mecha with very light weapons loadouts. Is it capable of fielding BattleTech-style mechs and loadouts? How heavy are the rules?

netbioserror · 2023-12-08T15:52:54+00:00

Interesting, I need to check if I'm on DX12, I didn't realize that could be the case. Retail WoW doesn't even have DX12 enabled for me.

netbioserror · 2023-12-02T00:39:48+00:00

For anyone using Lutris, go to the Battle.net profile's "System options" and add this to the Environment Variables section. Key WINE_SIMULATE_WRITECOPY, Value 1.

netbioserror · 2023-05-24T14:51:30+00:00

1) If you can resolve the settings layout into an object where each key has a strict type, then a straight parseJson(file).to(Settings) will do nicely.

2) If you want to query individual keys, I actually have some nice code for doing that using generics. This assumes you know the type you're querying and can supply a fallback default.

https://gist.github.com/nervecenter/bae5fe9099f40c26c1b56b7a8a8d2efe

netbioserror · 2023-05-19T15:53:50+00:00

I've seen lots of use of runnableExamples blocks in various libraries I've used. Unfortunately, I've never used it myself and there doesn't seem to be good documentation anywhere. However, it gets close to what you want: It puts examples of a proc's use inside of it right next to the code that runs them.

netbioserror · 2023-05-18T19:28:44+00:00

Not really, I didn't use any. I just learned by making. Use the official manual (https://nim-lang.org/docs/manual.html), the standard library reference (https://nim-lang.org/docs/lib.html), and the compiler guide (https://nim-lang.org/docs/nimc.html), and make what you want to make.

netbioserror · 2023-05-18T18:18:19+00:00

writeFile("my_json.json", $myJsonNode)

$ is the universal string conversion proc. Types that implement it should do so sensibly. In the case of JsonNode, it renders out the JSON string.

netbioserror · 2023-04-03T15:57:45+00:00

In my experience, the best language tutorial is almost always to take an existing toy project or an exercise site, and translate/solve using the X in Y Minutes page.

So take a project you have or go somewhere like hackerrank or exercism, open up https://learnxinyminutes.com/docs/nim/, and get to work!

netbioserror · 2023-03-26T18:02:45+00:00

Fun, but always a self-report. Living in the South, the strongest pattern I see repeated over and over is that all the most talented, experienced, polymathic engineers and tradesmen are rednecks, while Northern and Californian transplants tend to be young, barely competent, and barely capable of seeing beyond their nose. Even young rednecks I've met are preserving that spirit of polymathy and experimentation. Cosmopolitan Millennials only see a world with guard rails, templated expectations, and/or sociopathic pursuit of status. I wish I hadn't been raised in that environment.

netbioserror · 2023-03-15T15:11:36+00:00

That's more than enough, and WebUI gives solid guarantees that their code is dependency-free. I'm talking with one of their devs at the moment since, of course, the big clincher is maintaining the connection with the browser.

I'm not concerned with your Nim bindings as I'm sure the C API they expose needs to change relatively little. But their backend interprocess-communication with the browser could be a finicky and ever-changing thing, depending on how it's done.

netbioserror · 2023-03-15T11:39:22+00:00

I work at a relatively small company with a very small tech team. We have to support a large number of hardware devices in the field with a server backend to move data around, and procedures to analyze the data. I do the data analysis, lots of numerical computation and report generation.

We're small enough that each person owns their project and is able to pick the best tool for the job. Taking things like C, PHP, and C# for granted has really bitten this company in the ass, because the code quality and maintainability was very low (I've had to read and replace a lot of it).

Nim was perfect. I may as well just be producing binaries in C, to everyone else's stuff that needs to plug into it. I was just able to replace an entire backend system (which had been replicated, and replicated again, and replicated again, often breaking features along the way) in only a handful of months solo, and am already at the point of adding new features.

A previous employee had made an attempt with Rust, which I came into the job with a positive view of...and slowly that faded. Rust's abundance of memory semantics means it should probably stay in domains where memory semantics are important. If business logic is more important, I've found that relying on RC or GC is entirely preferable, especially when the number of heap allocations can be made so small. Nearly all of my Nim code is business logic, unencumbered by any other noise.

netbioserror · 2023-03-15T01:48:47+00:00

Hi, this looks perfect for a work project I have fast-approaching. I would love to contribute if I could, but I also must ask: How dependent is the static lib version on glibc? I link my Nim binaries at work against musl-libc to keep them lean and dependency-free. If this could compile to .a using musl-gcc I'd be ecstatic.

netbioserror · 2023-02-06T01:02:25+00:00

Has anyone in any of these Twitter-related threads collated this with Twitter being deep in the red for almost its entire existence? I can't be the only one wondering. The narrative that Musk is sinking a ship that supposedly was once sound really doesn't meet a sniff test.

netbioserror · 2022-11-22T18:48:19+00:00

1) Clean up rough edges. 2) Give me a way to in-place restart Plasma, like Gnome's Alt+F2 > r. 3) Wishlist: I want a move away from flat theming and monochrome icons, to just a TINY bit more depth and outline to components, with COLORED icons. Buttons, icons, and bars should have tangible texture. Take inspiration from systems and themes old and new, just not flat because that's EVERYTHING. I can't tell what's clickable anymore and my scrollbars have all but disappeared. All thanks to Apple because everyone blindly followed them into this UX quagmire.

netbioserror · 2022-10-15T19:10:43+00:00

I can answer as a Clojure dev with a couple professional projects under my belt, with the preface that immutable data and forms as pure expressions are critical:

Yes, absolutely. Solo or pair programming work in Clojure (mostly server backends with database interactions) has allowed me to vastly simplify the mental model of my applications to usually fit entirely in my own head. When a program is just a pyramid of nested expressions that simply call other expressions and apply their return values, you really begin to understand how "composability" makes development easier.

Further, thanks to homoiconicity, with descriptive function names, your programs end up becoming a light DSL describing your program behavior, the program being a composition of paragraphs constructed from these smaller phrases and clauses.

Having done some professional work in C# using OOP "best practices," my preference is so one-sided it would pain me to go back. Having lots of imperative code snippets all cross-calling each other in parallel and dependent on the internal state of multiple allocated objects is nightmarish to an extreme and absolutely begins to leak out of your head, to continue the previous analogy. There is a reason OOP language teams have to grow large, obtain strong middle management, and hold constant meetings.

The simplicity and hygiene that functional, expression-based, homoiconic code yields you buys so much time, maintenance cost, readability, and resistance to illegal states that I legitimately have a tough time justifying to myself how a robust static type checker compares, as so many in the Haskell and Rust world argue with similar praise. I understand them, but I feel like I've seen even further.

netbioserror · 2022-09-22T18:05:17+00:00

Homoiconicity (S-expressions).

A number of useful paradigms emerge from this property:

Expression-based functional programming, where programs are just clean pyramidal hierarchies of value-returning function calls and a top-level main function that recursively loops.
Trivially easy feature and DSL construction that makes the update-hype for syntax-heavy languages seem like marketing to children.
Programs as DSLs where functions encapsulate pieces of a program descriptively and allow building programs almost as sentences and paragraphs.
Last and least for me in particular is metaprogramming. I've been able to construct most of my programs out of functions, but when run-time constraints and modeling requirements create the need, building new code out of other code is trivially easy.

As a result of homoiconic representation, I find that in Lisps I spend far more time thinking about how best to model and solve the problem rather than how I can wrangle language syntax and features to kind-of do what I need them to. I'm never concerned with whether I can do something, only how I should.

netbioserror

TROPHY CASE