- 0 Posts
- 45 Comments
and, perhaps more critically, some Chinese GPU makers from utilizing CUDA code with translation layers.
Like that ever deterred China from violating copyright claims to trademarks. Maybe if they’re huge companies that want to export, but if they’re just making in-country chips, especially if it’s useful for the Chinese government, these companies are not going to change anything based on some license warning
It depends on the language, since you mentioned you don’t want to do manual testing -
Start with a mono-repo, as in, 1 repo where you add every other repo as a git submodule
Then, every time something changes you run that repo though the build server, and validate that it at least compiles.
If it compiles, you can go a step further, build something that detects changes, for example by parsing the syntax tree of everything changed, then check the syntax tree of the entire project which other methods / objects might be affected. In dotnet you’d do this with a Roslyn Analyzer
I think I couple of those points come down to the tech-lead to write a “Definition of Done”
1 - This is useful for junior members or new members to know what to expect. For example, “Definition of Done” would include that a new function should be documented, it should be refactored into clean code by the code standards, it should be tested by QA, there should be unittests covering the function, the function should be released to production to be marked as done - etc
2 - When giving managers that don’t know anything about coding an estimation - either by you, or by someone in your team - they can take the Definition of Done" as a reference point. If a manager asks how long something will take, you don’t just consider “Oh, I guess I can build this in a couple of days”. Yea ok sure, you can build it to meet the managers minimal requirements for the function to kinda work but its messy code and untested - so if you keep in mind that there are loads of other meta-things to do besides just building code, you can pretty much double your initial estimation
Otherwise you just accumulate more and more technical dept, and at some point your “just build it” estimation gets inflated because for every change you have to touch lots of 1000 line files, figure out what broke by the changes, fix that, see what failed now, etc etc
And it would have been better in the long run if you would have spend more time on it while you were working on the function
Do you mean their code is already setup with some kind of output to terminal that you can use to add a unit test into as well?
I don’t even recall what I was messing with awhile back, I think it was Python, but adding a simple print test didn’t work. I have no idea how they were redirecting print(), but that was a wall I didn’t get past at the time.
Yea, probably not every language has a concept of unittests, but basically test code.
Like if you have a calculator, there would be a test (outside of the real project) of like
If Calculator.Calculate(2 + 2) then assert outcome = 4
That way - if lets say the calculator only does + operations - you could still copy that test line, and create a new test of
If Calculator.Calculate(5 * 5) then assert outcome = 25
Your test will fail initially, but you can just run through it in a debugger, step into the code, figure out where it’s most appropriate to add a * operator function, and then implement it, and see your test success.
Other benefit of that is that if you submit your change as PR, with the test the repo maintainer doesn’t have to determine whether your code actually works just by looks, or actually running the calculator, your test proves you’ve added something useful that works (and you didn’t break the existing tests)
That stuff seems like a language on top of a language for me, and when it errors I get really lost.
If you’re just programming for yourself without the intent to submit it for a PR, you can just throw away the linter file. But I mentioned it was good to have in a project, because if there were multiple people working on it, all with their own style, the code can become a mess quite fast
I get sick of something that annoys me and want to go in and fix the issue despite being completely unqualified, but naive enough to try.
Well, I mean, that’s basically all the things right? You start completely unqualified, mess around for a while, and after a while you’re them more-qualified next time…
With stuff like Marlin, I seem to like the hardware side of things.
Just messing around with stuff you like is a good way to learn - though in my experience doing anything with hardware is way more difficult than just plain software. If you have to interface with hardware its very often pretty obscure stuff, like sending the correct hardware instructions to a driver, or to just “hardware pins” even… Like trying to start modifying a driver as a kind of starter project doesn’t sound like something I’d recommend
Generally mostly by cyclomatic complexity:
-
How big are the methods overall
-
Do methods have a somewhat single responsibility
-
How is the structure, is everything inner-connected and calling each other, or are there some levels of orchestration?
-
Do they have any basic unittests, so that if I want to add anything, I can copypaste some test with an entrypoint close to my modifation to see how things are going
-
Bonus: they actually have linter configuration in their project, and consistent commonly used style guidelines
If the code-structure itself is good, but the formatting is bad, I can generally just run the code though a linter that fixes all the formatting. That makes it easier to use, but probably not something I’d actually contribute PRs to
How do you learn to spot these situations before diving down the rabbit hole? Or, to put it another way, what advice would you give yourself at this stage of the learning curve?
Probably some kind of metric of “If I open this code in an IDE, and add my modification, how long will it take before I can find a suitable entrypoint, and how long before I can test my changes” - if it’s like half a day of debugging and diagnostics before I even can get started trying to change anything, it’s seems a bit tedious
Edit: Though also, how much time is this going to save you if you do implement it? If it saves you weeks of work once you have this feature, but it takes a couple of days, I suppose it’s worth going though some tedious stuff.
But then again: I’d also check: are there other similar libraries with “higher scoring” “changeability metrics”
So in your specific case:
I wanted to modify Merlin 3d printer firmware
Is there any test with a mocked 3d printer to test this, or is this a case of compiling a custom framework, installing it on your actual printer, potentially bricking it if the framework is broken - etc etc
This situation is due to npm’s policy shift following the infamous “left-pad” incident in 2016, where a popular package left-pad was removed, grinding development to a halt across much of the developer world. In response, npm tightened its rules around unpublishing, specifically preventing the unpublishing of any package that is used by another package.
This already seems like a pretty strange approach, and takes away agency from package maintainers. What if you accidentally published something you want to remove…? It kind of turns npm into a very centralized system.
If they don’t want to allow hard-removals because of this, why not let people unpublish packages into a soft/hidden state instead? Maybe mark them with the current dependencies, but don’t allow new ones - or something
I prefer the approach of Azure DevOps more. When you publish any nuget, or npm into their system, the entire package dependency tree is pulled in and backed up there. So you don’t rely on NPM anymore to keep your referenced packages safe
He gave me one last tip. If I ever want to have a career in a management role, like CTO in the future, I must emphasize more on “taking credits” from the beginning of my career. He said being humble or modest is overrated and it would not do me any good for my career.
I don’t really know if any of this is true, or what the context is. Maybe this is how it is in American Corporate culture, but it’s not really how I experienced it.
If you’re a beginner programmer, sure, you can brag about how cool your code is, and how much you’ve build. But if at some point you become a lead developer and you’re still doing that, it seems kinda toxic.
As lead developer in the standup or reports I’d usually downplay what I did - like instead of saying “I build this cool new feature” - present it as “The backend team build this cool new feature”. If someone else build something cool, I would specific say something like “Bob build a really cool feature”
I must emphasize more on “taking credits” from the beginning of my career. He said being humble or modest is overrated and it would not do me any good for my career.
A good Team Lead or CTO needs a good team, and the team usually appreciates it a lot more if you’re spreading the credits around instead of taking them for yourself.
Besides that, a random developer in a big company is very unlikely to just become the CTO by not being humble. If you want to become a CTO, you either join a startup or start your own company
I don’t know if this is a relatively “new” computing paradigm, though if you compare it to the pre-2010 area, its pretty much the standard for bigger applications. And I think it’s very much tied in with the Move to Cloud Computing paradigm.
In the good old days everyone just had their own servers running somewhere, so what are you going to do when its super busy on your platform? Add a new server for a couple of days? If you have a new server anyways, you’d just permanently add it to the network.
With cloud computing, as you mentioned, there’s Service orchestration like kubernetes, auto-scaling of bare-metal machines, and Serverless Applications that just keep track of usage and allow you to very easily temporary add more power based on demand, and upscale your infra for the time that it’s needed.
If you start getting into paradigms like that, you might end up with 100s of services running at the same time (multiple copies of the same services for load balancing, or edge-locationing etc) - Then you also don’t want to put cross-cutting like logging and analytics hard-coded in every service like you’d potentially do in a monolith. And you need those kinda metrics to see that everything is still running healthy, and to automatically kill unhealthy services to replace them with new ones, etc
Cool, how much of your 25 years was to “write test automation to test the front end” full time?
This guy is in his 3th job after 6 years - so job-hopping every 2 years (as per the current programmer-job-meta. - ) trying to find the right job that fits him - but obviously he hopped into a disaster of a job. Its a personal anecdote of his experience so far.
If you have 25+ years of experience, but you can’t relate at all to what he’s experiencing, then this guy already has more experience than you do
Yea, I kept my original comment language-agnostic (Just referring to it as y language) - but added the extra wink to Rust because generally they seem to be the highest offenders.
I have years of experience in loads of languages: PHP, Ruby, Java, Python, C#, C++, Rust - And that’s probably how I’d order the level of elitism. PHP Devs know everything they’re doing is shit - Python should probably be next in ranking of how shit they are, but they’re not self-aware enough - (Sarcastic elitism aside here - )
Anyways, besides that - at the end of the elitism-spectrum there seems to be Rust. Someone like me says something about Rust in a general unrelated-to-Rust thread like this - and a Rust enthusiast sees it, and it would just devolve into a dumbass back-end-forth about how good Rust is
Could you elaborate in what context and to what extend? I can agree that bigger companies with large user-bases should have a focus on accessibility and internationalization -
But generally a lot of projects start with just one dev solving a problem they have themselves and make their solution Open-Source. Anecdotally, I’m dumping my solutions on Github that are already barely accessible to anyone somewhat tech-illiterate. No one is paying me anything for it. Why would I care whether it’s accessible or internationalized for non-English speakers?
This. I’ve had someone in my team that was completely self-taught with no relevant education that was a great dev.
I’ve also interviewed someone that supposedly had a master degree and a couple of certificates and couldn’t remember how to create a loop during the interview.
I don’t know how you could properly implement “standardization of qualification and competencies” without just min-maxing it in a way that favors academics
Well sure, it depends on the context. If it’s a shitpost on /c/programmer_humor, whatever, meaningless banter.
If it’s a serious question, (maybe for a beginner) asking how to do something in their language, and the response is “It would be a lot easier in y language” - I don’t think it’s particularly helpful
Probably less elitism. “Oh you build it in x language? Well that’s a shit language. You should use y language instead. We should be converting everything to y language because y language is the most superior language!”
(If this feels like a personal attack, Rust programmers, yes. But other languages as well)
The question is a bit too vague to answer, there’s not really any right answer.
Just - find what you like to do with it, and go for it. Want to make a game? Maybe play around with Godot or unreal engine or something.
Do you have any repetitive task that you’re doing a lot that you could maybe automate? - try doing that.
You can read some books or watch some tutorials or something, but the best way to actually learn is to actually program.
Yea true, if people can vote on something, other people will use those votes as metrics for how good something is
My perspective was more about what they actually do. Not the meta-effects they might have socially
Eventually, you will be able to turn a repository with a high star count into money or advancement
I think you overestimate how much money or advancements you can really get from it though.
Money wise - I can’t find an overview of “Most Sponsored github repos” - but it’s pretty bare. I checked to see if I could find any example, for example if you look at FluentAssertions - A project that basically everyone uses, has 292.6 Million total downloads on Nuget. If you check their sponsers - they currently have 17. Assuming their the lowest tier, you’re getting $85 a month. Which is cool, I guess, but a neglectable amount for a developer with a normal job
And advancements wise - any actually good developer doesn’t really have a problem getting a good job - And any good company reviewing a candidate might fool the HR by buying stars, but a dev reviewer or something will actually look though the code won’t care much about stars
Stars don’t really do that much, people mostly use it to “favorite” your repo. Or just a general “Upvote” or something
I have a repo with about 1.4k stars, so what it gives you:
- The Starstruck badge in your profile with different tiers at 16/128/512/4096 stars
- Visibility in search: When you search for something in Github, it takes into account the amount of stars something has
Not sure if that affects other searches, like google
Even more stars (apparently like 5k+ or more) gives you
- Github Copilot is free if you’re a “maintainer of a popular open source project”
for postgres and Ms SQLserver
It’s not really a SQL Language feature, more an IDE feature. So to tell you where the settings are, we’d have to know which IDE you’re using.
For example, in DataGrip (which I think you can use both for postgres and MSSQL), there’s “Show warning before running potentially unsafe queries”
If you forgot to put the WHERE clause in DELETE and UPDATE statements, DataGrip displays a notification to remind you about that. If you omitted the WHERE clause intentionally, you can execute current statements as you planned.
do you worry that Microsoft is going to eventually do the Microsoft thing and horribly fuck it up for everyone?
I’m not really sure what you have against Microsoft, or what “Microsoft classic” you’d be referring to…
In the last 10 years or so they pretty much moved everything C# related to Core, cross platform and open source. Even the decision making for the language is “Open source” - Microsoft is not really behaving the same as the Microsoft from 2000…
Soo, I don’t really know how they could possibly fuck it up. They might add more and more features you might not like, but you could just choose to stick to an older version of the language
This whole article could have just been a report of “How I found a bug in the Kernel and helped fix it” - instead of something this negative
I disagree. If noone spoke out about Linus Torvalds calling people “dumb fucks”, he would still be doing it.
It’s kind of a leap from “not accepting a PR because the maintainer thought the code wasn’t good enough to accept it at face value - and the maintainer apparently didn’t care enough to give the contributor an extended code-review on how to fix it” vs “calling people “dumb fucks””
If a maintainer get a PR that’s bad and it would take an hour to write an explanation on how to fix it - and then hoping the end-result from the contributor is as expected, otherwise he’ll have to write another explanation on how to fix it and go back and forth for a while - vs - just spending that hour rewriting the fix himself - I’m pretty sure most maintainers just do it themselves.
When you actually work for a company and you’re working with other (junior) devs, you should go for the option of educating them on what’s wrong with their PR… But in this case - I don’t even know if the maintainer is doing this as a paid job or just in their spare time - but either way why would the maintainer spend time getting the PR right if it was apparently far off.
Did the author do the best job with this article? Probably not. That does not invalidate his experience though.
I didn’t say his experience was invalid, but his experience probably isn’t unusual. He could’ve taken this experience as “I contributed the QA and diagnosing part of this bugfix, but my code wasn’t up to par. Next time before submitting some random fix for a bug that I found (that wasn’t even “Up for grabs”) (or discussed how it should be fixed at all) - I should contact the maintainer first” - Instead it seems he found a bug, didn’t really report or communicate about it, because he wanted to race for a fix himself because he wanted to get recognition for actually creating the code the fixed the bug
Edit: the amount of downvotes you get for saying something unpopular without being violent or abusive is showing the lack of guts to discuss something in a civilized manner. Shame on you.
People aren’t discussing this because “try to sue in this case” is just an absurd concept - but okay.
Who are you going to sue and for what? His concept of recognition is just “getting his code into the kernel”? He could have written a blog post in the context of “How I found a bug in the Kernel and helped fix it” - He did contribute, he did the QA part and the diagnosing part, thats contributing.
But his post with the sentiment of “I did it all for nothing!” makes it seem like the goal was to get “recognition” and get his code into the repo… The goal is just to fix bugs, and he did contribute to that
That in itself is the problem. If the kernel community wants to attract new contributors, mentorship is important and appreciation of effort is important, despite the result of that effort not being up to par yet.
Well it depends on the quality of the PR. If there are minor things wrong, you can point them out the the contributor and help them get their PR to a level you want…
If the PR is “Ok, thanks for pointing out where the issue is, but I’m going to have to rewrite your solution entirely” - what is the maintainer supposed to do? Take their PR, overwrite the solution, and git squash them together so the original contributor gets “credit” in form of being in the git history?
I doubt the maintainer would even consider that the contributor would feel “belittled and angry” if their fix wasn’t accepted at face value, or if they didn’t get enough credit would write an angry blog post about it. This whole article could have just been a report of “How I found a bug in the Kernel and helped fix it” - instead of something this negative
Yea, I was thinking the same. I have the JetBrains toolbox, and already have these installed:
- Rider
- RubyMine
- PyCharm
- GoLand
- CLion
I don’t really get why they need to make 10 different IDEs for every language, instead of just consolidating everything into a single UI/IDE.
For pricing it doesn’t make that much sense, anyone that wants more than 2 JetBrains products is better off buying the entire toolbox.
[…] Blazor WASM has a massive initial payload, which makes it slow and heavy.
Blazor WASM doesn’t need to have a massive initial payload, that’s only if you’re making your projects too big, and aren’t really structuring them correctly. To be fair, Microsoft hasn’t really done anything to make this easier, or address this
(Shameless self promotion) - I however, have fixed that: https://github.com/RonSijm/RonSijm.Blazyload Your “landing page” should basically ideally be pretty much the only thing that’s initially loaded, so that the initial load is fast. Once that is done, you can quietly lazy load the rest of the dlls you need
I read someone saying that the lack of contributors was due to the software stack being unconventional and takes people a while to get used
I don’t think the software stack does matter that much. I’ve downloaded the Lemmy source and ran it from source, and my main caveat with it is the structure. I would have liked to see a much more modular design, with an add-on kind of system. Now, when an instance owner wants to add a feature, their only two options are either to: Try to get their specific feature into Lemmy main, or create a specific Lemmy fork with their own feature(s).
The entry level to just create your own Lemmy add-on would be much smaller than to try to get something new into the main repo. Plus it’d give you a sense of ownership when you’d see something like “50 instances have added your add-on” - over “I made a cool feature, it got PRed into main, and pretty much no one knows who build it”
For example, a great system is something like Home Assistant - Where this is a structure of “Addon-Repo” and “Addons” - with a Main Repo and you can add your own custom repo, or just install from .zip if you want that for some reason. Kind of similar as something like Nuget
If people could “contribute” with their own standalone things instead of having to PR stuff into a repo, you’d get much more contributions and user created add-ons
I’m not very familiar with the ActivityPub protocol, but there are easy ways to flatten an hierarchy.
For example, the tag could literally be “NSFW/Porn/Straight” - though I assume then there’s no system in place to request tags by their parents… So posts with that tag would just get 3 tags: “NSFW”, “NSFW/Porn” and “NSFW/Porn/Straight” in the API, and would be hidden / breadcrumbed in the UI.
Though it’s not ideal to do it like that, as it would make maintaining structure more complicated - though not impossible.
Just curious, how open / extendable is ActivityPub? Just to say “the protocol doesn’t have it (yet)” - doesn’t mean it can’t be implemented, either properly or through some workaround like mentioned above
I’d like tags, but they’d have to be something different than just communities / categories, since that’s already what communities are for.
I’ve build multiple CMS like systems, and how I’ve implemented tags before, and liked the most was as a node tree - Since a lot of the comments are focused on NSFW, to illustrate an example:
- SFW
- NSFW
- NSFW/Porn
- NSFW/Porn/Straight
- NSFW/Porn/Gay
- NSFW/Gore
- NSFW/Porn
This allows users to use tags as a sort of searching mechanism with an hierarchy, and fine-tune how specific they want to search for a specific thing. Do you want all NSFW stuff, or something more specific.
The downside is that it could get complicated to maintain a good tag structure, plus you might run into scenarios where 1 subtag might fall under more categories. In that case a “Parent 1-x> Child tree” doesn’t work anymore, and you’ll end up making an “Parent x-x> Child structure” - which is even more difficult to maintain
The argument against tags, is that posts are already categorized by communities. Though not everything, and not every niche thing needs it’s own community in my opinion. Look at !programming@programming.dev for example - a “general purpose community”. Just taking the top 2 posts there, you could still create a similar note-tree tag structure there like:
- Programming
- IDEs
- VSCode
- VSCodium
- VSCode
- Code Style
- Tabs VS Spaces
- IDEs
These tags could still be “communities”, but communities are non-hierarchical, and at what point to we really need an extreme niche “Tabs VS Spaces” community? If there would be a tag system like this, people could select the “Code Style” tag, and see posts under that tag plus all child tags.
This is just an idea for tag structuring, the concepts of ACLs of “who can make these tags” and “who can move around tags” or “who can append new child tags” - and “Introducing new child tags could require reordering the parent content into those tags” is an whole other discussion
I don’t know if there’s a “definitive guide” - it’s not that complicated to get a torrent client up and running. What kind of content are you looking for? Movies, Series, Music, Games, Books…?
Best is probably to try to get access to a decent private tracker, and an “easy” one - one with a bonus point system for seeding and uptime - that makes it much easier to keep a good ratio with a NAS, if you’re just permanently seeding everything you download, you’ll get points and “rise the ranks” of that tracker.
Once you’re a high enough rank on that tracker, you’ll get access to their “Invite Forums” where other private trackers advertise and give out invites to their trackers
What software/OS are you running on your NAS? If you’re running some goofy software on a private tracker your client might not be whitelisted.
Besides that - this NAS is attached to your home network I assume? Is it behind a router? Are the ports you’re using for torrenting port-forwarded?
What tracker are you testing this on? A bunch of trackers will have a “Connectivity check” that will tell you whether or not your client is connectable
preemptively running source as it was written
It’s not preemptively running source as it’s being written, it’s preemptively evaluating methods as you’re debugging it
This looks like it’s preemptive compiling, which isn’t just unwise, it’s potentially dangerous.
So I think what you might mean is preemptively evaluating methods at runtime? - which would be unwise / potentially dangerous - since it could cause side effect
For example, evaluating a method that increments something and modifies the state. So if it’s preemptively called by the debugger, the state would be modified, and the actual invocation would be different
I installed the Resharper RC, and this is how it looks like in a small project that parses an excel file: https://i.imgur.com/g4s0P3h.png
So, in the example my debugger is still on the allTheFieldsEmpty line and hasn’t ran it yet, but resharper already evaluated it to false. Then it also greyed out everything in the if(allTheFieldsEmpty) block, since it knows it wouldn’t hit that
The next line you can see there was a warning, “Possible impure evaluation” - which is that I assume you were talking about, and it didn’t evaluate that yet. I can click the box and make it evaluation it.
The debugger inspects the method, as the article mentions, it check for the PureAttribute - indicating that it’s safe to use
After I marked that GetMappingField method as Pure, it actually did evaluate it without any interaction, and it predicted it would throw an exception https://i.imgur.com/zQ0K3Ge.png - seems pretty useful so far
Another thing that surprised me was how much chatGPT bot spam there is
Not really a bad thing. Part of the protest was to devalue the platform…
See what /r/ProgrammerHumor/ is doing - all titles are camelCase, and all the comments started including and returning things. It’s not really something anymore that reddit could sell to AI content farms.
If mods are removed for participating in the blackout, the next best thing is probably to let their sub go completely unmoderated and let things turn into a shitshow with unable content by spam bots.
Don’t think you can really teach an AI bot something by letting it regurgitate it’s own output
4.2 (5 ratings)
5 ratings… doesn’t really seems like anyone is actually using this. The $20/user/month is probably a hail mary of “Lets throw this product out there, and if just one company with like 100 users accidentally enables this thing, we’re good”