Clarium Health

Senior Software Engineer

PerceptiLabs

Lead the development of the PerceptiLabs Machine Learning backend

Lead Software Engineer (Machine Learning)

Worked on the PerceptiLabs Machine Learning backend

Software Engineer (Machine Learning)

Ericsson

Implemented machine learning models, big data pipelines and performed data analytics within the DevOps world.

Machine Learning Engineer

ZENUITY

Implemented data pipelines, deep learning models and performed statistical analysis on big data.

Results published at the 2019 IEEE Intelligent Transportation Systems Conference (ITSC).

Chalmers Teknologkonsulter AB

Full-stack mobile application development. Worked on several smaller projects for various startups.

Software Engineer

Alive Event Promotion

Full-stack development for a video streaming startup.

Part-time: everything from startups to open-source game engines to commercial video game bots.

Founder / Freelancing Software Developer / Open-Source Contributor / Hobbyist

Learning is at the core of Software Engineering.

Despite my years in the industry, I recognize that the pursuit of mastery is a perpetual journey, one I humbly navigate with dedication and curiosity.

I'm passionate about traditional software engineering, software quality, and continuous delivery. My work primarily centers on data-intensive applications and machine learning systems.

Join me as I share insights, challenges, and progress along this ever-evolving path.

Code is read-heavy.

We spend more time reading existing code than we spend writing new code. 

For example, anytime we need to repair, extend or optimize existing code we must start by reading.

We must read to find the relevant parts. To understand how it works. To know the consequences of changing it.

If it takes a long time to read the code, it will take a long time to write any meaningful changes to it.

Therefore, readability matters for productivity.

Optimize for it.

#softwareengineering

Anton K

Unit Testing doesn't magically prevent bugs in new code.

You still have to think *carefully* about which cases to check.

However, the value of a good unit test is that it prevents you from accidentally introducing bugs in old code. 

That's incredibly useful, because you may not remember all the details and assumptions about the code you created months ago. 

That's especially useful for large projects. Especially as they continue to grow. Without the unit tests, you could waste a lot of time fixing the old code when you're really supposed to be writing new code.

Therefore, Unit Tests enable sustainable project growth.

#softwareengineering

Don’t just build software.

Do what the most productive engineers do:

Build systems for building software.

Create powerful abstractions and reusable components. Automate tedious and repetitive tasks. Write scripts and tools to help with routine operations.

Look for patterns where you can standardize and systematize to ramp up your productivity. 

(It’s important that there’s a *strong* pattern - nothing kills productivity like over-engineering).

#softwareengineering

"Don't test the database, mock it"

Clean Architecture, etc, popularized this idea. Hide away the real DB using simple adapters. The rationale is to keep business logic away from the DB so that the application becomes easy to test.

This is great advice when you're doing simple CRUD stuff.

This is horrible advice when you're routinely doing non-trivial data transformations on large volumes of data.

Especially if you're building a data-intensive application and the database is a managed dependency (i.e., there's lots of data to transform and noone else messes with it).

Dismissing a modern RDBMS (e.g., Postgres) as dumb storage is naive. Operating on the data close to where it lives is an excellent way to achieve high performance with minimal effort.

It *does* take some extra effort to test properly, but it's perfectly viable using modern tooling and methods. 

Typically, it goes something like this:

Spin up a clean instance, apply migrations, insert data, run a query, check the data. 

Pretty much like a unit test, but with some extra bells and whistles. 

