emacs --daemon
emacsclient -c             # a new graphical frame
emacsclient -t             # a new frame on this terminal

Easy peasy. And, once the server is warm, lickety-split.

Except that this combination does not work in an unpatched Emacs Mac Port. GNU Emacs includes its official backend. Emacs Mac Port is a separate port with its own collection of excellent macOS integrations and its own mac display backend. On a mac it should be the obvious choice. However, in Mac Port as it stands, GUI-first startup redirects -t to a graphical frame, while daemon-first startup makes -c fall back to a terminal frame. 0/2.

The current Mac Port source still says that it does not support multi-tty together with its GUI. TTY-only multi-tty is supposed to work.

My current workaround was to stop using the Mac Port. I gave up the Mac Port-specific features, but I do get the client/server model I was trying to configure. But there is hope on the horizon.

The failure is asymmetric

First, an Emacs vocabulary lesson. A graphical window containing Emacs is a frame. An Emacs window is one of the panes inside it. A terminal screen occupied by Emacs is also a frame, on a different terminal. Multi-tty is Emacs’s ability to attach one running Emacs process to multiple terminals at the same time. Each terminal gets its own Emacs frame, while all the frames share the same buffers. A graphical frame and a text frame belonging to one Emacs process are one particular instance of this.

One Emacs process is designed to use graphical and text terminals simultaneously. The documented jobs of emacsclient -c and emacsclient -t are to ask that process for a graphical or text frame, respectively. This is the general Emacs model.

So there are two kinds of failures in current release Mac Port:

• Start the GUI first and call server-start: graphical client frames work, but emacsclient -t is instead redirected to a graphical frame.
• Start a frame-less --daemon first: the process cannot initialize the Mac GUI later, so emacsclient -c cannot make its first graphical frame. When -c cannot make a graphical frame, emacsclient deliberately falls back to a terminal frame, and so it looks like the client is just ignoring our request.

Both of these symptoms are described in the still-open issue #52.

A partial fix ships downstream

Railwaycat’s Homebrew builds apply a downstream multi-tty patch in the current formulas for Emacs Mac 29, 30 experimental, and 31 experimental.

That patch fixes the GUI-first half. Start the Mac Port as an ordinary graphical application, run server-start, and the same process can serve both GUI and TTY clients. Users of Railwaycat’s working Homebrew builds do not have to apply it by hand. As of September 1, 2026, however, the 31 experimental formula fails to install because that patch no longer applies cleanly after upstream branch changes; the failure is tracked in issue #420.

It does not fix the daemon-first half. A true Mac Port daemon still cannot initialize its first graphical display. And deleting the last graphical frame while a TTY frame remains can leave the Mac application in a bad state. The established mac-pseudo-daemon workaround handles that lifecycle problem by starting graphically and keeping a hidden GUI frame alive. It is a useful pseudo-daemon, but the “pseudo” is doing real work in that name.

Good news everyone—a full fix?

Here is a delightful bit of news. On August 30, 2026, someone opened Mac Port pull request #143, “mac: support GUI and TTY frames from daemons”. It removes the remaining mixed-frame blockers, makes a frame-less daemon recognize the Mac display before its first GUI frame exists, and starts AppKit event processing after that display is initialized. The author reports passing the server and client tests and manually testing TTY and GUI clients in both orders.

The patch is small and cleanly mergeable, but it has no human review or project CI result yet. This is the first credible candidate I have found for the whole Mac Port problem. This two-day-old code could be just the piece we needed. Right now it is awaiting review.

The state of play as of September 1, 2026, is:

So, multi-ttwhy?

The best way to solve a problem is sometimes to let it be the problem of someone with more time or talent. Here, GNU Emacs already had the model, Railwaycat carries the practical Mac Port patch, and now a new pull request attempts the last daemon-to-GUI step.

The prospective full fix is only two days old, but our long international parenthetical editing nightmare may soon be over.

With a little googling, I pulled together a list. ‘Programming languages’ is flexible here; formal methods, verification, compilers, PL theory, types, and functional and logic programming and fellow travellers. My filter criteria was ‘how interested would I be to go to this and how much would I get out of it that relates to my research area’. I asked Claude to look back for historic dates when apps opened. This is mostly retrospective, but if past precedent has any relation to future stuff, then maybe this will also tell you when to start paying attention in 2027 and beyond.

