DEV Community: Sarah Matta

Creative coding like this is exactly the kind of work that reminds us tech can be both expressive and deeply human. Plus pure CSS for sky, stars, and aurora ✨

Sarah Matta — Thu, 12 Jun 2025 02:47:49 +0000

Tombri Bowei

Jun 10 '25

Juneteenth Freedom Clock - A CSS Art Celebration

#frontendchallenge #devchallenge #css

Comments 16

2 min read

Csharp .NET Interview Topics - How'd I do?

Sarah Matta — Tue, 10 Jun 2025 19:17:02 +0000

As prep for recent interviewing, I worked up this list of topics. I chose to keep in mind .NET 8 and .NET 9 as latest versions, as .NET 10 has not been fully released yet.

How'd I do? What topics have you been asked about in your Csharp .NET interviews and what was the position that you were interviewing for?

What You Should Know For a Csharp .NET Interview

What to Know for a C# .NET Interview: A Practical Guide

Whether you're preparing for your first .NET developer interview or brushing up for a senior role, it's essential to know both theoretical concepts and hands-on best practices. This post outlines key areas that interviewers commonly focus on, along with real-world explanations and code samples.

1. Entity Framework Core (EF Core)

Transactions and Concurrency

EF Core uses implicit transactions during SaveChanges() or SaveChangesAsync(). If any part fails, the whole change set is rolled back.
For multi-step or multi-context operations, use explicit transactions with BeginTransaction().
Concurrency is handled via optimistic concurrency. Use [Timestamp] or .IsRowVersion() to track changes and handle DbUpdateConcurrencyException when conflicts occur.

Best Practices

Structure user code in repository and unit of work patterns to allow testability.
Use LINQ for querying, and parameterization protects against SQL injection.
Transactions can be handled with BeginTransaction or TransactionScope, but be cautious with async flows.

2. Asynchronous Programming in .NET

How It Works

await suspends execution until the awaited task completes.
It builds a state machine under the hood to resume execution without blocking threads.

Key Concepts

Use ConfigureAwait(false) to avoid resuming on the original context (especially in libraries).
Use async Task, not async void, to allow proper exception handling and testability.

Collections for Async / Multi-threaded Use

ConcurrentDictionary, BlockingCollection, ImmutableList, Channel<T> for thread-safe operations.

3. C# Language Fundamentals

Class vs Struct

Classes are reference types (heap), structs are value types (stack).
Use structs for small, immutable data with no inheritance.

Abstract vs Virtual

abstract means no implementation and must be overridden.
virtual provides a default that can be overridden.

Generics

Enable type-safe reusable code: List<T>, Func<T>, Action<T>.
Support constraints: where T : class, new(), etc.

Dynamic vs Object

object: compile-time type checking.
dynamic: runtime resolution (lose IntelliSense and safety).

4. Design Patterns and Testing

Dependency Injection

Promotes loose coupling, testability, and separation of concerns.
Configure services in Startup.cs or using .AddScoped(), .AddSingleton(), etc.

Mocking

Used in unit tests to simulate external dependencies.
Libraries: Moq, NSubstitute.
Mock IService methods to test business logic in isolation.

Writing Testable Code

Favor interfaces and DI.
Avoid static or tightly coupled dependencies.
Use clear layering: Controller -> Service -> Repository.

5. SQL and Database Concepts

Cursors

DBAs prefer to avoid them: they're slow and procedural.
Use set-based operations (joins, CTEs) instead.

Indexes

Primary Key vs Clustered Index:
- PK: enforces uniqueness.
- Clustered: defines physical order.
Non-clustered index: separate structure for quick lookups.
You can have multi-column PKs and clustered indexes.

Stored Procedures & Transactions

In SQL Server, nested transactions aren’t truly independent.
A ROLLBACK anywhere will roll back the entire outer transaction unless savepoints are used.

6. Frontend and Web Development Topics

