Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
165071 stories
·
33 followers

Episode 116: All Broken Up About the Chocolate Goodies at Trader Joe's

1 Share

It has been said that breaking up is hard to do. We respectfully disagree. At least when it comes to chocolate, that is. We're big fans of holiday sweets that are intended to be smashed, melted, or otherwise broken up prior to eating. In this episode of Inside Trader Joe's, we do a bit of traveling, visiting the founder of the company that makes our fun and festive Break Apart Reindeer. This founder is a self-admitted chocoholic, and his love of chocolate really does benefit the rest of us in truly delicious ways. We also travel to a conference room in our mothership to chat about a few other breakable chocolate treats you'll find at Trader Joe's during the holiday season. It may not be breaking news, but it's definitely worth taking a break to listen.

Transcript (PDF)





Download audio: https://traffic.libsyn.com/secure/insidetjs/All_Broken_Up_About_The_Chocolate_Goodies_at_Trader_Joes.mp3?dest-id=704103
Read the whole story
alvinashcraft
just a second ago
reply
Pennsylvania, USA
Share this story
Delete

140. Excuse-Driven Development and AI Testing with Bram Albers

1 Share

Send us Fan Mail

Does AI make testers obsolete, or does it turn everyone into one? Rick and Oskar talk with Bram Albers, Principal Quality Assurance at Betabit and self-proclaimed quality annoyer, about testing in a time of AI agents.

With AI you can write ten tests where you used to write one. But as Bram says: "My understanding doesn't scale as fast as my code or my tests do." And if it doesn't fit your head, can you really own it?

We talk about why asking a lot of questions makes a team better, the ratio of developers to testers, guardrails for AI agents, and why testing becomes a job for the whole team. We also get into AI burnout, throwing code away without regret, quantum computing and why legislation can't keep up.

Near the end, Bram explains what he calls excuse-driven development. Teams make excuses when things break, and AI turns out to do the same, only faster. The conversation ends on full ownership: if you see a problem and you don't know who owns it, it's your problem.

Chapters
00:00 More testing, but not by testers
00:06 Intro with Bram Albers
00:34 Why asking questions makes your team better
04:11 Do teams still have testers?
05:33 Security and pen testing in QA
08:04 How AI changes testing
09:53 Fair and unbiased AI
13:28 10 tests instead of 1
16:03 Throwing code away
17:03 AI burnout and one more prompt
18:34 Can a guardrail tell you to stop?
21:06 From developer to product owner
22:45 Spec-driven development
23:27 Totally random question
27:04 What a time to be a nerd
28:47 Quantum computing
32:37 Legislation can't keep up
38:11 Excuse-driven development
42:57 Full ownership
44:30 Outro

Betatalks is the podcast by Betabit about software development, cloud and tech. Follow the show so you don't miss the next episode.

Follow Bram: (45) Bram Albers | LinkedIn

About Betatalks: watch our videos and follow us on Instagram, LinkedIn, and Bluesky. 





Download audio: https://www.buzzsprout.com/1622272/episodes/20114300-140-excuse-driven-development-and-ai-testing-with-bram-albers.mp3
Read the whole story
alvinashcraft
just a second ago
reply
Pennsylvania, USA
Share this story
Delete

On-Device Text Recognition with OCRTool in iOS 27

1 Share
On-Device Text Recognition with OCRTool in iOS 27

With iOS 27, Vision adds OCRTool, a system tool you attach to a Foundation Models session. Before this, reading a cover meant calling RecognizeTextRequest and picking the title out of the string yourself, or sending the photo to a cloud model. OCRTool stays on the phone. You label the image, the on-device model calls the tool when it needs the printed words, and you never upload the photo. In this tutorial, we'll photograph a book cover and turn it into a small card: the title, the author, a blurb from the cover, one line on why it's worth reading, and a short list of similar books.

This follows the Foundation Models series: Getting Started, @Generable, and Tool Calling. You can follow along without having built those sample apps.

OCRTool isn't a framework of its own. It's a Vision tool you pass into a LanguageModelSession. To follow along, make sure you have Xcode 27 installed, with the iOS 27 SDK.

Ready to get started? Let's dive in.

The Demo App: Shelf Spine

Shelf Spine takes a cover and automatically extracts text from the image like title, subtitles, and author. You can download the demo on GitHub and try it out.