“Summer school” is used loosely. The list includes spring and winter schools when they serve the same research-level purpose.

As I said, I also use “PL” broadly: beyond the aforementioned, stuff like synthesis, rewriting, analysis, logic, proof theory, category theory, and other areas belong when the connection runs through how programs are expressed, implemented, analyzed, or proved correct.

I can personally speak to PLMW, OPLSS, ICLP DC, SPLV, FoPSS, and NASSLLI. All were great. I know that I know colleagues whose word I would take as gospel who can recommend PLISS, MGS, and the Dutch one.

Calendar

These are month-sized reminders, not promises. Some school names link to a note below; the rest go to the official site.

Direct schools

Related or special-topic schools

Programs to check each year

Both recur, but their topics change; check the year’s program to see whether it belongs here.

Emerging schools

PLMW

The Programming Languages Mentoring Workshop has editions at POPL, PLDI, ICFP, and SPLASH. It is normally a one-day workshop for senior undergraduates and early graduate students, combining introductory PL research talks with advice about graduate school and research careers. Ordinary attendance comes through conference registration; funded participation is a separate app. In 2026 those support deadlines fell in November for POPL, April for PLDI, and June for ICFP.

FLOLAC

FLOLAC alternates emphasis: even years tend toward PL and type theory, while odd years tend toward automated verification and model checking. Its registration behaves partly like a National Taiwan University course rather than an ordinary international school, and the external-student window may last only 1–2 days. Set a January reminder for special tracks and a May reminder for the ordinary course timeline.

ICLP DC and Summer School

The ICLP DC and Summer School is a conference-attached, submission-based opportunity for doctoral students in logic programming. Recent meetings have lasted 1–2 days. Its April–May dates are DC submission deadlines, not ordinary school registration deadlines.

SPLV

SPLV rotates among Scottish universities. Scholarships, travel support, early registration, and subsidised housing may all close before ordinary registration. Apply in April for money or cheap housing; ordinary registration is a later process.

VTSA

The Verification Technology, Systems and Applications school is mobile, so “summer” is more reliable than a particular month. Its selective app, accepted-applicant registration, and housing blocks are separate processes. In particular, a later registration opening for accepted applicants is not the opening of selective apps.

International School on Rewriting

ISR moves among hosts and months. Its subject matter—term and graph rewriting, theorem proving, semantics, and protocol verification—is squarely within this calendar. Announcements can appear in November; early registration and associated travel-support deadlines tend to follow in May or June.

ICTAC Postgraduate School

The ICTAC Postgraduate School is a short conference satellite; the 2026 school ran in early Nov. It offered three intensive courses on formal methods for mission-critical software and was aimed at PhD students and young researchers. Attendance used conference registration; no independent app was listed.

FoPSS

FoPSS is one mobile, 1-week European school per edition. The official history shows hosts in Portugal, the UK, Poland, Italy, and Denmark, with a different theme each time. Recent editions fell in Feb., July, and Oct.; check the central ETAPS page and TYPES announcements in Nov. and again in April.

Dutch Winter School on Logic and Verification

The Dutch Winter School on Logic and Verification covered concurrency semantics, coalgebra, Agda and dependent types, session types, and concurrent separation logic. Its January 2026 program suggests watching from October, with hotel and early-registration deadlines arriving before the school’s final registration cutoff.

Remember that the money, cheap housing, and selective-admission deadlines are often weeks or months earlier than ordinary registration.

Shriram Krishnamurthi’s FAQ on getting a CS PhD in the US is the best general advice I know. What follows is about the narrower problem of trying to use a US MS program as preparation for a PhD.

That usually means sustained work on an uncertain problem, some artifact that makes the work visible, and a detailed letter from a researcher who watched you do it. A thesis, manuscript, system, or careful reproducibility result may supply the artifact.

This advice is for people who have not already been actively engaged in a research lab, including people whose undergraduate program did not give them that opportunity.

The difficulty

At least in the US, an MS is not a small PhD. Standalone MS programs are course-based professional degrees.

