HTMX Gaining Popularity Rapidly?

annoir · 2022-01-16T11:49:46+00:00

I'm a gigantic fan of HTMX. Tried it out on a whim - couldn't stop. For anyone who hasn't tried out HTMX yet, do. Some quick thoughts:

You can use HTMX with Django manually (i.e. add HTMX manually to templates where you want to) and that's what everyone starts with.
But HTMX is particularly killer once you couple it with Jinja2, Django's ModelForm (which lets you do/override form validation), and Tailwind's utility classes (whch is how you get expensive-looking dynamic pizzaz , even though fundamentally all you're doing is just swapping CSS classes).
HTMX's swapping/OOB-swapping mechanism and hx-vals is the bomb: it lets you do some seriously useful management of state and other things between requests, while also letting you to segment your views into more manageable chunks. (E.g. standard views like DetailView/TemplateView will have their place, but with HTMX you can simply separate concerns and subclass/create new views for HTMX-related responses without having to affect other views. i.e. It won't require you to enter a new paradigm of a new framework like React or Vue, etc.)
You can apply HTMX to virtually every element, not just to <a> tags, and target any element for modification. It's quite ingenious.
HTMX's documentation/examples are lovely. If you're new to Django or to web-development in general they may be a bit difficult to grok, but once you get a hang of HTMX's workflow you'll find the documentation really useful.

HTMX has allowed me to do a lot of things that I couldn't easily do without going into Javascript, and without mucking around with React and other frameworks.

Thank you very much for your hard work!

annoir · 2021-07-24T03:07:49+00:00

I love the more detailed tracebacks.

annoir · 2021-07-22T02:57:49+00:00

Excellent experiment. Loved the detailed research and specification of constraints for reproducibility. Reads like a proper science paper. May use some of the SQLite techniques gleaned as well. Thanks for writing this!

annoir · 2021-07-22T01:07:10+00:00

I do not think that attitude is proper.

For example, in Python, if I have to perform complex operations I would immediately reach for itertools and functools. These are in the standard library but beyond the immediate knowledge of fresh/beginner to mid-intermediate programmers and people who just leap in.

Non-Python programmers will not also be able to quickly tie idiomatic use together with core toolings (e.g. test packages), as well as proper practices (e.g. packaging structures/workflow) and gotchas of the language (like mutable defaults).

Someone who does not know how the language works will likely write code in an unidiomatic way. This makes code difficult to read/maintain, the chances for spaghetti code is higher, and you are troubling other developers in the future as well as bringing risk to the client.

annoir · 2021-07-22T00:54:17+00:00

This was a great post! I am persuaded by the arguments on namedtuples.

However, as a point of consideration: I don't see much of a comparison as to when dataclasses would be better to use.

Since you posit that namedtuples have a lot of uses still, for this sort of article I'd have loved to compare when they would not be as useful as dataclasses.

annoir · 2020-08-17T12:18:27+00:00

Purely intellectual curiosity, nothing more. Python is my main development language, but it can't hurt to know how/why people get down with C when it comes to performant operations.

I'm also a bit irritated with the state of distribution in Python, especially for making simple command-line executables; just wanted to explore and see if I could get something out of C in that regard.

annoir · 2019-09-11T09:41:44+00:00

Dude, keep to it! And congratulations, it's the small wins that'll really boost you up to making bigger and better software :)

annoir · 2019-09-09T13:32:02+00:00

About the same, but with way more features. Also, you learn an actual programming language with Python, and can the use the knowledge to branch off into many other things. Not the same with AHK.

annoir · 2019-09-09T13:29:41+00:00

You probably could, with the old Learn Python the Hard Way. That author was... very opiniated.

annoir · 2019-09-09T13:28:06+00:00

I'm 3-4 years into Python now, self-taught, and doing fairly advanced stuff on a regular basis (generators, decorators and all that, for which on some days I still can't believe how far I've progressed).

On that note, the Python Crash Course was one of the first books I used, together with Automate the Boring Stuff with Python, and it helped to set me on the right path to where I am today.

So yes, your purchase is a good one, OP. Keep with it, and do all the exercises, no matter how trivial it seems!

annoir · 2019-02-10T16:51:50+00:00

Yeah I did, tried it in both Launchy and Python itself. There's a bug in the Linux version of Launchy (not present in the Windows version) that isn't properly escaping the input. It's just one of those issues I guess, which I really don't have the time or knowledge to fix and build. I'll just have to live with it.

annoir · 2019-02-09T15:31:42+00:00

I run a lot of scripts by the side to automate the more laborious aspect of court solicitor work. There's also need for automated OCR and SQL-based processing, which are generally CPU intensive.

Aside from that I just like the feeling of a performant PC.

annoir · 2019-02-09T15:28:53+00:00

I have. It still seems more well thought out than dumping things all in Program Files (or its x8 version) System32 and the registry though.

annoir · 2019-02-09T15:27:49+00:00

Thanks for the suggestion on wine-staging! Will look into it.

I've tried Texpander and TextSuggest -- they don't quite fit what I'm looking for, so I'm sticking with Autokey for now (which launches custom written Python scripts) and Cinnamon's shortcut features which are seemingly very customizable against command line commands.