Open it in Xcode 27 and run it on an iOS 27 simulator or on an iPhone. If you test it on a simulator, use the sample cover to test it out. For physical iPhone, you can take a photo of any book covers and let the app recognize the book information. The read uses SystemLanguageModel, the on-device model, so the app works offline.

On-Device Text Recognition with OCRTool in iOS 27

The Basic Usage of OCRTool

To read the printed words on a cover, you give a language model session a Vision tool called OCRTool. It recognizes text in an image and returns a string containing all the text it found. You don't call the tool yourself. You attach it to a LanguageModelSession, and the on-device model uses it when the prompt needs those words.

You import Vision alongside FoundationModels and create a session with an OCRTool. Here's the basic setup from Apple's documentation:

let ocrTool = OCRTool()
let session = LanguageModelSession(tools: [ocrTool])

That's enough to get started. OCRTool() uses a default name and description. If you want to steer when the model reaches for the tool, you can override both. Here's how you customize them:

let customTool = OCRTool(
    name: "extractText",
    description: "Extract text from documents"
)

The name is how the tool is exposed to the model. The description is what the model uses to decide when to call it.

You also pass the photo as an Attachment and give it a label. That label is how the model identifies which image to hand to OCRTool. We'll use that when we read the cover.

One more thing: OCRTool isn't available in Simulator. You'll see how the sample deals with that later.

Checking the Availability of the System Language Model

The first thing the sample does is check whether the on-device language model is available. That's SystemLanguageModel.default.availability. If the model is ready, you show the shelf. If it isn't, you show the reason and stop. Here's the check from the sample:

private var model = SystemLanguageModel.default
​
var body: some View {
    switch model.availability {
    case .available:
        mainView
    case .unavailable(let reason):
        Text(unavailableMessage(reason))
            .multilineTextAlignment(.center)
            .padding(24)
    }
}

mainView is the rest of the screen: the sample button, the card, and, later, the similar-books list. The unavailable branch is a sentence, not a spinner. The model can be missing because the device isn't eligible, because Apple Intelligence is off, or because the model is still downloading. Here's the helper that turns that reason into a sentence:

private func unavailableMessage(_ reason: SystemLanguageModel.Availability.UnavailableReason) -> String {
    switch reason {
    case .deviceNotEligible:
        return "The device is not eligible for Apple Intelligence."
    case .appleIntelligenceNotEnabled:
        return "Apple Intelligence is not enabled on this device."
    case .modelNotReady:
        return "The model isn't ready. It may still be downloading."
    @unknown default:
        return "The model is unavailable."
    }
}

If you stop here, the app already runs. It either shows the shelf or it tells you why it can't.

Reading a Book Cover with OCRTool

Now that you should have a basic understanding of OCRTool, let's see how we use it to recognize a book cover.

Here's how the sample creates the session:

private func makeSession() -> LanguageModelSession {
    #if targetEnvironment(simulator)
    LanguageModelSession(model: model, instructions: instructions)
    #else
    LanguageModelSession(
        model: model,
        tools: [
            OCRTool(
                name: "readBookCover",
                description: "Read the printed title, author, and blurb on a book cover or spine."
            )
        ],
        instructions: instructions
    )
    #endif
}

OCRTool() with no arguments is enough if you're happy with the default name. The sample names it readBookCover so the prompt can ask for that tool by name. The instructions stay short: use the printed title, author, and blurb, and don't invent a different book.

The #if is there because OCRTool isn't in the Simulator SDK. On a Mac that can run the on-device model, Simulator can still fill the card. It just can't call OCRTool.

The next step is to ask that session to read the cover and fill the card. You do that in one call: a short prompt, plus the photo. The photo goes in as an Attachment, and you give it a label, book cover. That label is how the model knows which image to hand to OCRTool. Here's the call:

card = try await session.respond(generating: BookCard.self) {
    "Read this book cover. Use readBookCover on the image labeled book cover. Fill the title, author, and blurb from the printed words only."
    Attachment(image).label("book cover")
}.content

respond(generating:) is the guided-generation call from the @Generable article. The prompt builder takes a string and the labeled attachment together. The sample imports UIKit, so Attachment can take the UIImage from the camera or from the study cover. You can leave the photo at the size the camera gave you.

