Comments by "Christian Baune" (@programaths) on "ThePrimeTime"
channel.
-
For XP, most companies only accept professional experience. In 2001, I was open-sourcing a shell to add tabs to Internet Explorer. Around the same time, Firefox came out.
Before that, I was toying with Basic and made the usual suspects: snake, Tetris, and even a screen-by-screen 3D maze (which will be a raycasting engine in VB6 later on).
In 2005, I did the most challenging track available (Industrial computing) because I already knew most of the material from my hobby. At that point, I already had more than 5 years of practical experience, including trying j2me.
So, I was flying through the curriculum. So much so that I was helping students from later years.
Got my first job without even looking. I just had to say yes.
Then I got fired in the last batch of 300 people due to the crisis.
When I wrote my resume, I listed languages I was comfortable with, and recruiters just binned my resume. So, I took a shitty job, regretted it, and quit.
In all interviews, I was rejected. Good on the technical part, but a danger for the company. With my knowledge, I could decide to go at any moment, which was terrible.
Also barred from most free training because I didn't sit well during test. Acing them is not the right thing to do.
I cried to join a training because they promised that 95% would be hired. Got to join and ''follow" the movement, which mainly was providing support to classmates.
I ended up in a company where I managed servers, repaired label printers, and developed.
I did a burnout because I was doing a 5 man job. So, I explained it to my boss, who didn't believe me for months, telling him I was drifting away.
One day, I just went to his desk and handed him my resignation letter. He tried to say that he understood, that he would change things. I said it was way too late.
He hired 3 people to replace me and sunsetted multiple projects I was working on because the new people needed more time to maintain and improve them.
In another company, I became critical. I warned my boss that the company would die if I got sick for too long or became unavailable. So, I needed a double.
He ignored my request because he didn't want someone sitting on his ass all day.
Then I discovered the abuse on colleagues as it became worse and worse. So, I told the boss that if the abuse did continue, I would quit.
And the worse part was that I was also working for a company developing a database, and who... needed help understanding their implementation. So, I had to send them test reports and bug fixes (realm, which wasn't a good fit for the project, but the boss didn't want to let that go!).
I faked some efforts, we had some discussions, and I quit. A few months later, the company was dead.
Ultimately, I am aware that I am "not hirable" because I don't fit well in a team, not due to any skill issues but my mobility (easy to move on) and the technical gap with peers. The "Why don't you do that? It will take only 5 minutes"." your reply can only be ''Because I am doing more important things that would take you even more time." This is condescending...So, it creates dissent.
74
-
I did interviews and also offered practice interviews.
There was a guy who did everything wrong.
I told him to dress like he would for an interview; his trouser zipper was wide open, and not all button on his skirt was buttoned. So, I had to tell him to go out and fix himself.
During the interview, he lied overtly, knowing I read his CV and knew his track. During the interview, he gradually turned his head to the side; at a point, he was looking at his side while speaking to me.
After a few interviews that mainly went ok, I told him we would get someone from the floor to spectate the interview. He started begging me to not do that while we walked down the hallway to find someone with some spare time. So, I couldn't do it because I sensed he would be broken. I called HR instead because he knew that girl from HR.
He lied during the interview again.
He was fired because he was terrible on all fronts.
In an interview, I got someone so out of place that I asked him: what is the company's name? The CEO was sitting on my side and looked at me like, "Did I really hear that question?". I was so confused by the candidate's answer that I believed he went to the wrong interview. 😂
Another interviewee was a girl who thought she would get the job because no girls were on the team. I had to explain to her that she did poorly.
I also had a phone screening. One guy laughed loudly and answered poorly after bragging. He was shortlisted by the CEO, to whom I explained the BS.
In another company, we had an interviewee who did spit nonsense. So, we gave him a generated text from "pipotron" and asked the guy what he thought. He gave the same kind of answer to that.
I also had a guy who didn't do great with English and couldn't understand Javadoc properly. But during problem-solving, he showed great intelligence, and when explaining the JavaDoc, what he said made some sense. So, we ended the interview; I gave the feedback and told him he would be hired if he wanted to move forward. His answer was heartbreaking. He asked if it was affirmative action at play because of his skin color. He did great.
So, yes, interviews can be wild ^^
22
-
11
-
Things have to be contextualized. "Little experience" meant someone who knew how to peek and poke memory and wrote a few classics (snake, Tetris, pacman...) and usually mixing primary with assembly, if not going complete assembly.
The entry barrier was high, and JS did a lot lower it. Each new language lowered the bar.
How many people could create a simple platformer game if they had the only facility to display sprites? Very few considering how people are stumped by game engines that do 99% of the job.
In my first year of CS, we were tasked to make various games in ASM (tasm and nasm), like light-out tanks. And one of the final exams was doing a UI, but if you did your projects correctly, it took a full hour at best. If you didn't, the exam was 8h.
And even the tools lower the entry bar. When I started, I did web pages using Notepad, and the browsers didn't had debug tools. There was the "view source," which would show you what you typed in Notepad.
Also, don't forget that browser did suck in rendering HTML. One misplaced page and your table base layout became funky.
One has to consider how JQuery was a godsend at some point.
Sure, today we do SPA games in the browser. But you've like a catch-up that happens between what you are asked to produce and the advances in ease of use of technologies.
As a stupid example, having a date picker on a web page was quite some work. Then came JQuery, but you still had to find the right JQ plugin. Then browsers implemented type=datetime.
So, now, if you need to input a date, it's a given that you should show a date picker. It looks more complex, but it's infinitely much easier to do.
Even for games, you can program those in Godot and deploy them to the web, thanks to WASM.
Always consider the times when things were created.
11
-
When I was a QAM, I sat down with the developer and discussed, knowing what was wrong and what was a better way to do it.
That way, the developer knew why it was incorrect and why the new implementation was better.
I had a developer who told me, "fuck you," because his code was full on SQL injection and XSS. 🤣
To top it off, the management was not backing me up (I was free-floating).
Then, they got hacked by a gray hat, and they understood how important it was to fix those.
I fixed many of those myself, then took the time to explain how prepared statements work and how to sanitize for output in HTML.
One guy left, and I was a "plus" for another guy. He wanted to go because there were not enough challenges, and I could retain him until I quit because I told him that in other companies, he may not have someone to show him cool stuff.
In fact, when I left, the team dissolved in a few weeks. 🤣
Basically, if you're a QAM, you should do your job with passion and grow others.
9
-
6
-
 @KevinJDildonik In interviews, I asked to implement "overlap(a,b,c,d)" where a and b are respectively the lower and upper bound of the first range and c and d are respectively the lower and upper bound of the second range. So, they don't even need to validate that. Yet, most programmer fail to write good code.
