DEV Community: Mindy Zwanziger

Models - Oversimplified

Mindy Zwanziger — Mon, 10 Feb 2025 23:50:57 +0000

Generally writing this for my own benefit as I'm diving into Natural Language Processing (NLP) for a current project. In the era of AI, folks throw around the term "model" and my mind (even as a certified math person™) replaces that with <vague mathy, computer-sciencey magic thingamajig>.

But I wanted to understand it a little more and did a little digging. My current understanding can be narrowed down to:

a set of test data
a set of features (things about the data - like "is capitalized")
a set of weights (numbers between 0 to 1) for each feature
a loop where the program makes a guess, changes the weights, and tries again - millions of times until it gets it right enough that it's worthwhile to keep around

Concretely, if you were implementing NLP you might have categories that define a word as being a person, an organization, or a location.

So you'd get some basic features like the below:

word_features = {
    "is_capitalized": true,
    "previous_word": "new",
    "next_word": "announced",
    "is_followed_by_Inc": true,
}

And you might start off with random weights and then, through the loops (this is the "training" part of creating a model), it'd eventually get to something like this:

weights = {
    "is_capitalized": {
        "ORG": 0.8,    // High, most organizations are capitalized
        "PERSON": 0.7,  // ...same for person names
        "LOC": 0.6     // Somewhat high for locations - as some are capitalized and some aren't like "school" vs "Fred Meyer"
    },
    "previous_word": {
        "new": { 
            "ORG": 0.5, // etc... for the rest of the categories and features
       },
    },
}

Then, of course, there's some probability mathy mathness in there that looks at all the weights across all the features and decides which category is most probable.

Makes me think of those personality tests I took in middle school: "if you answered mostly C, you're a sporty tortoise"! Though I suspect it's more complicated than that.

First Year Retro

Mindy Zwanziger — Tue, 23 Feb 2021 23:48:48 +0000

I've just wrapped up my first year as a professional software engineer. It's been quite a ride - a little chaotic at times, but full of good as well.

As an intro, I'm a career-changer who took a very circuitous path to get to where I am today. The outline version of my story involves graduating with a double major in math and math education, spending three years exploring a variety of odd jobs, teaching middle and high school math for two years, and then working as an admin at a civil engineering firm for four more years.

I started looking into coding because a coworker's partner who worked as a software engineer encouraged me to try it out. I dabbled for a few weeks until deciding to attend an online code school called Launch School. About halfway through the program, I attended an ACT-W conference (Advancing the Careers of Technical Women) and met an engineer there who offered to meet up with me and help me find and communicate the value of my non-tech experience in the context of a particular job opening at New Relic. I applied for that position and (unsurprisingly) didn't get that first job, but it did kickstart my job search.

Before this becomes a retro on my job hunting experience (TLDR: it was unpleasant), I'll fast forward a bit. I was offered a position as an "Application Engineer Trainee" at a small company (Sitka Technology Group) that worked with folk in the natural resource management field. The position would last at most 6 months and could lead to a permanent role as a Junior Engineer on their team. It did lead to a new role, but it wasn't permanent - because I was offered a position in the Ignite program back at New Relic and couldn't pass up that opportunity.

My cohort couldn't participate in the traditional Ignite program (COVID), and instead, I was placed directly on a team. That’s where I am now, and I’m happily chugging along. So without further ado...

What's gone well

