734129837261

Many of the ones I know end up at other companies that had troubles finding good employees before. And a bunch of others started their own companies, and they are/will hire their own employees, too.

I wonder if there are statistics about this kind of trend. How many new companies spawn for ever 100 tech layoffs? How many more jobs are created in 1, 2, 4, and 8 years after the layoffs?

Fun fact: so are Rolex watches and so many other luxury nonsense products with a high price. Wear one on each arm. Travel via airplanes across borders. Sell the watches. Now you have a lot of untraceable cash. Fly back and forth for business purposes seven times in one week. Maybe bring more expensive watches, perhaps that $200,000 USD Patek Philippe is a great way to get that payoff across borders.

Crypto and NFTs are just easier, less risk, less chances of being caught.

Maybe we should talk diamonds. Inherently worthless objects, easy to hide and transport, easy to make part of jewelry, and thus free to transport almost anywhere. Yet that one tiny rock can cost tens of thousands and will allow the corrupt politician to sell for cash money perfectly fine.

I was working on my own project. Medium-sized, a full-stack web application that I'll release somewhere this year. It's a Next.js front-end, I did all my own CSS and optimisations, semantic HTML, accessibility, load performance, TTI optimisations. The CMS is a headless one that I use Next.js to connect directly to the database with. It's hosted on a server I manage myself, and I set it up so that a git push to the main branch would build and deploy the entire thing.

Setting all that CI/CD stuff up took me maybe 6 hours. Building the website (front and back-end) took me a few weeks. It's a complicated piece of software, but fun to build.

I avoided using unnecessary tools. I only added what was absolutely necessary. And based on my 22+ years of experience (including some FAANG companies and the likes), in any professional setting, this project would've taken 5 front-end developers, 3 back-end developers, 2 testers, 1 project manager, 1 scrum master, 1 product owner, 1 UX and 1 UI designer, and perhaps one or two interns.

And it would've taken 2 years or longer.

I've done projects with teams like that in the past where trivial work was drowned in red tape, office politics, endless opinions and meetings, weekly time-wasters (Scrum... fuck I hate Scrum!), endless "documentation" that nobody reads...

And I remember being put on a dashboard page. The team was taking 4 hours to plan all the stories. During that time I just started working (remotely, muted, camera off) and I finished the entire dashboard completely to specs, no bugs, in the time it took them to write the stories and tasks and estimate them.

"Done."

"What?"

"I'm done. It's all done. I pulled all 18 tasks to myself, verified them, and the entire story and epic is now done."

"What?"

"I also wrote all the e2e-tests."

"What?"

"Scrum is a huge waste of time."

"Actually, I disagree, because..."

Yeah, consultant who is paid by the hour. It makes perfect sense to pull all 20+ people into a 6-hour long retrospective every single week. Because 12 of those people are from your employer, and that's a lot of money for doing fuck all.

When I worked at Apple, we had a small team and we just did standups on Slack. Just write "I did X, I will do Y, no impediments," and that's it. No scrum bullshit, no sprints, no retrospectives. We just communicated using words (written, preferably) and got shit done.

Now I'm working for a large corporate company that follows all the things by the book. And the book sucks. I counted: 16 hours per week in unnecessary meetings. Then another 10 hours in meetings where most people are unnecessary. And when I speak up against it, people don't trust me. Scrum is their God.

I hate my job so much.

I'd imagine that, as people in poorer regions in the world get access to laptops, we'll see a big increase in free operating systems. Sure, you could crack Windows, but why would you? Windows 11 isn't really good, and cracked software gets no support. Might as well go for a legal Ubuntu with lots of community support and decades of online help for all possible issues. It's a modern OS nowadays.

The real question should be: would most developers WANT to use a Mac, if given the choice?

Personally, I think OSX is the superior of the two simply because it's stable as can be, takes no (and allows almost no) tinkering to get working. Controversial opinion, I'm sure.

I compare it all to using Github Copilot in my daily work. Before, I needed to Google many problems to find answers, curate the answers, scroll down websites, read downvoted comments on StackOverflow, copy/paste code, refactor it, turn code into TypeScript, etc.

Now, I just tell Copilot what I need to do, and I simply curate multiple solutions.

ChatGPT also understands what I need to do and changes things based on human instructions. It gets things right much more quickly.

The same trick is applied to trick potential customers into going through a sales funnel and convert to a paying customer.

"There are 42 people watching this hotel right now! Only 3 rooms available for your dates! We'll murder ANOTHER puppy if you don't book right now!"

Yes, I worked for Booking.com. They don't do it everywhere, in some places it's illegal, and sometimes they simply change the words slightly to make it suggest urgency.

I hate Tailwind with the passion of a million suns. It's loved by novices and those who don't know what they're doing, almost exclusively. They claim they know CSS, but will fail after any casual test.

The best arguments against it:

1. Spamming utility classes causes horrible git commits, git history, git difference checks;

2. Conflicting utility classes aren't clear, and sometimes the order cannot be trusted;

3. Replacing `p-4` with `p-4` will require you to replace its occurrence all over your app, sometimes affecting thousands of matches. And since there is no context to it, it'll be hard to JUST replace them where you would want them to.

