Tag Archives: Development

Hey there! I know it can be difficult to know what to say in standup. One of the most important things you can do to keep your team in the loop is to share a meaningful standup update on your progress. Think of it like a relay race – each team member needs to know where the baton is, how fast it’s moving, and whether there are any obstacles ahead.

When I enter standup and giving my update, I like to ponder: “What info can I give to the team that might be meaningful for a standup update?”

Tips for sharing meaningful standup updates

Update the team on your current work status
Let your team know how close you are to meeting milestones, deadlines, and if you’ve encountered any issues. For example, “I’m 85% complete with the License/phone selector for site settings and should have it ready for review by tomorrow morning.”
Communicate any changes that may impact others
Let your team know of any changes to your work that may impact or unblock the work of others. For example, “I’ve finished the API bits for both site and account phone/license, which should now unblock the UI stories for the rest of the team.”
Customize your updates
Tailor your updates to your team members’ interests and needs. For example, provide more details on a technical challenge for a team member who’s interested.
Be proactive in sharing updates or asking questions
Don’t wait for someone to ask for an update. For example, “I wrote up a bug I believe I noticed a bug in production, I would like to see if we should address it now or a future sprint.”
Provide context
Share not only what you’ve done but why you’ve done it. Providing context can help non-technical team members better understand the value it brings, and how it fits into the overall vision. For example, “I’ll be starting work on the date pickers, this is part of the new reporting view we’re building.”

Why do Good Standup Updates matter, you ask?

Well, here are a few reason:

Keep your team up-to-date
Regular updates help everyone stay informed about the progress of the project and any potential roadblocks.
Identify and address issues early
Sharing updates on any issues or challenges you’re facing can help your team address them early on, preventing them from becoming bigger problems down the line.
Foster team cohesiveness
Sharing updates can help your team understand each other’s work and goals, leading to better communication and collaboration towards a shared vision.

“The single biggest problem in communication is the illusion that it has taken place.”
– George Bernard Shaw (1856 to 1950)

So, the next time you’re in a standup meeting, don’t just rattle off a list of tasks you completed – instead think of your standup updates like a baton in a relay race – an opportunity to keep everyone informed, stay on track, and work together to reach the finish line.

Ask yourself: “What info can I give to the team that might be meaningful for a standup update?” and you’ll build a strong team culture that values open communication and collaboration, leading to more productive and successful projects.

Project Management

What is a Feature Flag?

December 10, 2021 Jonathan Stassen Leave a comment

Perhaps you’ve heard of Feature Flags, maybe you haven’t. What is a flag? What do they solve?

We value low stress deploys that are independent of feature launching. We value working in small batches enables us as a team to be agile to priority changes.
We value these things so that we may continuously delivering the highest value product to our users of our application.

Feature flags are a tool that help us meet these values.

We utilize Feature Flagging as a mechanism to Continuously Deliver product with both confidence and safety. A partially built feature can live behind a flag instead of a feature branch. Feature branches are worthwhile avoid to eliminate merge conflicts, reducing work, and integrated.

A feature flag create two universes that live in parallel

A feature flag creates two universes that live in parallel for a period of time – one with the feature, and one without. Ultimately when the feature is live, the flag will be removed.

Life cycle of a feature flag

A flag is short lived and is removed after the feature is live.

📋 Flag added →
🏗️ Feature incrementally built behind flag →
👷 Feature tested with flag enabled →
🚀 Feature enabled in Production →
🧹 Flag and old code removed

If we want to use a flag more long term, it’s more likely an application setting. Feature Flags should be temporary.

What does a feature flag look like in practice?

A flag is essentially an if statement around a body or line of code. Let’s say we’re adding a dark mode to our site and want to give users a setting to use it, but it’s going to take a while to build theme the entire site. We could make a very simple flag to hide it from the settings page until it’s ready.

const darkModeFeature = false;

const SettingsPage = () => {
  return (
    <div>
      {darkModeFeature && <Checkbox label='Dark Mode'/>}
      <Checkbox label='Send me emails'/>
    </div>
  );
}

This flag is inline and in the same file, It can be a good idea to centralize flags into a single file like config/featureFlags.ts or use services like LaunchDarkly, Split.io, or other services.

Levers can be use to enable a feature flag

Depending on your service you use, or how you implement your flagging, flags can be automated to have to be triggered on / off by different signals. For example:

Deployment Environment (Development, Staging, Production)
Comparing the current date to launch date and time.
Set of User ID
User Role
A small percent of users

Each have their uses and potential benefits and the options will widely very by your creativity and application. However most common will likely be the deployment environment.