Unless stated otherwise, MS programs are ‘terminal’ and not designed to turn their students into PhD applicants. I would not expect the admissions staff, or even most faculty, to know how an MS student can make that happen. This is an uncommon path, and you may have to create it for yourself.

If this is nonetheless your quest, then make this the minimum test of any MS program you consider: can students do independent study and write a thesis as part of the degree?

I would apply to MS programs almost as though you were applying to work with particular PhD advisors, then try to create a shadow apprenticeship before you arrive. Choose programs around particular researchers, not simply departments or course offerings.

Read enough of their recent work to understand what their groups are actually doing, look at their students and research software, and begin writing to people before you apply. You may have better luck by writing to graduate students than to professors. Graduate students are often closer to unfinished work and may have a small subproblem on which help would actually be useful.

Everything I just said, except the graduate-student part, is what you would have been doing to find a PhD position. Because you’re doing essentially that.

“Free labor” alone isn’t sufficiently attractive: the scarce resource is time and supervision. You need to offer free labor whose expected supervisory cost is low—reproducing a result, getting a research system running, handling an open issue, running experiments, improving tooling, etc. Be reliably useful enough that involving you becomes easier than not involving you.

You may have to send a lot of mail. Make each message specific enough to show that you have read the work, follow up once, and expect most attempts to go nowhere. If someone gives you an opening, do a killer job, and ask for more.

The message should be cheap to evaluate. In a few sentences: say what work of theirs you read or tried, identify the particular thing you could do, and ask whether that contribution would be useful. Attach evidence only when it helps them judge the offer: a small repository, reproduction note, bug report, or short technical write-up is better than even the most enthusiastic fan letter.

The goal need not be a publication; it should be serious enough to produce a thesis, manuscript, system, or other clear artifact, and to let an advisor write in detail about you.

You want to be able to earn a letter from this person. You want to demonstrate enough capability and talent that they would recommend their personal researcher friend at another school invest 300,000 and a half a decade in you.

Remember that if the MS is only a year and you apply to PhD programs during your first fall, you would have only a few months in the program to build those relationships and results. Even if you’ve had a 6-9-month collaboration before starting the MS, it may still be worth choosing a two-year program or allowing an extra application cycle rather than rushing the very part of the master’s you need most.

The attempt is to manufacture the missing apprenticeship: find the people doing work you care about, make it easy for one of them to try working with you, learn fast, become genuinely useful, and turn that usefulness into visible research judgment.

This advice asks you to behave like a beginning graduate student before you have received the apprenticeship that normally teaches someone how to be one. This is an unfairly high bar, and it is why I would not have expected this strategy to work for me. Nonetheless, I think this is the most plausible way to turn an MS into a PhD apprenticeship.

If you can choose a route that already provides research mentorship, choose it. If an MS is the route you must take, coursework is the official program. The research apprenticeship is the unofficial program you are trying to build inside it.

Further reading

• Mor Harchol-Balter, “Applying to Ph.D. Programs in Computer Science”
• ThanhVu Nguyen, “Demystifying PhD Admissions in Computer Science”
• Jason Eisner, “How to Do Research With a Professor”

On macOS, clicking that link does not necessarily mean your browser gets to decide what happens. The operating system gets the first vote. And my macOS system is sure eager to send it to FaceTime. Which I don’t use and is a dead-end on my system.

Here’s how it works. LaunchServices looks for the application registered as the handler for the tel: URL scheme, and it sends the URL there. Meaning if FaceTime is the current default handler, then clicking a phone number in Google Maps, in Chrome, can still end up in FaceTime. No amount of poking through Chrome preferences will fix it. You can see if you try the more general:

open 'tel:+18005550111'

Boom. FaceTime. From macOS.

I wanted all the tel: links that the system knows how to dispatch to open my Google Voice account instead. From the browser, from a terminal, from a document, from whatever you can think of.

That’s the reason for the little helper app:

google-voice-tel-handler

What the helper does

This is an AppleScript applet with an on open location handler. The OS can send URL events to an applet, so the script receives the original tel: URL, extracts the phone number, and opens the corresponding Google Voice call URL in the default browser.

The script accepts the common shapes I’ve seen:

tel:+18005550111
tel://+18005550111
tel:800-555-0111

