Ever wonder how your favorite email newsletter sends you emails from a personal email addresses such as pat@starterstory.com instead of something like noreply@starterstory.com? With Ghost you can manage your email configuration easily. However, there could be some complications.
“noreply”: The default email configuration in Ghost
If you belong to the not-so-technical camp but still desire to write online, Ghost’s hosting service could save you some trouble. When you set things up right, you will be able to write a post and publish it on the site and send it as an email newsletter to your subscribers at the same time.
This is my first newsletter sent to myself with Ghost. The email was sent from noreply@michaelshoe.com via m.ghost.io. The only thing I did before this was linking my own domain with Ghost, and magically, I am capable of sending out email newsletters in bulk to my subscribers (though I still don’t know the mechanism behind)!
I want to get “personal” with my dear followers.
To be specific, my goal is to accomplish these two things:
Enable readers to reply to the sending domain (i.e. replying to noreply@michaelshoe.com) and have a direct one-on-one email communication with me (i.e. hit reply, write an email to me directly)
Use a custom email sending domain to send out newsletters, i.e. replace noreply@michaelshoe.com with something like hi@michaelshoe.com
The process, as it turned out, was easier said than done.
Enabling readers to reply to the sending domain
Accomplishing #1 is my priority, since it is important to talk to my dear subscribers directly in my initial phase, an embodiment of “doing the things that don’t scale” mantra. I tried to reply to noreply@michaelshoe.com, and then checked my personal email – the one I used to sign up to Ghost – the email was nowhere to be found.
I then went to my domain registrar, Porkbun, to look for some clue. Porkbun actually provides free email forwarding up to 20 for free if you purchased a domain with them, and I swiftly set it up to have emails sent to noreply@michaelshoe.com delivered to my personal email. However, even though I can receive emails sent to noreply@michaelshoe.com, I can only reply via my personal email address. Additionally, I disliked “noreply” as it presents a robotic feeling, and it literally tells people NOT TO REPLY. So I kept on looking for a better solution.
Just type in “noreply” in the first box and type in your own email address in the second
Use a custom email sending domain to send out email newsletters
To accomplish #2, I first activated an email account with my domain registrar, Porkbun, by leveraging their free three-month email domain service. Now I have my own custom email domain, hi@michaelshoe.com, with their email host. I also configured DMARC, an additional security measure that uses SPF and DKIM to help prevent email spoofing, even though I have absolutely no idea what it means (more on this later). After I’ve acquired my own email domain, I also set it up so that I can send and receive emails from hi@michaelshoe.com in my Gmail mailbox. If you are also using Porkbun, you can read “How to Set Up an Email Address in Gmail” here.
If you are using Ghost (Pro) to send email newsletters, there are two places where you need to make further configurations if you want to use your custom email sending domain. The first place is your membership portal, and the second place is your newsletter.
Membership portal
Your membership portal (Membership -> Portal settings) is the place to:
Customize the look & feel of your signup button and your signup modal
Change the support email address, i.e. the email address that sends the welcome email to the first-time subscriber
Membership -> Portal settings -> Account page
Newsletter
“Newsletters” is the place to:
Customize the design of your newsletter, i.e. how it arrives in your subscribers’ mailbox
Set up basic newsletter info, i.e. name, basic descriptions, and sender email address and reply-to email address
Solving one problem created an even bigger one
I changed all email addresses to my own hi@michaelshoe.com, both for the Membership Portal and for the Newsletter, and then gave it a shot. Something horrible happened afterwards: all my email newsletters and signup welcome emails went straight into spam; when I dug them out of the graveyard, they were covered with a warning sign like this:
What made this an even bigger problem was that regardless of how I tried to tell Gmail that this wasn’t spam, Gmail was adamant about its original opinion. I clicked on the “Looks safe” button, and marked it as no spam, and tried sending again. Again the letter ended up in the spam.
At this point, I’ve exhausted all my skills and methods, so I resorted to the Ghost support team for help. They replied within a few hours and gave me a clearcut solution – disable DMARC in my email hosting. It worked.
As it turned out, Ghost (Pro) offers custom sending domains, but this feature is only supported on the Creator Plan or higher on Ghost (Pro). As a humble Starter Plan user, I don’t have the luxury to this feature.
I’ve figured out how email configuration works in Ghost, but decided it’s not worth it to change.
At this point, I was able to accomplish both goals, i.e.:
Enable readers to reply to the sending domain (i.e. replying to hi@michaelshoe.com) and have a direct one-on-one email communication with me
Use a custom email sending domain to send out newsletters (hi@michaelshoe.com, instead of the default “noreply”)
However, I’ve decided to revert back to Ghost’s default sender addresses. I’m not technical enough to figure out the problems, and it’s just not worth it to risk not delivering the newsletters into every subscriber’s mailbox. It doesn’t matter how personal-sounding your name is if all your emails are ending up in the readers’ spam. Ghost has done a great job to ensure deliverability and it’s just too risky for me to change that. Plus DMARC sounds too important to be turned off.
I still want to have that personal connection with my subscribers, and my solution is simply to add my hi@michaelshoe.com email at the bottom of each newsletter so people can just click and start writing to me.
P.S. the question that finally got answered: who created the “noreply” email domain and why I can only send, but not receive, emails from it?
This question finally got answered by the Ghost support team (kudos to them!).
Sharing my learnings about the core skills on how to run life like a company in the Me Inc. Newsletter. Topics covered: Copywriting, Finance, Technology, and Productivity. Read my why here or join directly👇. No spams. Ever. – Michael
Welcome to the Me Inc. Newsletter.
Build yourself into a business, before you start one.
Learn. Grow. Build. Now.
function ml_webform_success_14362356() { var $ = ml_jQuery || jQuery; $(‘.ml-subscribe-form-14362356 .row-success’).show(); $(‘.ml-subscribe-form-14362356 .row-form’).hide(); } fetch(“https://assets.mailerlite.com/jsonp/918262/forms/119754151914637238/takel”)
Piles Karel is a relatively simple problem. In a 7 by 5 world, there are three piles of beepers in the first row, and Karel should pick them up.
The simplest method would be to get Karel to move to each beeper location and pick all the beepers up, and move to the next pile, etc. The code will look at this following the method:
def main():
move()
while beepers_present():
pick_beeper()
move()
move()
while beepers_present():
pick_beeper()
move()
move()
while beepers_present():
pick_beeper()
move()
if __name__ == '__main__':
main()
Incorporating Decomposition
While the above code does the job, it’s hard to read.
Karel really is just doing two things while solving this problem:
move
pick up beepers
Move is just … move, and there is no room for further docomposition. However, we can write a new function to have Karel pick all the beepers on a single spot.
def pick_all_beepers():
While beepers_present():
pick_beeper
So whenever there are beepers present, we can just use pick_all_beepers( ):
What if we don’t know the exact size of world and locations of beepers?
Before we were dealing with a certain world with a set size and beeper locations. We are using our human eyes to spot where beepers are located, and we are actually doing half of the work.
How can we write codes so that Karel can deal with an uncertain world? Would Karel be able to identify where beepers are located, pick them up, and stop right in front of the wall?
This is a very important point. Whenever we are writing codes, we should try to provide a universal solution that is capable of dealing with all types of situations.
Recall that Karel does only two things in solving this problem:
move
pick up beepers
And Karel should be doing exactly those two things while its front is clear. And because we don’t know the exact size of the world – the world could be just ONE single column – meaning that Karel may not be able to move at all, we still need Karel to pick up those beepers in her original spot. After that, Karel should move and pick up beepers until she hits the wall.
The final solution
The code then will look like this:
def main():
pick_all_beeper()
while front_is_clear():
move()
pick_all_beeper()
def pick_all_beeper():
while beepers_present():
pick_beeper()
if __name__ == '__main__':
main()
This solution can work in all sizes of worlds, and it’s much more readable by human eyes. Karel is doing exactly what the names of those functions are telling you: she first picks all the beepers in her position, and while her front is clear, she will keep moving and picking all beepers in each spot, on spot at a time, until she faces a wall, i.e. her front is NOT clear.
Sharing my learnings about the core skills on how to run life like a company in the Me Inc. Newsletter. Topics covered: Copywriting, Finance, Technology, and Productivity. Read my why here or join directly👇. No spams. Ever. – Michael
Welcome to the Me Inc. Newsletter.
Build yourself into a business, before you start one.
One of the most important concept in coding is decomposition, which is the art and skill of dividing a big problem into smaller units. It’s a type of skill because you will need to know how to use different functions to get the results you want to see in each step; it’s a type of art because the basic functions won’t get the results directly, so you will need to figure out your way of getting there, i.e. the art of breaking down a big problem into smaller problem that the functions can work their magic.
Jigsaw Karel, though not a complicated problem per se, illustrates this concept.
The Problem of Jigsaw Karel
The problem is quite straightforward. Karel starts from the bottom left and will pick up the last piece of the puzzle (beeper) and put it into the only empty spot. Karel will then return to its starting position.
Remember, Karel can only do four things:
move( )
pick_beeper( )
put_beeper( )
turn_left( )
The solution without decomposition
I can certainly ask Karel to move and pick up the beeper and put it in the spot by using the four functions in the most basic manner without considering decomposition.
from karel.stanfordkarel import * def main(): move() move() pick_beeper() # Karel now stands on the beeper, and picks it up. move() turn_left() move() move() put_beeper() # Karel now stands on the empty spot, and puts down the beeper. turn_left() turn_left() move() move() turn_left() turn_left() turn_left() move() move() move() turn_left() turn_left()if __name__ == '__main__': main()
The problem, however, is that the next reader of the code will NOT easily understand what I’m trying to do. Not unless I explain to him directly. In fact, I won’t be able to read it just about five minutes after I wrote this.
The solution with decomposition
So decomposition is really for human, not for machine. Machine doesn’t care or discriminate, and will be able put the puzzle back to its place no matter what. Human, on the other hand, might need some help in understanding.
Now, let’s see how we can divvy up this simple problem and try make it more readable.
At its core, the Jigsaw Karel problem is about picking up something, putting it down, and return to Karel’s original position. We can use the status of the beeper to separate the program, i.e. to decompose. Here are the steps:
1. Move and pick up the beeper
To finish this first step, Karel needs to move forward twice and pick up the beeper. We can simply name this function move_and_pick( ).
def move_and_pick(): for i in range(2): move() pick_beeper()
2. Put the beeper in place
After that, Karel will take the beeper in her pocket to the empty spot in the puzzle. We can name this part put_puzzle( ).
def put_puzzle(): move() turn_left() for i in range(2): move() put_beeper() for i in range(2): turn_left()
3. Return to initial position
Now that Karel has finished her job, she needs to return to her initial position, which I call Ground Zero. So we can call this function return_to_zero( ).
def return_to_zero(): for i in range(2): move() for i in range(3): turn_left() for i in range(3): move() for i in range(2): turn_left()
Now that we’ve defined the three decomposed steps, all we need to do is to call these functions in the main function. Here is my solution to Jigsaw Karel:
from karel.stanfordkarel import *def main(): move_and_pick() put_puzzle() return_to_zero()def move_and_pick(): for i in range(2): move() pick_beeper() def put_puzzle(): move() turn_left() for i in range(2): move() put_beeper() for i in range(2): turn_left()def return_to_zero(): for i in range(2): move() for i in range(3): turn_left() for i in range(3): move() for i in range(2): turn_left() # There is no need to edit code beyond this pointif __name__ == '__main__': main()
This solution is decomposed into three functions that are easy to understand. One doesn’t need to spend lots of time trying to figure out the coder’s original thinking.
Final thoughts
Obviously, there is room for improvement. For example, there are several times when Karel has to turn left twice or three times, which can be simplified. If you think about it, turning left twice is actually turning around, and turning left three times is turning right!
def turn_around(): for i in range(2): turn_left()def turn_right(): for i in range(3): turn_left()
In addition, you should pay attention to the continuity of the final status in each decomposed step. What I mean is that you should maintain a level of consistency in how Karel finishes a step. For example, if Karel picks up the beeper in the first step (function), she should also put the beeper down in the second step to stay consistent. In this way, Karel will always be ready to take action to the next step.
Sharing my learnings about the core skills on how to run life like a company in the Me Inc. Newsletter. Topics covered: Copywriting, Finance, Technology, and Productivity. Read my why here or join directly👇. No spams. Ever. – Michael
Welcome to the Me Inc. Newsletter.
Build yourself into a business, before you start one.
Learn. Grow. Build. Now.
function ml_webform_success_14362356() { var $ = ml_jQuery || jQuery; $(‘.ml-subscribe-form-14362356 .row-success’).show(); $(‘.ml-subscribe-form-14362356 .row-form’).hide(); } fetch(“https://assets.mailerlite.com/jsonp/918262/forms/119754151914637238/takel”)