Wait You Use a GUI for GIT?

July 2, 2020 Jonathan Stassen Leave a comment

Yes, Yes I do!

I’m a firm believer in using whatever tool you need to get the job done.

Is there shame in using a GUI?

I’m don’t believe in shaming devs for using a GUI and not using a CLI in the Terminal.

Dev shaming is toxic. It hurts people, and that’s not what we want, we want to build each other up! We want to get excited at each others accomplishments!

The tools we use to accomplish the task don’t really matter, what matters is that we build amazing software. There is no elite-ism of using one tool over another.

“You’re not a real dev if you don’t use a CLI” is a myth. Never believe those words. You’re a real dev if you can write software that works!

Why do I use both?

Personally I really use a mix of GUI and CLI. Some tasks are quick and easy in one or the other for me. For you it might be a different mix of benefits.

I prefer GUI for

Quick glance context: Current branch, commits behind/ahead, conflicts, other branches status, changed file count.
Cherry pick lines to commit, discard lines
Interactive rebasing & squashing with ease
Scrolling through exactly what lines of code I’m committing

I prefer CLI for

Quickly switch branches
Hard reset easily
Pull new changes
Committing & Pushing
Adding a new remote

Let’s end the culture of Dev shaming!

Coding

Code: Laravel Scope Query on a Model

March 7, 2015 Jonathan Stassen Leave a comment

Let’s talk a bit about scoped queries in Laravel. First here is a basic Book Eloquent Model with two handy scopes for type and fewerPagesThan.
//Book Model class Book extends Eloquent { public function scopeType( $query, $type ) { return $query->where( 'books.type', '=', $type ); }

public function scopeFewerPagesThan( $query, $pages ) { return $query->where( 'books.pages', '<=', $pages ); } }

Using scoping

I often see confusion when we try to use scoping. Some would expect the following to give them back all 'autobiography' books:

Book::type('autobiography'); // This works right? Nope!

But it doesn't. Scoping functions will only refine your query. For instance all the following are great examples of using scoping:

Book::type('autobiography')->get(); Book::with('author')->type('autobiography')->get(); Book::fewerPagesThan(500)->type('autobiography')->get();

Building up scopes

When using scopes to refine and filter down which Models to retrieve, you will always need to add a ->get() at the end. This allows you can chain multiple "scopes" onto each other as in the 3rd example. Basically it needs to know when you are done filtering down and when to actually hit the database.

So the 3rd example could be broken down like this to really drive home the point:

$maxPages = 500;

$books = new Book(); $books->type('autobiography'); if( $maxPages ) $books->fewerPagesThan($maxPages); $opportunities->get();

In every case before the ->get() call $books var is a Eloquent/Builder that is being built up.

After the ->get() call $books var gets overwritten with an Eloquent/Collection that has been filled with our data from the database.

This is a very powerful and flexible to way to scope and filter down models that are in your database. It is better to filter them down with scopes in the DB query than filter down a collection that has already been loaded into memory. Make the your DB do some weight lifting for you. 😉

Utilites

Utility: FTP Automation and Sync

August 15, 2013 Jonathan Stassen Leave a comment

I write code. I often find my self manually uploading every change to an ftp server using wither FileZilla or Windows Explorer native ftp browsing. Keep the FTP in sync is tedious as you may know. Save file – Switch to ftp – upload – refresh browser. In the past I have searched for a simple answer for ftp automation but found nothing. Perhaps I didn’t search long enough, however I have an answer at long last!

Enter WinSCP

WinSCP has a built in “Keep remote directory up to date” function. It is brilliant let me tell you. You select the local folder and remote folder, tinker with settings (like if it should monitor subdirectories in addition), and away you go! Instantly as soon as you save the file it will upload any changes. FTP automation. What a time saver and frustration eliminator!

FTP Automation – It’s like magic!

There is very little latency for WinSCP to detect a changed file, perhaps a fraction of a second at most! It is important to note, this automation is upload only, it doesn’t appear to support download sync as it doesn’t monitor the server side for changes. However, it does have a directory comparison tool and manual two way folder synchronization options in the main toolbar. But both of these are manual operations.

I recommending give it a try to see if WinSCP can help your workflow and save you time by eliminating the pains of manually uploading to an FTP server.

Overall I’m very pleased with this application, I think I may say farewell to FileZilla.

Download

Head over to WinSCP’s site for the latest downloads.

In addition WinSCP has some great scripting options with WinSCP.com. I have used it for automation / scheduled FTP transfers. I will write more on that in the future.

Thoughts