At this point it's too early to tell how well moderation can work in the long term. I'd rather they take it slow than burn out.

Same for any expectations regarding lemmy itself.

Nice choice of logo colors, btw.

Hard to tell without knowing some details.

Maybe they are incompetent or lazy. Maybe they don't expect the project to last that long. Maybe they are seniors that know your suggested architecture doesn't actually add to maintainability but increases connascences.

How would we know, OP.

So that's what inspired Vigil...

If religious can keep to themselves

Since religions compete, that doesn't sound feasible.

Indeed. Makes it more work to filter the handful of good or even great articles from the 99.99% that use this platform for its apparent ease of money grubbing.

I learned about gameprogrammingpatterns which led me to Nystroms other stuff as well. Which taught me programming techniques I used in a professional setting a couple of years later.

Also learnt where to buy non-labelled tshirts.

Programming Languages and Compilers. To be clear: The former exists on programming.dev, but there's a serious lack of activity.

You can not perfect old languages, since there are a lot of features that you can not add on or change afterwards, OP. Not in a worthwile way. This is not a philosophical question, it wasn't for a lack of trying. And since there aren't enough skilled people in this niche, fashion driven field, expect history to repeat itself and some langs at best get 60 to 80% right.

Yeah, at some point my new team switched off null safety, because some consultants told them to.

grundstoff.net

Seems to be specific to germany, though.

I'm glad it doesnt.