Learning a new language/framework/etc...
At Sitka, we used C#, .NET, MySQL, and AngularJS - none of which I'd used before. I picked it up without much trouble which was a definite confidence boost.
My team(s)
I've had the fortunate experience of working with really supportive folk. People have always been encouraging and willing to step in to either pair or mob our way to answers. I've never felt discouraged from asking questions or seeking out help. Special props to my current team who are some of the most affirming folk I've ever worked with.
Challenging work
My brain hurts regularly and I'm happy about it. Most of the time.
Rhythms of engineering work
The daily/weekly/monthly rhythms of engineering work suit me well. It's a great combo of meetings/collaborative work and solo, heads-down time.
Focus on growth is multi-faceted
Engineering isn't purely about technical ability and the teams and managers I've worked with have been all about incorporating and encouraging growth in core (aka "soft") skills along with technical expertise. I can't get enough of that stuff.
Supporting other career-changers
This transition was hard and I wouldn't have made it without the support and encouragement of a lot of people who are actively engaged in making the tech world a better place. Friends and mentors from The Collab Lab, Agile PDX, and the PDX Junior Developers Group, I'm looking at you! I've started being able to give back to these communities and that brings me so much joy.

What's not gone well

Loneliness
At various times over the past year, there have been times in this pandemic-ridden land where I've felt I was on my own, just fighting to keep moving forward. I think this was inevitable, despite the efforts of the wonderfully supportive folk around me. #yaycovid
Imposter syndrome
This is actually a recent development for me. For the first 9 months or so, I was just like "I'm new, I don't know anything and that's okay!" but now that I'm not so new, I get to battle with the feeling that I should already know _____ (fill in the blank). It's silly because I don't expect other people to know everything, but you know - I have to be perfect *rolls eyes*

Surprises

Different companies, different roles
My work at Sitka was significantly different from my work at New Relic. I simultaneously expected this (small vs big company, a different type of product, etc...) and was surprised at how different it really could be.
I knew more than I thought I did
While building projects on my own, I always assumed there was a better way to do literally everything I was doing. Now that I've seen a lot more examples of professional code, I realize the work I'd done previously was actually perfectly fine. Room for improvement? Absolutely. But nowhere near as bad as I thought it was!

Action items (current goals)

Knowledge sharing
I get in my own way a lot by assuming folk don't want to hear what I have to say. I'm working towards being more vocal and contributing more to my team, my company, and the industry in general.
Mentoring
I've been fortunate to have folk come alongside and support me as mentors. It made (and is making) a world of difference. I want other folk to have that same benefit. So I've signed up as a mentor with The Collab Lab and am also always on the lookout for impromptu/on-the-spot mentoring opportunities in my community.
Technical depth
There's so much to learn and understand! I'm participating in technical book clubs, constantly asking questions, and taking on new roles and tasks where I can. So much learning happens automatically with my current role but making concerted efforts to gain contextual or tangential knowledge has also been helpful.

So here we go, on to year two! Code well, my friends!

Ohhh, a SIGTERM signal!

Mindy Zwanziger — Mon, 12 Oct 2020 22:46:46 +0000

Fun fact: When you use Ctrl + C to stop your application, that sends a SIGTERM signal.

Oh a SIGTERM signal! 🐧🧊
...
What's a SIGTERM? 🐧
What's a signal? 🧊

A signal is basically a road sign for a computer. Stop, slow down, prepare for a stop, road closed, etc... It's referred to as a form of "inter-process communication" or IPC and is typically used in POSIX-compliant operating systems. POSIX being "Portable Operating System Interface" which is just a set of standards used to help operating systems work well-ish with each other.

A SIGTERM is a type of signal, namely of the "prepare for a stop" variety. It's a type of signal that your code can "catch" and use - usually to wrap up any processes you have going on before the application shuts down fully. This is in contrast to SIGKILL, which just shuts down automatically.

Graceful Shutdowns

Why is this important? You can "catch" and handle a received SIGTERM to perform a graceful shutdown of an application.

A graceful shutdown can include:

Stopping new requests from coming in
Finishing any ongoing requests
Cleaning up resources (like database connections)

It leaves your app, resources, and users in a happy place.

For some apps, this will require a significant amount of configuration. Sometimes though, all you need is a timeout to let a process finish:

process.on('SIGTERM', shutdown);

const shutdown = () => {
  const gracePeriodInMS = 30000;

  setTimeout(() => {
    process.exit(0);
  }, gracePeriodInMs);
}

Code well, my friends!

