If you want a trade school grad, hire one from a trade school. There's nothing wrong with that.
TasTAFE offers a Cert III in Information and Communications Technology. This looks to be one third tech support, one third networking and server operations, and one third python / web / CSS. So not really much programming.
A programming trade school to Mr would look like: four years on the job as an apprentice, full time, at some discounted pay rate.
Two weeks four times a year at a training institution, away from the demands of the job, where theory and practice are taught.
My trade certificate (metal fabrication) is a Cert III, my trade school included a fairly wide variety of subjects, both theory and practical.
The employer would be required to give progressively more difficult tasks, and doing apprentice swaps with other businesses to cover industry experience if in-house doesn't provide opportunities for key requirements.
Is anyone, anywhere doing that?
I help train two apprentices every year here in metal fabrication. It's not that difficult, but few developing foetuses are borth wielding a welder. I mean the trade is not difficult, training people is hard.
You can do it in Switzerland:
When finished you can continue for a master degree at a university, but have to take 1 year to get caught up on the theory you missed by not doing a bachelor degree on a university level.
If someone wants a person with good CS fundamentals and an idea of how to write code in a non-trivial codebase (so commit messages and an idea of concrete SQL and not just "I've proven this expression is correct but never ran it") they should look at Computer/Software Engineering programs, or at least select CS candidates from schools where the program incorporate real software development.
These usually are the worst "programmers", in my experience. And I was one as I didn't go to CS school and was mostly self-taught. Lacking the basics of CS, you are just a code monkey.
> I've encountered far too many CS interns and grads who couldn't actually write reliable, non-spaghetti code.
An intern is an intern, I guess.
> They also typically write commit messages that consist entirely of "Updated $THING" (no shit, I can see that from your diff), nothing about the why.
You should have a an employee handbook and a coding style. Lazy people are everywhere, however.
That's the type of condescending, discriminatory bias that having a degree affords, I guess.
But you're right that there should be schools that teach the practical programming skills. But it's the the trade schools that should be developed towards this goal, not universities.
Lots of degrees have no pathway to a job or career.
In Europe where third level is far cheaper, it's more looked upon as continuing education. The way in the US people look at high school. Sure you'd like to get a job after, but it's really just a stepping stone to your career and not a huge financial investment that needs to be repayed.
It's still made for those that want to be educated.
In the Netherlands the have, for example, the Hoger Beroep Onderwijs (HBO), which translates to Higher Professional Education. It is exactly tailored for the job market.
HBO sounds more like a vocational system that provides diplomas vs a bachelor degree in reference to universities in this discussion.
This type of system definitely exists in many places but I just assume it's out of scope as we're talking about in reference to CS graduates i.e. bachelor courses.
Sure, but those things can be learned on the actual job. So after a few years, the CS student knows both the theory (because of uni) and the practice (because of work)... Whereas someone who only learnt the practical stuff, well, usually lacks the theoretical foundations.
So a CS degree is useless in industry. By the time you learn how to build things that work, you know how things work.
This bears repeating.
It's important to learn how to deal with asynchronous and concurrent and parallel programming, but it's more important to have a firm grasp of message-passing and event-driven architectures.
Rote learning the computational complexity of obscure algorithms no one uses does not hold a candle to knowing how to write clean and testable code, and design a component to accommodate changes.
This computer science bullshit starts to feel a lot more like an exercise in ladder-pulling than actually prepare and assess an individual's ability to do meaningful work.
// rewrite this function so it's portable and doesn't use uint128_t
uint64_t lemur64(void) {
static uint128_t s = 2131259787901769494;
return (s *= 15750249268501108917ull) >> 64;
}
Software developers aren't paid to write code. They are paid to deliver value.
Your code delivers no value whatsoever. Many masters and PhD thesis are boiled down to a shareable library or even function call. You might feel clever for coming up with it or by knowing some trivia behind it, but ChatGPT can easily spit it out negating all the value you believe you were able to create.
There is no value in something being hard. There is value in delivering value.
I'm fairly sure it's the people that pay our salaries and choose to keep us employed while we do whatever they need to, based on their perception of our output and how the needs of the customers/users are met.
Will ChatGPT and other solutions like that be helpful with the complex, low level stuff? Perhaps, sometimes - depending on how explicit you'll be with your prompts, but more knowledge about what and how to ask will be necessary and even then good results aren't guaranteed per se.
But will they help out a lot of developers with common, well known tasks and problems, for the majority of developers whose job consists of creating a few RESTful endpoints, maybe a database migration and hooking it up to React? I'm inclined to say yes a bit more confidently.
For starters, if you can't argue what is the value then none can fill in the void in your reasoning.
Secondly, software developers have as part of their job description the task of finding solutions to problems. If they find solutions to problems that don't involve or require whatever trick you have in mind, that tells you what is it's value.
Thirdly, did you ever saw any job advert explicitly requiring prior knowledge of any trick you have in mind? Or do you see ads for the ability to solve problems with a pre established software stack?
> who can't multiply and shift t
Tell me, how many open positions have you ever saw whose main ask was "can multiply and shift"? Zero.
> That would be like Google hiring engineers who only got good because they're good at using Google.
No, it would be like Google hiring people without any CS or IT degree who were good at software development but rejecting PhDs who had nothing to offer other than their little trivia on stuff no one cares about.
You know, reality.
The person paying for it with their own money.
We don’t do it because we’re paid for it[0]. If that’s your primary motivation maybe this is the wrong website.
[0] sure, [too] many people are in tech primarily to make money, but it’s a bit sad.
uint64_t lemur64(void) {
static uint64_t a = 2131259787901769494ull;
uint64_t b = 15750249268501108917ull;
uint64_t a_lo = a & 0x00000000ffffffffull;
uint64_t a_hi = a >> 32;
uint64_t b_lo = b & 0x00000000ffffffffull;
uint64_t b_hi = b >> 32;
uint64_t a_x_b_hi = a_hi * b_hi;
uint64_t a_x_b_mid = a_hi * b_lo;
uint64_t b_x_a_mid = b_hi * a_lo;
uint64_t a_x_b_lo = a_lo * b_lo;
uint64_t carry_bit = ((0x00000000ffffffffull & a_x_b_mid) +
(0x00000000ffffffffull & b_x_a_mid) + (a_x_b_lo >> 32)) >>
32;
uint64_t multhi =
a_x_b_hi + (a_x_b_mid >> 32) + (b_x_a_mid >> 32) + carry_bit;
return a = multhi;
}Employers MUST NOT require university degree where trade school is sufficient (99% of positions in industry).
This is just a simple misunderstanding of what college is for, expanding one's knowledge for the sake of expanding one's knowledge -being a good programmer is not the intent but it might be a by product.
I've encountered far too many CS interns and grads who couldn't actually write reliable, non-spaghetti code. They also typically write commit messages that consist entirely of "Updated $THING" (no shit, I can see that from your diff), nothing about the why.
My perspective may be slightly skewed from being called in as a consultant to fix the software these "computer scientists" have been hacking on, but I encountered a lot of these people when I was a undergrad student also.