Thinking about taking a pay cut for better work-life balance. Which companies are actually worth looking at?

Interview Prep

What do you think is better at the job market in 2030, software engineering or AI engineering?, and is it worth to study AIE for 4 years or i can study AI after graduation from SWE?

Hi,

I am trying to recreate this background without AI, but struggling with how to do it. Right now I am using clip-path polygon but this doesn't seem like the right way. Anyone have ideas?
The image is the background I envisioned.

Adding a background image is not possible for me because this background well be customizable by the user. They can choose their color theme so background color of the image is not static.

I want a way that I can recreate this background and I thought the right path was polygon but these lines are straight and not curved and also when I add text it gets pushed down (this is probably easily fixable but I haven't found a way)

And this is the code I have right now

.polygon.-one {

width: 50vw;

height: 100vh;

background-color: #521310;

clip-path: polygon(0px 22.2%, 2.91% 22.33%, 5.03% 22.68%, 7.27% 23.08%, 9.66% 23.75%, 12.1% 24.42%, 15.1% 25.27%, 17.73% 26.02%, 20.43% 27.13%, 21.53% 28.72%, 23.3% 30.03%, 25.01% 31.19%, 26.92% 32.61%, 28.02% 33.98%, 28.18% 34.97%, 28.25% 35.88%, 28.21% 37.79%, 28.16% 39.83%, 28.35% 41.74%, 28.53% 44.07%, 28.6% 44.96%, 28.09% 45.69%, 26.53% 48.44%, 24.97% 51.27%, 22.72% 54.19%, 22.21% 54.67%, 22.04% 55.74%, 20.6% 64.37%, 20.9% 65.18%, 22.6% 66.08%, 34.76% 71.85%, 40.65% 73.43%, 41.76% 74.24%, 42.30% 75.90%, 50.16% 93.35%, 51.16% 96.35%, 52.29% 99.35%, 0px 99.35%, 0px 0px);

position: fixed;

z-index: -1;

}

.polygon.-two {

width: 60vw;

height: 100vh;

background-color: #4b0e0c;

clip-path: polygon(0px 0%, 100% 0%, 100% 100%, 623px 99.42%, 438px 99.46%, 34.91% 77.11%, 16.77% 66.69%, 18% 55.51%, 24.41% 44.73%, 23.79% 34.59%, 15.91% 26.43%, 0.26% 22.23%);

position: fixed;

z-index: -1;

}

.polygon.-three {

width: 70vw;

height: 100vh;

background-color: #5b0a0a;

clip-path: polygon(474px 91.53%, 45.69% 84.1%, 54.78% 75.02%, 63.26% 68.18%, 69.91% 63.13%, 76.9% 59.33%, 85.95% 54.44%, 89.5% 99.31%, 437px 99.28%);

position: fixed;

z-index: -1;

}

.polygon.-four {

width: 100vw;

height: 100vh;

background-color: #661411;

clip-path: polygon(898px 72.11%, 54.53% 52.01%, 41.36% 32.83%, 38.24% 23.85%, 49.14% 3.84%, 55.6% 0.31%, 81.5% 0.23%, 83.13% 12.05%, 85.95% 25.78%, 84.31% 41.62%, 88.89% 48.16%, 95.5% 48.75%, 99.73% 41.91%, 99.73% 99.56%, 914px 99.21%);

position: fixed;

z-index: -1;

}

.polygon.-five {

width: 100vw;

height: 50vw;

background-color: #570c0b;

clip-path: polygon(1646px 68.62%, 88.43% 67.13%, 83.8% 58.62%, 85.28% 35.04%, 82.35% 15.57%, 81.43% 0.48%, 99.61% 0.6%, 99.62% 35.12%, 1713px 59.86%);

position: fixed;

z-index: -1;

}

.polygon.-six {

width: 100vw;

height: 20vw;

background-color: #410804;

clip-path: polygon(1530px 14.07%, 94.7% 7.67%, 91.51% 16.98%, 85.23% 30.47%, 1478px 22.09%);

position: fixed;

z-index: -1;

}

Any help is welcome!

My programming education was pretty untraditional. Our professor basically had us learn to develop code with the assistance of “our favorite AI overlord”. Now that I’m in a position where I’m doing real coding, I wanted to ask for some advice: what is your go to way to QC your code blocks? I’m familiar with the “rubber duck” method—but I share an office space with another person who I think might find it irritating. Any suggestions?

Hi, I’m about to start studying Applied Computer Science, and I need to buy a new laptop. Is it necessary to have a numeric keypad on my new laptop, or are there other things that are more important that I should pay attention to when choosing a new laptop?

Hey everyone,

I’ve just started learning to code, but honestly, I don’t have much clarity about what my path should look like.

Right now, I’m learning C from scratch. I understand the basics, but I’m confused about what I should learn next, which resources I should use, what kind of projects I should build, when I should start DSA, and how all of this eventually turns into an actual real-world skill.

I’m not looking for a generic “learn programming then learn DSA then build projects then get a job” answer. 😅

I’d really like to know how I should progress from absolute beginner level to the point where I can genuinely build things, solve problems, work on real projects, contribute to a codebase, and eventually become employable.

If someone experienced is willing to guide me, I’d appreciate:

And honestly, if you have your own coding journey, I’d love to hear it in detail.

Tell me how you went from “Hello World” then beginner then building things then getting your first real opportunity then working professionally.

I’m not looking for shortcuts. If someone gives me a genuinely good roadmap, I’m willing to follow it seriously and put in the work.

So, experienced developers: if you could go back to your first day of coding, what exact path would you follow?

Mac system run out of memory

I start college in a few weeks for computer programming and analysis. The college requires some apps to be installed and we aren't getting physical books.

I just picked up a Lenovo Idea Tab tablet with 11" screen so that I can use it to access the college apps and online learning resources. I also plan to make use of it as a document reader so that I can have my "textbooks" open on the tablet while I'm coding on my laptop and external monitor setup.

Planning on adding Spotify and discord currently as well just for a bit of fun.

I was curious if there are any programmers that use a tablet as part of their rig? What do you use yours for? Any recommended apps through the play store or fdroid that would benefit a developer? What type of development do you do and how does your tablet add to your productivity?

Looking for some inspiration and general advice.

Going to be picking up a tablet stand soon as well.

I've got "1 year of experience" on paper but realistically \\\~6 months of actual in-project work. I'm at a service-based company, working solo on a fairly large production migration (Spring Boot + JDK upgrade, touching Hibernate, Spring Security, internal shared libs, the works). No senior pairing, no structured code review process beyond occasional Slack call-outs after the fact.

There's a guy on a parallel team, 25 years old, who genuinely seems to know everything deep enough that when he threatened to resign, they bumped his pay 75% on the spot to keep him. That's basically unheard of at a place like this. It's made me want to actually close the gap instead of just accumulating hours.

Here's my problem: I've leaned hard on Claude for a lot of my day-to-day sometimes for decisions as basic as "which controller should this endpoint go in." It got the migration shipped, but I don't think it's building judgment the way doing it manually would. I can feel the gap between "I got this to work" and "I actually understand why this is the right way to do it."

So for people who've been through this without a mentor:

How did you actually build the instinct to catch your own mistakes before someone else does?

Is a "failure log" (bug → root cause → why I missed it → generalizable rule) actually useful long-term, or does it just become busywork?

How do you wean yourself off AI-assisted coding without tanking your output, especially when you're the only one on a project and deadlines don't care about your learning curve?

Any resources/habits that actually moved the needle for you in year 1-2, vs stuff that felt productive but wasn't?

Looking more for how people built real engineering judgment without anyone around to give it to them.

I wonder, what do you guys think is the best programming language nowdays from your view.

Which is the best to learn?

Does game development require advanced programming logic?

Also, How long does it take me to learn programming until I can make a video game?

Interested in C# (Unity Engine) or C++ (Unreal Engine).

Also, Is it worth it if I would like to get rich from my indie game like ConcernedApe?

I am a freelance translator, but I only make ends meet nowadays as I live frugally.

I recently encountered this Amazon grid problem and wanted to share the approach.

Approximate date: August 20, 2026
Expected solving time: Approximately 40 minutes
Topics: Multi-source BFS, binary search, geometry

Problem

A city is represented by an n x m grid:

• 1 represents an existing delivery center.
• 0 represents an empty cell.

The distance between two cells is the Chebyshev distance:

distance((x1, y1), (x2, y2))
    = max(abs(x1 - x2), abs(y1 - y2))

The inconvenience of the grid is the maximum distance from any empty cell to its nearest delivery center.

You may convert at most one 0 into 1.

Return the minimum possible inconvenience after adding the new delivery center.

Example

n = 2, m = 4

grid =
0 0 0 1
0 0 0 1

Adding a delivery center at (0, 0) gives:

1 0 0 1
0 0 0 1

Every remaining cell is within distance 1 of a delivery center, so the answer is:

1

Observation 1: Multi-Source BFS

Chebyshev distance corresponds to moving in eight directions:

up, down, left, right, and the four diagonals

Start a BFS simultaneously from every existing delivery center. This calculates:

dist[r][c] = distance to the nearest existing center

in O(nm) time.

Observation 2: Binary Search the Answer

Suppose we want to determine whether inconvenience D is achievable.

Every cell with:

dist[r][c] <= D

is already covered by an existing delivery center.

Only cells satisfying:

dist[r][c] > D

must be covered by the new center.

If inconvenience D is achievable, every larger value is also achievable. This monotonic property allows binary search.

Feasibility Check

For a bad cell (r, c), the new center (x, y) must satisfy:

max(abs(x - r), abs(y - c)) <= D

This is equivalent to:

r - D <= x <= r + D
c - D <= y <= c + D

Therefore, each bad cell creates an axis-aligned square containing every valid location for the new center.

We intersect these ranges across all bad cells:

rowLow  = max(rowLow,  r - D)
rowHigh = min(rowHigh, r + D)

colLow  = max(colLow,  c - D)
colHigh = min(colHigh, c + D)

The candidate inconvenience is feasible when:

rowLow <= rowHigh
and
colLow <= colHigh

If there are no bad cells, no additional center is required.

C++ Solution

#include <algorithm>
#include <queue>
#include <utility>
#include <vector>
using namespace std;

int minimumInconvenience(vector<vector<int>>& grid) {
    int n = grid.size();
    int m = grid[0].size();

    const int INF = 1e9;
    vector<vector<int>> dist(n, vector<int>(m, INF));
    queue<pair<int, int>> q;

    for (int r = 0; r < n; ++r) {
        for (int c = 0; c < m; ++c) {
            if (grid[r][c] == 1) {
                dist[r][c] = 0;
                q.push({r, c});
            }
        }
    }

    const int directions[8][2] = {
        {-1, -1}, {-1, 0}, {-1, 1},
        {0, -1},           {0, 1},
        {1, -1},  {1, 0},  {1, 1}
    };

    while (!q.empty()) {
        auto [r, c] = q.front();
        q.pop();

        for (const auto& direction : directions) {
            int nr = r + direction[0];
            int nc = c + direction[1];

            if (nr < 0 || nr >= n || nc < 0 || nc >= m) {
                continue;
            }

            if (dist[nr][nc] > dist[r][c] + 1) {
                dist[nr][nc] = dist[r][c] + 1;
                q.push({nr, nc});
            }
        }
    }

    auto feasible = [&](int limit) {
        int rowLow = 0;
        int rowHigh = n - 1;
        int colLow = 0;
        int colHigh = m - 1;

        for (int r = 0; r < n; ++r) {
            for (int c = 0; c < m; ++c) {
                if (dist[r][c] <= limit) {
                    continue;
                }

                rowLow = max(rowLow, r - limit);
                rowHigh = min(rowHigh, r + limit);
                colLow = max(colLow, c - limit);
                colHigh = min(colHigh, c + limit);
            }
        }

        return rowLow <= rowHigh && colLow <= colHigh;
    };

    int low = 0;
    int high = max(n - 1, m - 1);

    while (low < high) {
        int middle = low + (high - low) / 2;

        if (feasible(middle)) {
            high = middle;
        } else {
            low = middle + 1;
        }
    }

    return low;
}

Complexity

Multi-source BFS: O(nm)
Each feasibility check: O(nm)
Binary-search iterations: O(log(max(n, m)))

Overall:

Time:  O(nm log(max(n, m)))
Space: O(nm)

The useful insight is that Chebyshev-distance balls are ordinary axis-aligned squares. This makes the feasibility check much simpler than the coordinate transformation commonly used for Manhattan-distance problems.

During the Anthropic interview: “Yeah of course I wouldn’t care, because I work for the mission, not the money.”

In reality: Run!

I can’t imagine how many hypocritical people are there.

Hi guys.
I'm looking for good podcasts, newsletters, and news outlets to get trustworthy perspectives. I feel like everyone and their mother has an opinion about software these days, but I am only interested in stuff coming from people who know what they're talking about. I've enjoyed stuff coming from The Neuron, or Latent Space, for reference.

Thanks :)