[-] lysdexic@programming.dev 14 points 11 months ago

There would be no other incentive for companies to buy it.

A company might want to extend it's service offering with a build pipeline/CICD system, and buying GitLab would get them the best-in-class service.

Microsoft bought GitHub for much of the same reasons, and GitHub didn't went to hell after the acquisition.

12
1
1
12
Lamport timestamp (en.wikipedia.org)
14
3
15
Graph Query Language GQL (www.gqlstandards.org)
1
42
4
1
[-] lysdexic@programming.dev 13 points 1 year ago

I've submitted this link because the topic is interesting to me, and !functional_programming@programming.dev is practically dead, with the last post dating back over 10 days.

For those who are down voting the contribution, be my guest and do better: submit interesting content.

42
[-] lysdexic@programming.dev 12 points 1 year ago

It’s a way of saying “these are wrong and should be deprecated.”

They aren't wrong. No one in their right mind just throws away years of work delivering a stable production project just because a random clueless person in the internet said something. It's lunacy.

[-] lysdexic@programming.dev 13 points 2 years ago* (last edited 2 years ago)

We have a client which is MAD cause the project is riddled with bugs, but the solution somehow is paying more attention. Except that it clearly isn’t feasible to pay more attention when you have to check, recheck and check again the same thing over and over…

By definition, automated testing means paying more attention, and doing it so well that the process is automated.

They say it’s a waste cause you can’t catch UI (...)

Show them a working test that's catching UI bugs. It's hard to argue against facts.

but they somehow think they are smarter than google or any other small or big company that do write test

Don't sell a solution because others are doing it. Sell a solution because it's a solution to the problem they are experiencing, and it's in their best interests to solve it. Appeals to authority don't work on everyone.

[-] lysdexic@programming.dev 14 points 2 years ago* (last edited 2 years ago)

From the article:

(...) but recently, another type of criticism seems to be on the rise.

The code that I suggest is too verbose. It involves too much typing.

This reads like a one-sentence strawman. Describing code as "too verbose" is really not about the risk of carpal tunnel syndrome. It's about readability and cognitive load.

The blogger seems to almost get the point when he writes the following:

In short, the purpose of source code is to communicate the workings of a piece of software to the next programmer who comes along. This could easily include your future self.

The purpose of source code is to communicate (...) to the next programmer who comes along.

If you make the mistake of going the "enterprise quality java code" meme approach, you're making the next programmer's life needlessly harder.

The blogger then tries to make his case with verbose code, and makes the following statement:

Which alternative is better? The short version is eight lines of code, including the curly brackets. The longer version is 78 lines of code. That's ten times as much.

I prefer the longer version. While it takes longer to type, it comes with several benefits. (...)

This is yet another strawman. The longer version is awful code, not because it's longer but because it's needlessly jam-packed of boilerplate code. Ignorign basic things like interfaces and contracts, It's been proven already that bugs in code are directly proportional to the number of lines of code, and thus the code the author prefers is likely to pack ten times more bugs.

The shorter code in this case would not be the 78-loc mess that the author picked as the thing he prefers. The shorter code in this case would be something like onboarding the project onto Project Lombok to handle all-args constructors, property methods, and even throw a builder in for free. This requires onboarding Lombok to the project, and add two annotations to the short example. Two lines of code, done.

After the blogger fails to make his case, he doubles down on the typing non-sequitur:

Perhaps you're now convinced that typing speed may not be the bottleneck (...)

This is a blog post that fails to justify a click. It's in the territory of "not even wrong".

[-] lysdexic@programming.dev 12 points 2 years ago

This article seems to be well-meaning but contrasts with the de-facto standard way of storing dotfiles. The Linux Filesystem Hierarchy Standard is quite unambiguous in how it specifies that the purpose of $HOME is to store dotfiles.

https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch03s08.html

FHS also specifies that applications can store their dotfiles in subdirectories, and this is leveraged by other standards like the Freedesktop's xdg-user-dirs spec to default to ~/.config

https://www.freedesktop.org/wiki/Software/xdg-user-dirs/

I'm not sure what's the point of arguing against the standard way of storing dotfiles while basing the remarks on no standard or reference.

[-] lysdexic@programming.dev 13 points 2 years ago

I don’t think it’s a stupid thing to want to have code in the kernel, especially after spending all my time debugging this issue.

The way that you jumped straight onto broadcasting drama when your very first Linux kernel patch stumbled on the code review stage is a major red flag.

I would hate to work with you because I would feel that I would be risking being subjected to a very public character attack each time I had to review one of your patches.

[-] lysdexic@programming.dev 12 points 2 years ago* (last edited 2 years ago)

Whew, here I was thinking it might be cool to try to contribute to some project, maybe even Linux! This thread shall serve as my reminder to never do that because that’s for god-tier emotionless techbros only.

I've stumbled upon this blog post first in HackerNews, and the comments there make it quite clear that, even though it wouldn't hurt to give more credit than merely reporting a bug, the author's submission was flawed and subpar, and the rewrite that went in was undoubtedly better in every way.

I don't think all this drama is waranted or justifiable. Also, if the first whiff of adversity bothers you and any feedback in a PR other than enthusiastic praise leaves you with a sour taste then collaborative work might not be for you, both as a participant and as someoje that everyone else has to endure.

[-] lysdexic@programming.dev 12 points 2 years ago* (last edited 2 years ago)

My workplace has the opposite problem.

I don't see that as a problem. The job description of an engineer includes dealing with new problems and onboarding onto new things. So you never wrote a parser and now you have to. That's ok, just go ahead and start from the ground up.

What I perceive as a major problem is the utter disconnect between what companies test for, and what companies actually do.

It makes no sense at all to evaluate candidates on obscure trivia questions no one will ever care about or use, let alone reject an applicant because they mixed up O(nlogn) with O(logn). It matters more if you know a good, healthy answer to tabs vs spaces.

I once was a part of an hiring loop where we assessed a candidate, and one other fellow assesser wanted outright to reject the candidate because he failed to answer one of his questions on data structures. Everyone in the meeting voted in favour of that hire, except that one guy. When we asked to reconsider his position, he threw a tantrum because he felt that it was a matter of principle that we had to not hire a candidate that didn't knew trivia. The hiring manager asked if that info was important, and in case he felt it was whether it could be looked up online in a matter of minutes, but the assesser tried to argue that it was besides the point.

Data structures and algorithms trivia feels like ladder pulling.

[-] lysdexic@programming.dev 13 points 2 years ago* (last edited 2 years ago)
[-] lysdexic@programming.dev 12 points 2 years ago* (last edited 2 years ago)

Here's a way to convince a team to write unit tests:

  • setup a CICD pipeline,
  • add a unit test stage,
  • add code coverage calculation,
  • add a rule where unit tests fail if a code coverage metric drops.
  • if your project is modularized, add pipeline stages to build and test and track code coverage per module.

Now, don't set the threshold to, say, 95 %. Keep it somewhat low. Also, be consistent but not a fundamentalist.

Also, make test coverage a part of your daily communication. Create refactoring tickets whose definition of done specifies code coverage gains. Always give a status report on the project's code coverage, and publicly praise those who did work to increase code coverage.

[-] lysdexic@programming.dev 12 points 2 years ago

(proceeds to cry and click on "subscribe")

view more: ‹ prev next ›

lysdexic

joined 2 years ago
MODERATOR OF