Threads for kellogh

  1. 13

    A server should not be treated as a community. The whole fediverse is out there. Treat it like you would email: ideally host on a domain you control, if you can’t then choose a host based on competence and stability and scaling etc. You can follow and interact with anyone on any server after that.

    1. 3

      Yeah, istm that blog + email = activity pub. It’s fine to use blog on BlogSpot or Medium if you don’t want the hassle of self-hosting, but if you’re serious about blogging, you should have your own domain name. Ditto email, if you’re serious you should own a host name, even if you outsource the hosting.

      1. 1

        No, a server really is a community. I hear what you’re saying, there’s no walls, except where server admins have created them. However, lots of people browse the local feed, a feed of all messages sent by people on that server. That means people will hear you even if they don’t follow you. One of the more frequent comments of newcomers is “wow, posting on mastodon isn’t like shouting into the void”, and this really is the reason. It’s a lot less lonely if you choose a good server.

        Hachyderm and fosstodon both have dense clusters of top-notch tech people. I’ve occupied both, and posting anything remotely interesting generates immediate chatter that leads to great conversations.

      1. 16

        The original author submitted this to HN with the following description, which I found as a refreshing take:

        Hi HN, I have been making this Cozo database since half a year ago, and now it is ready for public release. My initial motivation is that I want a graph database. Lightweight and easy to use, like SQLite. Powerful and performant, like Postgres. I found none of the existing solutions good enough.

        Deciding to roll my own, I need to choose a query language. I am familiar with Cypher but consider it not much of an improvement over CTE in SQL (Cypher is sometimes notationally more convenient, but not more expressive). I like Gremlin but would prefer something more declarative. Experimentations with Datomic and its clones convinced me that Datalog is the way to go.

        Then I need a data model. I find the property graph model (Neo4j, etc.) over-constraining, and the triple store model (Datomic, etc.) suffering from inherent performance problems. They also lack the most important property of the relational model: being an algebra. Non-algebraic models are not very composable: you may store data as property graphs or triples, but when you do a query, you always get back relations. So I decided to have relational algebra as the data model.

        The end result, I now present to you. Let me know what you think, good or bad, and I’ll do my best to address them. > This is the first time that I use Rust in a significant project, and I love the experience!

        1. 4

          This is the first time that I use Rust in a significant project, and I love the experience!

          After a quick browse through the code, it’s very well organized. Not much to nitpick.

          1. 3

            Woah. This looks incredibly far along for being less than a year old.

          1. 2

            got onto mastodon late last week and now I’m toying with some ideas. For one, I’d love to be able to follow any RSS feed. That would make it super easy to make a bot in the fediverse.

            1. 2

              I’d love to be able to setup a bot that reads from an RSS feed. I’ve got some feeds I manage that I’d love to make easily available on the Fediverse but I don’t want to code up the integration myself right now.

            1. 3

              Correct me if I’m wrong, but doesn’t git basically work in some way using linked lists to do certain things?

              1. 6

                Architecturally, git is a key-value database of objects that represent an acyclic graph of commits and a tree of directories/files. A simple case of linear commits is a linked list indeed, but that’s not the programming-language-level linked list that the post is about.

                1. 2

                  Okay that makes sense about commits. How did you learn about the inner-workings of git?

                  1. 3

                    I’ve found the official (free) book to be an excellent source.

                    https://git-scm.com/book/en/v2

                    Obviously not every part is relevant to you, skip what isn’t, but I found it generally well written and useful.

                    1. 3

                      This is another great resource for learning how git works internally: http://aosabook.org/en/git.html

                      Implementing something with libgit2 is another good way to learn the finest of the details. It’s thrilling to make a program that can construct a branch, tree, commit, etc and then have git show it to you.

                    2. 3

                      I’ve learned it the hard way, but these days there’s a bunch of tutorials about git inner workings. I highly recommend learning it, because it makes git make sense.

                    3. 1

                      but that’s not the programming-language-level linked list that the post is about.

                      The only difference I see is that it’s implemented in the file system instead of in memory.

                      1. 2

                        The arguments against linked lists are about memory cache locality, lack of CPU SIMD autovectorization, CPU pipeline stalls from indirection, etc., so the memory vs file system difference is important.

                        Linked lists on a file system are problematic too. Disks (even SSD) prefer sequential access over random access, so high-performance databases usually use btrees rather than lists.

                        git’s conceptually simple model is more complicated when you look at implementation details of pack files (e.g. recent commits may be packed together in one file to avoid performing truly random access over the whole database).

                        1. 1

                          Thanks for that context!

                    4. 4

                      Yeah, Git is similar to a Merkle Tree, which shares a lot in common with a single linked list, in that from HEAD you can traverse backwards to the dawn of time. However it differs because merge commits cause fork/join patterns that lists aren’t supposed to have.

                      1. 1

                        Interesting. I was looking into how to reproduce merge commits (oids) from someone else’s working tree that push to the same bare repo (e.g. on Github). I was forced to calculate a sha256 to verify that the actual committed files are the same between to working trees. Know there must be a lighter more efficient way. Probably would be a real nasty looking one-liner though.

                    1. 2

                      Admittedly, this comment is going to completely miss the point, however, there’s some other very cool optimizations you can do without much experience. I find weld the most interesting. It recompiles native code and “welds” the native parts together more efficiently. e.g. Pandas+numpy. The benchmarks are hot, often multiple orders of magnitude improvement.

                      1. 2

                        Oo, neat, hadn’t heard of it, will add it to my research list.

                      1. 1

                        Firefox uses a highly customized version of the jemalloc memory allocator

                        Why would one customize an allocator? I always assumed allocation is fairly generic

                        1. 3

                          Allocators can be optimized for different things. Minimum metadata usage, fast small allocations, fast free, fast larger allocations, etc. So you can get some decent wins by customizing your allocator for your specific workload even if the interface stays the same.

                          1. 2

                            This post illustrates why: they’ve modified the locking in stock jemalloc to perform better on loaded systems.

                            1. 1

                              So much so that it can’t be configurable? I can imagine Firefox’s customizations would be useful to other people. It seems driven by the C/C++ situation where sharing common modules is so difficult that “copy & customize” seems easier.

                            2. 2

                              Allocation is a fairly complex task - you have to give out memory while avoiding fragmentation, obviously, but also track a bunch of metadata and support all of this concurrently, and CPU and memory overhead from all this needs to be kept to an absolute minimum. So there’s a fair amount of complex algorithms, trade-offs, etc, all of which can be tweaked. I suspect it’s a combination of tweaking to work better in Firefox’s specific case (maybe Firefox makes allocations more frequently, or has shorter-lived allocations, I have no idea - the point is the trade-offs aren’t necessarily generic), and just general improvements they haven’t gotten around to upstreaming.

                            1. 2

                              Or fix git, so git reset --hard has an undo.

                              1. 2

                                hmmm…. you could probably do that with a few shell scripts

                                1. 2

                                  I haven’t dug into git’s internals in a while, but I think you are right. Worse case you have to have a wrapper around git reset or try to merge something upstream.

                              1. 2

                                I’ve found the git reflog to pretty much always have the info that I need to get out of trouble. There seems to be quite a few start on Github, so not trying to put this project down. But legitimately, what does this give someone who can use the reflog to reverse unwanted changes?

                                1. 2

                                  What if you didn’t commit those changes and just wrote to the file and then undoed with your editor? This has happened to me before though I’ve just used Neovim’s tree history to go back to my changes.

                                  1. 1

                                    I think the target audience (judging by the author’s comment about reflog), is people that can’t or don’t want to use reflog. Seems legitimate enough.

                                    1. 8

                                      Originally, my reasoning was that it covers cases where you simply didn’t commit often enough. reflog won’t help at all if there’s no Git object. In hindsight, the prospect of never using reflog again is a sweet one.

                                  1. 10

                                    I’m generally suspicious of anyone selling a process that has a name. There’s nothing wrong with borrowing a little from Scrum, a little from Kanban and a little from waterfall, as long as it works for the team/org. All processes are a bag of practices that each have trade-offs.

                                    1. 3

                                      And to add, most processes are arbitrary when it comes to a “best process” (hence why there are infinite to-do softwares). Pick a process and standardize and fluctuate to the business needs as best you can.

                                      Non-obvious optimizations and efficiencies are secondary to an operating team.

                                    1. 3

                                      I wasn’t aware that the plural of “Unix” is “unices”, but it makes sense

                                      1. 5

                                        Playful plural forms is an aspect of old hacker jargon. Another example is that the plural of VAX (the DEC minicomputer) was VAXen, by analogy with ox / oxen.

                                        1. 4

                                          -en in fact used to be the default plural suffix in English until it was displaced by -s.

                                          It is still the default plural suffix in Dutch, and quite common in German.

                                          1. 2

                                            Also applied to Unix plurals: https://en.wiktionary.org/wiki/Unixen :-)

                                            1. 4

                                              Emacsen (plural of Emacs) has a mention in Collins Dictionary too: https://www.collinsdictionary.com/dictionary/english/emacsen

                                        1. 22

                                          tl;dr the rustfmt team doesn’t want to be blamed for style decisions

                                          1. 8

                                            That strikes me as a really smart idea.

                                          1. 4

                                            I love the idea. Minor suggestion: Link-ify the domain name to make it slightly easier to investigate.

                                            1. 1

                                              Thanks for the feedback @kellogh! I’ve passed this on to Ian (co-author) to help with :-)

                                            1. 9

                                              The article doesn’t mention Free Software. This is unfortunate because Free Software licenses ought to be listed among the possible coping strategies. There are many licenses which designate Free Software but are unpalatable to corporations. Corporate entitlement can be stopped by saying “no”, but also it can be stopped by denying corporations entry into our ecosystem.

                                              1. 9

                                                I think almost all companies use GPL software including v3 except Apple

                                                I think almost all use AGPL software except google

                                                So not sure this applies

                                                1. 2

                                                  Apple doesn’t use Linux?

                                                  1. 6

                                                    Apple doesn’t ship GPL v3 stuff on their computers, like bash 4.0

                                                    That’s why they switched to zsh AFAIK

                                                    Linux is GPL v2

                                                    But even if Linux was GPL v3, they could still use it internally and not ship it on computers

                                                  2. 1

                                                    How about CPAL or EUPL? I have a more complete listing here.

                                                  3. 8

                                                    I’m not sure Free Software is really a solution for this problem. Entitlement also happens (maybe even more so) if you have end users who are not developers. Also, without corporate contributions the software would be developed less quickly in the first place. It’s important to realise that corporate users are not all “takers”!

                                                    1. 4

                                                      I don’t think it’s as much corporate entitlement. If you read the post, it’s the people within pushed by external factors that are under pressure, not so much corporate entity seeking to exploit.

                                                      That, and I suspect the way people treat OSS developers is orthogonal to economics. People will still be under those same pressures to get things working, regardless if it’s a cooperative or corporation.

                                                      1. 2

                                                        I do think that there need to be some more radical free software licenses, corporations have gotten used to many of the ones we have now. I agree with you though, to be clear.

                                                      1. 1

                                                        Why? It was associated “en masse” primarily with “class diagrams” and to a much lesser degree “sequence diagrams, both largely associated with OO. Object orientation has been (without real justification) going out of fashion for some time. It is increasingly becoming a meme today that it is simply bad, obsolete, a mistake or a corporate conspiracy. One used by the ignorant who knows not the wonders of functional or procedural programming.

                                                        1. 4

                                                          Sequence diagrams are great. I’ve used them in a number of ways outside OO, as well.

                                                          1. 2

                                                            Sequence diagrams might be the only formal diagram I still use. They’re especially helpful for explaining/documenting how several distinct systems interact.

                                                            1. 2

                                                              They can form the basis of a nice “fractal” / “zooming” exposition of how systems work, too. Sequence diagrams for the high-level system components, all the way down to API calls.

                                                              Years ago (2006?) I prototyped a thing that hooked .NET CLR debugging APIs to generate Visio sequence diagrams from running code. Even back then they were one of the few formal diagrams I used.

                                                          2. 2

                                                            Object orientation has been (without real justification) going out of fashion for some time. It is increasingly becoming a meme today that it is simply bad, obsolete, a mistake or a corporate conspiracy. One used by the ignorant who knows not the wonders of functional or procedural programming.

                                                            Citation needed.

                                                            I don’t doubt that people on programming forums often say things like that. I do doubt very much that their statements are actually representative of programming as a field.

                                                            1. 5

                                                              The statement is a bit too broad. A lot of OOP is conflated with inheritance.

                                                              In Java, unnecessary inheritance has been demonized as lasagna code, e.g., enterprise fizzbuzz. Java developers have been generally moving toward favoring composition over inheritence.

                                                              The Go programming language doesn’t support inheritance, and has poor (imo) support for polymorphism. The fact that Go has become fairly popular is probably the strongest evidence that OOP is in decline. Likewise, Rust has been the most loved programming language for several years in a row. Rust also has negligible support for inheritance (albeit great polymorphism).

                                                              As far as I can tell, the only OOP pillar that remains unassailed is encapsulation. Popular languages that lack strong support for encapsulation (e.g. Python) are generally criticized for this point.

                                                              1. 3

                                                                JavaScript has been eating the world lately, and I don’t think anyone would deny that it’s an object-oriented language, despite its lack of traditional inheritance. Go is popular, but I think it’s debatable whether Go’s popularity is attributable to rejection of object-oriented programming.

                                                                And most of your example links are, again, from the relatively insular world of things written on/by/for programming forums, which I continue to claim are not representative.

                                                          1. 7

                                                            Using mermaid as proof that UML isn’t dead largely misunderstands what UML was — deeply intertwined with OOP and waterfall. Using class to define a class also doesn’t mean you’re writing C++.

                                                            1. 14

                                                              TLDR: Akka is now source available, Alex is mad. Insofar as I can find a moral argument it’s that this represents a bait and switch. Alex also goes over the practical reasons devs like open source, which most significantly is avoiding bureaucratic processes.

                                                              I think this is right - any sustainable alternative to open source has to preserve that property. (My hunch is that a collecting society type model based on turnover is the way to do this). Alex mentions commoditization of ones complements. This points to open source being supported by businesses that specifically create it as a complement to their business; I think that’s fine but can only support a certain slice of software.

                                                              1. 6

                                                                Agree. Data storage has had a reasonable path for monetizing open source by making it REALLY EASY to pay money, e.g., a cloud service that maintains my MongoDB cluster for me. That cuts a lot of corners for enterprises. If you want your open source project to churn out cash, make it easy to spend money on. There’s lots of ways to do that. Forceful license changes ignore what the customer wants, which is a recipe for a failing business.

                                                                1. 2

                                                                  I think what they’re aiming towards is something like what people like to do with physical things:

                                                                  • Buy them once
                                                                  • change, sell, share or modify as you want
                                                                  • distribute blueprints of their reverse engineering to maybe replace parts of it, or build something compatible

                                                                  Problem is that this is software, which has no physical, single-quantity and changes a lot, so you would have to re-buy it (or pay monthly fees), to always have an “up to date purchase”. And the physical-object industry also tries to restrict such use cases (personal use only, no modifications, subscription based add-ons..)

                                                                  Ultimately this is the GraalVM debate all over again: Do I want to settle my product runtime and core on something that may just go away at any point? Everyone that had to interact with the company-wide legacy ERP system, which they never managed to replace, knows the fear.

                                                                2. 2

                                                                  (My hunch is that a collecting society type model based on turnover is the way to do this).

                                                                  Can you elaborate on this? I’m pretty much guessing what this might mean.

                                                                  1. 3

                                                                    What I mean is that multiple open source projects would band together to basically commonly issue commercial licenses, and if a company buys in a licence the revenue gets allocated between projects. The more projects get under a given umbrella, the easier it is for companies to adopt them.

                                                                    One project could be with multiple societies.

                                                                    In terms of pricing I was thinking at the most basic level something linked to turn over and then something less convenient for companies that want to try to save money.

                                                                    1. 1

                                                                      Thanks. In theory, something like this approach could also be useful for the governance and supply chain issues that we’re worried about today.

                                                                      1. 1

                                                                        How so?

                                                                      2. 1

                                                                        That sounds like https://tidelift.com/

                                                                        1. 1

                                                                          No, it’s very different. For a start tidelift doesn’t provide a better license. Tidelift is more like a consulting and support shop that kicks some money back to the free software projects.

                                                                    2. 1

                                                                      Thanks for the summary! It’s exciting that Akka is doing this. With luck it’ll kill the whole misbegotten mess. The actor model on the JVM never made any sense.

                                                                    1. 1

                                                                      Seems like diffusion models could be used to hack “blurring”.

                                                                      When people take screenshots of text, it’s common to obfuscate sensitive text like passwords via painting or blurring. It’s recommended to not use “blurring” because the original text can be brute-force calculated by blurring & comparing the images. i.e., blurring leaves a lot of information in tact, and that residual information can be used to reconstruct the original form.

                                                                      It seems like you could train a diffusion model to “un-blur” text or even go a step further and un-blur faces too.

                                                                      1. 1

                                                                        You can do that without these models. Reversing such effects applied to photos has been used to restore the faces of child abusers that subsequently went to jail.

                                                                      1. 4

                                                                        I wish there was a single dialect of SQL that could be translated to all other dialects. There’s babelfish, but that seems to only run on postgres

                                                                        1. 2

                                                                          Isn’t that dialect the SQL standard? Not all database engines implement all of the standard, but they all implement enough that there’s a useful common subset there.

                                                                          Maybe someone should make a linter which validates that your queries follow the standard and will work in the major SQL engines, but I don’t see a need for much more than that.

                                                                        1. 9

                                                                          I’ve been using this editor (and only this editor) since February. Decided to give it a shot for a few days after ~20 years in Vim, and it just kind of stuck. I honestly don’t think I’ve opened Vim since.

                                                                          If a fast modal editor is your thing, then I recommend giving it a shot.

                                                                          1. 8

                                                                            I didn’t think “fast” mattered, but I installed it and…WOW! yeah, fast matters

                                                                            1. 3

                                                                              “wow” indeed! I was skeptical, as a Neovim user, but Helix really does feel significantly faster, from a brief experiment. I’m curious how much of this is due to design/a clean-slate codebase without Vim’s legacy, and how much is due to all “plugins” being truly built in (rather than just Lua that ships with the editor). And how much is perceptual due to e.g. having fewer “flashes” in the UI (Vim/Neovim tend to flicker when updating floating windows, etc.).

                                                                              1. 2

                                                                                That’s why I was stuck in Vim for 20 years :D

                                                                              2. 5

                                                                                How long did it take you to get used to the differences between Helix and vim? Also are there any packages you miss?

                                                                                Helix looks nice and looks like it has most/all of the main features I would want. I haven’t tried non-vim compatible editors because having access to random vim packages can be really nice. But also, my current neovim set up is a headache to get all set up and running (although, I am not sure how much of that would be fixed by this editor).

                                                                                1. 5

                                                                                  I don’t recall tbh. The only thing that I ever really found difficult was this thing of constantly being in visual mode. I still occasionally mess that up, but eh.. just a quick undo and that’s that.

                                                                                  I never was big on plugins, but sometimes I’d like a good file tree viewer when exploring a new project.

                                                                                  1. 1

                                                                                    I appreciate the reply, thanks!

                                                                                    1. 3

                                                                                      Had a look at my plugins. I’d forgotten I used neovim, and that Lua is awesome. My plugins are

                                                                                      • wbthomason/packer.nvim
                                                                                        • Package manager (why isn’t this just built in?)
                                                                                        • Don’t miss this since Helix doesn’t have plugins yet.
                                                                                      • nvim-telescope/telescope.nvim
                                                                                        • Built into Helix.
                                                                                        • The other day while browsing around my notes (not code) I was missing live grep.
                                                                                      • neovim/nvim-lspconfig
                                                                                        • I forgot what this is. I assume it’s because neovim’s lsp integration isn’t (wasn’t?) quite there yet.
                                                                                      • nvim-lua/completion-nvim
                                                                                        • Very meta. It was to make it easier to write config for the editor.
                                                                                      • justinmk/vim-dirvish
                                                                                        • This is the one I kiiiind of miss… only this doesn’t actually show you a tree, so, I dunno.
                                                                                      • lukas-reineke/format.nvim
                                                                                        • Why isn’t this built in? No need for this in Helix.
                                                                                      • folke/trouble.nvim
                                                                                        • I just use space-g and ]d and [d now. Works fine.
                                                                                        • Fun fact, I couldn’t remember that g was the letter for the diagnostics viewer, so I hit space and it tells me.
                                                                                        • Another fun fact, I made all the links using the multi cursor function in Helix ;)
                                                                                      1. 1

                                                                                        Package manager (why isn’t this just built in?)

                                                                                        Mostly off-topic, but: historically, users have had strong personal preferences around package management in Vim/Neovim. This combined with the lack of a package specification standard/central package repository is (educated guess) why there’s no “full” package manager built-in, though the (semi-recent, Vim 8) native packages manager provides some of this functionality (e.g. basic loading control, though no downloading, updating, lazy-loading, etc.).

                                                                                        I’d also note that I would not advocate for packer, specifically, being built-in (at least in its current state). It’s too opinionated and does too many things that not all users will want/need. I think there’s a better argument to be made for integrating something simpler that can implement the bare-bones operations (e.g. git stuff, loading primitives, etc.), and which other package managers can build off of (similar to how the built-in LSP functionality is designed).

                                                                                2. 3

                                                                                  Did you set it up with something like helix-vim? I can’t see the rationale in learning a new set of keymaps for commands I have ‘baked in’ I have enough trouble with the little differences between neo-vim/vim/vscode-vim emulation.

                                                                                  1. 3

                                                                                    No. Don’t know what helix-vim is, sorry :)

                                                                                    For me it was mostly curiosity, and maybe a feeling that I/we spend a lot of time fighting something (legacy?) that we really shouldn’t have to fight with.

                                                                                    Helix has amazing discoverability and the key bindings make sense, but it’ll take a bit to learn of course. The biggest one for me, was to stop using x and just always use d.

                                                                                    1. 2

                                                                                      To me, just trying it again now, it’s that I hit dd to delete lines reflexively, use ciw to change inside a word a lot and hit x to delete. That entire trio of ops doesn’t work. helix-vim is just a repo with a premade config file to get helix back closer to vim: https://github.com/LGUG2Z/helix-vim

                                                                                      Trying it now it seems to fix x and dd but ciw doesn’t work, there’s some commentary on the page there on c taking extra configuration to make work. I do like the speed of helix, and it feels like a contender (especially if language server support gets really easy).

                                                                                      1. 12

                                                                                        Helix is a bit different that way. I’m not sure you’re going to have a good time if you want it to behave like Vim.

                                                                                        If you take ciw (which is imo one of vim’s most powerful things), then the mindset is that you select first (so, the iw part), and then what action you want to perform (the c). Pressing iw won’t work though, you’ll just insert a “w” where your cursor is. Instead, hit m (for “mark”) and read the little popup. i is what you want, which gives you another popup thing, where you can find w. So the sequence becomes miwc.

                                                                                        A, perhaps, better way to do this, is to realize that a word is the “next ast node up” from where my cursor is. Tree Sitter is a beast that I’m still exploring, but play with Alt-Up and Alt-Down (or Alt-o / Alt-i). You’ll see you can then just do Alt-Up c instead of ciw. It is really quite powerful.

                                                                                        1. 2

                                                                                          Hmm, now you’ve piqued my interest considerably in 1 paragraph. This feels (a) discoverable once you see how helix is working and see that it has popups (b) an actual new thing (as opposed to vi/vim features under a different keymap). Nice, I like this.

                                                                                          [edit] note that helix-vim steamrolls some of this interesting stuff, so I’m going to try vanilla helix to see if I can take advantage of its “stock” differences

                                                                                          1. 1

                                                                                            Happy to hear that! Have fun. I really think curiosity is the right approach :)

                                                                                            1. 2

                                                                                              I think I’d seen the initial announcement and thought, ok rethought out vim. Yesterday we had a power outage and I ran hx --tutor which is essentially how I learned emacs then vim back in the day. With the power out I didn’t have time to install the language server support, but I think overall helix makes sense as a rethinking of modal editing, and not a ‘remapping’ of vi/vim standards.

                                                                                        2. 2

                                                                                          helix-vim is interesting! I feel so seen by the README.

                                                                                    2. 2

                                                                                      Same here. I use it quite a lot Once Debugging is well supported it will mean i will ditch VSCode for good. Really love Helix.

                                                                                      1. 1

                                                                                        I’m curious about this. I don’t know VSCode very well; but what exactly is it you are missing? Setting breakpoints and such?

                                                                                        Edit: Just noticed Helix has experimental Debug features. I’ll explore those :)

                                                                                    1. 4

                                                                                      Reposting from a work chat about this exact article …

                                                                                      This actually feels eerily reminiscent of discussions about machine code vs. assembler vs. high level languages in programming … it’s not “real programming” if you’re not programming on the silicon vs. programming is now guiding the machine tools to generate code.

                                                                                      “It’s not programming art if you’re letting a compiler AI model handle the details”.

                                                                                      1. 2

                                                                                        It does seem to take a skill to generate good AI images. I don’t need to watch 30 hours of Bob Ross to acquire those skills. Skills like brush strokes & color choices aren’t really important with this new medium, but there’s clearly skills that I don’t yet possess. But I can also stumble into a semi-decent output without the skill every now and then too.

                                                                                        1. 5

                                                                                          Prompt engineering is a genuinely tough thing. You really have to think outside the box and it can sometimes require a few rounds of iteration with manually scribbling on prior outputs to get what you want. It’s not going to make artists go away any time soon. I use a lot of AI-generated art on my blog but I pay a lot of money to commission artists for things like the stickers you see on the blog.

                                                                                          1. 1

                                                                                            The phrase “prompt engineering” threw me for a bit, but I like it!

                                                                                          2. 2

                                                                                            Between the article and this comment, I now wonder if we’re seeing the dawn of “Poser, but for 2D art”.

                                                                                            Which isn’t bad, since Poser is “good enough” for a lot of tasks, but hasn’t replaced professional 3D artists.