SPA (Single Page Applications)

Frameworks like Blazor, React, Svelte.
Pros: fast navigation, richer UX.
Cons: SEO, initial load size.

Async in Svelte

<script>
  import { onMount } from 'svelte';
  let data;
  onMount(async () => {
    const res = await fetch('/api/data');
    data = await res.json();
  });
</script>

Testing Layers

Frontend: Unit tests, UI tests (e.g., Playwright).
Backend: Unit tests, integration tests.
Use mocking and DI to isolate.

7. Collections and LINQ

System.Collections.Generic

List<T>, Dictionary<K,V>, HashSet<T>, etc.
Collections tailored for performance, memory use.

System.Linq

Enables querying objects (.Where, .Select, .FirstOrDefault).
IEnumerable vs IQueryable: deferred vs translated execution.

8. .NET Ecosystem Overview

Languages

C#, F#, VB.NET (mainly C# now).

Frameworks

ASP.NET Core (Web APIs, MVC, Blazor)
MAUI (cross-platform apps)
Azure Functions (serverless)

.NET 8/9 Highlights

.NET 8: Native AOT, improved performance, better Blazor unification.
.NET 9: More performance tuning, tooling improvements.

Final Thoughts

These topics cover both conceptual knowledge and hands-on fluency expected in a modern .NET interview. By focusing on understanding why things work the way they do instead of how, you'll be better prepared to tackle technical questions, coding exercises, and design discussions.

10 Squircles Worth Checking Out

Sarah Matta — Mon, 09 Jun 2025 02:15:23 +0000

Week 1 of the June 2025 CodePen challenge is complete - and it was Squircles! Here are 10 that I thought worth sharing.

1. Proud Squircle

2. Animación de Squircles

3. Squircle Clock

4. Sliding Clock

5. Squircle Mathematics Explorer [EN/PT Interactive]

6. Squicles Buttons with Fluid Animations

7. Squircle toggle

8. CPChallenge: Squircles (Version 2)

9. GridClash: Squircles Match 3 Game

10. Squircle Variations

Hot Old Algorithms Looking for Features Near You!

Sarah Matta — Mon, 09 Jun 2025 01:33:05 +0000

I present to you a new tech conference speaker submission from me! This abstract is hopefully getting turned into a session for a conference near you this year!

Algorithmic Archaeology: Excavating Insights from Computer Science History

Many of the most well-known algorithms in computer science history are much more than clever solutions to specific problems. Whether you're optimizing microservices, designing ML pipelines, or debugging distributed systems, these classic algorithms offer more than historical curiosity. They're crystallized wisdom about how to think systematically about complex challenges and help encode mental models you can apply today and in the future.

This talk digs deep to excavate the useful problem-solving principles buried within classic algorithms and reveals how these decades-old insights directly address today's most pressing technical challenges. We'll journey through algorithmic history to cover:

Dijkstra's shortest path algorithm (1956) - Not just for finding routes on maps!
Union-Find (1964) - Procrastinating for profit!
Fast Fourier Transform (1965) - Hidden structure in seemingly chaotic data

Through code demos and visual analogies, attendees will discover how these historical algorithms address timeless problem-solving strategies: transforming hard problems into easier ones, leveraging structure to reduce complexity, and trading immediate simplicity for long-term efficiency. You'll leave with a deeper appreciation for algorithmic history and practical frameworks for recognizing when ancient wisdom applies to contemporary challenges. In the end, this talk will leave you with a toolbox of proven strategies for decomposing, optimizing, and simplifying real-world systems.

Key Takeaways

Recognition patterns for applying classic algorithmic principles to modern problems
Framework for extracting transferable insights from any algorithm
Practical examples connecting historical algorithms to contemporary ML and distributed systems
Strategies for building algorithmic intuition through historical study

What algorithm has shaped your approaches?

New Tech Talk Proposal 😎 Just Dropped

