The Lounge is rated Safe For Work. If you're about to post something inappropriate for a shared office environment, then don't post it. No ads, no abuse, and no programming questions. Trolling, (political, climate, religious or whatever) will result in your account being removed.
I mean, probably not. I don't have time to research the ridiculous UWP bluetooth interface and tap into it from regular windows, which is apparently the only way to do it short of interfacing with the drivers directly.
Besides, I don't code out of spite. I may threaten to though.
But the latest horror story is that I installed Quartz against my better judgement, to test it out. Quartz is a general purpose "job runner" and my first warning sign was that it was ported from Java.
Rule #1: Never install any package ported from Java.
The next thing I discovered is that whoever maintains Quartz decided that every single API method should be async, including initialization. Which, because I'm not calling the initialization from an awaitable method, meant I had to wrap the call in a Task(async () => initialize) call. WTF.
What made this worse was that the examples I found online were all written before this atrocity, so I had no idea what I was getting into.
Rule #2: Never trust online documentation, even the documentation provided by the package.
Furthermore, finding anything useful about why I have to do things "the Quartz way" was completely absent. Of course, the main reason for that is because it's a Java port.
Rule #3: If you can't find good examples explaining "why" in the package's online documentation, run.
Ultimately, yes, it worked. Seemed to work quite well. My coworker, who was pushing to use it (he loves packages rather than rolling-your-own) liked some of the features, but neither of us could figure out how to use those features, like error reporting / handling.
Rule #4: If it isn't obvious, it isn't worth it.
In the back of my mind, I kept wondering why I'm adding a package to our already bloated project that consists of thousands and thousands of lines of code, for 99% of features that I won't be using and can't figure out how to use, instead of writing my own KISS CRON job processor in about 200 lines of code, and one that is tailored to what I need in terms of querying what it thinks it should be doing, error handling, testing, etc. I'll post an article, BTW.
Rule #5: The KISS principle should be the first consideration when evaluating a package.
Which gets me to my point.
After making the command decision to ditch it, I uninstalled the package.
Unbeknownst to me, the NuGet package did not cleanly revert. I should have simply rolled back the entire set of commits to the branch. Stupid me. Instead, it left breadcrumbs in a config file that included various .NET framework packages, the most scary of which included a DLL for running unsafe code.
WTF does Quartz need to use unsafe code for?
Anyways, while everything worked fine on our development server, without my realizing what was going on with the config file, on the production server, the app blew up -- wouldn't even start. This was really my bad. I didn't realize (lack of inspecting the change logs) coupled with my own failure to not roll back but instead trust the NuGet uninstall process, that our production build was doing something (still don't know what) that was causing the runtime loader to fail. Possibly flags disallowing anything having to do with unsafe code. Possibly missing framework DLL versions that config was expecting specific version of. .NET did not fix DLL hell.
So between my errors, and NuGet package "management", and Quartz being bloatware, it's what Kirk says about Klingons: "I don't trust them and never will."
I've noticed a trend (at least in South Africa) that a lot of developer job postings are looking for junior to mid level developers. Posts for senior level developers are scarcer. Companies are looking for young, energetic people. It seems like it gets more difficult to find work as an older developer, even though I would think that you would be valued for your experience. I think part of the reason is also that the salary for junior and mid level developers are less and companies are trying to save money. Perhaps there is also a stigma that older developers skills are not up to date?
Younger ones are cheaper: and there is an impression that this is a Young Man's Game.
Problem is the ones that can code are generally those that are still in the industry after 30 years, not those who just escaped from college ...
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!
Agreed - if only the employers can see it this way.
There's also the notion that developers must move on and become managers, which is not something I'm keen to do. I'd rather keep on developing software. I could start to look at other non people management paths like design / architecture.
I did that (retired now)! I purposely avoided a management roll since the designing and coding are the fun job activities. I will admit to being a team lead now and then but that's not really a management job.
Many years ago the company I worked for (as an operator, but learning programming) would recruit programmers only from the graduate pool. So we had programmers with first or second class degrees who could not write a decent program to save their life. Largely because there were no CS degrees then, so they all had degrees in totally irrelevant subjects. It took a few years for that to change.
But my overall experience is that age has no bearing whatsoever. I have worked with people of all ages who were useless, and some whose skills were excellent. The main thing I did notice about the good ones, was their attitude to doing the job, and learning new skills.
I think effectiveness has to come down to how an older developer spent his career and the base knowledge they started with. Knowledge turnover in this field is extremely high. Understanding the core principles allows one to gain further knowledge more effectively. Where those who learn formulas to work with a technology that will become obsolete within 5 years are in trouble from day one. (i.e. boot camp and problem based self taught victims) The vast amount of knowledge required to truly be effective and make critical design decisions spanning many technologies takes years to acquire. And this may be a point where your interest and your employer's interests diverge. They need you to get the project done and know an investment in you may not be around in 2 years. You have a future you need to protect. So it is easy to see how so many would become stranded.
So an older developer who learned how to "work in a technology" that has become obsolete and did not aggressively acquire new skills and knowledge is in serious trouble when you consider the impact of life, family, and degeneration. Degeneration also varies greatly based on ones attention to exercising ones mind. On the other hand, one who started with a good foundation and aggressively fed their knowledge is probably in a position to "out develop" 30 "new kids" based on the ability to make proper decisions and not waste time hunting for information or going down bad paths due to a lack of experience.
In essence, there is no "standard" for effectiveness over age. It depends on the individual.
Then again, those who are hiring might have their own personal agenda also based on how the new hire will impact their own future.
Make sure you are an asset and you will never have anything to worry about.
I've spent the last 15 years working as a contractor and consultant in software design and development. And one thing that is clear is each contract is different, and you have to constantly learn new technologies in order to stay relevant for each of your clients. To me, that is just part of the profession, just like it is for other professionals such as medical doctors or engineers, or any other field where the technology is always changing.
In my last contract, I worked for a government agency with a union IT shop. The managers are largely untechnical, and the IT staffers don't seem to be very motivated to learn any new technologies on their own time. Some of these developers have been there 20+ years, maxed out their benefits, and have very little drive or enthusiasm for what they do there.
And it showed in the amount of technical debt and the use of obsolete technologies in their various projects.
I agree that as we age, we do lose some cognitive abilities. But that is counterbalanced by the experience we bring, the ability to properly architect and design a system. And we have learned how to learn, to pick up new languages and technologies as appropriate.
(I should also mention that before starting my contracting career, I spent 25+ years before that as an employee at a number of software companies)
Going back to the original question, employers tend to hire people under 40. I started my professional development career when I was 21, working for bleeding-edge companies and getting laid off on a regular basis. When I turned 40, no one would hire me. Not a problem. I became a consultant and got a good number of jobs until I retired at the age of 62. Still, working 10+ years later, but not for an employer or as a contractor. What I do now is "fun work", selling a few products on the internet.
So, yes, younger developers are cheaper and are generally the ones who get employed. Older developers are more experienced and usually have a broad enough experience that allows them to be a one-person show who can do all the work necessary from conception to development. Not every company can afford the staff needed to do a project, so a single, talented consultant is the best solution. Most talented consultants tend to be older (over 40).
Last Visit: 31-Dec-99 18:00 Last Update: 13-Jun-21 14:46