dneaves

joined 1 year ago
[–] dneaves@lemmy.world 2 points 1 month ago

Cool. Cool cool cool

[–] dneaves@lemmy.world 8 points 1 month ago

It's a bear dance!

[–] dneaves@lemmy.world 2 points 1 month ago

Unfortunately, "sauron [command]" still won't see the Jia Tan backdoor obscured in the shadows, nor the_ring.yml that you're piping to /dev/null

[–] dneaves@lemmy.world 202 points 3 months ago (7 children)

Imagine being so disliked that it becomes the goal of elderly voters to live long enough to vote against you, nevermind that it's a former president

[–] dneaves@lemmy.world 13 points 4 months ago (2 children)

I find real-world examples help grasp concepts for me. I'll use an example like a video platform (like Youtube) as an example for this:

One-to-one: for each one User, you maybe only allow one [content] Channel (or, could be one-or-none, meaning a User may have one Channel, or may use use their User account to be a viewer and have no Channel. You might decide to change this later to be one-to-many, but for the example let's say you don't). All the data could be stored just on the User entity, but maybe you decided to separate it into two tables so you don't need to query the User entity which has sensitive info like a password, email, or physical address, when you just need a Channel. For each Channel, there is a foreign key pointing to the (owning_)user_id, and this is "unique", so no duplicate id's can exist in this column.

One-to-many (or Many-to-one): for each one Channel, there may be many Videos. You could use a relational table (channel_x_video), but this isn't necessary. You can just store the (owning_)channel_id on the Video, and it will not be unique like the prior example, since a Channel will have many Videos, and many Videos belong to one Channel. The only real difference between "one-to-many" and "many-to-one" is semantic - the direction you look at it.