Vanilla CSS using `:root` declaration, a fixed base size (using `rem` and `em`), CSS variables and `calc()` are SO powerful.

In almost every single use case, using vanilla CSS or SCSS is far superior. For React projects (and Vue.js, and Svelte, and Angular), I'd recommend anyone to just use (S)CSS modules. It's so elegant and doesn't come with any of the disadvantages.

Except maybe a slightly larger package size. Minimally so. Your framework of choice should be (or allow) code splitting to take place. And a few bytes more or less aren't going to make or break most websites.

I completely agree with this article, but it never bothers me in particular. But I'm a developer, so I'm an outlier. That said, I do wish that the error message I see every day would be simpler.

    <looks at TypeScript>

I sometimes miss the days of XSLT and XML. They were very performant and easy-to-use client-side templating technologies that had a lot of power. I still think there was a lot to be gained by combining XSLT and JavaScript client-side.

Then again, when I look at old projects I do find it extremely verbose and JSX makes me so much happier.

I still can't buy the PS5 in my country. To me, Sony is dead. I've had every Playstation console from the start and have bought one within months of release, it has been almost TWO years now and still there's nothing. I'll never purchase any of their things ever again.

They wrote you can be agile if you move to the cloud. Did you try that?

I jest. But that's kind of the point. SAP is terrible by the nature of the beast. It's a closed off system with specialised developers who require all sorts of expensive certifications. That doesn't make for good developers, that makes for pigeon-holed developers who don't have a lot of competition.

A terrible SAP developer with all the certifications to their name would probably still find plenty of work, because the expectations are low to begin with, as proven by SAP being held in low regard across the industry.

To me, needing expensive certifications to prove your worth (as if...) is a big red flag. I'm a developer who has 20+ years of experience, I recently worked for Apple and other Fortune top 50 companies, I went from startups to enormous companies.

Nowhere did I need certifications. And my past experience was never enough to land a job. I'd have to prove myself in every job application. That's tiresome and feels extremely unnecessary, but it requires me (and my peers) to stay sharp.

Of course, none of the above is very black and white. There are certified developers who are amazing, and there are open-source developers who keep themselves relevant who actually suck at what they do.

But I'd argue that the SAP group of developers have far more developers who aren't very good and grow complacent, oftentimes because of their certifications. That, combined with a closed-off system, bad documentation, a lack of online support, and a much smaller community, will MORE often lead to software that is of lower quality.

"We don't know how fire comes to life, and we will never know."

"We don't know how to defend ourselves against beasts, and we'll never know."

"We don't know how disease spreads, let's just hug it out, we'll never know."

"We don't know how to fly like a bird, we'll never know."

"We don't know how to land the booster of a rocket, we'll never know."

"We don't know how to cure that form of cancer, and we'll never know."

What a ridiculous defeatist attitude. History has proven that, so far, we've been very reliable at figuring out things that were deemed impossible.

I'd say we already know. It would be infinitely arrogant of us to think we're the originals. We're likely inside an inescapable but observable simulation, inside a simulation, repeat for any unknown number of times. That's probably how "the universe" (our universe) began.

Our parent universes probably have far more complexities to them that have been stripped from ours, for the sake of computational simplicity. Perhaps the actual originals, or any of our parent simulators, know exactly how the universe came to be. We might figure it out, too.

I'm just wondering why these services need centralised hosting to begin with. Peer-to-peer networking isn't new, Blockchain as a tech could take care of decentralised but shared information.

And I don't mean that a company of 10 people depends on each other, their messages are also hashed, seeded, encrypted, etc. on the entire network. Each company and each individual can have their own unique key that's used to make their own messages and content readable again.

Of course, a company should be able to choose to only share messages across their own employees and not to anyone outside, if they are wary of security issues. Messages could have set expirations, too, etc.

We shouldn't need an expensive middle-man. It should be a free open-source project.

But I'm not a networking expert. Is this simply not feasible for other reasons? I'd love to work on such a project as a software engineer, for sure.

TypeScript has come a long way, but one of its biggest issues is the complete lack of FORCED sensible naming conventions.

Generics are the worst offender, with people often using a single letter to represent something that's both hard to keep track of and impossible to intuitively make sense of.

Any type should be: `TUser` and not `User`.

Any generic should be: `<GPerson>` and not `<P>`.

Any interface should simply not exist because it's TypeScript, not InterfaceScript. The addition of classes into JavaScript was unnecessary sugar and they should just do away with it. So, `type` for everything, no more `interface`.

But that's a whole different subject.

I've also noticed that people over-engineer TypeScript. I had a team mate telling me he wanted to make URLs type-safe. I asked: "But why?" and he had no answer. There was no problem preceding it. There wasn't anyone asking for it. It wouldn't solve something we didn't know. It would just make the codebase more confusing to deal with because, in his solution, there wasn't a single place where routes were defined. Nope, routes would be inferred from Pages and their use of Page props.

It was genius. But it also was over 2000 (two THOUSAND) lines of code that I didn't feel like I wanted to deal with.

I gave him permission to publish it and get the open-source community involved. Once it's tried & tested over the course of many users and lots of time, we could consider it.

He wasn't happy. He was also not very pragmatic. TypeScript seems to do that to people. The "never any `any`"-crowd is so tiresome.