It strips the tel: wrapper, keeps the digits, and opens a Google Voice URL using the /u/0 account slot:

https://voice.google.com/u/0/calls?a=nc,%2B18005550111

Your default browser takes it from there.

How it works

You can see all the source code. It’s not much, and the AppleScript itself is pretty readable.

There’s a build script that compiles the applet with osacompile, then patches the generated Info.plist so the bundle has a stable identity and declares the URL scheme:

CFBundleIdentifier = com.jasonhemann.google-voice-tel-handler
CFBundleURLTypes   = tel

The tools involved are already on macOS: osacompile, PlistBuddy, and codesign.

If you ask whether reverse is fast, the right first response is: which reverse?

There is a mathematical function called reverse. It takes a list like '(1 2 3) and produces '(3 2 1). But there are many algorithms that compute that function. Some are linear time. Some are quadratic time. The result is the same; the amount of work can be very different.

Here are two Racket programs that both reverse a list:

(define (rev1 l)
  (cond
    [(empty? l) '()]
    [(cons? l)
     (append (rev1 (rest l))
             (list (first l)))]))

(define (rev2 l)
  (rev2-help l '()))

(define (rev2-help l acc)
  (cond
    [(empty? l) acc]
    [(cons? l)
     (rev2-help (rest l)
                (cons (first l) acc))]))

They compute the same answers:

> (rev1 '(1 2 3 4))
'(4 3 2 1)

> (rev2 '(1 2 3 4))
'(4 3 2 1)

But rev1 is slower for large lists. The reason is not mysterious once we look at what each step is forced to do.

Throughout, the complexity measure is time as a function of the length of the input list. When we say O(n) or O(n^2), n is the number of elements in the list being reversed.

Lists Are One-Way

A Racket list is built out of pairs. Each pair points at the next part of the list. That makes some operations cheap:

(first '(1 2 3)) ; 1
(rest  '(1 2 3)) ; '(2 3)
(cons 0 '(1 2 3)) ; '(0 1 2 3)

Each of those operations can be treated as constant time for this discussion. They look at, or add, the front of the list.

But append is different. To append one list onto another, Racket has to walk down the first list. For example:

(append '(1 2 3) '(4 5))

The result is '(1 2 3 4 5), but getting there requires visiting the elements of '(1 2 3). If the first list has length m, the append takes time proportional to m.

That one fact explains the difference between the two versions of reverse.

The Direct Version

The direct version says:

(define (rev1 l)
  (cond
    [(empty? l) '()]
    [(cons? l)
     (append (rev1 (rest l))
             (list (first l)))]))

In English:

1. Reverse the rest of the list.
2. Put the first element at the end.

For a small list, that is perfectly clear:

(rev1 '(1 2 3 4))
= (append (rev1 '(2 3 4)) '(1))
= (append (append (rev1 '(3 4)) '(2)) '(1))
= (append (append (append (rev1 '(4)) '(3)) '(2)) '(1))
= '(4 3 2 1)

The expensive part is hidden in “put the first element at the end.” Since lists are easy to add to at the front, but not at the back, rev1 uses append.

For a list of length 4, the append work has this shape:

append a list of length 0
append a list of length 1
append a list of length 2
append a list of length 3

For a list of length n, the append work has this shape:

0 + 1 + 2 + ... + (n - 1)

That sum is the familiar triangular number:

0 + 1 + 2 + ... + (n - 1) = n(n - 1) / 2

The important part is the n^2. The exact constants do not matter for big-O analysis, so this version is O(n^2).

We can also say this with a recurrence. Let R(n) be the cost of reversing a list of length n with rev1. Let A(m) be the cost of appending a first list of length m. These costs are still measured in terms of list length: R varies with the length of the list being reversed, and A varies with the length of the first argument to append.

R(0) = constant
R(n) = R(n - 1) + A(n - 1) + constant

Since A(n - 1) is linear in n - 1, R(n) accumulates a linear amount of append work at each level of recursion. Adding those linear pieces together gives the quadratic sum above.

The Accumulator Version

The second version uses a helper function:

(define (rev2 l)
  (rev2-help l '()))

(define (rev2-help l acc)
  (cond
    [(empty? l) acc]
    [(cons? l)
     (rev2-help (rest l)
                (cons (first l) acc))]))

This program carries an accumulator, acc, that represents the part of the answer built so far. At each step it removes one element from the front of the input list and adds that element to the front of the accumulator.

Here is the state of the computation for '(1 2 3 4):

When the input is empty, the accumulator is the reversed list.

The key operation is cons, not append. Adding one item to the front of a list is constant time. That means each recursive step does a constant amount of work, then moves to a list that is one element shorter. The accumulator grows, but the cost of cons does not grow with it.

If H(n) is the cost of rev2-help on a list of length n, then:

H(0) = constant
H(n) = H(n - 1) + constant

After n steps, that is just:

H(n) = constant * n + constant

So rev2-help is O(n), and rev2 is also O(n). Again, this is linear in the length of the original input list.

The Lesson

It is imprecise to say “the complexity of reverse” without saying which algorithm we mean. The function being computed is not the whole story.

rev1 and rev2 produce the same lists, but rev1 repeatedly pays for append, and those costs add up:

0 + 1 + 2 + ... + (n - 1)

That is why rev1 is quadratic.

rev2 does one constant-time cons per input element. That is why rev2 is linear in the length of the list being reversed.

The built-in reverse you expect from a language implementation should be the linear-time kind. But if you write your own, the difference between “put it on the end” and “carry an accumulator” is the difference between an algorithm that slows down quadratically and one that scales directly with the size of the list.

((lambda (i)
   ((lambda (j)
      ((lambda (j)
         i)
       5))
    6))
 7)

We will step through the execution of this program, but first let us acquaint ourselves with what the program actually does.

The Outer Application

At the top level, this is an application. It is the application of the operator expression

(lambda (i)
  ((lambda (j)
     ((lambda (j) i) 5))
   6))

to the operand 7. In an application form, we call the first expression the operator and the second expression the operand. The operator is a lambda expression. If I were unsure of that, we could write a program over our lambda-calculus datatype:

(define (primary-form expr)
  (match expr
    [`,y #:when (symbol? y) 'variable]
    [`(lambda (,x) ,body) 'lambda]
    [`(,rator ,rand) 'application]))

You can use this to verify the program for yourself. The body of that lambda expression is also an application:

((lambda (j)
   ((lambda (j)
      i) ; this will be the point we discuss most
    5))
 6)

There are three useful things to notice. First, this is again an application of a lambda whose body is also an application. Second, the ultimate value of this whole big expression is going to come from the value of i. Third, i is a free variable reference in

((lambda (j)
   ((lambda (j) i) 5))
 6)

This latter fact should not be surprising. If x occurs in the scope of an expression, such as in (lambda (x) (lambda (y) x)), then that is a bound reference to x, since the variable declaration of x in the lambda expression is the referent of that bound variable reference.

If we restrict our focus to the body of that same expression, (lambda (y) x), then there must be a free variable reference to x in the body. That outer (lambda (x) ...) is what will bind that free variable.

Environments Remember Context

We perform evaluation of our programs via structural recursion, the same way we write most other functions. That means the place where we actually want to get the value of a variable is when we work our way down to the variable line. For the program above, that happens when we have worked our way all the way down to i.

By then, it is too late to figure out the value of i all by itself, because we no longer have the information we need to determine what i means. Our solution is to accumulate that information as we recur into the expression, and then look up the meaning of bound variables in our accumulator when we reach a variable case.

Since there are potentially scads and scads of bound variables in an expression, we need to track each one differently. When we see i, we need to know to look up i and not x. We also need to track not just the name of the variable, but also its meaning. Our accumulator must therefore track two pieces for each variable: the name, or formal parameter, of the lambda expression, and the value, or actual argument, to which that formal parameter corresponds in this context.

When do we finally have both of those pieces? Look at the application line:

(match expr
  ...
  [`(,rator ,rand) ((valof rator env) (valof rand env))])

The rator has to evaluate to a Racket procedure, since we are about to call it like a procedure of one argument. We are going to call that procedure on the value of the rand. The rator and rand can both be big honkin’ expressions, but ultimately, when we get values for them and pass the results back up the recursion, the value of the rator had better be a procedure. The value of the rand can be any old value.

Only after we finish evaluating the two sub-pieces of the rator/rand form, and then do the Racket application, do we have both the formal and actual parameters at the same time.

Lambda Bodies Wait

Here is a simpler example of something like our interpreter:

((lambda (b) (if b 5 6)) (not false))

We first evaluate the operator and operand to values: the former to a Racket procedure and the latter to a Racket boolean. Then we call the Racket procedure on the Racket boolean. Only after that can we evaluate the body (if b 5 6).

That is an important point: we never evaluate the body of a lambda expression until after we have applied it to a value.

(define loop
  (lambda (x)
    (loop x)))

The reason you can get by with writing down a definition like loop is that we do not evaluate the body of the expression unless and until we invoke it with an argument.

Extending The Environment

It is on the lambda line that we actually extend our environment. The right-hand side of the lambda line is:

(lambda (a)
  (valof body (lambda (y)
                (if (eqv? x y)
                    a
                    (env y)))))

That is the function we invoke with true or 7 or whatever value we have in our example. It is not until we invoke that function that we begin to evaluate the body. As soon as we recur in to evaluate the body, we will no longer have access to the surrounding (lambda (x) ...), because that was the point of recurring down into the smaller expression.

To keep that information with us as we go, we add it to our accumulator, called an environment. We are using a functional accumulator; we can just as well look at our interpreter as a mathematical description of a particular function from variables to values.

This step, adding to the accumulator, is also called extending the function. If you think of a function as a set of pairs, then we have added one more pair: the mapping of (x, a). Notice also that if there were already a mapping from x, we will have locally overwritten it. We call this behavior shadowing, and the function extension in the lambda line shows how we implement that shadowing.

Walking The Example

Now let us evaluate the big expression:

((lambda (i)
   ((lambda (j)
      ((lambda (j)
         i)
       5))
    6))
 7)

We evaluate the two sub-pieces. The rator evaluates to a procedure, and the rand evaluates to 7. When we do the invocation, we start to evaluate the body:

((lambda (j)
   ((lambda (j)
      i)
    5))
 6)

We do so while keeping track of the association that i should mean 7. If we wrote the environment out by hand, it would now look like this:

(lambda (y)
  (if (eqv? y 'i)
      7
      ((lambda (y) <bomb>)
       y)))

So we evaluate that body in this environment. In the same fashion, we evaluate the two sub-pieces, produce the procedure and the value 6, and then do the application. That means we evaluate this body:

((lambda (j)
   i)
 5)

with one additional binding, j to 6. If we wrote the environment out by hand, it would now look like this:

(lambda (y)
  (if (eqv? y 'j)
      6
      ((lambda (y)
         (if (eqv? y 'i)
             7
             ((lambda (y) <bomb>)
              y)))
       y)))

Each time we extend the environment, we wrap the old one with an if statement that first checks for the variable we just added, and otherwise recurs to the slightly smaller environment.

Doing the same again, we evaluate the two sub-pieces, do the Racket application, and evaluate the body within the extended environment. In this case, that means we evaluate i in the following environment:

(lambda (y)
  (if (eqv? y 'j)
      5
      ((lambda (y)
         (if (eqv? y 'j)
             6
             ((lambda (y)
                (if (eqv? y 'i)
                    7
                    ((lambda (y) <bomb>)
                     y)))
              y)))
       y)))

Notice two things here. First, as we focus more tightly on a sub-expression of a sub-expression of a sub-expression, our environment has grown larger and larger. There is an inverse relationship between how tightly focused we are on a sub-expression and how large a nested function our environment has become.

Second, the innermost binding for j in our original expression, 5, has now blocked out the ability to look up the other meaning of j. This is our implementation of shadowing. Because we accumulate these bindings with the most recent one in front, we can use the recursion into the program’s structure to get the shadowing behavior right.

When we finally look up i, we check that it is not j, then that it is not j again, and then finally that 'i is 'i. Since it is, the lookup returns 7, and the whole expression evaluates to 7.

If you have heard the term “DWIC” before, then you’ll know what I’m about to say. Either way, please do make sure you see Paulette’s thoughts.The point is that “did well in my class” letters don’t count for much because everyone who submits an application did well in the class that they would have had with their letter writer. Anyone should be able to muster that kind of a letter, and so it doesn’t help distinguish the so-so candidates from the great ones. It’s basically table stakes.

Graduate schools typically want comprehensive letters of recommendation that give detailed, nuanced evaluations of your strengths and potential as a student. A letter that simply states that you did well in class doesn’t give much insight into your intellectual ability, research skills, leadership qualities, or any other relevant attributes that graduate schools are looking for in applicants. Good letters generally come from people who’ve seen you work on more long term projects, in either a small-group reading class, or an independent study or a research project. Sometimes this could be a co-op/internship supervisor, depending upon where you did your co-op/internship. A one-off professor can’t offer that kind of perspective, because they didn’t get a chance to work with you in that manner.

If you already have all that other stuff covered, and just need like a third letter to fill out your set, then that’s probably a better fit! Another important caveat: an un-tenured professor probably has less credibility than a tenured one. When could a non-research letter go further than an ordinary DWIC? When I’ve seen an individualized project or two that you’ve worked on, and we’ve talked together several times about that project. When I’ve reaching out for help in a new course. If I can speak to you as a TA or tutor as well as a student. If I’m writing a letter for a masters program vs a phd, or a local scholarship vs a national one.

Be sure and let me know (1) what specifically you’re hoping for me to speak to, (2) how I can best help fit into your overall letters and application, and (3) tell me what kind of a program is this for. MS CS ? PhD CS? MFA, DDS, or MBA? A scholarship? It helps to know what I’m aiming for.

It will also help if you can provide:

• A transcript
• A résumé/vita, with all of your pertinent info in it
• Anything in particular you’d like me to try and emphasize.
• A(nother) link to the scholarship/program information (and if they have multiple, which one you’re applying to!)
• And also tell me about your other letter writers.

$ bash --version 
GNU bash, version 5.2.15(1)-release (aarch64-apple-darwin21.6.0)

Looks good. If, however, we then go and check the BASH_VERSION …

$ echo $BASH_VERSION
3.2.57(1)-release

We get a very different and worse number. What gives? Well, your login shell is using a different version of bash than is currently front on your path.

This SO thread helpfully describes the problem and the issue. If you are using the new version of homebrew, then you might have had to move where you keep the programs brew installs: the new location is /opt/homebrew/bin. If that’s the one you want to set as your login shell, then you’ll have to first add it to the /etc/shells file, and then use the following to set it.

chsh -s /opt/homebrew/bin/bash
sudo chsh -s /opt/homebrew/bin/bash

(If you failed to add that to your /etc/shells file, then chsh will squawk that this is a non-standard shell.)

But after this, you should be good to go with an up-to-date login shell.

1. Get a second email address that doesn’t obviously look like a backup email address. You don’t want job mail spam in your inbox for the rest of eternity.
2. Make job hunting your full-time job until you have one. It’s a 9-5 process. There’s a lead time before you’re going to start seeing results, and you don’t know how long that is, but don’t sit and wait for that one org of your dreams to get back to you.
3. Start with the “usual suspects” job recruiting sites—Monster, indeed, etc. Fill out profiles and filters and set yourself up with a feed for job leads.
4. Any place that has an RSS feed, find yourself an RSS reader and subscribe to them. This can be your work list, and mean there’s a whole bunch of sites you don’t have to check.
5. Work backwards in time, from most recent to more distant postings.
6. Niche technology where you have experience can be a good place to start, because they probably have trouble recruiting for that.
7. When you find a job you want to apply for, do it from the company’s intranet if you can.
8. Google itself also has job search listings now, and you can use that too.
9. Often times when you’re looking up a job listing, you’ll find another site on which that job is posted that you hadn’t looked before. This is how you build breadth to your job search. Let the job listings lead you to more sites, and the job hunt sites lead you to more jobs listings.
10. Recruiters/headhunters can be useful, get in touch w/them too.
11. If you’ve graduated recently enough, the school might still offer advice on your resume. Some schools have an alumni network that to tap. The other thing I’ve seen is to update your LinkedIn profile, see where your colleagues and contacts are working, and then go to those companies’ websites for listings.
12. In fact, you can also start picking out companies that you’ve heard of that you wouldn’t mind working for, and apply directly with them. That’s another way to increase your pool of job sites.
13. Use several common search strings for positions on the search sites. You know that “software engineer” “programmer” “computer scientist” “software developer” “platform engineer” can bleed across one another, but the sites don’t and HR might not either. If a site only lets you have one active search, then get another email address and another login to that site, and have your second search set up that way.
14. Make sure your resume is AI/search friendly. Use the key words and phrases that will get you past the automatic filters and into the hands of a human being.
15. Borrow the address of a friend’s couch. If you’re willing to relocate, and you have someone in the area, then you can put that person’s address on the resume making you look like a local hire. “I’ve been staying with a friend out there while I .. I just recently moved back to my place…” yadda. IME, by the time you’re far enough along that you seem like a candidate worth interviewing in person, then that won’t matter. If it does.
16. As I understand it, in person commuting-to-work jobs are going to be less competitive than the remote jobs, because a) people place a premium on the work from home and b) you are already excluding all the people who aren’t in or willing to be in a commute distance of that job.
17. You can and probably should have multiple versions of your resume tailored to different kinds of positions. Depending on what technology they want you to work with and what the role requires, you’ll emphasize different things in your background. If you can, make it look like you’re already an expert at doing the job they want to hire you for.
18. Double, triple check your emails and spelling and that you’re addressing the right company with the right job. If you can, build yourself a little program that will automate portions of your cover letter. If you’re building it with PDF, then using TeX macros \longname \shortname \mediumname \specialreason to fill in a cover letter could both save you time and frustration
19. Likewise, before you send something, have a tool read it to you, out loud. You can listen for mistakes that sound obvious but are difficult to pick out. You can do this on 2x speed if you’re quick enough. This isn’t a place to be lazy.
20. If you have time, especially if you think you’ll be off for a while, pull out that side project you’d been working on, and spend some nights and weekends on that. It’s something new you can show off, looks good on your GitHub commit history, and gives you something to talk about at an interview.
21. This may be less applicable, but if you’re going to be off work for a while having a volunteer position doing something related could be helpful just to keep a blank off your resume. OSS and side projects are nice too, but that doesn’t fit in a spot on a resume. Maybe start thinking about this in your second month off, so that you can have something in hand. A position that you’ve had for 6 months working one day a week looks better than 5 months off and then a whole month straight of volunteering.

I know it’s tough out there. Most of that is probably common sense to readers, but I hope there’s something in there that’s worthwhile.

Easy command line access requires a little bit of study and configuration.

Firstly, the right tool for the job.

BTW, SFTP =/= FTPS

If you don’t know, SFTP and FTPS are not the same thing. If a person talks to you about “secure FTP”, stop that person immediately and make them clarify to you which they mean. It’s possible that they don’t know either: trust, but verify.

I found the easy way to connect to our server (tltc-web1h-prod.shu.edu) was to simply brew install lftp. Scads of dependencies I needed to download and update all handled for me; man alive package managers are great!

But I run into a problem when I actually try to use this to get to my space now. I can connect, but when I actually try and move around, you run into the following error.

$ lftp -u hemannja,"$PASSWD" ftp://tltc-web1h-prod.shu.edu/hemannja/
cd: Fatal error: Certificate verification: self-signed certificate ...

Certificates and verification

This error message is saying that the server has a self-signed certificate authority, and so my system rightly doesn’t trust it. If this were a nefarious actor, well, it wouldn’t make any sense to take his own word that he’s an honest fella. But I happen to know that I’m really dealing with the machine I think I am, so I want to, for this guy only, accept the certificate that it’s providing me.

So I need to get the certificate that this server is presenting me

$ openssl s_client -connect tltc-web1h-prod.shu.edu:21 -starttls ftp
...
---
Server certificate
-----BEGIN CERTIFICATE-----
123...
...
...456789abcdefgihijklm==
-----END CERTIFICATE-----
subject=...
issuer=...
---

I needed to save that certificate itself as a certificate file. Just the certificate, mind you.

$ cat > ~/tltc_web1h_prod_AES-256.crt
...

Once I had that, I needed to add it so that lftp knew about it.

Luckily this was a solved problem. If you want to add it to your MacOS Keychain, they also have a help page for this.