Between the lack of null safety (which really shouldn't have been a thing since the 90s), the incapacity in community management and lack of focus of the core devs mentioned by Gnome Kat and glad_cat, I tried Dlang in roughly 2015. It was an OKish experience for trivial tasks, but I noticed the amount of churn in dub packages.

TL;DR: I would not. And for the same reasons, I wouldn't recommend Scala either.

Please clarify, OP, did you mean

• hard to read semantically
• hard to read syntactically
• hard to relate how one could come with such a crappy idea, even considering all constraints of their time
• takes a lot brain real estate (justified or not)

?

Thunderbird. Hasn't bugged on me once.

Triangle, but with bevels. I believe old McDolan toys had those

Also, why has Python its own screws?

Or a signal that you'd rather not support the worst way to introduce type systems to frontend dev. While I'm not sure that applies to DHH, I am sure there are other devs that understand compromising all your goals to codepend on Node or even JS itself isn't that much of a win and rather see support for better options.

Well... https://httptoolkit.com/blog/apple-private-access-tokens-attestation/

Yes. They are largely "ordinary" patterns explained in the context of game (engine) classes.

It looks similar to Ruby but with an appropriately modern static type system and a macro system instead of runtime metaprogramming.

It also has its own concurrency story, as far as I remember.

Just wait until you learn that debuggers for XSLT exists. Wait, that's no reason to smile.

It'll probably take Valhalla for me, personally.

May I just ask how VB.NET code isn’t maintainable?

TL;DR: Lots of old code written by VB6/VBA programmers in the wild. It's way more holistic than C-hacker-ish C# code.

Speaking from a bunch of legacy projects, you will likely encounter:

• Option Strict Off activated, so your type checking and IDE tools are half broken now.
• Global imports from anywhere to anywhere, proper namespacing is unheard of.
• Object everywhere, because Variant.
• On Error Resume Next everywhere, so you switch off and on exceptions while debugging.
• ByRef everywhere, because VB Classic is call by reference first.
• All declarations on top of a function, drastically increasing their scope, because, you guessed it, this is the only way in old VB.
• Code bases riddled with poor reimplementations of string methods using Mid. Actually, that's a bonus, it's very satisfying replacing those with one call to a string member.
• Multiple assignments to function name variable instead of return, making code harder to follow.

That's not a positive, though.

Depending on how it pans out, it's either not useful enough. Who the hell doesn't use namespaces or enums. Or - as

These constructs are not in the scope of this proposal, but could be added by separate TC39 proposals.

implies - a door opener to outsource TypeScripts problem unto other peoples and not to investing into improving WebAssembly. That's just MS being lazy and making their problems other peoples problems.

I feel like this would be the ideal scenario: things working right out of the box without needing a compile step or additional tooling.

It's just annotations. No proposed semantics of a type system which your browser could check on its own.

Imagine using the menu key and always using the shortcut in the popup menu...

Git, probably

Background: Maintained legacy code for a handful of years.

Pros:

• They got generics syntax right
• Forms editor a bit less broken than for C#
• Better preprocessor, well, more powerful at least
• Explicit implementation of interfaces
• Better switch statement, though I think C# kind of caught up
• Some other advantages over C# from here I forgot

Cons:

• It is possible that Option Strict, Explicit and Infer aren't activated in that legacy project, so you should run
• Includes a lot of VB classic stuff
• No unsafe mode
• Less null safe than C#
• Microsoft basically seems to have abandoned it
• Includes some bullshit, like XML literals
• No pattern matching
• Index operator() doesn't read great
• Some other questionable design decisions from here I forgot
• It's .Net, something that I've felt less and less enthusiastic about as times progressed and which has become sort of a symbol of tragic waste for me

Indeed, and just as my old team fell for consultants, my new team also went ahead and let them add some overcomplex garbage into their codebases. And crap still keeps piling up. It's just like it's impossible for them to understand that from an average consultants perspective the only way to go forward is to keep adding complexity, wether they are aware of it or not.

I need it to steal content from programminglanguages.

people don’t want to admin

Exactly right.

• Oni
• Attack Of The Saucerman
• Urban Chaos (the older one, not sure about the new one)
• Half of the legit stuff Sseth reviewed.

Now, you’re paying for the product, and you continue to be the product.

So this is what "neofeudalism" boils down to?

It was indeed three pawns to introduce it. Nice eye for detail.

Thanks.

I'd prefer if the logo could be spinned...

How compiler builders see peppa:

even number of nostrils

Missed opportunity.

Working on it...

Of course, I might be overestimating how easy it is to get better braille oriented editors

A braille display traditionally is a personal, almost handfitted (estimated by price) device controlled by its screen reader software. Not the editor. This has some unfortunate implications:

• There is no (standardized) API to control your braille device directly. You could hand your screenreader filtered data, but that would be read as well. At best, you might be able to script your screen reader software to a varying degree of success. However:
  • Every aspect about this is extremely abysmal in every possible way, so it will likely require you to fork over some biiiiig amount of cash to one of the vendors to provide a brittle plugin. In particular if we are talking about JAWS. Think of extremely unstandardized COBOL dev with less stability and more price gauging involved.
  • As far as free readers are involved, only the proprietary and licensing aspect go away. Still, developing extensions is terrible in many ways. For example, for ORCA, I was able to find out that you can extend it somehow. Alledgedly. NVDA on the other hand has better documentation. That is to say, it has documentation. Now, you might recall that NVDA is written mostly in Python, and its devs rightly don't even pretend that one could develop stable software in Python, so APIs might change. However, I wasn't able to find a Filter function specific to braille output. That's likely because
• From my superficial experience, developers of screen readers think of braille displays mostly as an alternative to speech. It even took them quite a while to be smart about not displaying redundant, long lines of text.

So yes, you might be overestimating how easy that is, compared to telling some diva asswipe chucklefuck to use that formatter or work at McDolans.

Original poster is right by all accounts, of course. Now, let's come up with exotic significant indentations.

function xyz(a, b):
|   var x = 2

|   if true:
|   |   do_something()
|   else:
|   |   do_something_else()

|   anyway()

Pro: Your editor no longer needs to implement indentation hints.

Con: Looks obstructive if not highlighted like an indentation hint.

Your turn.

Oni: not possible to rebind keys.

As for honorable mentions, Urban Chaos/Attack of the saucerman: I can't imagine a successful remake.