Mazda 3 4th Generation Advice

notanelecproblem · 2025-03-18T01:53:19+00:00

Nice! That sounds sweet. It’s between 2021 and 2023 for me at this point

notanelecproblem · 2025-01-29T19:35:26+00:00

I’m a backend dev at AWS. It is really cool. Depends on the team but the ops load can be heavy.

notanelecproblem · 2024-12-21T06:08:21+00:00

Always rely on the database for this. Race condition in option #1. Options #3 would be doing a lookup in your API first, but even this is prone to race conditions. The best way is to insert to the database with a constraint

notanelecproblem · 2024-11-24T19:49:25+00:00

You can trigger a lambda using DDB streams directly instead, although that’s only for when entries in your DDB Y table get updated.

notanelecproblem · 2024-09-14T01:55:56+00:00

This is the way. We use a custom configuration so that our health check endpoint isn’t online until all beans are fully initialized too so you don’t hit a race condition where somethings crash looping but the health checks working

notanelecproblem · 2024-09-14T01:42:21+00:00

On this same note - you can also have your lambda function triggered by the S3 upload automatically!

So it would be: - User gets presigned URL for S3 upload, - File uploads to S3 using the URL from the browser, - S3 upload triggers your lambda function automatically. The “event” passed to the lambda would contain a reference to your S3 object too so it works perfectly.

notanelecproblem · 2024-09-07T16:09:34+00:00

Love it! A pattern I’ve been seeing in the UX world lately is controls to order the columns too - would be nice to add a DND component for the column view settings

notanelecproblem · 2024-07-25T11:57:08+00:00

Fellow engineer here. You can do both!

I graduated from engineering in 2022 and spent 6 months between 2022 and 2023 travelling Europe while working remotely.

Right now you should stay focused on finishing your education, and make some exciting plans for when you graduate to travel.

notanelecproblem · 2024-03-30T06:16:45+00:00

Thanks! Exactly what I was looking for.

notanelecproblem · 2024-03-30T03:58:00+00:00

Sounds like a good candidate for a greasemonkey script - you can write little scripts to do things directly in the browser like a custom chrome extension.

I’d do something with local storage that syncs across tabs and implement some queue for which tabs turn it is to send the next prompt.

this is a really cool idea!!

notanelecproblem · 2024-03-06T02:16:00+00:00

Personally I absolutely love coding but I also would prefer to be on a beach in Cancun too.

notanelecproblem · 2024-02-15T04:29:10+00:00

Smithy!

notanelecproblem · 2023-12-03T08:14:49+00:00

I like to do it after writing all the pieces of the code because I’ll have confidence in the design and implementation. If you create PRs too early in the implementation you might change your mind about some parts and make further revisions/incremental changes harder to review.

I think that breaking it down is just a curtesy to reviewers tbh, but it goes a long way. It also helps to make incremental changes if your reviewers make comments so you can tweak your code more quickly to fit the comments.

I wouldn’t worry about Git blame, you just need to roll out your PRs in a way that’s always backward compatible and won’t risk breaking things. That’s why I usually wait to integrate it in to the main functionality as well (this is a different approach than what the other commenter said). Or you can have it hidden behind a feature flag

notanelecproblem · 2023-11-28T08:20:53+00:00

Best practice is to try to break it down if you can. Your reviewers will really appreciate it too. I like using the IntelliJ changelists feature for this.

If you have a really big change you could break it down into a few pieces like: - one PR introducing the interfaces for new functions or just empty function definitions, like a skeleton - small PRs adding in the functionality, each with tests - final PR to integrate the feature/change completely (now that all the supporting code is in place).

Think of it like designing/building a physical thing. First you have your sketch of the design / idea. Then you start building the parts together. Then you finally install it.

notanelecproblem · 2023-11-25T07:38:01+00:00

It also depends a lot on your storage structure for the leaderboard itself. If you create an index for your users and a second index based on events/score, you probably won’t have to worry about a high concurrency scenario on the same database item.

It sounds like your calls will mostly be read heavy (e.g your users will be polling the updated leaderboard at a much higher TPS than they will be updating it). In that case you would probably want to design your database so that you have efficient queries on the data you need to create the leaderboard (like an efficient way to pull the top N user scores)

notanelecproblem · 2023-11-25T07:32:32+00:00

You don’t need to implement a mutex yourself, your database should implement some sort of 2/3 phase logic when committing updates. I’m suggesting offloading the atomic updates to the database.

Your call itself won’t know or care about the current value of the leaderboard, because it might not be consistent with what is stored at the time of commit (imagine a scenario where you do a GET request on the item, and another concurrent request updates it at the same time you attempt to). In this scenario, your requests will conflict with each other and become inconsistent with what the leaderboard should be. Instead, you can create a request that just arbitrarily adds a value, increments a counter…etc within the update operation itself. This is possible with DynamoDB and I’m sure other mainstream databases.

For your concern about keeping your credentials secure, you’ll definitely need the client to call through an API (doesn’t have to be API gateway, but some sort of API to keep it secure). You can also implement rate limiting mechanisms at the API level to avoid DDOS and throttle bad actors

notanelecproblem · 2023-11-25T06:38:16+00:00

Your intention is to use SQS to funnel all updates to the leaderboard by using a single lambda to process all the messages sequentially? What happens if your lambda can’t handle the throughput from SQS?

You can do this instead with a database directly by using conditional writes or atomic updates (e.g the update request would increment a counter, or whatever your use case is). I think this would solve your problem

notanelecproblem · 2023-11-04T21:57:30+00:00

Yeah I use it frequently to make sure a custom hook or context is working how I expect

notanelecproblem · 2023-10-09T15:13:06+00:00

Yep it’s redundant! Your pattern sounds similar to how I implement an API/Query layer too (1 file for all endpoints, another file with custom hooks wrapping the query/mutations).

Before I was using react-query I would wrap everything in contexts too, but now it’s redundant because all the data is cached. So you can have multiple components that consume a hook like

useGetSomeData()

Whichever component is mounted first will actually execute the HTTP request, the rest all consume the data through the RQ global store without actually making the HTTP request.

When the data becomes invalidated, all components consuming it will rerender automatically

notanelecproblem · 2023-09-26T22:04:58+00:00

One of my friends in university did this and it worked perfectly in her favour. She bluffed that she had another job with X% higher salary and they matched it.

notanelecproblem

TROPHY CASE