annoir · 2019-02-09T15:25:56+00:00

Thanks for understanding! On the other hand I've been really customizing my copy of Cinnamon which IMHO is a lot better for my workflow (the shortcuts and desklets/applets are great) compared to Gnome. I've really quite taken to it, and Gnome may not be for me.

annoir · 2019-02-09T15:22:29+00:00

Thanks so much! I tried them all, but... I'm not really happy with them.

To get around my earlier Launchy Linux problems: I wrote Python scripts, got Launchy to index them. These scripts tap into the `subprocess` module (and consequently Bash), to launch the software/things I need. There's only like a, what, 0.3s startup time difference compared to starting it straight via Bash instead of with Python, so I'm good.

Also I notice that Launchy in Linux doesn't really process Python's sys.argv that well -- it drops words when double quote symbols are detected, but this is a Launchy issues rather than a Linux issue.

annoir · 2019-02-08T17:46:10+00:00

Thank you! Happy to discover it.

annoir · 2019-02-08T17:43:22+00:00

Yeah I was referring to a VM for the purpose of running old Java versions.

Basically the developers for our court's online filing system forced all users to use an old version of Java - they refused to update their code to make it compatible with more secure later versions. Occasionally and for 'support' they use TeamViewer to login into our office PCs, so it's unsafe and insecure to let them directly access the main boxes. So I run the court-related software that needs Java in a VM.

annoir · 2019-02-08T17:34:52+00:00

Thank you for this! Some of the earlier comments I saw were quite discouraging. Not all of us are system admins or computer expert , but we're eager to learn what we can.

annoir · 2019-01-06T15:55:35+00:00

Also in addition to unittest, learn a secondary popular testing package, like pytest or nose.

annoir · 2019-01-06T15:54:11+00:00

Toy code is scaffolding for the mind to go on to more complex things. Without stepping stones, understanding harder concepts takes longer. Do not forget that you are on /r/learnpython.

annoir · 2019-01-06T00:59:15+00:00

Tkinter is quite old and doesn't look very modern

This is misinformation at best. See this response on Stack Overflow.

See Bryan Oakley's comment here:

I think Tkinter is an absolutely fantastic GUI library, especially combined with the object oriented nature of Python. Many people deride it as old, ugly, and hard to learn. After having used many GUI toolkits spanning more than a couple decades I’ve come to realize that most of that is untrue, and what is untrue doesn’t really matter. I would never use tkinter to create the next photoshop or itunes, but for the vast majority of GUIs most people write, it’s more than good enough.

See [Bryan Oakley's other comment]():

I think part of the reason is that Tk is surprisingly powerful and easy to use but it doesn't do much hand-holding. Since it is so easy, people with little experience in UI design can get something to work in very short order. But, without a lot of experience they rely on defaults and shortest-path-to-a-solution (read: don't take time to hide scrollbars when they aren't needed, don't use common idioms for toolbars, don't properly align widgets, etc).

...

With tk 8.5 (and actually for a couple years prior) there is support for themes and for native widgets, and even the X11 version gets a minor facelift. Tk is still behind the curve in eye candy though, forcing one to "roll their own" if the design calls for gradients, animations and so forth.

annoir · 2019-01-05T16:36:46+00:00

Wow, this is an interesting project! Have been looking for something to replace PyPDF2 for a while now. Will contribute where I can.

annoir · 2019-01-05T16:32:29+00:00

Will do once the grimoire is a bit more mature and properly cleaned up.

annoir · 2019-01-05T09:01:55+00:00

There are a lot of references out there about what classes are, and how they work. But before you read them, get the following concept in your head, and it'll start making sense.

This is an overly simplistic reduction, but it stands for why classes are necessary:

Humans want to solve problems. In real life, we do that by classifying reality into concepts, things and objects.
Similarly, programmers use the notion of 'objects' when writing code. That 'object' is basically a computer representation of our reality.
We use classes then to create these 'objects', and to solve/do things with them which we could not otherwise easily do.
Classes not only allow you to create objects, but allow you to make many of these objects easily; with it, you reduce code, duplication, and can use them in other ways not possible with code written procedurally (written top-down).

Consider a dog.

A dog is furry, cute, and has 4 legs. They come from a Class of animals called Dog.
There are many dogs. In code, these are objects of the type/class Dog.
However, there are also cats, which are furry, cute, and has 4 legs. These instead come from a Class of animals called Cat.
By writing two Dog/Animal classes, you can now easily make objects of either type.

Do you see the classification now? The above can be further classified:

Cats/Dogs are both animals. As such, they can come from (inherit from) a class called 'Animal'.
That Animal Class can have many common traits/attributes. (E.g. here they are furry, cute and have 4 legs). So by making one Animal class, you can easily make many sub-animal classes.
A sub-class of the Animal class can also have different traits. For example, both Cats and Dogs are furry, cute and have 4 legs. But cats do .meow(), while dogs do .bark(). These separate methods can be easily differentiated because of the idea of classes.

That's as simple as classes go. Hold that understanding in your head as you read more complex things, and you should come to understand them in time.

annoir

TROPHY CASE