More resources:
Graceful Shutdown in NodeJS
Linux Manual Page - Signals
Graceful Shutdown with NodeJS and Kubernetes: I particularly like the "How does it work" image here. I'm all about the visual representations!

Shortcut to a Folder - Command Prompt

Mindy Zwanziger — Thu, 12 Mar 2020 22:19:38 +0000

Find yourself going to a particular folder quite often? Here's a quick and dirty way to set up a command shortcut for Windows Command Prompt to get to that folder more easily.

Step 1 - Run command prompt as an administrator.

To do this, right-click on the icon - wherever it lives. I have my command prompt pinned to my taskbar. A menu will appear - depending on where it lives, the "Run as Administrator" option may be available on that first menu, or you may need to keep digging by right-clicking on "Command Prompt" again.

Step 2 - Create a file in `C:\WINDOWS\system32`.

If the command prompt window doesn't already show that you're in the System32 folder, navigate there using the cd command.

cd C:\Windows\System32

There are a number of ways to create a new file through the command line, but here is a simple command to use:

copy con filename.cmd

When you press ENTER, the cursor will hop down to the next line. This is the beginning of the text going into your file. As a note, the filename above is the command you'd like to use. For example, if you want to go to your project's folder you could use go_project_name as the file name (don't forget the .cmd)

Step 3 - Add the directory information to the file.

Let's say my project's name is Listly and it's lives on my Desktop. I'd create the file:

copy con go_listly.cmd

On the next line, I'd type cd /d file_path (the /d is optional and allows you to change directories across different drives).

cd /d C:\Users\Mindy\Desktop

Then type Ctrl + Z to save, and ENTER to finish creating the file.

Step 4 - Use the Shortcut!

And you're all set! Simply type your new shortcut anytime you're in your command prompt and you'll be redirected to your folder.

Command well, my friends!

Learning Javascript As a Rubyist

Mindy Zwanziger — Tue, 17 Sep 2019 01:37:11 +0000

A handful of simplified comparisons to make those first few steps into Javascript a bit easier.

Photo by Gratisography from Pexels

I love Ruby.

I also recently discovered that some people vehemently dislike it.

So here I am, learning Javascript.

The people I talked to would probably be appalled that their comments had such an effect on me. Here’s a secret —I still love Ruby and Javascript is the next part of the curriculum at the online school I’m attending (Launch School) so I’d be studying it anyway, but that makes for a much less interesting story.

So here I am, learning Javascript.

The first few days of diving into a new language feels a little like a firehouse of information being directed at your face. As a former high school teacher, I’m here to tell you how to deal, with a tip — we learn best by connecting new information to old information.

So let’s make some connections!

Writing Syntax

Commenting

In Ruby, we use # to make one-line comments, and =begin with =end for our multi-line comments.

A Ruby Example:

# Comments are great!

=begin
Honestly, I find this a weird
syntax for comments. 
=end

To write a comment in Javascript, you use // for a one-liner, and /* with */ for a multi-line comment.

A Javascript Example:

// I'm a wonderfully useful comment!

/* 
Me
Too! 
*/

cAsE

In Ruby, we use snake_case for variables, files, directories, etc…, CamelCase for class names, and SCREAMING_SNAKE for constants.

Javascript mostly uses camelCase. You’ll see PascalCase with constructors (more about whatever those are soon), and SCREAMING_SNAKE for constants, just like in Ruby. Underscores (_) are for use in constants only.

Methods vs. Functions

In Ruby, we use the term “method” to denote a function. In Javascript, we see the term “function” more often, as it’s part of the method/function definition.

A Ruby Example:

def method_name(parameters)
 # some code
end

A Javascript Example:

function methodName(parameters) {
 // some code
}

I find this quote helpful to further clarify this delineation from Tiffany White on a dev.to article earlier this year:

In short: a method is a function that belongs to a class. In JavaScript, however, a method is a function that belongs to an object.

String Interpolation

Both languages provide syntax for inserting variable values into a string.

A Ruby Example:

site_name = "Medium"

"Welcome to #{site_name}"

Javascript uses backticks (`) and a dollar symbol ($) to create what is called a “Template String Literal” which allows for string interpolation.

A Javascript Example:

var siteName = 'Medium';

`Welcome to ${siteName}!`

Methods, Etc…

A great reference point for these is the Mozilla Developer Network (MDN). Here’s the Javascript Reference link. I’d recommend starting by looking at something familiar, like the Array documentation.

Let’s start with something familiar — instance methods!

Instance method

Luckily for us, both Ruby and Javascript use instance methods.

A Ruby example: [4, 3, 2].sort

A Javascript example: [4, 3, 2].sort // Oh hey, they're the same — NICE.

In our handy MDN reference list, You can tell if a method is an instance method if it includes the wordprototype.

Static method

These are akin to Ruby’s class methods.

A Ruby example: Hash.new
A Javascript example: String.fromCharCode(65, 66 ,67) // Returns 'ABC'

Constructor

As an introductory point of reference, constructors can be compared to Ruby’s classes. While Javascript constructors and Ruby classes are very different at the core, they are both the vehicles by which a new object is created, and in that, they are similar.

A Ruby example:

class Dog
 def initialize(name, age, breed)
 @name = name
 @age = age
 @breed = breed
 end
end

new_dog_object = Dog.new('Coco', 8, 'Mixed')

A Javascript example:

function Dog(name, age, breed) {
 this.name = name;
 this.age = age;
 this.breed = breed;
}

newDogObject = new Dog('Coco', 8, 'Mixed');

Other comparisons can be made, of course, but this will give you a great place to start! Code well, my friends!

article.stop();

SELECT beginner FROM all;

Mindy Zwanziger — Sat, 03 Aug 2019 18:57:17 +0000

A collection of beginner commands for navigating SQL & PostgreSQL

For folk who are beginning their journey in using SQL, this can be a point of reference while you practice.

Index cards. Photo Credit: Pixabay

Replace anything in < >'s with your actual table name/column name/constraint/data/etc…

NOTE: Never spent much time in Google Sheets or Excel? Start there! I recommend spending 1–3 hours playing around with the QUERY function in Google Sheets — a.) it’s a ton of fun and b.) it may help you visualize what’s going on with some of these concepts. Check out David Krevitt’s course on the QUERY function (or if you’d rather not spend $49, just go to his blog post about it).

Terminal Commands

These are used when you’re in your terminal, before opening the psql console.

createdb <table name> : Creates a table

dropdb <table name>: Drops (deletes) a table

psql <table name>: Opens a terminal-based console to interact with PostgreSQL and the databases within — similar to irb for Ruby.

postgres is a default database that is created when you install PostgreSQL. You can always use psql postgres to open the console. Then, you can move to other databases from within the psql console.

psql <database name> < <file name>.sql: Imports a file into a database.

Meta-Commands

Always start with a backslash (). These are used when you’re in the psql console.

\q: Quits

\c <database name>: Connects to a different database

\l: Lists all of the databases

\dt: Describes the tables in the current database

\d <table name>: Describes the table

SQL Commands — DDL

Always end with a semicolon (;). These are used when you’re in the psql console.

CREATE/DROP

CREATE DATABASE <database name>;

Creates a new database.

DROP DATABASE <database name>;

Deletes the database. Careful with this one — irreversible!

CREATE TABLE <table name>(<column setup>);

Creates a new table within the current database. Column setup information goes in the parenthesis.

Column setup includes three items: the name of the column, the data type, and the constraints. The below example creates a table with three new columns, each with a data type and a constraint.

CREATE TABLE a_new_table(
 name data_type constraint,
 name2 data_type2 constraint,
 name3 data_type3 constraint
 );

DROP TABLE <table name>;

Deletes the table. Careful with this one — irreversible!

ALTER: TABLE

ALTER TABLE <table name> RENAME TO <new name>;

Renames a table.

ALTER: COLUMN

ALTER TABLE <table name> RENAME COLUMN <column name> TO <new name>;

Renames a column.

ALTER TABLE <table name> ALTER COLUMN <column name> TYPE <new type>;

Changes data type of a column.

ALTER TABLE <table name> ADD COLUMN <column setup>;

Creates a new column, <column setup> is the same as it is in creating a new table: <column name> <data type> <constraints>.

ALTER TABLE <table name> DROP COLUMN <column name>;
Deletes a column. Careful with this one — irreversible!

ALTER: CONSTRAINTS

ALTER TABLE <table name> ADD CONSTRAINT <constraint name> <constraint>;

Add a table constraint, you make up the constraint name.

ALTER TABLE <table name> DROP CONSTRAINT <constraint name>;

Delete a table constraint.

ALTER TABLE <table name> ADD UNIQUE (<column name>);

Adds a unique constraint to the given column.

ALTER TABLE <table name> ADD CHECK (<expression>);

Adds a check constraint to the table. Can use multiple columns in expression. SQL functions (explained below) are useful tools.

ALTER TABLE <table name> ALTER COLUMN <column name> SET <constraint>;

Add a column constraint.

ALTER TABLE <table name> ALTER COLUMN <column name> DROP CONSTRAINT <constraint>;

Delete a column constraint.

ALTER TABLE <table name> ALTER COLUMN <column name> DROP DEFAULT;

Remove a default clause.

SQL Commands — DML

Always end with a semicolon (;). These are used when you’re in the psql console.

INSERT

INSERT INTO <table name> (<column name>) VALUES (<data>);

Inserts data into the table. Can add more columns using commas and can add multiple rows of data by adding more sets of values in parenthesis after the first.

INSERT INTO <table name> (<col 1>, <col 2>)
 VALUES (<data-1a>, <data-1b>),
 (<data-2a>, <data-2b>),
 (<data-3a>, <data-3b>);

UPDATE

UPDATE <table name> SET <column name> = <new value> WHERE <expression>;

Updates data to the <new value> in the column given where the expression is true. The WHERE clause is optional — if you leave it off, the command will update every row in the table with the <new value>.

DELETE

DELETE FROM <table name> WHERE <expression>;

Deletes data where the expression is true. The WHERE clause is optional — if you leave it off, the command will delete every row in the table.

SELECT

SELECT * FROM <table name>;

Displays all of the data from the listed table. Note: * is a wild card character — grabs all of the columns in a given table.

SELECT <column name>, <column name> FROM <table name>;

Display specific columns by listing them after SELECT. Can display one or multiple by separating names with a comma.

SELECT Clauses

... WHERE <expression>; Specify which rows of data you’d like by adding an expression. See SQL operators below.
... ORDER BY <column name>; Sorts the data according to the column. Can add ASC or DESC to specify whether it is in ascending or descending order. Can also sort using functions.
... LIMIT <number>; Limits the results to the number given.
... OFFSET <number>; Leaves off some of the first results, depending on the number given.
... GROUP BY <column name>; Combines data by common values in the given column. Often need this in the SELECT command to use aggregate functions (see SQL functions below).

SQL Operators/Comparisons

=: Equal to

<> or !=: Not equal to

>, <: Greater than, less than

>=, <=: Greater than or equal to, less than or equal to

BETWEEN / NOT BETWEEN : Between or not between two values

IS NULL / IS NOT NULL : Is or is not NULL

AND, OR: Logical operators to add multiple clauses

LIKE / NOT LIKE: Use with % (multi-character wild card) or _ (single character wild card) to match substrings (e.g. ...LIKE %Smith; would match to “Harry Smith” and “Lane Smith”)

SQL Functions

String

length(): Returns the length of the given string argument.

Date/Time

now(): Returns the current date and time.

date_part(): Takes two arguments, the part of the date (e.g. ‘year’) and where that data is coming from (e.g. a column name).

age(): Takes a timestamp argument, calculates time elapsed between the timestamp and the current time.

Aggregate

count(): Returns the number of values in the data specified.

sum(): Returns the sum of the values in the data specified.

min(): Returns the minimum value in the data specified.

max(): Returns the maximum value in the data specified.

avg(): Returns the average of the values in the data specified.

There are so many other commands/functions/uses out there than what is described above, so be adventurous and scour the internet for more information when you need it. A great place to turn to first? The PostgreSQL Docs: postgresql.org/docs.

That’s all for now — code well, my friends!

\q

Files & Directories in Ruby: A Primer

Mindy Zwanziger — Thu, 18 Jul 2019 05:48:43 +0000

Because sometimes the documentation has too much information.

Continue reading on The Startup »

Intro to Pry — The Short Version

Mindy Zwanziger — Sun, 31 Mar 2019 16:13:46 +0000

Intro to Pry — The Short Version

While I have never been formally taught how to code until fairly recently, I’ve dabbled in it over the years quite a bit — playing in Google Apps Script, building simple web sites for friends, making my emails prettier. I had never used any sort of debugging tool prior to about a month ago. At which point, I had taken a free Google Apps Script course (from Ben Collins — definitely check it out if you’d like a quick intro) and learned about Logger.log.

Stack Overflow has, of course, been my friend for years, but I distinctly remember being frustrated anytime someone referenced using Logger.log. i.e. “Have you tried using Logger.log?” What kind of response is that? At the time, it seemed this unconquerably large unknown and I didn’t want to try to learn it because it would take too much time— now I use it constantly. It was a lot simpler to use than I thought it would be, and so is pry. At least at the most basic level — which is all you really need to learn at first.

So here’s the short version:

Step 1 — Install it.

You can check if it’s already installed by using this in your command line:

gem -i list pry

It will return a boolean. If it’s not installed, use this in your command line:

gem install pry

Step 2 — Require it.

At the top of your code, write out the line:

require “pry”

Step 3 — Insert it.

Use this as many times as you’d like in your code:

binding.pry

Place it at a point or points in your code. To start, just pick any spot, so you can play with it and see how it works. As you go, you’ll find where exactly you want to place it when you run into various logical errors.

Step 4 — Run your code.

Pry stops the code at the point(s) where you placed binding.pry. At each point you can type in various variables and see what’s going on in your code at that particular spot.

Step 5 — Exit.

Exit the pry session by just typing exit. Exit the whole program by typing exit-program.

That’s all, folks! It’s super simple. There are other add-ons and such you can use, and more to learn about it, but this will get you over the “THIS IS SOME WEIRD THING I DON’T KNOW ANYTHING ABOUT” hump.

Code well, my friends!

DEV Community: Mindy Zwanziger

Models - Oversimplified

First Year Retro

What's gone well

What's not gone well

Surprises

Action items (current goals)

Ohhh, a SIGTERM signal!

Graceful Shutdowns

Shortcut to a Folder - Command Prompt

Step 1 - Run command prompt as an administrator.

Step 2 - Create a file in C:\WINDOWS\system32.

Step 3 - Add the directory information to the file.

Step 4 - Use the Shortcut!

Learning Javascript As a Rubyist

Writing Syntax

Commenting

cAsE

Methods vs. Functions

String Interpolation

Methods, Etc…

Instance method

Static method

Constructor

SELECT beginner FROM all;

A collection of beginner commands for navigating SQL & PostgreSQL

Terminal Commands

Meta-Commands

SQL Commands — DDL

CREATE/DROP

ALTER: TABLE

ALTER: COLUMN

ALTER: CONSTRAINTS

SQL Commands — DML

INSERT

UPDATE

DELETE

SELECT

SQL Operators/Comparisons

SQL Functions

String

Date/Time

Aggregate

Files & Directories in Ruby: A Primer

Intro to Pry — The Short Version

Intro to Pry — The Short Version

Step 2 - Create a file in `C:\WINDOWS\system32`.