Many-to-many: many Users will watch many Videos. Maybe for saving whether a Video was watched by a User, you store it on a table (by the way, this example might not be the best example, but I was struggling to find a good example for many-to-many to fit the theme). Although each video-to-user relation may be one-to-one, many Videos will be watched by one User, and many Users will watch one Video. This would be not possible to store on both the Video or the User tables, so you will need a relational table (video_x_user, or include "watched" in the table name for clarity of purpose). The id column of each row is irrelevant, but each entry will need to store the video_id and the user_id (and neither will be unique), as well as maybe the percent watched as a float, the datetime it was watched, etc. Many-to-many relationships get very complicated often, so should be used carefully, especially when duplicate combinations of a_x_b can occur (here, we shouldn't store a new row when a user watches a video a second time)

[–] dneaves@lemmy.world 6 points 5 months ago* (last edited 5 months ago)

That's how languages should all work?

While I agree, should be is not is. Also, Javascript is still a widely used and favored language, despite it's flaws.

Sometimes people need to be convinced that there's something better, hence all the articles of "Javascript devs discovering actual typing", as you mentioned. Although it seems like the author already knew there's better (I see Typescript and Rust on their Github), that they were just sharing Gleam.

As for specifically Gleam, I will say it's a very nice language. Very simple to understand (with one minor exception: I personally find the use keyword is a bit odd), strong typing, no collections of mysterious symbols (cough, Haskell), no metaprogramming, no lifetimes, no borrowing, no unclear polymorphism, no pointers, no nonsense. I like it, and am excited to see it grow

[–] dneaves@lemmy.world 10 points 5 months ago (1 children)

To be fair, all three can probably do what you're asking for, in building a desktop application. So the real question comes as which flavor of language do you want to write. The only language of the three I can't speak on is Ruby, as I haven't used it.

Python is a "scripting language", but by that token technically so is Javascript. It's an immensely popular language due to its simple syntax, yet complex features as you get better with it. Python can build large-ish applications: web apps, desktop apps, terminal apps, and yes also of course AI, bulk data processing, etc. For GUI applications, I've personally used pyqt (4? 5? 6?)

Much of the same can be said for Javascript. As you said, there are "negative opinions" about JS, but everyone has their opinions (most factually-based) on the goods and bads of languages (although, yes, JS does get more negative opinions than others). Yet, Javascript is still a widely used language, and you'll probably end up needing learning it anyway if you decide to go into web development.

What I personally suggest is this:

  • See the learn x in y minutes pages for Python, Javascript, and Ruby. Make sense of the quick-tour of the languages.
  • Make a simple project using each of the three languages. Something that just reads something from STDIN, does some work, prints stuff, as an example. This helps you get to know the basics of the syntax, tooling, and quirks of a language, and helps you narrow down which language you'd like to be working further with.
  • Pick one of the languages you're leaning in favor of and go build your application. If you come to a point where you feel like the language you choose is no longer suitable for what you wanted to do, you can always retry with another language, and then you will know at least a fair part of more than one language.
[–] dneaves@lemmy.world 2 points 5 months ago* (last edited 5 months ago)

When the enum reaches your JSON, it will have to be a string (as JSON does not have a dedicated "enum" type). But it at least ensures that languages parsing your JSON will should have a consistent set of strings to read.

Consider this small bit of Elm code (which you may not be an Elm dev, and thats okay, but it's the concept that you should look to get):

-- A Directions "enum" type with four options:
-- North, East, South, West
type Directions
    = North
    | East
    | South
    | West

-- How to turn each Directions into a String
-- Which can then be encoded in JSON
directionsToString : Directions -> String
directionsToString direction =
    case direction of
        North -> "north"
        East  -> "east"
        South -> "south"
        West  -> "west"

-- "Maybe Directions" since not all strings can be parsed as a Directions.
-- The return will be "Just <something>" or "Nothing"
directionsFromString : String -> Maybe Directions
directionsFromString dirString =
    case dirString of
        "north" -> Just North
        "east"  -> Just East
        "south" -> Just South
        "west"  -> Just West
        _       -> Nothing

The two functions (directionsFromString and directionsToString) are ready to be used as part of JSON handling, to read a String from a key and turn it into a Directions enum member, or to turn a Directions to a String and insert the string to a key's value

But all that aside, for your restructuring, and keeping with the license plate example, both type and license number could be contained in a small object. For example:

{
    ...
    "licensePlate": {
        "type": "government"    <- an enum in the language parsing this
                                   but a string in JSON
        "plateNumber": "ABC123"
        ...
    }
    ...
}
[–] dneaves@lemmy.world 4 points 5 months ago* (last edited 5 months ago) (2 children)

If its something that represents mutually exclusive states, like the license plates examples (Gov't, Embassy, Learner), an enum like 4wd mentioned is a better idea than many boolean keys. This would also be the switch/case question you posed. For a "regular case", I would include that in the enum, but if you create an enum that only contains "special cases", you can always set it to null.

On the case of booleans, I would suggest avoiding them unless it is necessary, and truly a binary (as in, two-option, not binary numbers), self-contained-in-one-key thing (obligatory anti-boolean video). If the use case is to say what a different key's object represents, you don't need it (see: enums. You'll thank yourself later if you add a third option). If the use case for using it is saying another key contains value(s), you don't need it. Many languages can handle the idea of "data is present, or not present" (either with "truthy/falsey" behavior interpreting "data-or-null", or "Maybe/Option" types), so often "data-or-null" can suffice instead of booleans.

I would suggest trying to always include all keys of a present object, even if it's value is null or not applicable. It will prevent headaches later when code might try to access that key, but it isn't present. This approach might also help you decide to reduce the quantity of keys, if they could be consolidated (as in taking booleans and converting to a state-like enum, as mentioned above), or removed (if unused and/or deprecated).

[–] dneaves@lemmy.world 6 points 5 months ago* (last edited 5 months ago) (1 children)

You can feign immutablility on class attributes by playing with __setattr__. I don't remember the exact way to do it, but its roughly like this:

class YourClass:
    def __setattr__(self, name, value):
        if not hasattr(self, name):
            super().__setattr__(name, value)
       else:
            # handle as you wish if the
            # attr/value already exists.
            # pass, raise, whatever

I say "feign immutability" because there are still cases in which an attr value can change, such as:

  • the underlying attribute contains a list and appending to the list
  • the underlying attribute is a class and modifying the class's attributes
  • pretty much anything that does "in place" changes, because so much of python is referential and has side effects.
[–] dneaves@lemmy.world 1 points 5 months ago* (last edited 5 months ago)

There is some way to get things going on startup on Steamdeck, even in Steam-mode (Big Picture mode? Not-desktop mode?). I had to do it for Syncthing, I just don't remember exactly what I did. I probably made a service file if I had to take a guess, but I think an "@reboot" cron job might work too

view more: next ›