In a world often fixated on specialization, let’s shine a light on the invaluable contributions of generalist profiles. Here’s why their versatility is a force to be reckoned with:

🎯 Navigating the Hiring Landscape: Amidst recruitment processes favoring deep expertise in specific technologies, let’s not overlook the unique skill set that generalists bring to the table. While specialization has its merits, the ability to handle a wide array of tasks is a hallmark of generalist profiles. They excel in adapting to diverse challenges and bringing fresh perspectives to the team dynamic.

💡 From Concept to Completion: Generalists are the unsung heroes of product creation. Their ability to navigate the initial stages of a project, from ideation to execution, is unparalleled. Whether it’s brainstorming ideas, managing processes, or troubleshooting, generalists are equipped to handle it all. Their versatility also makes them invaluable assets in freelance opportunities, where the ability to manage projects from beginning to end is paramount (especially on smaller budgets!).

🤝 Collaboration Across Disciplines: Generalists thrive in the intersectionality of teams. Their ability to collaborate with individuals from diverse backgrounds, including marketing, design, development, and management, is crucial for fostering innovation and most of the times driving projects forward. They serve as the bridge between different departments oftentimes pushing the roadmap forward, seamlessly integrating ideas and perspectives to create cohesive and impactful solutions.

🤖 Adapting to AI in the Workplace: As AI continues to reshape the workplace, it’s natural to wonder about its impact on the role of generalists. While AI undoubtedly automates certain tasks and processes, the question arises: Could AI eventually replace generalists to some extent, pushing the world towards greater specialization?

The rise of AI raises valid concerns about the future of work and the need for specialized skills in certain domains. However, the adaptability and versatility inherent in generalist profiles offer a unique advantage. Generalists possess a diverse skill set that enables them to pivot and evolve alongside AI technologies. Rather than viewing AI as a threat, generalists can leverage its capabilities to enhance their problem-solving abilities and drive innovation.

While some tasks may become automated, the human element of creativity, critical thinking, and cross-disciplinary collaboration remains invaluable. Generalists excel in navigating complex, interdisciplinary challenges, bridging gaps between different domains and driving holistic solutions.

As we embrace the potential of AI in the workplace, the role of generalists may evolve, but their importance will endure. The key lies in recognizing the symbiotic relationship between AI and human ingenuity, harnessing technology to augment rather than replace the unique skills and perspectives that generalists bring to the table.

🌐 Tech Awareness: In today’s fast-paced tech landscape, staying informed is more critical than ever. Generalists possess a holistic understanding of the broader tech ecosystem, allowing them to anticipate trends, identify opportunities, and adapt to evolving industry dynamics. Their ability to connect the dots across different domains enables them to innovate and drive meaningful change.

Let’s celebrate the power of generalist profiles and recognize the unique contributions they bring to the tech world. Embracing diversity in skill sets fosters innovation, collaboration, and ultimately, success. Are you a generalist making waves in tech? I’d love to hear your thoughts and experiences in the comments below! #GeneralistPower #TechInnovation #EmbraceVersatility

I decided to try and automate the process as much as possible and created this proof-of-concept that attempts to retrieve emails from your Gmail inbox and summarize them using OpenAI’s API. DISCLAIMER: The script is written in Python and uses pip to manage dependencies. However, I’m almost certain it can be adapted to a JavaScript/Node-based environment if needed.

To create a command-line application that fetches emails from Gmail and summarizes them using OpenAI’s API, you’ll need to follow the following steps. We’ll be using the google-auth library for Gmail authentication and the openai library for ChatGPT API access. Please note that you’ll need to install these libraries first using pip:

pip install google-auth google-auth-oauthlib google-auth-httplib2 openai

Now, let’s create a basic script. Ensure you have the required API keys and credentials for Gmail and OpenAI.

import os
import openai
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
import googleapiclient.discovery

# Set up Google API credentials, these will be stored as JSON files that for simplicity's sake will live in the root directory of the project
SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']
API_TOKEN_PATH = 'token.json'
CREDENTIALS_PATH = 'credentials.json'

# OpenAI
OPENAI_API_KEY = 'YOUR_OPENAI_API_KEY'