Generating a Structured Book Card

A cover isn't a paragraph you want to split with components(separatedBy:). You describe the card as a Swift type, and the model fills it. BookCard lives in its own file. Here's the type:

@Generable
struct BookCard {
    @Guide(description: "The book title printed on the cover.")
    let title: String

    @Guide(description: "The author name printed on the cover.")
    let author: String

    @Guide(description: "A short blurb copied from the cover. Leave it empty if the cover has no blurb.")
    let blurb: String
}

@Generable builds the schema the model has to follow. Each @Guide description is a hint about that field, and those strings go into the prompt, so you keep them to a sentence. The blurb guide tells the model to copy the cover and to leave the field empty when the cover has no blurb. That's how you avoid a made-up plot summary sitting where the printed sentence should be.

readCover() writes response.content into the title, author, and blurb fields on the card. Those fields are text fields, so you can correct a word the tool misread.

If the call throws, or the title and author both come back empty, a photo leaves the fields blank so you can type. Try a sample cover doesn't stop there. The card uses the words printed on the study cover, and the recommendation still runs. Here's that branch:

} catch {
    if isSample {
        let session = makeSession()
        self.session = session
        showPrintedSample(liveToolUnavailable: usingSampleText)
        await writeRecommendation()
    } else {
        status = "Couldn't read that cover. Type the title and author."
    }
}

On a device, Try a sample cover still asks OCRTool first. showPrintedSample(liveToolUnavailable:) runs only when that read throws or comes back without a title. In Simulator, usingSampleText is true, so the note says this isn't a live read. A photo that fails doesn't get the printed-text fallback. You type the title and author, and you move on.

Writing a Recommendation

The card isn't finished when the fields are filled. We ask the same session for one sentence on why the book is worth reading, and we show that sentence under the blurb. Because the session already has the cover in its transcript, we don't attach the image again. Here's the follow-up:

private func writeRecommendation() async {
    guard !trimmed(title).isEmpty else { return }
    let session = session ?? makeSession()
    self.session = session

    do {
        let response = try await session.respond(
            to: "Write one short line on why \(title) by \(author) is worth reading. Keep it to a single sentence."
        )
        recommendation = trimmed(response.content)
    } catch {
        recommendation = ""
    }
}

Suggesting Similar Books

The last step is a separate tap, not another automatic call. Suggest similar books asks the same session for two or three other books. These are guesses from what the on-device model knows. They are not a search of a bookstore catalog, and the screen says that under the list. The study cover is a public-domain novel on purpose, so the guesses tend to be other books you'd recognize, rather than a random scrape of a catalog.

You describe one suggestion, then a small list with a count. Here's the result type:

@Generable
struct SimilarBook {
    @Guide(description: "The title of a similar book.")
    let title: String

    @Guide(description: "The author of that book.")
    let author: String

    @Guide(description: "One sentence on why it is similar to the cover we just read.")
    let reason: String
}

@Generable
struct SimilarBooks {
    @Guide(description: "Two or three similar books. These are guesses, not a catalog search.", .count(2...3))
    let books: [SimilarBook]
}

@Guide(.count(2...3)) constrains the array to a closed range, two or three items, instead of one fixed count. The model has to return two or three SimilarBook values, each with a title, an author, and one line. The button calls this:

let response = try await session.respond(generating: SimilarBooks.self) {
    """
    Suggest two or three books similar to \(title) by \(author).
    \(blurb)
    These are guesses from what you know, not a search of a bookstore catalog. For each book, give the title, the author, and one line on why it is similar.
    """
}
similarBooks = response.content.books

The code is very straightforward. We simply specify the instructions in plain text and ask the on-device to give us two or three books similar to the current one.

Summary

In this tutorial, we show you how to use OCRTool, a new tool in iOS 27, to perform text recognition in an image. Rather than being a standalone framework, OCRTool is a Vision system tool that you pass directly into a LanguageModelSession, letting the local Foundation Model read printed words whenever needed without manual string parsing like RecognizeTextRequest or uploading photos to the cloud.