Sarah Matta — Thu, 29 May 2025 23:19:38 +0000

I'm wondering if it's possible to compose and deliver a successful tech conference session on multiple databases. What do you think?

Everything You Ever Wondered About SQL Performance: Deep Dive

This is not your typical SQL tuning talk. We’re deep diving --> beyond basic indexing tips --> into how modern relational databases actually parse, plan, and execute your queries.

Do you know how SQL is parsed?
Why does the optimizer sometimes pick the “wrong” plan?

Along the way we'll stumble upon subtle ways things can go wrong!

How can correlated subqueries sabotage execution?
When do query rewrites go sideways?

From PostgreSQL's bitmap scans to SQL Server's parallelism quirks to MySQL's index merge madness - learn to spot performance killers and know exactly which optimization lever to pull.

If you've ever stared at a slow query wondering "what exactly is the database doing right now?" - find the answer in this talk. Packed with example code, edge cases, and real-world pathologies, it’s everything you’ve ever wanted to know about SQL performance (and probably a few things you didn’t - but should!).

You'll walk away knowing exactly what to do when a query runs slow. Instead of randomly adding indexes and hoping for the best, you'll systematically diagnose performance problems by reading execution plans like a roadmap to the bottleneck. You'll recognize optimizer mistakes, know when a table scan is actually faster than an index, and understand why that "helpful" CTE is secretly destroying your performance.

Most importantly, you'll think like the database itself. Predict which queries will be fast, which will be disasters, and how to rewrite the disasters into successes. No more mystery, no more guesswork, just the confidence that comes from understanding what's actually happening under the hood.

Women of Search and OpenSource Connections Mentorship Program

Sarah Matta — Thu, 24 Apr 2025 16:04:52 +0000

Women of Search: Building a Stronger, More Inclusive Search Community

Women of Search has partnered with OpenSource Connections to launch a mentorship program in the search community - spotlighting the achievements of women, building mentorship bridges, and nurturing the next generation of search engineers. This initiative is fostering a more inclusive future for search professionals.

Women of Search was founded by Audrey Sage Lorberfeld in 2021 "out of a desire to form meaningful connections with women in the search and information retrieval field". This week, Lorberfeld and David Fisher kicked off the mentorship program at Haystack US 2025 conference.

"Women of Search and OpenSource Connections want to help facilitate IRL mentorship within the search community, using Haystack US 2025 as an opportunity for the first meeting. Please sign up to be a mentor, mentee, or both on this form."
— Haystack US 2025

It’s already making an impact

I myself am a Software Engineer and lifelong learner currently diving deeper into data, search, and AI. I attended Haystack Conf 2025 and joined the mentorship program as a mentee. The Committee took a lot of time and care to match mentors and mentees based on a variety of stated preferences and professional backgrounds, and I was quite appropriately paired with David Fisher.

Meet David: A Mentor with Deep Roots in Search

David brings a wealth of experience and a passion for education to the Women of Search mentorship program.

Before diving into information retrieval, David began his career training restaurant managers at Friendly’s. He decided to pivot, returned to school, earned his undergraduate degree from UMass Amherst and his MS from Cal. He later returned to UMass to join the renowned Center for Intelligent Information Retrieval.

There, David wore many hats: managing the Natural Language Processing Lab under Wendy Lehnert, becoming principal engineer for the Lemur Project (a foundational open-source IR toolkit), and collaborating with IR legends like Bruce Croft and James Allen. He also helped shape future generations of engineers by designing curriculum and teaching Java, Software Engineering, Search Engines, and Applied Information Retrieval for the Master’s program.

After retiring from UMass, David joined OpenSource Connections to continue making an impact in the IR community.

Mentorship

Mentorship is not just a nice-to-have, but a catalyst for career transformation. David will help me navigate my own path in the search space with invaluable experience that only decades of curiosity and contribution can bring.