def authenticate_gmail():
    creds = None

    if os.path.exists(API_TOKEN_PATH):
        creds = Credentials.from_authorized_user_file(API_TOKEN_PATH)

    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(CREDENTIALS_PATH, SCOPES)
            creds = flow.run_local_server(port=0)

        with open(API_TOKEN_PATH, 'w') as token:
            token.write(creds.to_json())

    return creds

def get_emails():
    creds = authenticate_gmail()
    service = googleapiclient.discovery.build('gmail', 'v1', credentials=creds)

    results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()
    messages = results.get('messages', [])

    if not messages:
        print('No messages found.')
        return []

    return messages

def summarize_email(email_body):
    openai.api_key = OPENAI_API_KEY
    
    prompt = f"Please, summarize the following newsletter:\n{email_body}"
    
    # Adjust your OpenAI settings when processing content here
    # These are settings specific to OpenAI so check their docs if you want further clarity
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=prompt,
        max_tokens=150,
        temperature=0.7
    )

    return response.choices[0].text.strip()

def main():
    emails = get_emails()

    for email in emails:
        message = service.users().messages().get(userId='me', id=email['id']).execute()
        email_body = message['snippet']  # You may need to adjust this based on the email structure

        summary = summarize_email(email_body)
        # Uncomment the following line if you want the full original email to show right before getting the summary
        # print(f"Original Email:\n{email_body}\n")
        print(f"Summarized Email:\n{summary}\n")
        print("="*50)

if __name__ == '__main__':
    main()

Obviously feel free to adjust the code according to your specific use case, especially when handling email bodies and formatting (this can prove tricky as formats can vary wildly, I’ve noticed this to be more efficient with LinkedIn community newsletters).

I hope you put this weird little experiment to good use!

Ever since I left (most) social media, a lot of the information I consume is through RSS feeds (thanks NetNewsWire), so this was an issue. Yes, I could’ve signed up for email notifications but in all reality I wanted to have all the content centralized in my reader, so that’s when I took it into my own hands to offer myself a way to create a custom RSS feed.

Prerequisites

Before we start, make sure you have Node.js installed on your machine. If not, you can download it from Node.js’ website.

Step 1: Set Up the Project

Create a new Node.js project and install the dependencies we’ll be using.

mkdir goodreads-rss-feed
cd goodreads-rss-feed
npm init -y
npm install express request cheerio rss fs path

Step 2: Write an Express App

Write an Express App to expose an API endpoint to serve the XML output. Create a file named app.js and add the initial setup for your Express application.

const express = require('express');
const request = require('request');
const cheerio = require('cheerio');
const RSS = require('rss');
const fs = require('fs');
const path = require('path');

const app = express();
const port = process.env.PORT || 3000;

Step 3: Function to Create RSS Feed

Define a function createRSSFeed that will create the RSS feed by scraping Goodreads content. IMPORTANT: this approach could be used for virtually any website that has a sort-of defined HTML structure to offer a list of latest blog posts.

function createRSSFeed(url, feedTitle, feedDescription) {
  return new Promise((resolve, reject) => {
    request(url, (error, response, html) => {
      if (error || response.statusCode !== 200) {
        reject(error || `Request failed with status code ${response.statusCode}`);
        return;
      }

      const $ = cheerio.load(html);
      const feed = new RSS({
        title: feedTitle,
        description: feedDescription,
        feed_url: `${url}/rss.xml`,
        site_url: url,
      });

      // This chunk of code is based on Goodreads current HTML structure to show their latest blog posts
      // If you're using this for a different website, you'll need to inspect their markup and adjust this accordingly
      $('.editorialCard').each((index, element) => {
        const title = $(element).find('.editorialCard__title').text();
        const link = $(element).find('.editorialCard__title .gr-hyperlink').attr('href');
        const description = $(element).find('.editorialCard__body').text();
        const pubDate = $(element).find('.editorialCard__timestamp').text();

        feed.item({
          title: title,
          description: description,
          url: link,
          date: new Date(pubDate),
        });
      });
      
      const xml = feed.xml({ indent: true });
      resolve(xml);
    });
  });
}

