Crimping our own cables is more common in data center or IT. Normal people wouldn't cut their own cables. I've given up cutting my own cables for home use (fixing busted heads) because it's easier to just grab a new cable.
The last time I crimped one was three years ago when we moved into this house - I wanted a particularly long run of cable, and it was difficult to buy Just One.
The last time before that was when I was working as an IT tech in high school 20 years ago.
But yeah - I'm not even sure if "normal" people know you can make your own cables.
Not only that, but it's also fairly potent, allowing you to pass variables from one request to another, transform response, inject .env vars etc.
If all of your team is using Jetbrains products, you can also add the http files to the version control so everyone could have the requests ready to use.
Not using the mobile version that much, so I can't give feedback on that, but the desktop player is getting worse and worse for the past few years: searching, discovering (by browsing), library/playlist management etc.
It's like the Spotify guys are not even using Spotify anymore :)
@retrocryptid: probably you're looking only at the images from the article, but it seems it's a full keyboard. And it's symetrical AND programable so you can customize it as you wish.
CSS is one of the places in web dev that never really reached consensus, even today. We might get WASM as the app platform of the web before this even happens.
WASM is more of the same exact issue... web devs inventing fragmentation and trying to make things low level again even though they have such a great platform that's already batteries included...
While I don't really like it myself, Tailwind is a good CSS framework for the age of component-based application design, where your JS / CSS / HTML lives in a single file, and your application-design won't change that heavily.
But when you want to redesign a whole site after the fact, or if you want to keep your component library logic & templates, and port it to a new system, Tailwind might be more trouble than it's worth.
It's just that... Atomic CSS has its benefits, BEM has its benefits, etc etc etc.
Why do you feel it's nonsense? I'm genuinely curios.
Personally I'm using Tailwind for 90% of the styling. If I keep repeating a certain combination of classes often, I'll group it with a custom class. (Edit: See colejohnson66's comment for an example)
Two advantages of tailwind that I didn't see before I started using it:
- It's often easier to find what I want in the tailwind documentation, and it comes with nice examples. MDN is great, but with Tailwind I get reasonable presets.
- TailwindUI: Saves me a lot of time and looks good without feeling as generic as bootstrap.
Perhaps I'm just old-fashioned but I prefer semantic classes.
I completely rewrote the CSS for my website and I did not need to touch the templates. An .error is an error and a . collapsible is a collapsible. Their exact style is not dictated by the markup.
I also like that it keeps the markup small and easy to read, because it's not peppered with CSS.
It also avoids situations where two widgets look different because I forgot to copy one class over. A .collapsible is a collapsible.
Semantic classes make sense for small and brochure-style websites. For any moderately complex website or web application, your class semantics quickly become a challenge. Naming things is exceptionally hard, especially when each "component" can have multiple variants each with their own modifier classes e.g. `alert alert-danger alert-with-icon alert-collapsible alert-expandable alert-hidable`. Multiply this by hundreds of components and you find yourself in class soup that's almost indistinguishable from Bootstrap and Tailwind. So I've given up on semantic naming because it's futile for ambitious projects.
Restyling a website without changing any of the markup is a pipe dream from the CSS Zen Garden days when websites were much simpler and more static. Apart from small/personal/static websites, it just never happens in practice today.
If there were more opinionated frameworks actually meant for that kind of restyling, I don't see why it wouldn't work, at least some of the time.
Why do we need all these different classes? One CSS class can handle the presence or absence of a hide button just fine, and lots of frameworks just have .danger set variables or override colors, staying pretty much universal.
I cannot, for professional reasons, point you to any that I have personally worked on. However, Smashing Magazine (https://www.smashingmagazine.com) comes to mind as one of the early adopters of both highly semantic BEM and an SSG methodology.
Tailwind is one of those polarizing topics where people either love it or hate it. I've used it at a few companies and I didn't care much for it, but I had coworkers who swore by it.
We've been using it for a little over a year. So far my biggest finding is that Tailwind works best when you have a UX team that is forced to play by the same rules. In that context, with a heavily chopped down tailwind.config, it comes alive as a utility. It can even act to proof mistakes in the UX work. A div with a 1rem padding, with a BG of neutral lightest and a text color of "primary" is a spec defined by class names and a mock. I honestly think that in uncontrolled environments without a singular design system and without configuration, tailwind can become a mess. I really do not care for the out of the OOB config, it is way too free on color schemes. You need a few people to play the rulemakers and constraint for it to be helpful.
> Tailwind works best when you have a UX team that is forced to play by the same rules
I agree but found that Bootstrap (>v4) to be better at this. Instead of every possible color and tweakie, Bootstrap has pretty decent utility classes that are semantic, and in addition to all the basic components like button, etc:
My gripe with Tailwind is the redundancy of class definitions across elements that clearly would benefit from "normal" CSS. If I have a <table> with a whole host of <td> elements, those repeated class definitions become quite tedious.
The advantage of Tailwind, IMO, is that styles for one-off components (like a breadcrumb bar) can just be written inline instead of in a separate file. But reused components like table cells should be using CSS selectors.
Congratulations, you have reinvented the purpose of CSS classes. This is why I don't use Tailwind, at a big enough scale, it becomes lots of duplication, and if you use @apply, it's just...CSS classes as originally designed.
Part of the problem with the tailwind debate is that the appeal of tailwind is not just having your styles in your html, it's also having predefined style units, e.g. size intervals for things like margins.
CSS variable libraries like open-props also do this, only without the controversial use of utility classes. Add editor snippets to that and you have nearly the same ease of use as tailwind.
In practice, I never have found much benefit to that. If I need a base class, I will create a base class. .validation-message for instance, then if the validation is a success/error/warning/info, I will write those classes, then my validation message element will have 2 classes on it "validation-message warning"
That way there is no repeated rules like in the final compiled @extend/@apply operations.
You can't reinvent something that was never invented to begin with. "CSS classes"? ("as originally designed"?)
Class definitions are not CSS. They're markup. The CSS selector language does let you target them (with a leading dot, as in .foo)—just like CSS lets you target other things defined in markup with special syntax: element IDs (#bar), attributes ([foo=bar]), etc. It's not as if HTML existed without classes and without CSS, and then CSS was invented and with it came classes, too.
(This isn't to say that you're alone. A frighteningly high number of people reveal through their choice of language an apparent belief that `class` was invented by the CSS working group (or something). That when you're writing HTML, evidently 95% of it is HTML proper, but then when you get to the part where you type out 'c', 'l', 'a', 's', 's', that you're shifting into CSS and it's like, "This last piece with these "classes" was contributed by the CSS folks, and so that's why/how CSS leaked in," without ever seeming to realize that... they're not actually writing CSS. It's still just markup—using the ordinary syntax for specifying attributes and their values. The CSS only happens when you, uh, start writing CSS...)
It was just an example, but it's more broadly the redundancy of a list of repeated classes applied to elements that are identical or mostly identical.
These are things that CSS literally solved with the web2.0/semantic-web movement 20 years ago. I get the convenience of Tailwind but a lot of it feels like a massive step backwards.
The big thing about tailwind in the context of JS rendering is that this ends up being a code smell. If you find yourself repeating a set of classes...you probably should componentize that and DRY.
It's funny how the solution (use CSS as it was intended) is now being transformed into JS-powered component solutions.
But yeah take say a dashboard layout with a lot of cards of different sizes. They're going to have the same underlying design, padding, rounded edges, background colors, etc -- and usually only vary on maybe size and breakpoints.
This is all very well solved in semantic web, but it feels to me like the JS + Tailwind apporach is creating new problems and thus new solutions to accompany.
I think the detail is that this JS answer is really only for people working at a seriously large scale. At that size, there is absolutely zero room for non-componentized logic as cross-managing a billion pages with duplicate HTML elements is pretty unacceptable. That said, Tailwind also allows you to define your own classes that apply multiple TW classes.
You can turn on the autocomplete-by-enter by openening dev tools -> settings (f1) -> preferences -> console -> „accept autocomplete suggestion on Enter”
You go through an addmission process that's pretty much similar to an employement process (several interviews, technical interviews, tests etc).
After you get in, most of the jobs you get are strongly limited to your particular skill (so you won't be able to see what coding jobs are available if you're a designer).
Then, the customer aquisition process is slightly different, as you don't talk straight to the client while you're „bidding”, but with a recruiter, who deals with selecting the right candidate for a job.
Finally, for most of the jobs you don't even have to _apply_, as recruiters constantly send you messages for potential jobs.
Now, upwork & freelancer are mostly a race to the bottom; I personally got banned from upwork for having the audacity to apply to jobs and not winning any (because I didn't wanted to work for peanuts).
The short version: I was working on and off on upwork for the past... 10 years or so (since they were called elance). Didn't had too many projects (less than 20) and only applying there only for very small gigs, when I had some breaks from my regular clients (a couple of times per year).
Some years ago, one of my client went out of business and I wanted to give upwork a serious go, as I already had _some_ projects there, the account was verified and such.
Start applying on jobs that matched my skill set, asking for my regular hourly rate (hence the audacity). Looking backward, my requested rate wasn't even that high, but that's a story for another time. :)
Dunno how they work now, but back then they had a certain amount of credits every month that you could use to apply to jobs. IIRC, you could apply to 10-15 jobs every month with those credits.
Which I did.
I applied to about ten jobs, on most didn't had any replies from the client (they either closed the job or picked someone else), but the gist is that I didn't get any job.
One day, I get an email where the gist was: you weren't able to get any clients with your credits, so we don't need you. Same as OP, tried to contact them, but the decision was final and that's that. Fortunately, I didn't loose anything but some internet points :)
You literally can train anyone, as non-tech as possible, to crimp 8 wires with a $5 tool in 5-10 minutes.