By building a practical book scanner in Xcode 27, you have seen how effortlessly OCRTool turns a cover photo into a structured card complete with the title, author, blurb, and reading recommendations. If you want to bring fast, private text extraction to your next iOS app without relying on cloud servers or writing complex parsing code, give OCRTool a try in your upcoming projects.If you've got a photo of something with type on it, a receipt, a spine, or a label, try the labeled attachment first. The session you already use for @Generable can call OCRTool without a second framework and without a server.

Read the whole story
alvinashcraft
15 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Analyzing a .NET crash dump with an AI agent

1 Share
A container restarted during the night, and this is everything the log has: Unhandled exception. System.NullReferenceException: Object reference not set to an instance of an object. at Program.<<Main>$>g__GetCustomerDomain|0_2(Order order) in /work/series/CrashDemo/Program.cs:line 26 at Program.<<Main>$>g__Process|0_1(Order order) in /work/series/CrashDemo/Program.cs:line 20 at Program.<Main>$(String[]…
Read the whole story
alvinashcraft
34 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

For platform teams, the challenge is the way

1 Share

The survey for the Future of Platform Engineering report asked about the obstacles platforms hit along the way. My expectation of what this would reveal was overly simplistic; we’d find out the most common things preventing teams from building a successful platform.

As is often the case, reality was more complex and vastly more fascinating than that simple mental model. When Dr. Charlotte Fleming put the data through the statistical mangle, something surprising happened. We found there were two kinds of obstacles. In fact, we might label them obstacles and challenges, for reasons I’ll explain.

One set of obstacles met my original expectation. A lack of clear strategy, budget, and skills stops platforms from meeting their goals. If you don’t tackle these, particularly the strategy problem, you’re choosing to fail at Platform Engineering. If you need somewhere to start, a lack of clear strategy was a particularly strong failure signal.

The second kind, which we’ll call “challenges” rather than “obstacles”, tells us another story entirely. Tooling sprawl, competing priorities, resistance to change, and technical complexity were all more common in high-performance platforms. Successful teams were more likely to have these challenges and less likely to encounter the obstacles.

Chart showing how lack of clear strategy, lack of budget, and lack of skills are obstacles not encountered by high performers, while technical complexity, resistance to change, competing priorities, and tooling sprawl are challenges common to high performars.

The gap between high-performers and everyone else when it comes to obstacles.

The obstacles

Obstacles are less likely to be reported by high-performing teams. That makes it likely they are one of the factors preventing platforms from meeting their goals. Platform goals vary by organization, but we take into account each organization’s definition of success when we rate a platform’s performance.

The top obstacle is a lack of clear strategy. Platform teams that lack strategy are frustrated with their leaders, and team members report lower job satisfaction. They tend to build more platform components from scratch rather than building on top of best-in-class commercial and open-source tools. This has an up-front cost (and delay) and also creates an ongoing maintenance burden that can consume most of the platform team’s time.

Platforms should solve the problems unique to your organization, but common to many teams. A lack of a clear strategy results in a platform that doesn’t capture the task of tailoring and instead offers poor imitations of very general features that any organization could use.

Platforms should be competing with internal DIY solutions, not open source or commercial products. Don’t write your own version of things like build servers or deployment tools, as it will be undifferentiated. The only justification for doing so would be spotting an incredible competitive advantage in doing something in a completely different way, and an understanding that these tools require millions of dollars in time and effort to maintain.

The challenges

Challenges are more likely to be reported by high-performing platform teams. The teams experiencing them are doing the work of Platform Engineering, which is a good indicator that they are providing real value to the business. The top challenge for high-performing teams is tooling sprawl.

When a platform team begins building out golden paths, much of the initial work will be establishing stronger connections between the tools. This work is largely front-loaded, with improvements following along with updates whenever underlying APIs change.

An organization may have made many local decisions before the platform initiative, so there may be some rationalization work to reduce the number of options. You might want to reduce the number of different build servers from the free-for-all of ten different tools to just two or three options for teams to choose from. This is a sociotechnical problem, as along with the technical work, you’re asking people to change how they work, and may bring some resistance to change, which is another challenge reported by high-performing teams.

Completing the mission

The relationships between build approach, obstacles, and outcomes helps understand how these factors relate to each other.

The relationships between build approach, obstacles, and outcomes.

If you’re not getting the results you want from your platform, you should tackle the obstacles first. If you don’t have a clear strategy, budget, and skills, you’re inviting failure. Fixing the strategy is the first step to resolving other obstacles and will help you make better decisions at every other stage of your platform’s evolution.

The obstacles and challenges insight tells us that the challenges reflect the valuable work of Platform Engineering, while the obstacles block the path to success. High-performing platform teams have a clear strategy, budget, and the skills to focus on the challenges that platforms are built to solve.

The smooth integration of best-in-class tools, gaining adoption, and deciding what to build next is the work. These are some of the reasons we build platforms. Teams without obstacles can focus on challenges and deliver a return on their platform investment.

Remove the obstacles and embrace the challenges.

Happy deployments!

Read the whole story
alvinashcraft
1 minute ago
reply
Pennsylvania, USA
Share this story
Delete

Want a career in tech? As a seasoned professional, here’s what I wish I’d known

1 Share

The question was recently asked of me: “What advice would you give someone starting out in technology?”

In this article, I’m going to do my best to answer that. Some of this is advice I got when I was just starting out, and some of it I got – or didn’t get – until much later (some more from ruminating on my history in technology.)

And there’s some I just wished I had understood when I was younger.

I want to start out by telling you the big thing you should ask yourself right now: “Am I stuck where I am?”  

The breadth of what is considered a tech profession is insanely wide, as are the paths you can take. There will be people who think that you need to keep climbing the metaphorical career ladder all your life – the ‘if you aren’t going up, you’re going down’ approach.

Some of us, though, are just happy in more or less the same type of position for our entire career – as long as we’re getting more responsibility and higher pay, of course!

One key point before jumping in: some of this advice may feel out of touch if you are just starting out and struggling. This advice is valuable at every ‘level’ of your career, but is applied differently at each one. Some of it will hit harder now than it does later on, and vice versa.

Why it’s normal to fear the future in a tech career

The fear of the future is common across the board, no matter your age. In 1957, Mose Allison wrote the song Young Man, with the lyrics: 

Well, you know in the old days

When a young man was a strong man

All the people they stepped back

When a young man walked by 

But you know nowadays

It’s the old man

Who’s got all the money

It’s not a new concept to think of older people having everything, and you – possibly a younger person! – having nothing.

Why salary is more than just money…

When you get started working, getting paid is basically all you care about. You look at a job listing and think, “I can make this much $$$”.

Then, as time passes, you realize something is wrong. You have friends in the same industry, and they are all happy. They’re off for more than just a few hours a day, they go on vacation, and their occasional complaints about money are limited to ‘it being too expensive to go to the movies’ rather than anxiety about losing their home.

You, on the other hand, have a new Porsche, a beautiful family, and an apartment overlooking the city park. But to be honest, you couldn’t pick your family out of a lineup, and you haven’t been in the driver’s seat of that car outside of the work commute for longer than you can remember.

Further, you are pretty sure your family has moved on from you when you call home, and whoever answers doesn’t recognize your number. 

Fact is, you need money, but you also need a lot of other things. Like food and sleep, of course.

But there’s also training, vacation, respect, flexibility, and coworkers that aren’t out to stab you in the (hopefully) proverbial back to get ahead. 

…and why money is not a great long-term motivator 

To continue this thread of weird advice concerning money, this one comes from a coworker, and it’s a doozy.

“Money is not a great motivator.”

This took a lot of time to really understand at any level. The first time I heard it, I thought it was completely stupid – despite coming from someone I respect on many things.

“Of COURSE money is what motivates me,” I thought. “Without it, I can’t…”

And there it was. My motivation. When you need money, it’s the motivation. But once you have it, there’s always something else that motivates you. 

Think about the last time you really wanted a raise. You were likely motivated to get that raise. But once you got it, after a week or two your paycheck normalized and most likely, it was not the motivation anymore. In fact, you started wanting something else. 

Want a really true example? Get a smaller-than-expected bonus someday – something like a $10 gift certificate for saving the company a hundred thousand dollars (and change.)

You weren’t promised a dime, so 10 bucks should motivate you, right? Remember that old saying about it being the thought that counts?

Well, ask anyone and they will tell you: the only thing worse than forgetting to give someone a gift is to give them a really terrible one! 

And yes, I will completely admit it didn’t fully sink in until I had enough money to at least break even on the basic life I wanted to live.

OK, enough discussion of the filthy lucre. We all need to get paid and take care of our business, but there is more to it. 

Why you shouldn’t accept a promotion you’re not suited for

This one is the biggest mistake people make because, most of the time, promotions mean more responsibility but with less and less of the day-to-day work (and more of the stuff I said I would stop talking about).

After all, we naturally all want to advance further and further up the corporate latter – but it’s not for everyone. In fact, many people should not be progressing up that ladder.

For these people, the result could be bad for themselves, and really bad for the people in their influence. 

For example, as a data architect, I’ve basically held the same position for many years. Just because I can design a database that holds an org chart, that doesn’t mean I can get people enthused to do the job and others.

I love what I do, so it just ‘is what it is’. 

And while you should do what you can to progress as far as you can, be certain to know what you’re able to do at a level you’ll be proud of.  

Subscribe to the Simple Talk newsletter

All the latest articles, guides, podcasts, and more – delivered straight to your inbox.
Subscribe now

Why you should only do work you love (if you can)

There’s an old poem – Richard Cory – by Edwin Arlington Robinson. It was written in 1897 and was the inspiration of a 1960s song of the same name by Paul Simon of Simon and Garfunkel.

It details how wonderful his life seemingly was, so much so that everyone wished they were he. 

Yet, needless to say, Mr. Cory hated – and takes his life – as part of the poem. 

See, I told you the same stuff has been going on for a really long time. 

The happiest person on earth is the person that is doing what they love to do. So, if you have what you need, and love what you do, you’re a very lucky person.

How to build a reputation for knowing things (and why it’s important)

There are a lot of people who are really great at what they do at a company. You can run a machine, you wrote some code that the company relies on, etc. You could be the best person in the world at your job.  

But what if that job goes away? Or perhaps your ability to do the job goes away? Maybe you need to move for a family member’s exciting new opportunity? You suddenly need to find a new position, and that involves getting yourself out there and advertising your talent.

The best way of doing that is to be social. Meet people, find a user group, go to conferences (and maybe speak there), post on LinkedIn, write a blog post, etc.

Obviously, this takes time – but time learning, writing, and sharing your skills is always going to be a great thing for you later on.

Over time, you’ll learn more and more skills that are beyond what you do for your current employer and – assuming you can maintain a basic level of quality – this will give you a head start when applying for new roles.

There’s far more to life than just work

Anytime I hear someone treat this advice as if it’s a new phenomenon, I immediately think of The Muppet Christmas Carol, which features a scene where Scrooge’s girlfriend, Belle, leaves him because all he cares about is work.

This movie came out in 1992. And, rumor has it, the story is actually a repeat of one from way back in 1843. So, again, the concept of life being more than just work is not new!

The first bit of advice about money was also sneakily about work-life balance, too. It’s really easy to laser-focus on how much money you’re making and forget that you have friends, hobbies, and family – whether big or small. They all need your time.

You don’t want to get into a position where you’re making lots of money that you never have time to spend.

Even if other people are spending it, that won’t keep them around forever!

Of all the lessons I am glad I eventually learned, the best was that life is more than work. For me, for example, writing about tech is less about work done for my employers, and more about learning stuff about database platforms to share.

So, I’ll always suggest you spend time outside of office hours learning your craft, but I also strongly advise you don’t turn it into everything you do, or make it all you care about.  

No matter your life situation, there will always be more work than you have time for. If you let them, many employers will demand as much from you as they can get.

And if you have any fun writing, blogging, etc – you can end up spending a lot of time working every week.  

Are your teammates like family? Sort of…but not really 

Some controversial advice from one group of people would suggest that your teammates (and even the wider company) should feel sort of like a family, and you should treat them as such. 

Then, there’s another group who think you shouldn’t think of them as anything other than simply being part of a transaction, or perhaps even an enemy.

In the best case, they’re a bit of both.

The biggest thing is to never believe that they are the same sort of family as a mom, dad, a spouse, a close friend, or anyone that you can’t imagine leaving.

Instead, they’re the kind of family that shares a common bond of working, for a common purpose, for a season of life. You may form important bonds for life, and sometimes you may need to make sacrifices for your teammates – as they’ll likely do for you. 

On the negative side, just like you may have family members that drive you nuts, or that you constantly argue with, that may also be the case with a coworker (or multiple…)

For better and for worse, this shared bond can make you care about people more than you want.

However, the huge difference between the people you work with versus any other family is that, no matter how much or how little you care for them, and they for you…it’s a temporary relationship.

Even if it is one that lasts for a very long time.

Why you should value yourself more than anything

You are a line on a spreadsheet in the exact same way that they are a line on your spreadsheet. And either of you can say “bye, I can’t afford to keep you” at any time.

You don’t have to think of your company as an adversary if you don’t want to. Just be aware that you are more than the job. 

Why being yourself is so important (but there are limits)

So, this is the hardest one, because no matter how many companies say things like “we will support you being your true, authentic self”, what isn’t always mentioned is that there are limits.

If your true self feels like letting out a primal scream every 10 minutes that makes you a better worker, you just can’t do that in a 3-hour all-hands meeting!

Or you might be someone who feels that bathing once a month keeps you clean enough, or… you get it. You are part of a team.  My last company had a wonderful way to put it (and I paraphrase), “Don’t be a jerk”.  

So, always be yourself, and don’t hide who you are – just realize you are a citizen of where you are. 

Why you should get employer promises in writing

Get all your non-negotiables in writing – and read your entire contract.

Don’t assume anything, and don’t just simply believe that things won’t change.

It is, in fact, one of the hardest things. You get a promise that “you can attend a conference every year”, and for a year or two that is followed through on. It’s all great. 

But then the budget changes, or you get a shift in management, and suddenly the stuff you have been promised is no longer true. Now you have to make a decision: does this reduction in salary still make this job worth it?

(I said salary for the reasons I outlined in the “Salary is a lot more than money” section earlier; everything you get is part of your pay.)

If you have it in writing, then you have it documented that it was part of your position. You may still lose it – and it may not be reasonable to argue/fight/sue etc – but, at the very least, you have a document that verifies you were promised something you’re now losing.

The one question to ask yourself regularly

I have written about this before, and it’s at the heart of every piece of advice within this article. It all leads to this one question, which you should ask yourself regularly:

“What would it take to make me leave my current job?”

What amount of salary, benefits, training, happiness and fulfillment, life/work balance, teammates, being who you are, and contractual obligations do you need to be happy? 

If someone offers you more money but no training and no vacation, is that worth it? How about if there’s the potential for regular business travel?

Or maybe you have to be someone you are not (even if that is just a person working in a suit instead of shorts and a tee shirt). Would you be comfortable with that? 

I also wrote another similar article, “What’s your price“, and I stand by what I discuss within it. Keep a list somewhere (other than your work computer unless you are trying to make a statement!) that reminds you what you would change jobs for.

Nothing’s set in stone

This list is going to change wildly over the years, too. In your very early days, the list will probably just be two items: ‘more money’ and ‘even more money.’ Over time, other things will creep in – insurance and time off, for example.

Eventually, it might extend to respect, training, and maybe even power. Respect in your chosen field is far more important than you might imagine right now.

Once you’ve become established in your career, that list will start to include certain companies as well – and the ‘money’ line may just become “I want at least the same amount of money, or more.”

I mean, I’ve told everyone that there are few companies I’d leave my current employer for, but if Imagineering calls, there may just be a Louis-shaped puff of smoke where I used to be at my desk…

In any case, this list will really help you decide if your current position is what you actually want. When that list gets down to “I want just enough money to cover lunch next week”, it’s definitely time to leave. 

Conclusion: advice changes with your career stage

I know all this advice sounds like ‘blah blah’ to you if you’re not yet at the stage of your career where your net worth is at least increasing annually. And if you are at that stage, there’s some other advice that won’t hit (or just be relevant) until even later down the line. 

Working in tech has become weirder and weirder lately, and AI is just going to keep making it so. I expect it to make people ask that “what would get me to leave my current job?” question quite a bit more often.

Simple Talk is brought to you by Redgate Software

Take control of your databases with the trusted Database DevOps solutions provider. Automate with confidence, scale securely, and unlock growth through AI.
Discover how Redgate can help you

The post Want a career in tech? As a seasoned professional, here’s what I wish I’d known appeared first on Simple Talk.

Read the whole story
alvinashcraft
1 minute ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories