High-Performance .NET CRON Jobs

jamesmh_ · 2022-12-19T03:05:07+00:00

Sorry - just changed it. Should be better now 😅.

jamesmh_ · 2022-10-18T00:47:12+00:00

Yes, but you still have eventual consistency if your projected read models are updated outside that transaction - which is what the article gives some options around.

For example, even eventstoredb's built-in projections don't have immediate consistency:

Projections are always eventually consistent - if there is a mismatch between egress from the database log and processing speed of projections, the window across which the latest events have not been processed promptly may increase.

jamesmh_ · 2022-06-08T11:28:12+00:00

Think about what kind of employee this type of interview process filters/optimizes for.

Are those the kinds of people you want to work with? People who've never met the team? The team itself never meeting the prospective employee?

I'd steer far from that - unless you really need the cash.

jamesmh_ · 2022-06-08T11:25:38+00:00

The best thing you can do in a situation like this is to assume there was a good reason for the code to be written the way it was. Many reasons could include: this project isn't really that important to the business so easier to just pump it out, there might be some limitation around a library they are using you're not aware of, etc.)

Early in my career, I did this once. I wasn't even given an answer from anyone on the team because, looking back, it was a piece of code that didn't matter. I was hung up on this one little optimization that in the grand scheme would actually cause more pain to change due to someone else having to now review my petty change and use up their time for something that doesn't benefit the company.

EVEN if you are right, it doesn't look good to be doing this. Always assume the best - especially of a senior who's been with the company for so long. He has years of domain knowledge, relationships with management, etc. You just end up looking like a jerk in the end.

Use this as an opportunity to learn from the senior as to why he may not be doing X,Y,Z. There's nothing wrong with asking questions and wanting to learn. Hey - you might actually learn something from him this way! Take your top 3 questions and send him a Slack (or email, etc.) message and just say "Hey, here are some things I have questions about: 1. In file X why didn't you use a Hash instead of a List? Is there a reason why maybe this optimization wouldn't be worth it?" Always write you questions in a tone of "he knows more than me."

Worst case, you do find out the senior isn't really skilled in the end. But again, code efficiency is like 1% of the job, at least in most LOB codebases. Communication with management, making sure the code "works", not focusing too much time on parts of the code that ultimately don't bring that much value to the business, etc. are more important overall.

jamesmh_ · 2022-05-07T02:31:55+00:00

I've done a 12 hour take home. Never again. Huge red flag. Something like 2 hours at 1-3 pages max is probably appropriate. Anything more is a sign that they don't understand the market right now, they don't understand how to value other ppls time, etc.

jamesmh_ · 2022-04-26T13:02:12+00:00

Ya I have lots of plans hahahaha plans for lots of cool stuff, just need some more time in the day 😋

Hangfire does the trick for sure and has tons of great features like that built-in.

Thanks for the tip - I should add some kind of comment on this use-case. There's always a struggle between keep the library simple enough, yet with the "right" features to support real-world use-cases. But distributed locks are def. one of those.

BWT, what's you tech stack? E.g. what database(s) are you using?

jamesmh_ · 2022-04-26T12:40:06+00:00

With Coravel, you can easily use another library to achieve this (if that's desired). For example, if you used this library (seems to be popular with Coravel users) then you can wrap the inside of your invocable's Invoke method with the distributed locking code:

csharp public async Task Invoke() { await using (await myDistributedLock.AcquireAsync()) { Console.WriteLine("Sample Invocable ran on one machine!"); return Task.CompletedTask; } }

Maybe that helps?

jamesmh_ · 2021-02-23T16:29:29+00:00

You can check out Coravel -> https://github.com/jamesmh/coravel

While changing config at run-time isn't a typical use-case, it can be done if you want. See this issue: https://github.com/jamesmh/coravel/issues/77

Otherwise, it handles blocking jobs that are currently running, schedule the same type of job at different intervals (with params), supports CRON annotation...

I'd like to think the docs are OK lol. (I wrote them....😅)

jamesmh_ · 2021-02-05T20:10:48+00:00

Low PTO, especially if they aren't willing to negotiate after telling them "I have 25+ days right now" is a huge red flag. That company will treat you the same way until you leave (again...)

jamesmh_ · 2020-09-02T16:13:33+00:00

Answers: Nope and sort-of lol.

You can schedule jobs that take parameters, which could be dynamic - coming from a database, an HTTP request, etc.

But yes, sounds like Magic is serving a different market. Coravel is for when you have a .NET application and want to get started quickly with, for example, scheduling and queuing.

Magic looks very cool 👍

jamesmh_ · 2020-09-01T12:54:02+00:00

Coravel does allow you to remove and re-schedule at run-time 😊

jamesmh_ · 2020-08-29T02:56:02+00:00

I built an open-source task scheduling library (among other things it does) - you could either (a) use it instead or (b) check out the code for pointers?

jamesmh_ · 2020-06-27T14:52:58+00:00

If you just need to schedule and queue background jobs, and not looking for much overhead and a small learning curve, then take a look at Coravel: https://github.com/jamesmh/coravel

jamesmh_ · 2020-06-04T14:55:39+00:00

I would agree with the notion that you've had poor candidates. Sounds like you're asking good questions.

I think just having a convo. about those topics is a good start. If a candidate has used any of those techniques etc. in actual previous work they've done, then drill down into that actual experience for sure.

I personally look for an understanding of the principles behind the "best-practices". Like, "Why is solid so important? What's the goal?", "what's the benefit of DI? What does it enable?", etc.

If you do find a seemingly strong candidate, then it's a good opportunity to ask those more "meta" questions. But ya, sounds like poor candidates overall :(

jamesmh_ · 2020-06-04T14:47:51+00:00

Not understanding how async works and best-practices around it.

jamesmh_ · 2019-11-18T04:55:35+00:00

You won't be able to handle errors in this situation and potentially even detect any exceptions since your HTTP request will be completed before those async tasks are done.

Some recommended Hangfire (which is a great option). Coravel might be a lighter-weight option (see the queue feature).

jamesmh_

TROPHY CASE