You can use testcontainers to spin it up (if you use Python, I can recommend pytest-postgresql, it's even lighter and can often be good enough). If performance becomes an issue, share the DB between tests and use transactions or functional data partitioning to ensure isolation.

Conclusion:

Keeping business logic away from the database in the interest of testing is often the right choice.

But not always. For some applications, leveraging the database as a workhorse can be a smart move, so find a way to make it work.

(note: it's an entirely different conversation if the DB is an external dependency and someone else controls the schema).

***

This is obviously just my opinion. I don't think there's broad consensus on this, so I would love to hear other takes.

#softwareengineering

One key difference between programming and software engineering is the element of time.

It is one thing to write a program that solves a specific problem here and now. It is a completely different thing to write a program that has to be maintained and evolved to solve new problems over time. 

Software Engineers deal with the latter. 

#softwareengineering

Context Switching.

As Engineers, we know the consequences.

Lost focus. Lost flow. Lost time.

Stress. Delays.

I had a manager who recognized these issues.

He did everything he could to not fragment the schedules of us engineers.

Here are a few of his habits:

- He made sure to schedule meetings around natural breaks. Before or after lunch break. At the beginning or end of the workday. 

- He often gave us subtle reminders that it's okay to go heads down as much as we needed to. E.g., by saying things like: "no need to respond to this message right away if you're in the middle of something".

- He never questioned why we were "away" or had "do-not-disturb" on Slack. He trusted that we'd get our work done at a reasonable pace as long as the objectives were clear. 

I appreciated these habits a lot.

They helped me do a better job.

Bonus tip for engineers: if your manager isn't aware of the issues, bring it up. Have a conversation about it. Most people are reasonable.

----

Help your engineers do a better job by helping them avoid context switching.

Small adjustments can be enough.

#softwareengineering

Writing well-structured code isn’t just about productivity.

It’s also about respecting your fellow team members who have to read the code you wrote.

#softwareengineering

Devs: this should be easy to fix

Also devs: **disappears for a week**

#softwareengineering

Defects found late are far more expensive than defects found early.

Therefore, cost-effective software engineering is proactive and not reactive.

#softwareengineering

Software Engineering is a game of balancing long-term and short-term goals.

If you live too far in the future, then you might spend too much time over-engineering & solving problems nobody really has. You do lots of work, but achieve nothing.

If you only live in the present, you might get things done now but the pace might not be sustainable. Technical debt, issues wity performance and scalability lead to an abrupt stop.

Finding the right balance is far from easy. But that’s what makes this job exciting, if you ask me.

#softwareengineering

Frequent software releases means less risk.

- The changeset is smaller

We reduce the blast radius when something goes wrong. Any errors that make it to production are easy to resolve before any serious damage is done.

- The feedback-rate is higher

We validate our assumptions sooner. We can reverse small design errors before they manifest and grow large. We can discard bad feature ideas before we sink too many resources into them.

This is where the derisking really happens.

(Note: none of this works if we're releasing often at the expense of quality. If the software doesn't work, then the feedback is worthless. If we want the benefits, we need strong quality checks and they need to be under constant refinement).

There is no better steering mechanism than putting software in the hands of a customer. Nothing is costlier than building bad systems or products and not finding out until it's too late.

Done right, releasing more often means less risk.

#softwareengineering

Devs: 

"I should have this done by the end of today."

Famous last words.

#softwareengineering

”Clever code”

This could be a compliment.

But if you’re writing software for the long-term it’s most likely an accusation.

#softwareengineering

The main benefit of automated tests:

You can make changes aggressively without internalizing every detail of the system. If you break something, the system slaps you on the fingers.

That’s incredibly useful for non-trivial systems with many contributors.

I'd even say it's critical.

#softwareengineering

Once you have experienced true continuous delivery - and all the practices that enable it - it's hard to imagine building software in any other way. 

#softwareengineering

Taplio

Anton K's Linkedin Analytics

Anton K

What is Anton talking about?

Anton K's Best Posts (last 30 days)

Want to drive more opportunities from LinkedIn?

Taplio

.css-1jgreyo{background-image:linear-gradient(284deg, rgba(39,43,72,1) 0%, rgba(33,47,183,1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Anton K's Linkedin Analytics

Anton K

What is Anton talking about?

Anton K's Best Posts .css-qqfgvy{font-size:var(--chakra-fontSizes-md);}(last 30 days)

Want to drive more opportunities from LinkedIn?

Anton K's Linkedin Analytics

Anton K's Best Posts (last 30 days)