Step 4: Express Route for RSS Feed

Define an Express route /api/rss that triggers the creation of the RSS feed when accessed and serves an XML output for your reader of choice to feed upon. IMPORTANT: I decided to use Vercel to host this API, which is why my route is preceded by /api, but this isn’t mandatory and could be adjusted based on how you’ll be hosting the application.

app.get('/api/rss', async (req, res) => {
  try {
    const feed = await createRSSFeed(
      'https://www.goodreads.com/news',
      'Goodreads RSS Feed',
      'Latest articles from Goodreads'
    );

    res.header('Content-Type', 'application/xml');
    res.send(feed);
  } catch (error) {
    console.error('Error generating or sending RSS feed:', error);
    res.status(500).send('Internal Server Error');
  }
});

Step 5: Start the Server

Start the Express server to make your RSS feed accessible.

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

module.exports = app;

Step 6: Run the Application

Run your application using the following command:

node app.js

IMPORTANT: for persistence, you could host this in a service such as Heroku or Vercel, rather than depending on the host machine running the application for availability.

Visit http://localhost:3000/api/rss in your browser to access the custom Goodreads RSS feed.

That’s it! You’ve successfully created a custom RSS feed for Goodreads using Node.js. You can now integrate this feed into your preferred RSS reader to stay updated with the latest content from Goodreads in a more personalized way.

NOTE: Since Goodreads doesn’t offer a full date on the posts they list on their website, and the markup doesn’t include a full date somewhere either, posts usually show up with weird dates. Similar issues may happen if other data is missing or is incomplete in the website you’re looking to create a feed for.

In my quest to fix the issue mentioned above, I started profiling and debugging what process was impacting starting times of Zsh, in order to see if it was something added by myself, or if it was a process that could be started/loaded asynchronously. Zsh has a built in profiler which can be used by adding zmodload zsh/zprof at the beginning and zprof at the end of the ~/.zshrc file. Initially, this indicated nvm to be the culprit, which ended up in having to include the following function to load it asynchronously:

