Yeah, C++ enums are just numbers that are really good at pretending to be types. And for that reason they're not actually objects that contain things like their name. And they probably shouldn't, in the vast majority of cases it would be an utter waste of space to store the names of enum members along with them. So you have compile-time reflection for those instead. And yeah, you could implement some kind of thing pretending to be a member but actually being a reflection thing but that's both horrifying and limited so C++ takes the reasonable approach of just adding general reflection in instead.
wow that's really evil of them i quite don't like them for this as i too played garrys mod back in the day and it pains me to see such a loss of community effort and beloved mods
It's not like they're demanding the deletion of all mod content as the headline carelessly implies. Yes it's boring and corporate but I don't think it rises to the level of 'evil.'
It sort of isn't though. You put it there and you don't take it away. You don't put anything else in there to load it. It stops loading entirely if you take out the ethernet cable. That kind of seems like it's loading from the internet every single time. The setup function doesn't add anything to load it without the init script running. That's kind of weird, to me at least.
Oh, I didn't mean to imply it was a good way of doing things, just that the intent was to auto-update. Regardless of how the auto-update works, if a program like this is auto-updating then you're giving arbitrary execution permission to the project.
Whatever Neuralink is missing, it's none of these things. They're certainly missing a lot, as is their owner, but it's absolutely none of these things. Like, we've been using brain electrodes to control devices for a very long time now. They know the issues. As they are originally a neuroprosthetics company whose whole goal was to develop means for paralyzed people to control limbs and devices, they're perfectly in their zone. That's not their issue.
As what their owner wants them to be, with data transmission into the brain and individually addressable neurons, they're leagues off from a functional product. Extracting and interpreting brain signals is, while not simple, well-known and well-practiced. The other direction is practically unexplored and the most we normally do is poke around with a bit of electricity and hope it makes the brain work better. To move data from a computer into the brain would be a total revolution. Needless to say, their current product does not do this, and they've shown zero development to this end. Which kind of makes it feel like they're hoodwinking Musk to develop actually useful medical devices instead of playing into his naive technocratic futurism. That just means they know what they're doing even more strongly than what their other actions have already shown.
> Extracting and interpreting brain signals is, while not simple, well-known and well-practiced. Their current product does not do this, and they've shown zero development to this end.
I was following you until this. Can you clarify? Isn’t their most recent work precisely an example of inferring and applying a person’s intent by deciphering their brain signals?
Ah, sorry, one of those situations where you think about what you'll write and don't end up writing it down. I am of course referring to the inverse in the second sentence, moving data into a brain from a computer. Corrected in the original comment now, thanks!
I don't think currying happens without you asking to, though. It happens because it happens, it's part of the language, and it's something you implicitly keep in the back of your mind every time you see a function call. I don't program a lot in Haskell, only some maths things I sometimes might need since it is rather useful for that, but the concept of currying is so natural that it's constantly expressing itself in the code. Very rarely do you apply arguments and consider that to be a function call in itself instead of like, three function calls. And since partial application is so incredibly important to Haskell and other similar languages, without currying writing would be very difficult. Consider the actual simple example of
> I don't think currying happens without you asking to, though. It happens because it happens, it's part of the language, and it's something you implicitly keep in the back of your mind every time you see a function call.
Eh, but that's my point: I want less cognitive load. Currying is another thing that I have to keep in the back of my mind, and Haskell already has way too many of those, and it's not a particularly useful thing. I've got limited space in the back of my mind for things and if I'm going to keep things in the back of my mind I want them to be useful. I mean, if your argument in favor of currying is that it saved you a few keystrokes in that example, color me unimpressed.
Maybe I'm just too stupid to understand easily, but the "simple" example you're giving is taking me a while to understand. If a junior dev on my team submitted that in a PR I'd send it back asking them to break it up into a few smaller named functions and probably not use a partial application at all. Something like "I know it's fun to be clever but let's make this easier for the next person who has to figure out what it does".
I guess what I'm saying is that for that example it seems like you're going for tersity rather than clarity for future readers of the code. If you were going for clarity you probably wouldn't write it either of the ways you've given.
And in big projects clarity is the number 1 concern[1]. In toy examples like this I can slog through and figure something like this out, but when it's 30 functions written like this, all calling each other in the most clever ways possible, nobody can figure it out.
[1] EDIT: Okay #2 after correctness perhaps. But it becomes hard to achieve correctness without clarity as a project grows.
Hi, as someone who has been interested in functional programming for a while but who struggled to read point-free Haskell code until recently, I think it might be useful to share my perspective.
If this Haskell code does not look clear, it's because people are unfamiliar with point-free style, not because the this code is badly written, and especially not because the reader is stupid.
The given Haskell code reads naturally to me now. (I'm only a little uncertain because I can't write Haskell.) It would have been line noise to me before before point-free style clicked.
I tend to read Haskell code in articles from right to left, and it reads: "Choose the symbols whose first letter is '*', get their respective (neighboringNumbers numbers), and choose the results whose length is 2". I read (neighboringNumbers numbers) as if it were a noun.
I don't know how this clicked, but I'm pretty sure it has nothing to do with stupidity. Perhaps it was by chance, or perhaps it was by banging my head against the wall enough times.
Would I introduce point-free style in a JS codebase? Probably not. People are unfamiliar with this kind of style. Would I introduce this style in a Haskell codebase? Almost certainly, because it's clear and I think it reflects how Haskell programmers think.
They say that array languages are pretty readable once you get used to them, too? But you’re drastically limiting your audience. Part of readability is writing for people who aren’t as fluent as you are.
Expert jargon can sometimes be useful, but it often obscures things that would be pretty simple if written some other way.
With Haskell there’s a tension between saying “I only care about writing for other expert programmers” and “more people should learn Haskell.” The idioms are part of the turnoff.
It's not really saying "only expert programmers" though, is it? It's people who know Haskell, which by coincidence happens to be overzealous undergraduates and a certain subset of experienced programmers. FP is a paradigm among many, its basics somewhat predate (or since it's so close, co-date?) more imperative descriptions of computation. That we mostly use and as such mostly teach beginners with procedural languages is a quirk of history. Nothing would prevent a change to that except historical inertia. Saying "more people should learn Haskell" is saying "I don't want to write code only for other expert programmers." It's just as natural if you know it, and even beginners could know it, they just don't.
However as I mentioned, since it is not true that most people can read FP code, I mostly avoid using it. The example comes from my solution to AoC2023's Day 3, "Gear Ratios", which is just about the only thing I use Haskell for.
That doesn't mean that using it doesn't have practical applications, since being used to multiple paradigms opens you up to unconventional solutions. I've recently sped up a MATLAB function ~100x through using a more functional style to manipulate memory more efficiently. Async/await, certain styles of modern iterator manipulation and generators escaped F#, CLU and others into C# and from there into the world at large specifically because Microsoft programmers saw a problem they had had a solution for in previous functional projects. So it's not all useless.
For the record, a more imperative version could be written as
symbols = [ imagine there's stuff here ]
gears = []
for (symbol, coord) in symbols:
if symbol == '*':
ns = neighbouringNumbers(coord)
if len(ns) == 2:
gears.append(ns)
or in Python's functional-inspired notation which directly mirrors what's happening in the Haskell code
gears = [ neighbouringNumbers(coord)
for symbol,coord in symbols
if symbol == '*' and len(neighbouringNumbers(coord)) == 2 ]
though that requires an unnecessary extra call to neighbouringNumbers, which you could solve with a walrus op but I can't remember how to do that. I also changed the entire pair being passed to neighbouringNumbers (which was convenient in Haskell) to only the coordinate that is required (which is convenient in Python).
Personally I just find nowadays that having to comprehend "it collects neighbour-pairs from '*' symbols" from the imperative code harder than having that be the thing that is actually written down.
It’s true that readability is culture-specific, that if the culture were different and people learned different things then different languages would be more readable. But I still think there are differences between languages in the sense of how much you can understand without knowing the definition of every term.
For example, if you’re looking at Lisp code and you don’t know whether an outer term is a function, macro, or special form, you really don’t understand anything inside it except at the most superficial level. It might as well be JSON. Macros aren’t marked, so any unknown term might be a macro. (Knowing the surface syntax is still helpful, though. Well-known syntaxes for data are useful.)
With Forth it’s pretty bad, too. Not knowing what a single word does means that you don’t know what’s on the stack afterwards.
A Unix pipeline is a bit more orderly since you know that there are streams of bytes. You know the command names and the arguments to each command. But if you don’t know what a command does, you don’t know much at all about what the data looks like after that point.
I find currying and point-free programming to be pretty opaque because I can’t tell where the function calls are or how many arguments each function takes from usage. I don’t know what the dataflow looks like. It seems like you need to know some precedence rules too?
Languages with conventional function call syntax, augmented with named parameters, seem better. I can tell where the function calls are and where the inline functions are. Augmented with reasonable names for temporaries, I can make reasonable guesses about what the code does.
These syntax concerns seem independent of whether it’s a functional or imperative language? Making reasonable guesses is what we do when we read pseudocode. Maybe what I’m saying is that some syntaxes seem better for pseudocode than others, and I like languages that look like pseudocode better.
I suspect that these syntax differences also have an effect on how good the error messages are when you screw up.
> you really don’t understand anything inside it except at the most superficial level
This is true, but:
- the name of the operator is typically a word that you can easily search for in the documentation or on the web, or with "jump to definition" in your editor, if it's something locally defined in the source tree.
- you usually understand the shape of what is inside it. You know what parts of the program you are looking at are arguments to that mysterious operator and which are not. If asked which expression is the third argument of that operator, you can easily find it and know where it begins and ends.
> Macros aren’t marked, so any unknown term might be a macro.
Yes, that's a problem.
There are two clues:
* Macros typically have naming conventions. For example anything beginning with DEF should be a defining macro, not a function. Anything with DO- will be a control structure. Anything with WITH- will be a scoping macro. And so on. Avoid active names like CREATE- and use DEFINE- instead. CREATE-CLASS would be a function, DEFINE-CLASS would be a macro.
* In source code the enclosed code typically has syntax and special indentation, when used with macros. Functions have certain uniform indentation rules.
Above is a function and uses one of the typical formatting/indentation rules for functions. Line up the arguments. Start with the required argument and then the named argument pairs (name, arg).
The macro looks different. The first important things like name and superclasses are on the first line. The other parts of the class specification follow and are indented by two characters.
I guess my bigger complaint in this example is that there's a lot left out. What's in `symbols`? What is each `coord`? What does `neighbouringNumbers` do? What is this function trying to do?
I write Python a great deal for a living these days and the Python code isn't much clearer to me. In both the Python and Haskell examples I can tell what it's doing (except the opaque neighbouringNumbers)--I just can't tell why it's doing it.
It is in most places. At least in Europe where I live there's a limit of 12 years old for cycling on sidewalks and pedways marked with only a pedestrian sign, whereas sidewalks which are wide enough and marked with both a bicycle and pedestrian sign as well as paths marked with both a bicycle and pedestrian signs are for pedestrians and bicyclists equally. And of course this has its logical conclusion in bicycle-exclusive bike lanes and bike paths with no pedestrians at all on them. It's especially no issue if everyone gets the rules, generally on wide sidewalks where bikes are allowed the outer side with buildings is for pedestrians and the inner side near the road is for cars. Where no bicycle-OK sidewalk exists you just use the road or walk with the bike.
That's already an issue with cars. Most EVs beep or sing or hiss quite loudly when you put them in reverse gear and at low speeds where tyre noise is low they have to augment with ICE and/or whining sounds to not be so silent and deadly. Especially the last few decades from the walkman to ipods to modern bluetooth headphones it's already been really important that vehicles make noise to warn pedestrians of their presence. Suddenly getting reversed on in a parking garage makes nobody happy.
Sensors form a big issue, though. The newer Teslas especially are excellent at ruining safety sensors for the rest of the industry. Now instead of turning your head left to look left and see your blind spot out of what should be a far enough back window to see your blind spot, you can crouch over to press buttons and then look at the small circle on the big screen which shows your blind spot. Fine otherwise but it incentivises not even looking out of your left window as you begin turning, and takes your sight off the road in general, even if for just a look, and even when automatically activated by the blinker. It's a profoundly unsafe safety system because it acts to take your sight away from where it should go, even if it means you don't have to quickly turn your head, and it allows lazier and less safe vehicle design as you no longer have to make sure the driver has possible sightlines to blind spots.
Worse perhaps are all types of proximity sensors, because you can only trust them when they go off, and even then not always. Most cars get dirt on them, snow on them, rain on them and that tends to mess with proximity sensing enough to either disable the sensors or cause them to go off randomly. I don't think anyone has ever yet trusted the blind spot sensors on their mirrors to do a lane change, only aborted one because of them. Such non-camera sensors would fix almost nothing because at best they would sometimes cause people to reconsider swerving into a motorcyclist, and even then they usually go off way too late to prevent misfires while driving normally.
These are great features when they work but overengineering around fundamental design problems seems to me to only put people too much at ease in their cars and make bad driver behaviour worse, because why spin your head around to check when you can just not do that and stare at the little screen or trust your array of easily fooled sensors to do safety in your place. I think solutions like finding alternative pillar configurations, creating long or short enough front side windows for you to see back, harsher driver's license testing with longer required study periods and in cases where you can't do anything else such as some pickups just doing what semis do and having several well-aligned mirrors instead of one set of nice-looking ones would be a lot safer in the end.
As well as getting people who can't drive for shit off the road. That's sort of included in driver's license requirements but there's surely some other methods for it that I have not mentioned.
Yeah, I would guess Iowa is quieter. LAPD is one of those archetypal failing police organizations, with so much on their plate even their own officers form organized criminal gangs. No wonder they don't have time for some poor mental hospital hobo's insistence that his identity was stolen 30+ years ago and that people are pretending to be him, especially after he was already convicted for identity theft. But that's also a systematic failure, and it shouldn't be happening. No police organisation anywhere in the world in that bad of a shape shouldn't undergo basically complete restructuring and reconsideration of duties. No court should have ever let that first ruling pass. Such a simple thing as a paternity test to discover who is clearly in the right should have been the obvious thing to do right away, instead of brushing people away. Even in the first court case, honestly.
The tricky part is making another outcome happen when real life is involved. You’re welcome to try to change it if you like. A lot of people are doing so every day, and it would be even worse without that effort every day.
Solvable, yes, but at least in Europe it is currently dirtier than anthracite coal due to leakages in lifetime emissions. Solvable but not solved, and we really should be looking for solutions.
reply