And there are plenty of libraries for hat, yet, if they can't write such a simple code (it's a one liner), they certainly can't think about more involved problems where you need to use two or three libraries the right way....
And to top it, in my field (Tree to tree transformation driven by trees), custom made algorithms are a daily thing.
And no, I won't be asking a dev to do something we do on the job, because I don't have 2 weeks of interview ^^
6
-
5
-
4
-
4
-
4
-
4
-
47:18 A decade ago, we needed some authentication. I wanted something more serious than BasicAuth over TLS, so I implemented WSSE.
100% of implementors were confused because they didn't understand how the website could verify the password was valid if they sent a hash.
On top of it, the documentation stated that the password had to be based twice. So, you had to ask for the salt for a specific username (the website would return a hash even for nonexisting users).
Then you had to hash your password a first time with the provided salt, then a second time with a timestamp and nonce you created.
If you used twice the same nonce in the same interval (5 minutes), the website would reject the authentication.
When I left, the company abandoned it to use BasicAuth because it was too complicated for implementors.
Another huge point of confusion was why Basic Auth was wrong, even with HTTPS. People couldn't understand that HTTPS is not enough. So, I referred to an article from Microsoft about naked bikers ^^ Yet, people still had trouble wrapping their heads around. But I was persistent, and that's why we did WSSE.
The big downside was that I was the only one to know why it was done that way, even if I tried to educate my peers. It was already too complex.
It's not. Check "hmac," and you will see it's straightforward. It's just that, at the time, people were not used to that kind of security, and there were no plug-and-play libraries.
3
-
2
-
When I worked for the state, I made a deduplication software. It used Bayesian inference, and I found unintuitive things like there are more family names than first names.
So, if you grouped people by family names, you ended up with smaller groups than if you grouped by first name.
It's counterintuitive because you usually call people by their first name and rarely notice collisions. But you would be better off calling them by family names to avoid collisions. Which means that family name is a better discriminator. Better than date of birth.
So, I had to write a paper on how the data is vectorized, fed to the deduplicator, and then restored. That paper was just unreadable because of the mathematics involved in the biases (weights).
Summations over set theory and Bays.
I didn't know how to make it simple without making it a thousand pages, so I wrote a few formulas, explained some observations, and made a table showing step-by-step what happens to a pair being compared (even if the software doesn't compare teams, but that's a very high-level view and in the end, that's kind of what you would do).
The manager looked at it and told me it was convincing enough. I asked if he understood the formulas, and he told me: "No, but that looks very impressive, that will do."
All he needed was that it looked correct and good, even if nobody understood it. 😂
He was a good manager because he prevented me from doing stupid things and focused on the technical part of my job.
One day, I was writing an email to show how provably stupid a higher-up was, and that manager ran to me to say not to send "that" email.
His first word was, "Don't send it" and then he explained the politics around it and that I should ignore it and do something else instead of sending that email and possibly getting fired.
We could have done a mini-series about what happened there; it is just unbelievable ^^
The most comical one was when I was tasked to prepare some load tests, then I ran one iteration and got a direct phone call asking me to cease testing because servers went down. The real test was 50k times this with a slight ramp-up and cool-down. However, the test was too fast to send the data required to register a pupil. ^^
The load test was canceled, and it was fingers crossed in the hope school would not rush to do it on the last day. Organic smoothing. (That didn't happen ^^)
In big companies, there are always some idiots who are too important and don't want to listen because they know better, and that lands pretty well for interesting situations.
2
-
2
-
2
-
2
-
2
-
2
-
 @ed_iz_ed That's not the same.
Synchronous and asynchronous are different from concurrent and parallel.
For example, when you use emails, you use an asynchronous method of communication, but it's not done in parallel.
For example, processes were concurrent when the CPU didn't have multiple cores. So, one process that was not yielding (purposely or because of DMA, IRQ...) would stall the computer. So, programs had to yield while doing crunching!
Now, we have multiple cores that can do things in parallel; GPUs also work in parallel.
When using "aync" in JavaScript, the code may or may not run in parallel! So, you can't even know if it's parallel or concurrent. But it definitely looks asynchronous! (well, you can see if you know what is the event loop)
So, you can NOT use those two couples interchangeably.
2
-
2
-
2
-
2
-
1
-
1
-
1
-
Why do seniors tend to forget that code is written for being used?
We use Java because the JVM keeps stats on the code being run and can prune code that is seldom used, reorganize conditional so the hot path is the one that will be continuous in memory,
JVM will also do escape analysis so you can create objects; the executed code will not have those objects.
You can't write "fast code" because pattern usage changes. You want something that can monitor its use and rewrite it.
In that sense, everything that is compiled AOT is "slow." So, C is slow according to that standard.
Using C would be shooting in our foot on a multitenant system, where code should espouse how it's used.
Unless we can see that, for some reason, the software is always used in the same way, then we can beat the JVM by fine-tuning.
To better understand, it's like stating that a drag race car is faster because you always used it in a straight line.
Then someone else will tell you that the Veron is faster than the drag car because when there are a few turns, the drag race car does shit.
Then someone else comes with a panda and tells you it's much better in the city.
That's compiled languages.
Now, imagine a car that could do all of this because it would see that you're in a city and reconfigure its cartography and the type of tire to suit the environment.
Now, the downside of that car would be that sometimes, it would be adapting, especially if you are in a continuously changing environment.
Luckily for you, the environment doesn't change that fast in real life. So, you would beat the 3 other cars.
And sure, those cars would kick your ass in the first few seconds for a given task with a specific usage. I think the trade is worth ^^
And for those at the back of the room, this doesn't argue against compiled language. This shows that each has a specific use.
And so, no, it's not always a skill issue. It's a seniorism issue ^^
1
-
1
-
1
-
1
-
Code in a stupid way, and your program will survive longer ^^
In implementing form validation, I coded the whole thing, assuming I would have two magic functions. One is to retrieve a field from whatever structure was passed to it, and the other is to retrieve a value from whatever design was passed to it. So, relatively easy to do the validation using those functions.
Then I created those two first-order functions to grab fields/values from the right place.
When the same functionality was required in an Angular application, only those two functions were to be remade. I tried explaining that to the other developer, who insisted on changing the "core." I don't do Angular (I did AngularJS), but in the end, I did those two functions myself. The guy still didn't wrap his head around it.
Later, we had to update the core, copying one JS file. He had the same issue; he didn't understand it was just a copy-paste...Took a few times before he became confident. I even asked my boss if I could take over that part entirely because going into a call to copy a file is...painful.
In another application, I created an intermediate representation. My boss thought it was a waste of resources, but that intermediate format is more suited for processing. A small upfront cost for a lot of downward efficiency! I had to implement a new feature, and thanks to the intermediate format, it took a day instead of a week ^^
And I am the first to say comments are usually band smell (as a QAM, I used comments as a mean to quickly find code that belongs to a function), but most of them read like "do not attempt to simplify" or "bug in library, force reloading data".
Now there is a considerable drawback, people not used to that way of programming are stumped because it's not a big block of code where you can read from top to bottom. In the middle of the code, you have a call to a function coming from the parameters, so you've to see how it's called to see the body of that function in context...except that you don't have to because you're supposed to work at a different level of abstraction. So, it makes stuff way simpler as you just have to assume the function does what it says it does.
And that's the beauty; in the end, you concentrate on a very generic algorithm, which is relatively easy. Then you fill in the gap, which is relatively easy too. Then you end up with something complex but totally digestible if you don't freak out. On top of that, the JVM loves smaller methods. (No JIT if bigger than 8k, and I saw strategies much bigger than that ^^)
I have 15 years of professional development, 25 years with hobby. (You can look up "Navigateur à onglets gérant ses favoris et qui peut se dupliquer (==>capture)" for an example)
1
-
To give a practical example, I did a project for advanced form validation with configuration provided by the user.
I need to have literal values, computed values, and fields at some point.
The whole implementation has no clue about the fields themselves or where the value comes from.
It just asks something else: what is the value of field X? What is the value linked to some variable Y ?
Later, another dev had to implement the same feature in another technology.
It was a copy-paste, and all he had to rewrite was the part answering the two questions above.
It was so unfathomable to him that he didn't even understand that it was all he needed to do.
It was so strong that I had to ask him to take control, do the copy-paste, and write a few lines of code with him...then it just worked.
The other nicety is that testing was much more straightforward. The core worked, so only the pluggable part had to be tested for his specific project, which was as easy as reading the code to confirm it did what it should.
And yes, it looks weird to have a class that required a FieldLocator and ValueLocator, but that made it easy to port.
It also makes the core more high-level and reusable. You don't have to read some documentation to have an outline of the algorithm; the class is so short you can read it at a glance.
It's the kind of code a junior would refactor to "reduce complexity" or "flatten the object graph." 😂
And I saw that at play. I wrote a set of decorator classes in one company to implement different concerns. There were like 5 types involved, and it looked like this: new A(new B(new C()))
I quit, and someone wrote that by merging the content of each class. The company asked me if I could give them a hand because it hadn't worked since the rewrite.
Yeah, that's why it was done the way it was done. To ease adding and removing features without confusing oneself passing a train of booleans to the method ^^
It is also much faster in a test; you can just initialize your service, omitting one decorator (the one making requests to a third party for legal reasons).
"It's over-engineered" or "It's written academically" is a cope for "Albeit it looks simple, I am uncomfortable with it, so I will rewrite everything, and it will be bristle."
1
-
1
-
1
-
​ @Asto508 So, you know and still give attitude 😅
Simple questions are made to target one skill.
That overlap question allows to see how analytical you are. If you have many edge cases, you are already going too fast for your own good. That means you didn't explore the problem at all.
If you do a bit of exploration, then it becomes trivial.
And indeed, problems you'll have at work (in my domain, which is heavy tree-to-tree transformation driven by tree) will be much more complex. So, the questions must be straightforward and probe what is essential. The rest can be learned.
If I were in management systems, which you are probably (e-commerce, ERP, cutom sites, stock management, ...) then you can have a talk "how would you xxx" as it's a good teller if somebody did something.
I could not afford that!
Also, part of my methodology comes from my background in psychotechnics and testing. I was trained in proctoring intelligence tests and practiced for two years. That heavily influenced how I did recruit.
And I know that candidates despised it, because they came prepared with a good script and showcases, then I ask them what makes an HTTP request, why an architecture is unsuitable or to identify what's wrong in a code fragment.
I even fashioned an arithmetic problem in my revised interviews because I felt that it would be an high discriminant. It was 😂
You can disagree; I filtered a lot of candidates but only got rock stars.
For me, that's a good enough proof I did somethig right and a great source of pride and satisfaction.
Diversity of hiring practices ensure that more people find a job! In my interviews, even those who could not sell themselves were hired.
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
​ @buster9877 The original question is indeed with a better naming and a mkre descriptive name.
The question is really good when you know its purpose.
That question is deceptively simple and will throw of people like Astro.
If you explore the problem by drawing the few situations, you will see that there are 15 cases. Which is way too much to handle.
That's where you analytical skills need to kick in.
You would see that there are only 2 cases where there is no overlap, it's when the other set is completely to the left or to the right. And because that's the negation of what you need to implement, you can write the negated condition of "isDisjoint()".
While this level of thinking is not really needed in management systems (where you mostly deal with retrieving and displaying data), it's a basic foundation in my domain since you'll have to solve complex problem each day.
On example I had was:
Text formatting is being represented as a tree of formatting node as such that each node has only 3 values:
- The formatting being applied (bold, italic or underline)
- The children
- The text fragment
Create an array which can be read left to right which can be given to a formatter which will read it sequentially. Each even position will contains an object describing if the folowing text need to be bolded, underlined or italicized, every odd entries will contain the text subjected to the previous entry.
Example: (b("tests",u("another)) -> [{b:true},"tests",{u:true,b:true},"another"]
A bit harder than "overlaps/4".
Yet, that's expected to be no more than 30 minute of work.
(It doesn't use any trick and use basic primitives for working with trees)
Tge irony is that I don't ask questions about trees, because one who can solve an array of problems can learn idioms to deal with trees very easily. The hardest part is solving the problem in a reasonable time.
I also had an arithmetic question and a lot of candidates complaines because they didn't do maths for quite some time. Happens that good abalysis is closely related to math 😅 So, that's a proxy for their raw analysis skills and the "not my job" behavior.
Good questions are rarely what they seem to be. Candidates lie ^^
1
-
​ @Coach-Solar_Hound The original question is indeed with a better naming and a more descriptive name.
The question is really good when you know its purpose.
That question is deceptively simple and will throw of people like Astro.
If you explore the problem by drawing the few situations, you will see that there are 15 cases. Which is way too much to handle.
That's where you analytical skills need to kick in.
You would see that there are only 2 cases where there is no overlap, it's when the other set is completely to the left or to the right. And because that's the negation of what you need to implement, you can write the negated condition of "isDisjoint()".
While this level of thinking is not really needed in management systems (where you mostly deal with retrieving and displaying data), it's a basic foundation in my domain since you'll have to solve complex problem each day.
On example I had was:
Text formatting is being represented as a tree of formatting node as such that each node has only 3 values:
- The formatting being applied (bold, italic or underline)
- The children
- The text fragment
Create an array which can be read left to right which can be given to a formatter which will read it sequentially. Each even position will contains an object describing if the folowing text need to be bolded, underlined or italicized, every odd entries will contain the text subjected to the previous entry.
Example: (b("tests",u("another)) -> [{b:true},"tests",{u:true,b:true},"another"]
A bit harder than "overlaps/4".
Yet, that's expected to be no more than 30 minute of work.
(It doesn't use any trick and use basic primitives for working with trees)
Tge irony is that I don't ask questions about trees, because one who can solve an array of problems can learn idioms to deal with trees very easily. The hardest part is solving the problem in a reasonable time.
I also had an arithmetic question and a lot of candidates complaines because they didn't do maths for quite some time. Happens that good abalysis is closely related to math 😅 So, that's a proxy for their raw analysis skills and the "not my job" behavior.
Good questions are rarely what they seem to be. Candidates lie ^^
1
-
1
-
​ @Coach-Solar_Hound The original question is indeed with a better naming and a more descriptive name.
The question is really good when you know its purpose.
That question is deceptively simple and will throw of people like Astro.
If you explore the problem by drawing the few situations, you will see that there are 15 cases. Which is way too much to handle.
That's where you analytical skills need to kick in.
You would see that there are only 2 cases where there is no overlap, it's when the other set is completely to the left or to the right. And because that's the negation of what you need to implement, you can write the negated condition of "isDisjoint()".
While this level of thinking is not really needed in management systems (where you mostly deal with retrieving and displaying data), it's a basic foundation in my domain since you'll have to solve complex problem each day.
On example I had was:
Text formatting is being represented as a tree of formatting node as such that each node has only 3 values:
- The formatting being applied (bold, italic or underline)
- The children
- The text fragment
Create an array which can be read left to right which can be given to a formatter which will read it sequentially. Each even position will contains an object describing if the folowing text need to be bolded, underlined or italicized, every odd entries will contain the text subjected to the previous entry.
Example: (b("tests",u("another)) -> [{b:true},"tests",{u:true,b:true},"another"]
A bit harder than "overlaps/4".
Yet, that's expected to be no more than 30 minute of work.
(It doesn't use any trick and use basic primitives for working with trees)
Tge irony is that I don't ask questions about trees, because one who can solve an array of problems can learn idioms to deal with trees very easily. The hardest part is solving the problem in a reasonable time.
I also had an arithmetic question and a lot of candidates complaines because they didn't do maths for quite some time. Happens that good abalysis is closely related to math 😅 So, that's a proxy for their raw analysis skills and the "not my job" behavior.
Good questions are rarely what they seem to be. Candidates lie ^^
1
-
​ @Coach-Solar_Hound The original question is indeed with a better naming and a more descriptive name.
The question is really good when you know its purpose.
That question is deceptively simple and will throw of people like Astro.
If you explore the problem by drawing the few situations, you will see that there are 15 cases. Which is way too much to handle.
That's where you analytical skills need to kick in.
You would see that there are only 2 cases where there is no overlap, it's when the other set is completely to the left or to the right. And because that's the negation of what you need to implement, you can write the negated condition of "isDisjoint()".
While this level of thinking is not really needed in management systems (where you mostly deal with retrieving and displaying data), it's a basic foundation in my domain since you'll have to solve complex problem each day.
On example I had was:
Text formatting is being represented as a tree of formatting node as such that each node has only 3 values:
- The formatting being applied (bold, italic or underline)
- The children
- The text fragment
Create an array which can be read left to right which can be given to a formatter which will read it sequentially. Each even position will contains an object describing if the folowing text need to be bolded, underlined or italicized, every odd entries will contain the text subjected to the previous entry.
Example: (b("tests",u("another)) -> [{b:true},"tests",{u:true,b:true},"another"]
A bit harder than "overlaps/4".
Yet, that's expected to be no more than 30 minute of work.
(It doesn't use any trick and use basic primitives for working with trees)
Tge irony is that I don't ask questions about trees, because one who can solve an array of problems can learn idioms to deal with trees very easily. The hardest part is solving the problem in a reasonable time.
I also had an arithmetic question and a lot of candidates complaines because they didn't do maths for quite some time. Happens that good abalysis is closely related to math 😅 So, that's a proxy for their raw analysis skills and the "not my job" behavior.
Good questions are rarely what they seem to be. Candidates lie ^^
1
-
1
-
1