nvm() {
  unset -f nvm
  [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
  nvm $@ # This copies arguments after nvm
}
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion

But even with nvm out of the way, the shell still took its sweet time to load and I ended up trying a myriad of other fixes to patch things up and see what was causing this issue. After several hours of googling, I stumbled upon a user called bmike, posting on Apple’s StackExchange, regarding a similar issue to my own: https://apple.stackexchange.com/questions/437511/how-do-i-debug-zsh-when-startup-performance-is-slow/437729#437729. Noticing that both the issue and the environment matched, I went ahead and looked into the responses, noticing someone mentioning Homebrew as the responsible for this issue. The user noted that the issue is happening even before the contents of .zshrc are executed, and realized that Homebrew includes the following lines of code in .zprofile (or in some cases .zlogin):

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> /Users/[your-user-name]/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

For each shell started, the last line will repeat itself (I had almost 3000 lines of evals), ending up in a .zprofile file similar to this:

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> /Users/[your-user-name]/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"
eval "$(/opt/homebrew/bin/brew shellenv)"
eval "$(/opt/homebrew/bin/brew shellenv)"
eval "$(/opt/homebrew/bin/brew shellenv)"
...

Cleaning up the file, leaving only a single evaluation and commenting out the first line, solves the issue. Your resulting file should look something like this:

# echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> /Users/[your-user-name]/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

It is unclear to me why Homebrew would do something like this, whether it is intentional or simply a mistake that hasn’t been fixed (at least on my installation). Nonetheless, my shell is now snappier than ever.

After a bit of a hiatus, I’m back in the virtual town square to share some thoughts about a seismic shift that’s been reshaping the world as we know it – AI, the unstoppable force in the tech realm. Today, let’s put the personal anecdotes on hold and shine a spotlight on the game-changing force that AI has become. Buckle up, it’s quite the ride. 🌌

Remember how I’ve always donned the polymath-wannabe hat? That spirit of versatility that let me juggle myriad roles? Well, AI’s like that, but on turbocharge. The ability to learn, adapt, and make decisions, all at the speed of light – it’s like having a team of hyper-efficient polymaths in your digital back pocket.

In the grand tapestry of technology, I unwittingly ended up dipping my toes into the AI pool deeper than I initially expected. From crunching numbers to speech recognition, AI’s woven into more aspects of our lives than we realize. Its algorithms sift through mountains of data to reveal patterns that spark innovations we can only dream of.

But hold on to your hats, because the “AI-is-everywhere” phenomenon doesn’t come without its quirks. AI’s rapid evolution brings along its own set of hesitations and awe-inspired “whoa” moments. The question of balance emerges – how much of the decision-making reins do we hand over to AI without sacrificing our human touch?

Cue the whispers in the tech corridors: “AI is the answer!” “AI is the villain!” It is like walking a tightrope, similar to that headspace when you’re trying to shift mindsets. Balancing the brilliance of automation with the irreplaceable spark of human ingenuity is the name of the game. The debates rage on, the “AI-is-the-future” chant blends with the “but-humans-are-irreplaceable” mantra, and the digital world transforms before our eyes.

So, here’s to the present and future of AI, the technological maelstrom we’re all navigating. As I stand here, reminiscing about my own journey, I can’t help but marvel at how AI, much like product management, has journeyed from the fringes to the forefront, shaping industries, revolutionizing processes, and rewriting the rules.

Dive into the rabbit hole of AI’s possibilities, and let’s continue shaping a future where we harness this incredible power for the betterment of all. Here’s to embracing change, navigating uncharted territories, and riding the waves of AI-powered innovation! 🌟

#AIInTech #TechTransformations #RidingTheAIWave

It’s been a while since I last posted something here. Not as much time as in other ocassions but still for me it feels like ages, mostly ‘cause I’ve been through some big changes. Those changes have been both at a personal and professional level. Let’s focus on the work stuff for now ‘cause the other one is a can of worms I truly rather not open up to the internet. That last one is something I’ve been practicing lately (oversharing much?)

Ever since I can remember, I’ve taken pride in being a polymath-wannabe, a generalist, someone that could juggle different aspects of a whole, and that really paid off. While I always worked mostly as a developer of sorts, being able to do almost anything gave me an advantage. I was an asset to my employers. Being a generalist gave me the opportunity to learn a little about a lot. I’ve worked solo as a freelancer, I’ve worked with marketing teams, development teams, business teams, and from every experience I took in as much as I was able to do so without exploding.

I always worked as a product manager at some level without even realizing, and subconsciously I knew that managing was something I was relatively good at, but never dived too deep because my focus was somewhere else. Somewhere I felt needed my attention at the time. Somewhere I, unequivocally, thought would be more helpful for the future than my task/people-handling skills. I did design work and, although it definitely is my weakest suit, that boosted my understanding of both UX principles and UI best practices. I also did development work (a bit on the back-end, mostly on the front-end) and that taught me how to approach solutions in a logical and organized manner. After being disappointed and disenchanted with the traditional educational system, I did some self-teaching and realized I could learn virtually anything I wanted as long as I had access to the internet.

The “you-are-nothing scaries” is what I called the feeling I got whenever I thought of focusing mostly on management rather than development. It is likely something exacerbated because of the public discourse that says “everyone should know how to code” (when in reality it needs to be something a bit more along the lines of “everyone should learn how to think logically”) and also the “managers are useless middlepeople” misconception.

I retired all of my design work, and honestly it relieved me because when I looked at what I did in the past, I cringed a lot. I shouldn’t though. Past work paid for my bills, allowed me to purchase stuff I thought it wouldn’t ever be possible, taught me to push my limits, and helped me grow at my job. I also retired part of my creative coding demos. I made up my mind, I wanted to focus mostly on management, grow on how to effectively work with my teams, how to provide support for them. And here we are today.

The journey so far has been great, I was lucky enough to participate in projects for brands such as Pepsi, the US Open or Cardano, among others. It has also proven tricky. I’ve struggled, and sometimes I still do if I’m honest, with stripping of my predominant web development profile. I still need to concentrate mostly on helping my team from a management perspective with just a pinch of former dev-thinking rather than full-on suggesting them approaches from a technical standpoint, and I know at these times I fail my teammates at some level. It’s a long road, I guess.

I’m hoping this publication is the entry way for me to walk you through all the amazing stuff we’ve been building at Way Too Digital these past couple of years (shout out to Agus for trusting me with obligations he thought I was responsible, sensible and smart enough to tackle. Without his trust I probably wouldn’t be where I am today professionally).

I’m honestly really eager to tell you some of the many stories I’ve been collecting: web3 boom, product development hurdles, amazing teammates, you name it and we can talk about it.

There’s been tons of articles explaining, or at least trying to encompass, what web3 actually is and how it relates to its theoretical predecessor, the so called web 2.0, a term coined in early 2000s and lately popularized at its peak around 2010 to describe how social media came into play in all this. Although this intro might be unnecessary, I feel a quick showcase of a diagram, that by now most likely 90% of the internet saw in the NFT craze from mid-to-late 2021, is necessary:

Credits to GettingSmart.com

It is fair to start this blogpost by clarifying that it isn’t my intention to talk about the ethical implications or the actual practicality of the phenomenon, but rather take a look into what the development process of a decentralized app looks like based on my very own, heavily biased, experience.

At the moment I began to work with a web3 related project, there was a considerable amount of information around but it sill was somewhat of an emerging trend. This initial project I took part in required to look into Ethereum-based NFTs: the client commended us to work on a web-based NFT project initially leveraging on OpenSea’s SDK to be able to provide an MVP-like experience and test the waters. Needless to say, the moment I began working on it, almost the entire team was fully unaware of what a wallet address even was, so from the get go we had a lot of homework to do.

For an outsider to be able to get into blockchains is somewhat of an over-complicated hurdle, as the saturation of possibilities was something that dizzied us in the beginning (see Bitcoin, Solana, Ethereum, Ethereum side-chains like Polygon, etcetera). Our first right choice tackling this was to focus solely on the inner workings of Ethereum exclusively: figuring out wallets, smart contracts and their capabilities, and how marketplaces like OpenSea played a part was key.

After figuring out how wallet addresses, private keys, seed phrases; and smart contracts, proxies, ERC standards, we moved on to understanding the actual process of developing smart contracts, and the limitations of Solidity as well. This part included multiple failed attempts of deploying smart contracts to testnets and manually going through the entire token creation flow we had created, a process we knew we will most likely not use but would help us figure out the ins and outs of OpenSea as the most difficult part yet would be understanding what role custom smart contracts played in the ecosystem of marketplaces. Surprising no one, we weren’t able to figure this out before our launch day, thus we ended up using OpenSea’s shared storefront smart contract. For context: all smart contracts deployed that create (a.k.a. mint) NFTs outside of OpenSea’s shared storefront smart contract are picked up automatically by the platform, and the wallet address that deployed the contract is considered the “creator”, making that address the only one in control to update the collection’s information (e.g.: description, name, picture, cover picture). All smart contracts that mint NFTs are considered “collections” by most marketplaces, similar to what factories are in development.

Note: ERC standards are a particularly tricky subject, especially with themes such as fungibility of tokens. Investing many hours of research into this particular part will be absolutely worth it, trust me.

Long story short, the initial product launched, we relied heavily on OpenSea, but we could’ve easily relied on the actual blockchain to prevent further centralization, it was only a matter of having more time to do research and execution. There were some misses that in hindsight are obvious -for example, we used cronjobs to keep track of some transactions rather than simply going with a websocket implementation-, but we didn’t have the space to conduct proper proofs of concept because of different constraints. Nonetheless, even with this somewhat misguided approach, within the first hour of launching the product the first sale for an exclusive piece of digital art was sold, and the team was ecstatic.

As with every advancement on the web front, web3 has adepts and detractors, and I personally believe it is only natural to explore emerging proposals in order to be able to form an opinion and contribute to the public discourse. I don’t believe I have an ulterior motive by writing this article other thant simply logging my experience with this particular part of web history and maybe be of assistance to anyone that might be going through a similar experience in the future. The end.

When I first started as a developer, considering that moment to be after having my first real freelancing gig, my boyfriend and mentor passed away, and ever since I’ve been doing my best to absorb the experience of others to understand what is the best way to conduct myself in whichever role I’m currently situated. My experience with an in-house role was fairly limited and lasted only about 6 months when I moved to Buenos Aires, but every instance before and after my attempt at working in a “traditional” physical office were done from a small town, giving me zero access to a face-to-face dev community, and thus limiting me to, again, getting all my knowledge and third-party experiences only from the wonderous world of the Internet.

I always considered myself to have a keen eye for organization and attention to detail, which gave me a great advantage not only when it came to translating designs into HTML and CSS, but also to organize my work without too much hardship. Kanban boards, ToDo lists, excerpts for clients, Gantt charts, they were never really something strange to me, and they indeed came super handy when first starting freelance jobs. This is a quality I assume naturally helped me take somewhat of a management role while developing the sites or apps I was working on, no matter if independently or as part of a team. When collaborating with a group, most project managers were thankful of this capacity, which is why I decided to value it and kept on nourishing it.

Even if organizing the tasks in the project isn’t your main responsibility, helping your team have a clear vision of the current status and next steps is always desired. Same goes for proposals for features and approaches to solving different problems, for example.

As my responsibilities naturally grew when I kept on expanding my skillset as a developer, I eventually started freelancing for WayTooDigital, and I induce that my contractor, Agustín, found the capacity of a developer to be able manage a team from a technical standpoint valuable, since he offered me to join in a somewhat more solid manner soon after a couple of projects. Accepting was one of the best decisions I’ve ever made, as it opened up the possibility to get my hands dirty directly with clients and the product design process altogether, and this was mostly enabled by Agustín’s trust that I was up for the task from beginning to end.

Meanwhile, I kept getting more involved in the lifecycle of a product and I was able to add my, and my team’s, own touch to the ideation and execution of each project, allowing us to grow both in the management department and in the latest technologies used for different types of requirements. Navigating this stage while trying to excel in both engineering and the arrangements of instructions to get a product to life is incredibly challenging, and this is where I had to make a decision on which front I wanted to be the most involved in. I eventually decided that my interest leaned towards management and this is where I steered into properly organizing what I needed on my end to provide my team with the best tools and processes for them to work and focus on their expertise areas. I was rather inexperienced in this front, so I ran through a list of what I was able to grasp were the areas that successful product managers focused on:

• Helping the team in a “cross-functional” approach, considering each step of the way as a key part of a whole so they can collaborate holistically
• Accompanying designers and developers in depth when reviewing feature proposals or deliveries to properly prioritize and stage releases
• Helping clients, product owners and stakeholders understand already set realistic roadmaps with input from all parts of the team

As I kept on getting deeper and deeper into this, I struggled to keep up with the requirements I considered were needed for my team to be successful, especially having a hard time with Proof of Worth and impostor syndrome on my end. Shreyas Doshi helped me a great bunch with this when I read the following Twitter thread:

Proof of Worth, a gentle product management rant:

When an early-career PM starts on a team, they might be told that they must build credibility with the builders (eng, design, analytics…)

They must prove their worth.

Fine advice, but it can go wrong long-term.

1/11

— Shreyas Doshi (@shreyas) May 30, 2020

I know I’m cutting this short, and there isn’t exactly a conclusion to this entry, as this role for me is still an active living and breathing ongoing process, but I thought that sharing how it went so far might help other people in the same place as me, who might not exactly have a mentor or someone to lean on to explore an unconventional road to an already established role in the industry.

Best of luck to all new managers out there! It’s a wild wild world, but we got what it takes to make the best of it.

This post was somewhat influenced by Michelle Barker’s post, which in turn was encouraged by Colin Devroe.

Routine is good for me as long as I can keep a straight score, but as soon as something ruptures those habits everything falls into chaos, which is why the last couple of years (and I mean that literally, it must be around 2 years or a little bit less) that I ended up finding a system that works for me and has a decent amount of structure but still is flexible enough to allow interruptions without throwing everything into disarray.

Because of everything I’ve written in the previous paragraph I won’t be using hours but rather chunks of the day to describe what I do daily:

Early morning: I wake up, do my skin care routine, and prepare some quick breakfast (it usually is a banana smoothie with strawberries or blueberries, peanut butter and honey. It can also be eggs, toasts and coffee). Once breakfast is ready I head over to my desk -lately that means the living room table of my apartment- to either read emails or organize the day. If there are bills to pay or I need to settle something, this is the moment where I try to be as productive as possible: concise answers, resolutive approaches.

Mid-morning: Once those early morning tasks are done, I start by prioritizing what part of my work needs to be done with more urgency. Said work can either be bug fixing, feature work or documentation (depends on the client I’m working for at the moment). Some days are harder than others when it comes to having the drive to get to business, which is why I’ve been setting goals as a way to fuel my motivation. So far it’s been working good enough. At this time, if I get hungry this is the moment where I’d grab some cookies, yogurt or an apple.

Middle of the day: Munch munch, crunch crunch. This is where I take a little time to, only lately, prepare a home-cooked meal with my boyfriend and sit and watch a short YouTube video while we have lunch together.

Early afternoon: Where my energy is at its lowest, which I why I use this time to answer Slack messages, set up calls, and check for new emails. I try to keep all activities that don’t require much focus in this timespan so I don’t, for example, code mindlessly.

Late afternoon: Sometimes this means 6pm, other times this means 1am. It all depends on the task I’ve been working on, how much I procrastinated or how complex it is. I been trying to keep it to 7pm at maximum, and that’s mainly because I head to the gym at the end of the day to catch a quick 50-minutes crossfit lesson (or an acting lesson if it is Tuesday) and be back home by 8 or 9pm. Once back home I take a shower, cook something with my boyfriend and our roommate, watch a TV show episode (lately that is Ryan Murphy’s “Pose”, but a couple of weeks ago it was Attack On Titan so we could catch up to the fourth season), and if possible be in bed by midnight. I used to read a decent amount a couple of years ago and I’ve been trying to get back to that but I have to admit I’ve been failing miserably (which is sad because with the whole Twilight Renaissance the internet has seen lately I would very much like to read the entirety of Midnight Sun).

Aaand that is a typical day for me. I obviously switch it up whenever something new comes up, like having to babysit my nephew (I became an uncle like 4 months ago, yay!) or go to a doctor’s appointment, but the overall succession of events looks like the list above.

Looking forward to read your typical days!

TL;DR: if possible, switch all your Flexbox containers for block-level elements. Changing display: flex for display: block should do the trick as long as you don’t mind stacked content when printing (otherwise you’ll need to tinker around to rearrange your print layout)

I’ve been working for a client for almost 3 years now, his project involves students and teachers that usually require printing guides to use whenever they don’t have an internet connection to use on their devices.

The platform uses different modular types of content (some of that is video along text, other are images in a grid, and other components are just plain text), which is why whenever building the print styles I decided to remove any extra whitespace along with background images, plain images, iframes etcetera. When testing said print styles, everything seemed in order in major browsers like Chrome, Firefox and Edge, but Safari, for some reason, included weird large gaps in between paragraphs and/or titles and content.

Theory 1: hidden images, iframes and grids were causing these gaps. Seemed unlikely given those elements all had the display property value set to none. After checking out these elements in the devtools, manually removing them from the DOM and printing a PDF, it was obvious this wasn’t the solution.

Theory 2: CSS page breaks needed to be set in order to get this page printing properly. After setting up page-break-before, page-break-after and page-break-inside property values wherever the issues arised, I tried to print a PDF using Safari but none of these changes gave me the expected results.

Theory 3: Similar to what happens with some older JavaScript plugins when combined with Flexbox, there might be sizing issues when printing, causing large computed numbers for widths or heights. After switching all my display properties to use a block value rather than flex, everything showed up as it should in the generated print PDF file using Safari.

I was lucky enough that the print layout for this use case was simple, and stacked content was the inteded result. If you need to print layouts that are a bit more complex, you are most likely going to have to dedicate some time to rearrange your components so they play nicely.