If you're interested in the search space, or already in it, don't miss your chance to get involved. Sign up today and be part of the movement to shape a better, more connected search community.

👉 Join the mentorship program

Let’s keep building together.

Greener Code: How Developers Can Increase Sustainability with Cleaner Software

Sarah Matta — Fri, 11 Apr 2025 14:29:30 +0000

When we talk about sustainability in tech, the conversation often centers around hardware, data centers, or corporate ESG policies.

But what about the code itself? As developers, we often overlook the carbon cost of our work. Yet every inefficient loop, every bloated dependency, and every redundant API call consumes energy. Multiplied across millions of devices and servers, these inefficiencies add up.

The good news? Cleaner code is greener code.

1. Optimize Algorithms and Data Structures (⓿_⓿)

Efficient code doesn't just run faster—it consumes less energy. Choosing the right algorithm or data structure can significantly reduce CPU cycles.

For example, a search operation using a hash table instead of a linear array scan can drastically cut execution time, reducing energy use on every operation. Multiply that by millions of requests, and the carbon savings become tangible.

2. Reduce Code and Package Bloat (￣︶￣*))

We love our packages and frameworks, but not all of them are necessary. Be selective about dependencies. Loading large libraries to use one or two functions increases the memory footprint and slows down execution.

Audit your codebase regularly to remove unused or outdated dependencies.

3. Embrace Lazy Loading and Caching ( *︾▽︾)

Lazy loading ensures that resources are only loaded when needed. This reduces the initial load time and minimizes unnecessary computation. Similarly, effective caching prevents redundant processing and network calls.

These strategies not only improve performance but also lower energy consumption, especially in large-scale systems.

4. Measure Your Impact ◑﹏◐

Tools can help measure the carbon footprint of your applications. These insights help you identify hotspots and track progress over time.

I'll be writing individual articles about some of these tools in the near future. If you have one to suggest, comment below or reach out!

In the mean time, you can check out Sustainable IT Manifesto Foundation here or on LinkedIn.

5. Refactor for Efficiency []~(￣▽￣)~*

Code tends to grow messy over time. Regular refactoring ensures that legacy inefficiencies don’t accumulate. Clean, well-organized code is easier to optimize and maintain.

Conclusion (～￣▽￣)～

As developers, we have more power than we think. Sustainability can and should be an integrated piece of the development process.

Encouragement! （￣︶￣）↗　

The next time you write or review code, think of it as an opportunity not just to improve functionality, but to reduce your carbon footprint.

Exploring Numbers in Programming

Sarah Matta — Tue, 01 Apr 2025 16:18:32 +0000

Hi! I’m Sarah.

I am a self-taught programmer with a passion for where math meets programming.

This blog post represents a talk I gave at the inaugural Tech Talk Augusta.

As an introduction to my talks, I like to read the intro to Neil deGrasse Tyson’s Starry Messenger because it is applicable as well as impactful to STEM and it really sets the mood to consume and digest STEM considerations that you're about to hear (or read, in this instance). You can read it here: Starry Messenger

What is STEM? (o゜▽゜)o☆

Science, Technology, Engineering, and Mathematics. STEM builds the communities and realities that we live in. It both reflects on the past and propels us forward.

Today, let's focus on the M in STEM - Mathematics!

You Know More Math Than You Think ╰(°▽°)╯

I have always loved math, but I never progressed as far as I would have liked (and still would like to). I’ve heard many programmers say similar things. People often claim they “don’t know math.”

If you just thought to yourself:

(>﹏<)
“Yep, that’s me”

today I’m going to try to convince you that you know more than you realize.

Number Sense ♪(^∇^*)

What is Number Sense? ヾ(＠⌒ー⌒＠)ノ

I believe I have “strong number sense.” Number sense is the intuitive understanding of numbers and their relationships. It starts with grasping concepts like:

Quantities
More & less
Bigger & smaller

