i'll just say, and i understand this is not the point of the article at all, but for all its faults, if you got in on flash as earl as html 2.0 and you were staring at an upcoming dead-end of flash in say, 2009, you also knew or had been exposed at that time to plenty of javascript, e4x and what were essentially entirely clientside SPAs, providing you a sort of bizarro view of the future of react in a couple of years. honestly, not a bad offramp even if flash itself didn't make it.

as an anecdote, for some jobs i've applied to, i received an internal referral to a specific recruiter and it just never went anywhere (although i could often observe the recruiter looking at my linkedin profile from linkedin's own upgrade promo emails). in many cases, i would have preferred a 5 minute call to see if i was even a good fit so as to cross a job off a list.

i'm not anybody special, also degree and over a decade in, but it seems like a market where i could be connected 1-1 to an internal recruiter that is actively filling a role but where on several occasions i was ghosted is just a different sort of environment than what you're describing.

it also solves the problem where sparklines feel useful to somebody reading a summary and not so useful to somebody that's just exploring data "in the moment." having it be available in postgres is brilliant.

a bit of shameless self promotion, i had done something similar ages ago but with a custom webfont and some small js to handle scaling of the input dataset, solving the problem of unicode graph characters not being baseline aligned well. http://nsfmc.github.io/chartjunk/ (turns into dust while looking at the last commit date)

  const useCountdownValue = initialTime => {
    const [time, setTime] = React.useState(initialTime);
    React.useEffect(() => {
      const interval = setInterval(() => {
        setTime(t => t - 1);
        if (t === 1) clearInterval(interval);
      }, 1000);
  
      return () => clearInterval(interval)
    }, []);
    return time;
  }

  const Countdown = ({time}: {time: number}) => {
    return time > 0 ? <>Time left {time} : <>Done
  }
  
  const ActualCountdownInContextSomewhere = () => {
    const remainingSeconds = useCountdownValue(60)
    return <>
      
    
  }

but like, whatever works for your team! i think it's fair to argue for either direction, but neither is zero-cost unless you have buy-in for one direction vs another from your coworkers, which honestly is all that matters especially if you have to eat lunch with them occasionally.

https://en.wikipedia.org/wiki/Transformative_use

you can see, for instance san diego's rates [1] which are $0.38/kWh in the winter and $0.48/kWh in the summer. for context, this means if i pay 11 dollars in electricity generation (because i'm part of a municipal electric generation coop), i'm still paying $36 for distribution/transmission/etc, which is $47 for 106kWh used or ~$.44/kWh which is roughly what electrify america charges ($.48/kWh) when i go to 'fill up my car.' as far as i can tell from talking to people, this is is more than most people anywhere in the country (including hawaii) pay for their electricity.

[0]: https://www.publicadvocates.cpuc.ca.gov/-/media/cal-advocate... [1]: https://www.sdge.com/sites/default/files/regulatory/1-1-24%2...

https://jonathanhaidt.substack.com/i/101249738/increases-in-...

additionally, if your app has any design/layout issues, now you need to hire for people that can do visual layout using tcl/tk.

If your app consumes rich text, you're in for a real treat as you are now on the hook for figuring out how to manage that as well (in addition to serialization, you also need it to likely be emitted into some web friendly format anyway. if your app consumes some feed (say new-user facing features or whatever), you need to find some meta-format that your app can use to layout that content (or i mean, i guess you can use a webview, but then...)

if your customers are enterprise-ey, you are now dealing with some overzealous IT dept that is skeptical of your application running with user permissions.

if you're trying to push a fix/update to your users, you now need to build infra around deploying new apps as well as customer support determining if users are somehow running old versions when they report a bug.

the web is a total "mo money, mo problems" situation, but i think people dismiss how many problems the web solves for your developers on a day to day basis: easy to push updates, simple to whitelist your app's domain on some restricted network, easy add dynamic content/layout to portions of your app with stored content, (less sync resolution issues because your app probably requires network to operate) etc. Native apps have their own issues, they're great, don't get me wrong, but people demand a lot from basic apps of any stripe these days, and as those requirements increase, so does the amount of complexity that developers need to manage at all stages of the pipeline.

having (somehow) completed many of these requirements for my 18c degree, i would say that analysis is not necessary if your interest is actually applied math. There's a great line in rudin's preface that says that his approach is ~"pedagogically sound at the expense of being logically incorrect," and recommending analysis for somebody that's not looking to mainline a pure math degree to me feels "pedagogically unsound (but logically correct)"[0].

I took analysis and i appreciated it, but i really loved the applied classes in my degree: 18.310, 18.311, 18.781 (theory of numbers) along with algebra 18.701/702. If you haven't taken a higher-level algebra class, it will let you know if analysis is right for you because you'll brush up against the edges of it without (what i consider to be, at least) its hallmark punishing density.

There are other great electives in math at mit, shop around the 18.4* classes and dial in by interest, most of them only require a prereq of 18.02/18.03/18.06 and you can sort of figure the rest out along the way.

Something to be aware of is that for a while 18.310 didn't have a dedicated instructor, so it really was all over the place. 18.311 was also somewhat hastily structured the semester i took it, but it is actually pretty good material.

You may find that after you've done all these classes that you are actually interested in pure math and at that point i would suggest looking at 18.100b (analysis), 18.700 (linear algebra), 18.100c(real analysis), 18.901(topology) and the rest of the "hard math classes," but i really do think that you'll find that the rationale for those classes doesn't click if you haven't taken a few classes like 310 or 701 first.

just my two cents! good luck, have fun!

[0]: this is the actual quote, it's in the preface rudin's principles of mathematical analysis 3rd ed. which is the 'textbook' for 100b.