To understand these concepts is to understand math logic. Understanding math logic is comparable to understanding programming logic.

Math is Logic (～￣▽￣)～

How many of you know what this symbol is?

\sum

How many of you understand it?

\sum_{i=1}^{n} i^2

This is Sigma notation, also known as summation. It represents:

Performing an operation (right)
Starting from a defined lower bound (bottom)
Going up to a defined upper bound (top)
Incrementing at each step
Adding each result to an overall sum

How many of you know what this is?

for (let i = start; i <= end; i++) {
    sum += operation(i);
}

Yes! It’s a for loop.

Guess what? They’re the same! Sigma is a For Loop!

\sum_{i=1}^{4} i^2

\sum_{i=1}^{4} i^2 = {1}^{2}+{2}^{2}+{3}^{2}+{4}^{2}={30}

for (let i = 1; i <= 4; ++i){
    sum += i*i;
}

Now, how many of you understand Sigma notation?

The Power of Number Sense in Programming (⓿_⓿)

Problem-Solving Foundation ( *︾▽︾)

Good number sense is foundational to problem-solving. And how many of us would call programming problem-solving? 🙋‍♂️

Math teaches logical reasoning and problem-solving skills that are essential in programming. It helps in breaking down complex problems into smaller, manageable parts just like writing a program or debugging code.

A friend once said:

“My high school geometry class is what helped me start to excel at programming. My teacher emphasized proof-based geometry, and it really helped me figure out how to break big problems down into smaller ones.”

Math is Logic, Programming is Logic (〃￣︶￣)人(￣︶￣〃)

This talk is focused on numbers specifically, so let’s adventure beyond bits and bytes and explore The Numeric Foundation of Programming.

Precision vs. Accuracy: A Computational Perspective

If precision vs accuracy sounds familiar to you, you have probably taken a physics class! 😆

In programming, they have distinct meanings and can have profound implications.

Precision refers to the level of detail in a measurement or calculation. Example: the number of decimal places a computation can represent.
Accuracy refers to how close a result is to the actual, true value. It’s about correctness, not just detail.

Concept	Definition	Example
Precision	Level of detail in a result	3.1415926535 (high precision, may not be accurate)
Accuracy	Closeness to the true value	3.14 (lower precision, but accurate)

Speed vs. Correctness

Speed depends on numeric type and computation method.
Context determines the right approach.

So what does precision vs. accuracy mean in programming?

Binary vs. Decimal: The Foundations of Numeric Representation ◑﹏◐

Decimal vs. Binary in Csharp

// Decimal vs Binary floating-point comparison

double binaryResult = 0.1 + 0.2;  // 0.30000000000000004 - fast

decimal decimalResult = 0.1m + 0.2m;  // Exactly 0.3 - slow

double binaryResult = 0.1 + 0.2; represents precision because it provides many decimal places but isn't exactly accurate. It’s faster but has a small error.
decimal decimalResult = 0.1m + 0.2m; represents accuracy because it gives exactly 0.3. It’s slower, but mathematically correct.

Binary Numerical Systems (Base-2)

Binary numbers are the native language of computers, representing data using only two states: 0 and 1. This fundamental representation stems from electronic circuitry's on/off nature.

Decimal Numerical Systems (Base-10)

Decimal numbers represent our natural human counting system, using ten distinct digits (0-9).

Performance Considerations

Binary is the most efficient for computer processing.
Decimal calculations are precise but the slowest for computer processing.
Decimal also requires conversion for computer storage.

Common Use Cases:

Type	Used For
Binary	Performance-critical computations, game development, memory-constrained environments
Decimal	Financial calculations, scientific measurements

Conclusion []~(￣▽￣)~*

Math is deeply embedded in programming. Understanding number sense, precision vs. accuracy, and binary vs. decimal can help programmers write more efficient and effective code.

So the next time you think, “I don’t know math”, remember - you already use it every day in programming!