Our mission is to enable companies to turn their data into an asset

Meru Data

What Are the Top Startups in Oceania?

This is a continuation from the last story on MVP — , published on . The curious case of MVP — The Why and How Hackernoon CONTEXT — WHY THIS FOLLOW UP? I was asked a couple of questions, and well — my response kind of got out of hand. This was the response I received on the aforementioned story by Ram Nitharshan Ram’s simple, short and concise answer. I couldn’t however, keep the response concise. I started responding to his queries, and usual digressed. Felt the stuff was important enough (and more importantly quite long) to have its own story. Hence a new read. We talked about MVP in the . We took a couple of examples — one of them being a dish recommendation system. Something that just tells you the best dishes in a locality and the restaurants where they would be available. And for a product that would obviously be online, I recommended/suggested a MVP that was just a piece of printed paper. There were a lot of issues I did not touch in that example — primarily to keep the piece short ( ). last story or relatively shorter at least. It was still a 8/9 min read I think This time, I address a couple of those topics. If you haven’t read already, please do so to have the right context. You may also want to read the , which led to this story getting its own space. that story conversation between Ram and and I WHY CAMPAIGN AGAINST BUILDING AN APP FOR A MVP Okay. So anybody who knows me knows I am strongly against the notion of “ ” when it comes to business. So if they were reading it, they would nod their head — , mutter a “ ”, and keep moving on. There is an app for that in disapproval, submission or hopelessness Same Old, Same Old And yes. It is true. I love mobile apps. And I know there is an app for that. But I think the one question businesses forget to ask themselves — practically every Should there be one? But we won’t get sidetracked here anymore. Even so. In this case, my stand against building an app for the MVP has got nothing to do with my personal feelings and politics on the matter of apps. And it has got everything to do with the philosophy behind a MVP. The intent (of the MVP) is to evaluate the usability and value of the product, and not the medium by which that delivery should happen. So whether it is an app or not is meaningless. It is irrelevant. I am just trying to save some time, and a lot of effort in building something that probably nobody wants to use. Except you, that is. You were convinced if you build it they will come that you built a watered down version of your system, called it an MVP and thought that was it. Then when ‘ ’ didn’t come, you thought maybe you did not add the right features, so you add a couple more, you spent more ad dollars. You did all this, without answering the question — ? they Forget the mode of delivery, do they even need this That is why the sole intent of the MVP should be to ascertain that. If you need to build a product to do that, sure — by all means. Go ahead. But you should do that because , not because . YOU NEED TO YOU WANT TO THE RESTAURANT EXAMPLE As far as that one goes, there were multiple questions there, the biggest of them all being this. If I had all the right indications for launching the product today, and could do so, would I ask consumers to pay for the product? ( ) You would remember that I asked consumers to pay me $0.30 for the print brochure The answer is — No I wouldn’t. WHAT??? SO WHY CHARGE FOR THE BROCHURE? The brochure wasn’t kept free because if you keep the product for free, the market indication you would get could be skewed in your favor — to a large extent. Just imagine. If I was simply handing out these brochures. I may have been able to have 70–80 of the 100 consumers I pass through take those from me. By assigning a price — any price, you could have kept it at $0.15 also — to the item, I made sure that the transactions that do happen are happening because of the value that they see in the product and not because of “ ” mentality. At best, I would be able to get a conversion rate of 30% if my product offers real value, and the price-point is just low enough not to trigger a mental-block threshold. What do I have to lose HMMM…MAKES SENSE…BUT WHY NOT CHARGE THEM LATER AS WELL? After all, the consumers have shown a clear willingness to pay, right? So why not charge them when I launch my product as well? ( ) Lets assume that the product is indeed an app The answer lies in SCALE. If 20 consumers are seeing enough value to pay for the service, 60 would see enough value to use it if it were free. Monetization is a switch. If your product is adding value to the lives of consumers, there are countless primary, secondary and tertiary revenue streams you could deploy. The first intent has got to be growth here. Add value to the lives of as many consumers as possible. More consumers → More usage pattern and data → More informed decisions as to the future of the business I would rather facilitate building a community and an audience where I can potentially make $0.30 per month from a base of 1,000,000 as compared to charging $3/mo for a consumer base of 100,000 — even though the effective revenue being generated in both cases is . paying EXACTLY THE SAME WHY? Because it is easier to grow 1,000,000 to 2,000,000 for a free product than it is to grow 100,000 to 200,000 for a paid one. THE OLA CITATION Bhavish would be the right guy to answer this question, and maybe some early investors of Ola, but let me try to take a stab here. I think the biggest and most common question that Ola would have had to face when they started their operations would have been circling around the potential, the need. Does the market for such a service even exist? Or is the ‘ ’ already saturated? cab space If I remember right, Ola launched in 2010 — almost three years before Uber entered India. The cab market could have been segregated primarily in two categories at that time: — Meru Cabs, Mega Cabs being the two major players. The major usecase scenario for these services could be tracked back to pickups and drops from and to the airports respectively. The cabs were plying within the city as well, but the frequency with which you will spot one was quite low. A difficult and tedious booking process, a long wait time requisite ( ), and the perceived expensive nature could be cited as the three reasons behind the lack of mass usage. The radio taxis You had to book the cab a couple of hours before you wanted to travel — Primary usecase scenarios: (a) Urgent, unforeseen circumstances, (b) Long travel, (c.)Outstation trips, (d) Hourly packages (4 hrs, 8hrs). So there was no mainstream usage with the kind of frequency that an aspiring unicorn would want. The unorganised sector Naturally when Ola would have argued its case, its comparison would have been made to the first category — the radio taxis. A segment in which Meru was a clear leader. There had been attempts by newcomers to overthrow Meru off of its pedestal, but to no avail. And even though meru was making good money — largely owing to its leadership position, the year on year growth was not something that would put a twinkle in your eyes. So the natural questions would have been: Is there room ( ) for yet another radio taxi? and opportunity Isn’t the market already achieving its saturation point? Can Ola be thought of as a replacement ( ) for the unorganised sector? And even if that is the case, the frequency usage is still low. So where is the cherry? or a superceding layer The best way to address these concerns? Go up against them and prove the hypotheses you had started with. Hence the call center. Quick to implement, relatively cheaper, real time data. Oh. And Ola would have been called a taxi company itself. It has taken them years and years of effort ( ) to even begin to position themselves as a tech/product company, and even after all this — they are still largely perceived off as a taxi company. Ola and Uber both THE THING ABOUT MVPs AND VCs Let me just state the obvious. Startups need the external capital. This is not always true, but has been so for a good majority of them. But they need money to scale, and not to lay the foundations. The sooner this distinction becomes clear, the more clearly we can think on what the foundation should look like. VCs invest — with conviction — when as a business you can demonstrate having arrived at a connect with your consumers. No. I am not talking about product market fit. That end of the rainbow is still miles away. I am talking about having a product that consumers love ( ), or hitting all the right notes by how you present your product in front of consumers. Often, it will be just the first one, but if you add the second one to the mix as well, you are the kind of business VCs would kill for. solving a need Both are important. A good product presented poorly may be received ridiculously. That is why MVP becomes important. To show that you’ve got the pulse right. The product can change, the business model can change. Getting the pulse right has got more to do with the macro-vision. So. Don’t be so rigid on how the MVP should look like. You don’t even know what your product will look like in 5 years from now. Ola certainly didn’t! Foodiebay didn’t even know it would be calling itself in 5 years. Focus on the right questions, channel your energy in the right direction. Zomato **[OPTIONAL READ]** SOME NOTES FROM MY PERSONAL USAGE OF OLA A lot had changed by 2012, when I first used the service. But it was nowhere close to what it is today. They did have an app though. Btw. It would be interesting to note here that at this stage, at least in Bengaluru, Ola was more expensive than Meru. Meru’s per km rates were Rs.18, Ola’s Rs. 21 ( ). Yet I used Ola more frequently. As much as a few times every week. If I remember the rates correct WHY? — The booking process was simple. Location based. One click. No more filling up the complete address like you needed to on Meru. There were no cab types as you see today. The idea was simple. Get a cab at the click of a button. Simplicity — There was just one button. “Pick me up”There was no scheduling a cab for later option at all. You booked a cab, and the cab would be there within mins. Now that’s convenient. Quick gratification — One of the biggest perils with radio taxis was the night time charges. 25% over and above your normal bill. Ola had one flat rate — . So while it was more expensive than Meru in the morning, for nighttime usage, it was coming off as just a shade cheaper. And for any person with an active social life, night time cab usage is always the one with more utility. So, Ola stuck in my head. No night prices ALWAYS The points are actually mentioned in descending order of priority. Yes! The price element was not even the most critical one for me. The simplicity and instant nature of it was what won me over. LIKE THE STORY? SHARE WITH A FRIEND! Getting in touch is easy. I am available on , . I write on Medium, but I guess that you already knew. I also have a account. :-) Twitter Facebook, Quora, LinkedIn mail Have fun! Let’s chat. Humans, bots — really doesn’t make much difference to me.

..[cont.] The MVP Saga

Building a data scraping application is common for many developers, especially in fields where data collection, analysis, and storage are crucial. Using the Puppeteer, Node.js, and PostgreSQL trio is an excellent approach. is a great choice for this task. It allows you to control a headless browser, which is crucial for scraping dynamic websites. Many websites now use JavaScript to load content, and Puppeteer enables you to interact with and scrape this dynamic content. Puppeteer is well-suited for building scalable and efficient server-side applications. It's non-blocking and event-driven, making it a good fit for handling concurrent requests in a scraping application. Node.js will handle the backend of the data-scraping application. Node.js Storing the scraped data for the app will be handled by because it supports complex queries and indexing, which makes it suitable for storing and retrieving scraped data efficiently. PostgreSQL is a PaaS provider that aids the secure deployment of applications. It also provides database management services, with PostgreSQL being one of its supported databases. Hence, this project will use the managed PostgreSQL service provided by Aptible. Aptible In this tutorial, you'll discover how to build a data-scraping application using Puppeteer, Node.js, PostgreSQL, and Aptible. The application will scrape data from a popular movie streaming app, Netflix, and store it in a PostgreSQL database managed by Aptible. Prerequisites To follow along with this tutorial, you will need the following: A node version of 16.13.2 or greater is installed on your machine. You can install it by following the instructions on the . official Node.js website An Aptible account. Visit the to sign up. Aptible website A fundamental understanding of JavaScript and Node.js. Setting up the project To get started, create a new directory for the project and initialize a new Node.js project in it by running the following commands: mkdir web-scraper
cd web-scraper
npm init -y This will create a file for you with the following output: package.json Wrote to /home/user/web-scraper/package.json:

{
  "name": "web-scraper",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
} Installing dependencies To install the dependencies for the project, run the following command: npm install puppeteer pg dotenv This will install the necessary packages, which are Puppeteer, Node-postgres, and dotenv. Creating the database For the PostgreSQL database, you will use the managed database service on Aptible. To do this, follow the steps below: Log in to your Aptible account and create a new environment. Navigate to the new environment and click on > . Databases New Database Click on the dropdown menu and select . This will create a new PostgreSQL database for you. PostgreSQL 16 Input the Database Handle and click on to create the database. New Database This will provision a new PostgreSQL database for you. You can view the database by clicking the tab on the left menu. Databases Creating a database endpoint To connect to the PostgreSQL database, you will need to create a database endpoint. To do this, follow the steps below: Navigate to the database you created and click on > . Endpoints New Endpoint Include an IP address in the field. This will allow you to connect to the database from your local machine. IP Allowlist After the endpoint has finished provisioning, click on the tab. ConnectionURL Click on the button to copy the connection URL. You will need this to connect to the database. show Create the scraper script. This scraper script will scrape data from Netflix and store it in the PostgreSQL database. To create the script, create a new file named in the root of the project directory and add the following code to it: scraper.js const puppeteer = require("puppeteer");
const { Client } = require("pg");
require("dotenv").config(); The code above imports the necessary packages and loads the environment variables from the file. .env Below is a breakdown of the packages imported: : A headless browser automation library for Node.js used for web scraping. puppeteer : Part of the pg library, a PostgreSQL client for Node.js. Client : A library for loading environment variables from a file, used to load database credentials. dotenv Next, add the following code to the file: scraper.js async function run() {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();

  // Navigate to the website you want to scrape
  await page.goto("https://netflix.com/");

  // Extract data from the page
  const data = await page.evaluate(() => {
    const title = document.querySelector("h1").innerText;
    const url = window.location.href;

    return { title, url };
  });

  // Close the browser
  await browser.close();

  return data;
} The code above creates a function named which will be used to scrape data from the Netflix website. run A brief explanation of the code above: is an asynchronous function that launches a headless browser using Puppeteer. run It opens a new page, navigates to , extracts data (title and URL) from the page using a function provided to , and then close the browser. https://netflix.com/ page.evaluate The extracted data is returned as an object. Next, add the following code to the file: scraper.js async function saveToDatabase(data) {
  const client = new Client({
    connectionString: process.env.DATABASE_URL,
    ssl: { rejectUnauthorized: false },
  });

  try {
    await client.connect();

    // Check if the table exists, and create it if not
    const createTableQuery = `
      CREATE TABLE IF NOT EXISTS scraped_data (
        id SERIAL PRIMARY KEY,
        title TEXT,
        url TEXT
      );
    `;
    await client.query(createTableQuery);

    // Insert data into the database
    const insertQuery = "INSERT INTO scraped_data (title, url) VALUES ($1, $2)";
    const values = [data.title, data.url];
    await client.query(insertQuery, values);
  } finally {
    await client.end();
  }
} The code above creates a function named which will be used to save the scraped data to the PostgreSQL database. saveToDatabase A brief explanation of the code above: is an asynchronous function that connects to the PostgreSQL database using the credentials in the environment variable. saveToDatabase DATABASE_URL It checks if the table exists and creates it if it doesn't. scraped_data It then inserts the scraped data into the database using an SQL query. Next, add the following code to the file: scraper.js (async () => {
  try {
    const scrapedData = await run();
    console.log("Scraped Data:", scrapedData);

    // Save data to the database
    await saveToDatabase(scrapedData);
    console.log("Data saved to the database.");
  } catch (error) {
    console.error("Error during scraping:", error);
  }
})(); The code above calls the function to scrape data from the Netflix website and then call the function to save the scraped data to the PostgreSQL database. run saveToDatabase A brief explanation of the code above: This immediately invoked function expression (IIFE) executes the scraping and database saving process. It catches any errors that occur during scraping or database operations and logs them. If successful, it logs the scraped data and a success message. All together, the file should look like this: scraper.js const puppeteer = require("puppeteer");
const { Client } = require("pg");
require("dotenv").config();

async function run() {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();

  // Navigate to the website you want to scrape
  await page.goto("https://netflix.com/");

  // Extract data from the page
  const data = await page.evaluate(() => {
    const title = document.querySelector("h1").innerText;
    const url = window.location.href;

    return { title, url };
  });

  // Close the browser
  await browser.close();

  return data;
}

async function saveToDatabase(data) {
  const client = new Client({
    connectionString: process.env.DATABASE_URL,
    ssl: { rejectUnauthorized: false },
  });

  try {
    await client.connect();

    // Check if the table exists, and create it if not
    const createTableQuery = `
      CREATE TABLE IF NOT EXISTS scraped_data (
        id SERIAL PRIMARY KEY,
        title TEXT,
        url TEXT
      );
    `;
    await client.query(createTableQuery);

    // Insert data into the database
    const insertQuery = "INSERT INTO scraped_data (title, url) VALUES ($1, $2)";
    const values = [data.title, data.url];
    await client.query(insertQuery, values);
  } finally {
    await client.end();
  }
}

(async () => {
  try {
    const scrapedData = await run();
    console.log("Scraped Data:", scrapedData);

    // Save data to the database
    await saveToDatabase(scrapedData);
    console.log("Data saved to the database.");
  } catch (error) {
    console.error("Error during scraping:", error);
  }
})(); Creating a file .env The file will contain the database credentials. Create a new file named in the root of the project directory and add the following code to it: .env .env DATABASE_URL=postgres://<username>:<password>@<host>:<port>/<database> Replace the placeholders with the database credentials from the database endpoint you created earlier. Note: Running the scraper script To run the scraper script, run the following command: node scraper.js This will launch a headless browser, navigate to the Netflix website, scrape data from the page, and save the data to the PostgreSQL database on Aptible. You should see the following output: Scraped Data: {
  title: 'Unlimited movies, TV shows, and more',
  url: 'https://www.netflix.com/'
}
Data saved to the database. You can verify that the data was saved to the database by logging into the PostgreSQL database using the credentials from the database endpoint. You can do this by running the following command: psql <connection_url> Replace with the connection URL from the database endpoint. Note: <connection_url> Once you're logged in, you can list the tables in the database by running the following command: \dt You should see the table listed in the output: scraped_data List of relations
 Schema |     Name     | Type  |  Owner
--------+--------------+-------+---------
 public | scraped_data | table | aptible
(1 row) You can view the data in the table by running the following command: scraped_data SELECT * FROM scraped_data; You should see the scraped data listed in the output: id |                title                 |           url
----+--------------------------------------+--------------------------
  1 | Unlimited movies, TV shows, and more | https://www.netflix.com/
(1 row) Conclusion ​​In this tutorial, you learned how to create a data scrapping application using Puppeteer, Node.js, PostgreSQL, and Aptible. To enhance this project, consider adding more functionality to the scraper script. For instance, you can expand it to scrape data from multiple websites and store it in the database. Furthermore, you can extend the application by incorporating a frontend. This addition lets you visualize the scraped data in a web browser, enhancing the user experience.

Build a Data-Scraping App Using Puppeteer, Node.js, PostgreSQL and Aptible

Generative AI stands at the forefront of technology, embodying the pinnacle of machine creativity and innovation. This facet of artificial intelligence goes beyond mere data analysis, stepping into a realm where machines can generate new content that's comparable to, or in some cases, indistinguishable from that created by humans. The spectrum of its potential is vast and encompasses various industries, including art, music, healthcare, and even finance. It is the magic wand that can potentially turn abstract ideas into palpable visuals, create music, or even generate realistic human faces. The allure of Generative AI has spurred a significant surge in interest and investment in AI technologies. As we inch closer to a future where AI might become as ubiquitous as the internet, the importance of a solid educational foundation in this domain can't be overstated. For those keen on delving into the intricacies of Generative AI, embarking on an educational journey through reputable sources is imperative. Courses like the Artificial Intelligence Course provide a comprehensive overview of AI principles and applications, while the MIT AI Course into the advanced algorithms and techniques that drive generative models. These courses not only equip individuals with the knowledge to comprehend the mechanisms of Generative AI but also furnish a platform to contribute to a future where the interaction between machines and imagination will be commonplace. Through a blend of curiosity, education, and innovation, the horizon of what can be achieved with Generative AI is bound to expand, heralding a new era of technological advancement. dives deep Historical Background of Generative AI The trajectory of Generative AI has been fascinating, tracing back to the early inklings of machine learning. Here’s a concise chronicle of its evolution encapsulated in a table: Year Milestone 2006 Introduction of Restricted Boltzmann Machines (RBMs) 2014 Inception of Generative Adversarial Networks (GANs) by Ian Goodfellow 2016 Emergence of Variational Autoencoders (VAEs) 2018 Advancements in GANs leading to the creation of realistic human faces The journey commenced with the introduction of Restricted Boltzmann Machines (RBMs) in 2006, which laid the groundwork for more sophisticated generative models. The real breakthrough came in 2014 with Ian Goodfellow's invention of Generative Adversarial Networks (GANs), a novel framework that pitted two neural networks against each other to generate new, synthetic instances of data. The narrative of generative models was further enriched in 2016 with the emergence of Variational Autoencoders (VAEs), which brought about a more stable and controlled way of generating data. The timeline witnessed a significant milestone in 2018 when advancements in GANs led to the generation of realistic human faces, emblematic of the immense potential of Generative AI. Through these evolutionary strides, Generative AI has burgeoned from foundational models to a powerhouse of synthetic data generation, continually pushing the boundaries of what machines can create. Core Technologies and Algorithms At the heart of Generative AI lie robust algorithms and technologies that fuel the generation of new, unprecedented data. Among these, Generative Adversarial Networks (GANs) and Variational Autoencoders (VAEs) are the linchpins. Generative Adversarial Networks (GANs) operate on a dualistic framework where two neural networks, a generator and a discriminator, contest with each other. The generator creates new data instances while the discriminator evaluates them against real data. This adversarial process iteratively refines the generator's output, enabling the creation of highly realistic synthetic data. For instance, GANs are employed in creating realistic imagery, as seen in the generation of artificial faces or artwork. On the other hand, Variational Autoencoders (VAEs) are probabilistic models that generate new data by learning and approximating the data distribution of the input. They are vital in scenarios where controlled generation is imperative, such as in drug discovery, where creating molecular structures requires a defined set of parameters. Other pivotal algorithms include Transformer models like GPT-3, which have shown prowess in text generation, creating coherent and contextually relevant text based on given prompts. Delving deep into these core technologies requires a solid educational grounding. an Artificial Intelligence Course can provide the requisite knowledge and hands-on experience. These courses offer a deep dive into the underlying principles, algorithms, and applications of Generative AI, furnishing a profound understanding that is essential for anyone aspiring to explore or work in this exhilarating field of artificial intelligence. Through rigorous coursework and practical applications, individuals can grasp the mechanics of these algorithms and their real-world implications, preparing them for a future where they can contribute to the burgeoning landscape of Generative AI. Pursuing Current Applications of Generative AI Generative AI has carved out a significant niche across a myriad of fields, proving to be a catalyst for innovation and enhancement. Generative AI plays a critical role in data augmentation in technical domains, which is pivotal in training robust machine learning models. For instance, in medical imaging, Generative AI helps augment datasets by generating synthetic medical images, aiding in better disease diagnosis. The realm of art has witnessed a renaissance with the advent of Generative AI. Algorithms like GANs have been used to create new artworks, exemplified by the project "Next Rembrandt," which generated a new painting in the style of the legendary artist Rembrandt by analyzing his existing body of work. The music industry, too, has been touched by the wand of Generative AI. OpenAI's MuseNet is a testament to this, as it can generate musical compositions in various styles, spanning multiple instruments. Its ability to create harmonies that resonate with human emotions showcases the prowess of Generative AI in music creation. Generative AI's foray into the gaming industry has also been noteworthy. It aids in creating realistic textures, environments, and characters, enhancing the gaming experience manifold. Games like 'Minecraft' have utilized GANs to generate realistic texture packs, illustrating the potential of Generative AI in creating immersive gaming environments. Furthermore, Generative AI has made strides in voice synthesis and natural language processing. Tools like Descript's Overdub and OpenAI’s GPT-3 have revolutionized content creation and text generation, making the processes more efficient and creative. These applications underline the versatility and potential of Generative AI in not only augmenting existing fields but also in paving the way for new avenues of exploration and creativity. Through a blend of technology and imagination, Generative AI continues to redefine the boundaries of what's possible across a wide spectrum of disciplines. Future Prospects of Generative AI The horizon of Generative AI is continuously expanding, promising a future replete with groundbreaking advancements across various domains. In the sphere of drug discovery, Generative AI is poised to play a pivotal role. By generating molecular structures that could potentially be new drug candidates, it accelerates the traditionally long and arduous process of drug development. For instance, generative models can help identify novel compounds with desired properties, significantly reducing the time and resources required to bring new treatments to market. Climate modeling is another area where Generative AI can have a profound impact. By generating realistic simulations of climate scenarios, it aids researchers in understanding and predicting climate change dynamics. This, in turn, can guide policy-making and planning, contributing to a more sustainable future. Moreover, Generative AI holds promise in automating and enhancing design processes in fields like architecture and engineering. By generating design proposals based on specified criteria it can foster creativity and efficiency, facilitating the realization of innovative and optimized designs. In the realm of education, Generative AI could customize learning materials to cater to individual needs and preferences, thus personalizing education. It could generate practice problems, essays, or interactive lessons, enhancing the learning experience. Furthermore, Generative AI can contribute to enhancing cybersecurity by generating scenarios to test and bolster security systems against a myriad of threats. By simulating cyber-attacks, it helps in identifying vulnerabilities and fortifying security infrastructures. The burgeoning capabilities of Generative AI herald a future where its applications could be transformative. From healthcare to environmental sustainability and from design innovation to personalized education, Generative AI is set to be a cornerstone of technological advancements, propelling society into an era of unprecedented innovation and problem-solving. Ethical Implications The ascent of Generative AI is not without ethical quandaries, with deepfakes being a glaring exemplar. Deepfakes, fabricated videos generated using GANs, can create realistic-looking footage of real individuals saying or doing things they never did. Another notable example of deepfake technology being misused is the case of a deepfake video that went viral in 2020 featuring the Belgian Prime Minister Sophie Wilmès. In the fabricated video, the Prime Minister appeared to state that the country had decided to combat the climate crisis by committing to a bold ecological agenda, including the decision to collaborate with the fictional 'BLUR' initiative. The video was actually created by the Extinction Rebellion Belgium group to raise awareness about climate change and to prompt action from the government. This scenario underscored the potential of deepfakes to spread misinformation and potentially influence public opinion or governmental actions, albeit with the intention of promoting a social cause in this particular instance. Aside from deepfakes, Generative AI can perpetuate biases present in the training data, leading to discriminatory or prejudiced outcomes. Moreover, the potential misuse in generating synthetic data could infringe on privacy rights and intellectual property. Mitigating these challenges necessitates a multi-faceted approach. Technological solutions like better detection algorithms can help identify deepfakes and other synthetic media. Legal frameworks need to evolve to address the new kinds of misuse that Generative AI enables, ensuring accountability and protection against malicious use. Moreover, promoting transparency and ethical practices in AI development and deployment is imperative. Education plays a crucial role in ethical AI usage. Artificial Intelligence Course delves into the ethical dimensions of AI, equipping individuals with the knowledge to navigate the moral landscape of Generative AI. Through a combination of technological innovation, legal reform, and ethical education, the adversities posed by Generative AI can be significantly mitigated, steering its development toward a more responsible and beneficial trajectory. Wrapping Up Generative AI encapsulates a realm of endless possibilities, poised to significantly alter the landscape of numerous industries. From revamping creative domains like art and music and augmenting technical fields through data generation to potentially accelerating life-saving drug discoveries, its potential is both profound and far-reaching. However, as we tread further into the expanses of Generative AI, the ethical implications demand meticulous attention and scrutiny. The advent of deepfakes and the potential perpetuation of biases underscore the necessity for responsible innovation and robust legal frameworks. Education emerges as a cornerstone in navigating the complexities and harnessing the potential of Generative AI responsibly. Through comprehensive courses, individuals can attain a deep understanding of both the technological and ethical facets of Generative AI. Armed with knowledge, aspiring innovators can contribute to a future where Generative AI serves as a catalyst for positive transformation while mitigating risks and ethical quandaries. As we stand on the cusp of a future intertwined with Generative AI, fostering a culture of ethical awareness, continuous learning, and responsible innovation is imperative. It is through such a balanced approach that the promise of Generative AI can be fully realized, ushering in a new epoch of technological advancement and societal betterment.

Generative AI: What Does the Future Look Like?

As of this week, I’ve officially accepted a role and started a new chapter as a Product Manager - and I’m super excited. The journey to this pivotal moment was nothing short of exhilarating, marked by challenges, growth, and a whole lot (I really mean a lot) of learning. Today, I’m thrilled to unveil the story of how I made the leap from a SaaS sales background to a - no filter, just pure insights. Product Role Embracing "No" as a Catalyst for Innovation: Hearing "no" can be as important as hearing "yes" in product development - and that rings true to landing a role in Product. This is an uber challenging role to get, given it has so many facets and transferable skills are abundant. “NO” challenges us to rethink, refine, and innovate. It encourages us to focus on what truly matters and prioritize effectively - and that’s how I managed my application pipeline. Every no was an opportunity to iterate on my strategy & resume. It was akin to a check-in, a 1:1, albeit slightly demoralizing at times. Mastering the Art of Technical Skills: One of the most pivotal aspects of my transformation was delving deep into the technical realm. SQL, , and JavaScript became my trusted companions. With SQL, I could dissect complex datasets, unraveling patterns that guided our product strategies. Python empowered me to automate tasks, freeing up valuable time for strategic thinking. JavaScript, on the other hand, allowed me to create interactive prototypes, bringing ideas to life in a tangible way. These skills weren’t just tools; they were keys that unlocked doors to innovative product development. Python The Power of User-Centric Thinking: Remember when I mentioned transferable skills? Being deeply rooted in the world of sales had its advantages. Initially, I thought my skills and my goals were poles apart. It turns out that through sales, I understood our users’ pain points intimately, empathizing with their challenges. This empathy became the cornerstone of my . I delved into the intricacies of user research, conducting in-depth interviews and usability tests. These interactions weren’t mere data points; they were stories that painted a vivid picture of our users’ experiences. Armed with this profound understanding, I could craft products that not only met but exceeded our users’ expectations. product management philosophy Hustling with Side Projects: Here’s a Gen Z secret: We thrive on side hustles. I took my passion projects seriously. Whether it was redesigning a clunky app interface or brainstorming a new e-commerce feature, these side gigs showcased my creativity and problem-solving skills. I took on product development at my sales job; I built out two bilingual markets in two vastly different B2B platforms. Put yourself out there and position yourself as a subject matter expert, EVEN if your title does not encompass that job function. Get Real with User Research: Sure, we've all heard about user research, but let’s talk real talk. I didn’t just stop at surveys and focus groups. I immersed myself in the world of users - which was easier due to working in sales. I went where they went, talked like they talked, and felt what they felt. This deep dive into their lives gave me insights that no amount of data crunching could provide. Product Management is all about understanding human behavior, and this unconventional approach got me noticed. Words of Wisdom for Aspiring Product Managers: To my fellow of product management, I offer you this advice: embrace the unknown with open arms. Every unfamiliar territory is a chance to learn something new. Invest time in mastering technical skills; they are your ticket to decoding the language of technology. But don’t forget that the heart of product management lies in . Dive deep into the psyche of your users, empathize with their struggles, and celebrate their victories. Let their stories fuel your innovation. Gen Zers aspiring to make a mark in the world understanding people Surround yourself with a supportive community of like-minded individuals. Seek mentorship, ask questions, and never shy away from admitting what you don’t know. The product management landscape is vast, but with curiosity as your guide and resilience as your armor, you can navigate its intricacies with finesse.

My Journey to Product Manager: From Sales Top Performer to PM

Even with the multitude of libraries available today, it can sometimes be challenging to find one that offers the specific functionality needed for a particular task. Instead of spending time searching for the perfect library, I recommend crafting your own implementation; even if it's tailored specifically for one project. Once, I found myself in need of a library that could easily convert data classes into an Excel document for report generation. When I couldn't locate a suitable library, I decided to develop functionality tailored to my specific needs. My ambition was to design a library akin to Jackson, which would use annotations to transform a list of data classes into an Excel document as dictated by the annotations. I want to share the library I created, hoping it may benefit others or inspire them to create their own mapper for their unique tasks. Let's explore how to develop in Java such a data mapper to achieve this: from this: void demoReport() {
    var excelMapper = new ExcelMapperImpl();

    var fileName = "demo-out-" + LocalTime.now() + ".xlsx";
    List<Demo> demos = generateDemos();

    try (Workbook workbook = excelMapper.createWorkbookFromObject(demos);
         var fileOutputStream = new FileOutputStream(fileName)) {
        workbook.write(fileOutputStream);
    }
} Defining Annotations Let's identify the main elements essential for Excel mapping. At its core, we require an Excel column. This foundational component of the report should distinctly showcase the column name and the corresponding value in each row. Moreover, we must incorporate support for formula cells, allowing us to utilize values and present the results dynamically. At the column's end, a concluding formula is essential, whether it represents an average, sum, or any other pertinent metric for the end-user. Beyond mere data cells, we should also integrate features to easily manage cell styling. After identifying the essential elements, the next step is to craft the necessary annotations. The initial annotation will embed metadata about cell styling. This annotation will encompass fundamental attributes along with their default values: @Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcelStyle {
    ExcelColumnDataFormat cellTypePattern() default ExcelColumnDataFormat.NONE;
    IndexedColors cellColor() default IndexedColors.AUTOMATIC;

    boolean isWrapText() default false;

    boolean isCentreAlignment() default false;

    boolean isFramed() default true;

    ExcelColumnFont fontName() default ExcelColumnFont.DEFAULT;

    short fontSize() default -1;

    boolean isFontBold() default false;

    ExcelColumnCellTextColor fontColor() default ExcelColumnCellTextColor.AUTOMATIC;
} The primary style elements crucial for report creation are conveyed as attributes. Following this, the initiation of an Excel column annotation can be undertaken: @Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcel {
    String[] applyNames() default {};

    int position();

    ColumnExcelStyle headerStyle() default @ColumnExcelStyle(
            fontColor = ExcelColumnCellTextColor.BLACK,
            isCentreAlignment = true,
            isFontBold = true,
            fontSize = 14,
            isWrapText = true);

    ColumnExcelStyle cellStyle() default @ColumnExcelStyle;
} This annotation encompasses potential column names (for mapping from Excel) and a mandatory field - ' '. This will determine the column's placement and be instrumental in formula calculations. Additionally, it will detail the style of both the header and the cell. position Excellent. Now, let's formulate an annotation specific to Excel formulas. Anticipating a dynamic formula contingent on the row's position, this annotation will be exclusive to methods: @Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcelFormula {
    String name() default "";

    int position();

    ColumnExcelStyle headerStyle() default @ColumnExcelStyle(
            fontColor = ExcelColumnCellTextColor.BLACK,
            isCentreAlignment = true,
            isFontBold = true,
            fontSize = 14,
            isWrapText = true);

    ColumnExcelStyle cellStyle() default @ColumnExcelStyle;
} Lastly, let’s introduce an annotation for the culminating formula, which typically occupies the final row in Excel, summarizing or illustrating the cumulative result for a column. Given that the formula's annotation also mandates its applicability solely to methods: @Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcelTotalFormula {
    boolean useValue() default false;

    int position();

    ColumnExcelStyle cellStyle() default @ColumnExcelStyle;
} Building an Excel Reporting Service With Apache POI After the creation of all necessary annotations, crafting a service class becomes the next step. The core library utilized will be , effective for working with .xls and .xlsx files. This class will use annotations’ attributes to generate an Excel report. Apache POI The primary method accepts a list of objects as input and returns a prepared workbook. For added flexibility, an overloaded method will be introduced to enable the specification of both the file name and the sheet name for report generation: <T> Workbook createWorkbookFromObject(List<T> reportObjects) {
    return createWorkbookFromObject(reportObjects, 0, "Report");
}

<T> Workbook createWorkbookFromObject(List<T> reportObjects, 
                                      int startRowNumber, 
                                      String sheetName) {
...
} To extract information about the class using reflection, any element from the array is selected. After accessing the class details, the first row can be established. Utilizing data from the annotation allows for the creation of cells with their respective names. If a name is absent, the class field's name can serve as an alternative: private <T> void createHeaderFromDeclaredExcelColumns(Row row, Class<T> clazz, PropertyDescriptor propertyDescriptor) {
    try {
        Field field = clazz.getDeclaredField(propertyDescriptor.getName());

        ColumnExcel columnExcel = field.getDeclaredAnnotation(ColumnExcel.class);
        if (nonNull(columnExcel)) {
            String headerName = columnExcel.applyNames().length > 0 ? columnExcel.applyNames()[0] : field.getName();
            createHeader(row, columnExcel.position(), headerName, columnExcel.headerStyle());
        }
    } catch (NoSuchFieldException e) {
        log.debug(e.getLocalizedMessage());
    }
} When fashioning the header, remember to assign a style to every cell. Style parameters can be derived from the annotation: @ColumnExcelStyle private void createHeader(Row row, int position, String name, ColumnExcelStyle columnExcelStyle) {
    Cell cell = row.createCell(position);
    cell.setCellValue(name);

    setCellFormatting(cell, columnExcelStyle);
    row.getSheet().autoSizeColumn(cell.getColumnIndex());
} The process then turns to generating rows in the report based on data from the provided array. By iterating over the data, successive rows are formed: for (T report : reportObjects) {
    Row bodyRow = sheet.createRow(proceedRowNumber);
    createCellsFromDeclaredExcelColumns(bodyRow, report);
    proceedRowNumber++;
} Property descriptors are procured to utilize getters instead of granting direct access to fields: private <T> void createCellsFromDeclaredExcelColumns(Row row, T tObject) {
    try {
        PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(tObject.getClass()).getPropertyDescriptors();

        for (var propertyDescriptor : propertyDescriptors) {
            createCellFromDeclaredExcelColumns(row, tObject, propertyDescriptor);
        }
    } catch (IntrospectionException ex) {
        log.debug(ex.getLocalizedMessage());
    }
} With the property descriptor, a cell is formed: private <T> void createCellFromDeclaredExcelColumns(Row row, T tObject, PropertyDescriptor propertyDescriptor) {
    try {
        Field field = tObject.getClass().getDeclaredField(propertyDescriptor.getName());
        Method readMethod = propertyDescriptor.getReadMethod();

        ColumnExcel columnExcel = field.getDeclaredAnnotation(ColumnExcel.class);
        if (nonNull(columnExcel)) {
            Class<?> returnType = readMethod.getReturnType();
            Cell cell = row.createCell(columnExcel.position());

            Object invokeResult = readMethod.invoke(tObject);
            if (nonNull(invokeResult)) {
                defineAndAssignCellValue(returnType, cell, invokeResult, readMethod);
            }
            setCellFormatting(cell, columnExcel.cellStyle());
        }
    } catch (NoSuchFieldException | InvocationTargetException | IllegalAccessException e) {
        log.debug(e.getLocalizedMessage());
    }
} Next, let’s turn our attention to processing the annotations. Crafting formulas proves slightly more complex than simply extracting a value from a field. A method is expected to generate a formula, which is subsequently assigned to the cell. @ColumnExcelFormula The method should consistently return a string and accept the row number as an argument, ensuring accurate data usage from adjacent cells. Thus, it falls on the handler to verify these conditions are met before forming the cell with the specified formula: private <T> void createCellFromDeclaredExcelFormula(Row row, T tObject, Method readMethod) throws IllegalAccessException, InvocationTargetException {
    ColumnExcelFormula columnExcelFormula = readMethod.getDeclaredAnnotation(ColumnExcelFormula.class);
    if (columnExcelFormula != null) {
        Class<?> returnType = readMethod.getReturnType();
        Cell cell = row.createCell(columnExcelFormula.position());

        if (returnType.isAssignableFrom(String.class)) {
            cell.setCellFormula((String) readMethod.invoke(tObject, row.getRowNum()));
        } else {
            log.debug(" Return type for the method: " + readMethod.getName() + " with @ColumnExcelFormula annotation has to be String " +
                    "and now it's: " + returnType.getName() + " method is ignored for the reason");
        }
        setCellFormatting(cell, columnExcelFormula.cellStyle());
    }
} The final step involves creating a row to display the concluding results. Importantly, this row should be generated only once, irrespective of the number of objects relayed to the handler. An annotation in a static method is anticipated for this purpose. This method receives both the number of the initial row and the current row where the cell will be instantiated as arguments. Provision of the initial row's number is vital, enabling the method to devise a formula that leverages the aggregate result for the entire column: private <T> void createTotalFormula(Class<T> tClazz, Row row, int firstRowNum) {
    Method[] methods = tClazz.getDeclaredMethods();
    for (Method method : methods) {
        ColumnExcelTotalFormula columnExcelTotalFormula = method.getAnnotation(ColumnExcelTotalFormula.class);
        if (columnExcelTotalFormula != null
                && method.getReturnType().isAssignableFrom(String.class)
                && method.getParameters().length == 2
                && Modifier.isStatic(method.getModifiers())
                && !Modifier.isPrivate(method.getModifiers())
        ) {
            String cellFormula = (String) method.invoke(tClazz, firstRowNum, row.getRowNum());
            Cell cell = row.createCell(columnExcelTotalFormula.position());
            cell.setCellFormula(cellFormula);

            if (columnExcelTotalFormula.useValue()) {
                cell = applyFormulasValue(cell);
            }
            setCellFormatting(cell, columnExcelTotalFormula.cellStyle());
        }
    }
} Making a Report The main functionality is now in place, and it's time to see it in action. Let's construct a simple report to demonstrate its operation. For this, let’s create a ' ' class and incorporate all the necessary annotations: Sales @Data
@Accessors(chain = true)
public class Sales {

    @ColumnExcel(
            position = 0, applyNames = {"Date"},
            headerStyle = @ColumnExcelStyle(
                              fontColor = WHITE, 
                              cellColor = DARK_BLUE, 
                              isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                            cellColor = GREY_25_PERCENT, 
                            cellTypePattern = DATE))
    private LocalDate date;

    @ColumnExcel(
            position = 1, applyNames = {"Sold"},
            headerStyle = @ColumnExcelStyle(
                            fontColor = WHITE, 
                            cellColor = DARK_BLUE, 
                            isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                          cellColor = GREY_25_PERCENT))
    private Integer sold;

    @ColumnExcel(
            position = 2, 
            applyNames = {"Price Per Unit (USD)"},
            headerStyle = @ColumnExcelStyle(
                            fontColor = WHITE, 
                            cellColor = DARK_BLUE, 
                            isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                          cellColor = GREY_25_PERCENT, 
                          cellTypePattern = USD))
    private Double pricePerUnit;

    @ColumnExcelFormula(
            position = 3, 
            name = "Total Sales (USD)",
            headerStyle = @ColumnExcelStyle(
                             fontColor = WHITE, 
                             cellColor = DARK_BLUE, 
                             isCentreAlignment = true),
            cellStyle = @ColumnExcelStyle(
                            cellColor = GREY_25_PERCENT, 
                            cellTypePattern = USD))
    public String sales(int rowNum) {
        return new CellAddress(rowNum, 1).formatAsString()
                + "*"
                + new CellAddress(rowNum, 2).formatAsString();
    }

    @ColumnExcelTotalFormula(
            position = 0,
            cellStyle = @ColumnExcelStyle(
                           cellColor = LIGHT_BLUE))
    public static String total(int firstRowNum, int lastRowNum) {
        return "CONCATENATE(\"Total\")";
    }

    @ColumnExcelTotalFormula(
            position = 1,
            cellStyle = @ColumnExcelStyle(
                          cellColor = LIGHT_BLUE))
    public static String unitsSold(int firstRowNum, int lastRowNum) {
        return "SUM(" + new CellAddress(firstRowNum, 1).formatAsString() + ":"
                + new CellAddress(lastRowNum - 1, 1).formatAsString() + ")";
    }


    @ColumnExcelTotalFormula(
            position = 3,
            cellStyle = @ColumnExcelStyle(
                          isCentreAlignment = false, 
                          cellColor = LIGHT_BLUE, 
                          cellTypePattern = USD))
    public static String totalSales(int firstRowNum, int lastRowNum) {
        return "SUM(" + new CellAddress(firstRowNum, 3).formatAsString() + ":"
                + new CellAddress(lastRowNum - 1, 3).formatAsString() + ")";
    }
} The class comprises three fields: , , and . Additionally, it has a sales formula and a concluding line with the totals: and . The fields utilize the annotation, denoting the column's position and name. date sold pricePerUnit unitsSold totalSales @ColumnExcel The annotation defines the style for both the header and individual data cells: @ColumnExcelStyle @ColumnExcel(
        position = 0, 
        applyNames = {"Date"},
        headerStyle = @ColumnExcelStyle(
                          fontColor = WHITE, 
                          cellColor = DARK_BLUE, 
                          isCentreAlignment = true),
        cellStyle = @ColumnExcelStyle(
                          cellColor = GREY_25_PERCENT, 
                          cellTypePattern = DATE)
) As previously discussed, when creating a formula, the method must accept a parameter indicating the row number. This requirement is evident in the method's signature: public String sales(int rowNum) {
        return new CellAddress(rowNum, 1).formatAsString()
                + "*"
                + new CellAddress(rowNum, 2).formatAsString();
    } Given the row number and column indices, crafting any specific formula becomes feasible. Within the class, methods intended for the concluding formulas are static and require two parameters: the starting row's number and the ending row's number: public static String unitsSold(int firstRowNum, int lastRowNum) {
        return "SUM(" + 
                new CellAddress(firstRowNum, 1).formatAsString() + 
                ":" + 
                new CellAddress(lastRowNum - 1, 1).formatAsString() + 
                ")";
    } Now, let's launch the method: void salesReport() {
    var excelMapper = new ExcelMapperImpl();

    var fileName = "sales-out-" + LocalTime.now() + ".xlsx";
    List<Sales> sales = List.of(
                new Sales().setDate(LocalDate.of(2023, 1, 1))
                        .setSold(50)
                        .setPricePerUnit(10d),
                new Sales().setDate(LocalDate.of(2023, 1, 2))
                        .setSold(40)
                        .setPricePerUnit(11d),
                new Sales().setDate(LocalDate.of(2023, 1, 3))
                        .setSold(55)
                        .setPricePerUnit(9d);

    try (Workbook workbook = excelMapper.createWorkbookFromObject(sales);
         var fileOutputStream = new FileOutputStream(fileName)) {
        workbook.write(fileOutputStream);
    }
} And examine the generated report: Conclusion Writing a specialized library for a specific task proved to be straightforward. The library crafted meets the requirements and includes the planned functionality. The approach utilizing annotations facilitates quick and convenient customization of cell styles, modification of formulas, and dynamic report creation from varied data sources. Hence, the next time a suitable library is elusive, considering the development of a personalized one might be beneficial. Naturally, presenting every line of code in this article was not feasible; thus, only the primary methods essential to the mapper's operation were highlighted. The complete code is available on my . GitHub page

From Data Classes to Excel: Building a Java Mapper With Annotations

ডেটা ক্লাস থেকে এক্সেল পর্যন্ত: টীকা সহ একটি জাভা ম্যাপার তৈরি করা

Von Datenklassen bis Excel: Erstellen eines Java-Mappers mit Anmerkungen

De clases de datos a Excel: creación de un asignador de Java con anotaciones

Des classes de données à Excel : créer un mappeur Java avec des annotations

डेटा क्लास से एक्सेल तक: एनोटेशन के साथ जावा मैपर का निर्माण

データ クラスから Excel へ: 注釈を備えた Java マッパーの構築

데이터 클래스에서 Excel까지: 주석을 사용하여 Java 매퍼 구축

Das classes de dados ao Excel: construindo um mapeador Java com anotações

От классов данных к Excel: создание Java Mapper с аннотациями

Veri Sınıflarından Excel'e: Ek Açıklamalarla Java Eşleyici Oluşturma

Từ các lớp dữ liệu đến Excel: Xây dựng trình ánh xạ Java bằng chú thích

从数据类到 Excel：使用注释构建 Java 映射器

In the digital age, data became an invaluable resource for companies to make informed decisions and set their strategies. Simultaneously, while product management was once seen as a nice-to-have, it is now essential in managing the production, delivery, and betterment of products. However, product management is set to be replaced by "data product leadership," which will be the principal influencer in modern data organizations. The Rise of Product Management In digital businesses, product managers hold significant influence, actively driving strategy and curating products to address customer needs. As a result, it's no surprise that product management is beginning to shift away from the CIO/CTO's purview and secure a place within the C-suite as a full-fledged member of the executive team. However, even as this shift is occurring, the core skills that defined the product manager's role over the past decade are quickly becoming outdated. Product management has gained its current notoriety by focusing obsessively on UX design. Product managers have curated these skills over decades of designing online tools, social media platforms, mobile apps, and internal business systems, all meticulously engineered for efficiency. This focus has produced legions of product managers obsessed with user experience, fostering a tendency to view a product solely in terms of what appears on a screen and what it takes to get there. Locked-up Data Unfortunately, deadlines and pressure often force product managers focused on UX to take shortcuts that result in use-case-locked data, giving them significant challenges in retooling for alternative applications. They struggle not only with the effective utilization of their existing data but also with their ability to respond quickly and effectively to new opportunities, particularly in the realm of AI innovation. Use case-locked data can severely limit a company's ability to harness the full potential of that data. This constraint not only impedes swift decision-making, crucial for maintaining a competitive edge in today's rapid business environment but also confines data to a single use case. This is limiting the data's potential for broader application. A dashboard designed for marketing insights, for instance, might not be suitable for financial analysis or product development and especially not suitable for AI. AI algorithms require clean, structured data to function effectively and produce accurate insights. Without this, the implementation of AI can become a challenging, time-consuming, and costly process. Moreover, as AI continues to evolve and its potential applications broaden, companies with unstructured or chaotic data will find themselves ill-prepared to seize new AI-driven opportunities that emerge. These opportunities could range from improving operational efficiency and enhancing customer experience to creating innovative new products and services. Data Products & Data Product Leadership Enter data products. A data product transforms raw data into a format that enables decision-making or action. Unlike interfaces that merely present data curated to a specific use case, data products are designed from scratch to meet multiple use cases. In contrast to an interface-driven approach, a data product-driven approach liberates data from these restrictions, making it available for multiple use cases. By focusing on structuring and organizing data effectively, businesses can ensure that the same dataset can be used for a variety of purposes - from driving AI products, powering interfaces, and informing strategic decisions to sharing with integration partners, thus maximizing the value derived from the data. The leadership of your Data Product should ideally be entrusted to your Data Product Leader (DPL). You might wonder, isn't the DPL simply the role of a data engineer or a data architect? The answer is more intricate than it first appears. While the skills of a data engineer or data architect are indeed crucial for creating data products, their role is not identical to that of a DPL, in fact, it's not dissimilar to how an engineer's role differs from a product manager. The DPL plays a unique role, acting as a bridge between data engineering and customer use cases. They are tasked with anticipating the needs of internal and external customers, even before these needs arise, and considering the data requirements and architecture necessary to support those needs. Just as a Product Manager oversees the delivery of the product to the end client, the DPL manages the data assets that the Product Manager uses to create their interfaces. In essence, the DPL's role extends beyond mere data structuring; they ensure that the data assets are effectively leveraged to meet customer needs and drive product success. DPL vs Product Manager A common question that arises in this context is: Who holds the responsibility for setting the product strategy - the Data Product Lead (DPL) or the Product Manager? The answer is nuanced. Both the DPL and the Product Manager share the responsibility of understanding customer needs. However, the DPL has an additional layer of responsibility. They must comprehend not only the needs of the customers but also the requirements of other facets of the business. This includes understanding the needs of business partners and internal stakeholders. Moreover, the DPL is also responsible for determining how the data product aligns with and meets the needs of all product managers within the organization. In essence, while both roles play a crucial part in shaping the product strategy, the DPL has a broader scope of responsibilities, encompassing various internal and external needs related to the data product. The good news is that two decades of intense focus on User Experience (UX) and back-end systems by product managers have made the construction of APIs and interfaces more straightforward than ever. A well-managed data product can swiftly be transformed into an interface and made readily available to customers. This contributes to enhanced business flexibility and promotes more agile practices. The DPL oversees the creation, management, and strategic direction of data products. They play a vital role in shaping the data strategy, which has far-reaching implications for the entire organization. As such, it becomes important to empower them in the organization by placing them in a senior role. Depending on the organization, some may have a DPL leading product teams, and others may place a preference on putting the DPL in the Chief Data Office. Regardless, the DPL should be empowered to shape data product strategy and held accountable to the executive team. Finding Your Data Product Leader Data Product Leadership is a relatively new field; as such, finding a qualified and experienced Data Product Leaders can be a challenging task. However, there are viable alternatives for sourcing talent for this pivotal role. Product Managers often possess a wealth of relevant skills and experiences that can be valuable in the role of a Data Product Leader. They typically understand the product lifecycle, have experience working with cross-functional teams, and are adept at aligning product strategies with business goals. If they also have a strong affinity for data and are willing to deepen their knowledge in this area, Product Managers can make a successful transition to becoming Data Product Leaders. Data Architects have a deep understanding of how to structure, integrate, and maintain data. They are skilled in designing data systems that are scalable, reliable, and secure. These technical skills, combined with a broader understanding of business strategy and user needs, can make them effective Data Product Managers. Data Engineers have hands-on experience in managing and manipulating large datasets. They are familiar with various data technologies and understand the technical challenges involved in building data products. If they can complement these technical skills with strategic thinking and user-centric design, Data Engineers can also transition successfully to the role of Data Product Manager. With the right training and support, these professionals can evolve into effective Data Product Leaders, driving the organization's data strategy forward. Conclusion As we navigate the data-driven landscape of the 21st century, it's clear that traditional product management roles, while still valuable, are becoming less equipped to meet the evolving needs of modern businesses. The focus on UX design and functionality, while important, often results in data being locked into specific use-cases, limiting its potential for broader applications. As businesses continue to generate and rely on increasingly complex and voluminous data, this approach is proving insufficient. Enter the era of Data Product Leadership. As the custodians of data assets, Data Product Leaders (DPL) are uniquely positioned to bridge the gap between data engineering and customer use cases. They not only anticipate and meet the needs of customers but also consider the data requirements and architecture necessary to support these needs. Their role extends beyond data structuring to ensure that data assets are effectively leveraged to meet customer needs and drive product success. As the influence of traditional product management wanes, the rise of Data Product Leadership signals a pivotal shift in the business landscape. This transition underscores the growing recognition of data as a crucial business asset and the need for specialized roles to manage and leverage this asset effectively. This shift isn't just about staying current; it's about paving the way for the future of modern data organizations – a future where actionable insights are at everyone's fingertips, driving faster, smarter decisions that propel businesses forward. For any product individual eager to build efficient modern data organizations, embracing this shift is no longer an option but a necessity.

Goodbye Product Management -  Hello Data Product Leadership

গুডবাই প্রোডাক্ট ম্যানেজমেন্ট - হ্যালো ডেটা প্রোডাক্ট লিডারশিপ

Auf Wiedersehen Produktmanagement – Hallo Datenproduktführung

Adiós Gestión de productos - Hola Liderazgo de productos de datos

Adieu la gestion des produits - Bonjour le leadership des produits de données

अलविदा उत्पाद प्रबंधन - नमस्ते डेटा उत्पाद नेतृत्व

さようなら、製品管理 - こんにちは、データ製品リーダーシップ

상품관리 안녕 - 헬로데이터 상품리더십

Adeus gerenciamento de produtos - Olá liderança de produtos de dados

Elveda Ürün Yönetimi - Merhaba Veri Ürün Liderliği

Tạm biệt Quản lý Sản phẩm - Xin chào Lãnh đạo Sản phẩm Dữ liệu

再见产品管理 - 你好数据产品领导力

Last week my friend asked for help with coding a Telegram bot for the VIP 😏 customers of his herbs shop. The requirements of the said bot were: Pre-registration required Automatic welcome message Menu and sub-menus with buttons Confirm and clean order At the end of the order delete the chat menu Ok, get to work!! What we need Telegram account [ ] ChatID from the customers that are going to be allowed to use the bot. [ ] Server with a public IP with the following installed [ ] python3 [ ] pip3 [ ] python-telegram-bot [ ] telegram_menu [ ] Telegram configuration Create a bot in telegram, using BotFather /newbot, and take note of the API token and store it safely If you need to regenerate a token for an old bot, use BotFather /token Set privacy for the bot, using BotFather /setprivacy Avoid the bot to be added to a group, using BotFather /setjoingroups Get chat id On the search bar look for @myidbot, this is a public bot that returns the id of your account or group. You’ll need every user to do this and share their id. Server side In this case, once the users are pre-registered, we need access to the db, txt, json, file or however you want to store the customer data. For ease I will use json here [
    {
        "name": "Albus",
        "chatid": 142347567,
        "phone": 1234567890,
        "Address": "12 Grimmauld Place"
    },
    {
        "name": "Bob",
        "chatid": 123456789
        "phone": 1234567891,
        "Address": "124 Conch St., Bikini Bottom, Pacific Ocean"
    },
    {
        "name": "Crush",
        "chatid": 987654321
        "phone": 1234567892,
        "Address": "Sherman, 42 Wallaby Way, Sydney."
    }
] Now we have all we need to set up the server using python Let’s import libraries import telegram
from telegram.ext.updater import Updater
from telegram.ext.callbackcontext import CallbackContext
from telegram.update import Update
from telegram.ext.commandhandler import CommandHandler
from telegram.ext.messagehandler import MessageHandler
from telegram.ext.filters import Filters
from telegram.ext import CommandHandler, CallbackQueryHandler
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Updater, CommandHandler, CallbackQueryHandler
from functools import wraps
import asyncio
import json
import csv
import numpy as np Define variables ############################ Initialize bot and updater #########################################
API_TOKEN = '' #change the API key for your bot
updater = Updater(API_TOKEN, use_context=True)
dispatcher = updater.dispatcher

############################ Initialize  global variables #########################################
sub_options = [
    [
        ["💐Bouquet", "🪷Flowers - Bouquet added to the order"],
        ["🎍Basket", "🪷Flowers - Basket added to the order"]
    ],
    [
        ["🌱Seeds", "🌿Herbs - Seeds added to the order"],
        ["🪴Potted", "🌿Herbs - Potted added to the order"]
    ]
]

order = []
List_of_users = []
clear_message ="Order cleared" Limit access def allowed_users():
    fileObject = open("list.json", "r") #list of users that can use the bot 
    jsonContent = fileObject.read()
    Users_List = json.loads(jsonContent)

    for i in range(len(Users_List)):
        List_of_users.append(Users_List[i]['chatid'])

allowed_users()

def restricted(func):
    @wraps(func)
    def wrapped(update, context, *args, **kwargs):
        user_id = update.effective_user.id
        if user_id not in List_of_users:
            print(f"Unauthorized access denied for {user_id}.")
            return
        return func(update, context, *args, **kwargs)
    return wrapped
@restricted Commands definition: Here are listed the commands that the user will be able to execute ############################ Command definition #########################################

def start(update, context):
    reply_markup = main_menu_keyboard()
    message = context.bot.send_message(chat_id=update.effective_chat.id, text="Welcome! Please select a category from the menu below, or type /help", reply_markup=reply_markup)
    context.user_data['messages'] = [message.message_id]

def confirm(update, context):
    message = "Current order: "
    for o in order:
        message += o + " "
    update.message.reply_text(message)# comment this if you dont want to keep the order on the chat
    order.append(str(update.effective_user.id ))
    save_to_csv(order)
    global clear_message
    clear_message= 'Thanks, bye'
    clear(update, context)

def clear(update, context):
    context.bot.send_message(chat_id=update.effective_chat.id,text=clear_message)
    context.bot.delete_message(chat_id=update.message.chat_id, message_id=context.user_data['messages'][-1])
    context.bot.delete_message(chat_id=update.message.chat_id, message_id=context.user_data['messages'][-2])

def help(update, context):
    message = "List of available commands: \n"
    message += "/start - Welcome message with options \n"
    message += "/confirm - Confirm and send order \n"
    message += "/clear - Clear order \n"
    message += "/help - List of available commands"
    update.message.reply_text(message) Menus and keyboard definition I did the sub menu recursive because in practical a store doesn’t have only 2 categories with 2 products, so this could save time writing a lot of keyboards functions ############################ Menu definition #########################################

#basic menu
def main_menu_keyboard():
    keyboard = [[InlineKeyboardButton("Flowers", callback_data='1'),
                 InlineKeyboardButton("Herbs", callback_data='2')]]
    return InlineKeyboardMarkup(keyboard)

def main_menu(update, context):
  query = update.callback_query
  query.answer()
  query.edit_message_text(
                        text="Please select a product or type /help",
                        reply_markup=main_menu_keyboard())

#recursive menu based on the sub_options matrix
def sub_menu(update, context, sub_menu_num):
    query = update.callback_query
    keyboard = []
    query = update.callback_query
    for i in range(len(sub_options[sub_menu_num])):
        keyboard.append([InlineKeyboardButton(sub_options[sub_menu_num][i][0], callback_data=f'{sub_menu_num+1}-{i+1}')])
    keyboard.append([InlineKeyboardButton("Return to main menu", callback_data='main')])
    reply_markup = InlineKeyboardMarkup(keyboard)
    query.edit_message_text(text="Please select a product, the type /confirm to send your order or /clear to restart", reply_markup=reply_markup) Menu options ############################ Handle menu options #########################################

def button(update, context):
    query = update.callback_query
    if query.data == '1':
        sub_menu(update,context, 0)
    elif query.data == '2':
        sub_menu(update,context, 1)
    elif query.data == "main":
        main_menu(update,context)    
    else:
        sub_menu_num,sub_option_num = [int(x) for x in query.data.split("-")]
        query.answer(sub_options[sub_menu_num-1][sub_option_num-1][1]) #send a notification but not a message in the chat
        order.append(sub_options[sub_menu_num-1][sub_option_num-1][0]) Handlers ############################# Handle Commands #########################################
        
start_handler = CommandHandler('start', start)
dispatcher.add_handler(start_handler)

confirm_handler = CommandHandler('confirm', confirm)
dispatcher.add_handler(confirm_handler)

help_handler = CommandHandler('help', help)
dispatcher.add_handler(help_handler)

clear_handler = CommandHandler('clear', clear)
dispatcher.add_handler(clear_handler)

dispatcher.add_handler(CallbackQueryHandler(main_menu, pattern='main'))

callback_handler = CallbackQueryHandler(button)
dispatcher.add_handler(callback_handler) Start bot ############################# Start the bot #########################################
updater.start_polling() Save order to csv To keep all the orders, I’ll use a simple csv file ############################# Save to csv #########################################
def save_to_csv(options):
    with open("sample.csv", "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["New order"])
        for option in options:
            writer.writerow([option]) Finally let’s put all together import telegram
from telegram.ext.updater import Updater
from telegram.ext.callbackcontext import CallbackContext
from telegram.update import Update
from telegram.ext.commandhandler import CommandHandler
from telegram.ext.messagehandler import MessageHandler
from telegram.ext.filters import Filters
from telegram.ext import CommandHandler, CallbackQueryHandler
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Updater, CommandHandler, CallbackQueryHandler
from functools import wraps
import asyncio
import json
import csv
import numpy as np

############################ Initialize bot and updater #########################################
API_TOKEN = '' #change the API key for your bot
updater = Updater(API_TOKEN, use_context=True)
dispatcher = updater.dispatcher

############################ Initialize  global variables #########################################
sub_options = [
    [
        ["💐Bouquet", "🪷Flowers - Bouquet added to the order"],
        ["🎍Basket", "🪷Flowers - Basket added to the order"]
    ],
    [
        ["🌱Seeds", "🌿Herbs - Seeds added to the order"],
        ["🪴Potted", "🌿Herbs - Potted added to the order"]
    ]
]

order = []
List_of_users = []
clear_message ="Order cleared"

############################ Limit access #########################################

def allowed_users():
    fileObject = open("list.json", "r") #list of users that can use the bot
    jsonContent = fileObject.read()
    Users_List = json.loads(jsonContent)

    for i in range(len(Users_List)):
        List_of_users.append(Users_List[i]['chatid'])

allowed_users()

def restricted(func):
    @wraps(func)
    def wrapped(update, context, *args, **kwargs):
        user_id = update.effective_user.id
        if user_id not in List_of_users:
            print(f"Unauthorized access denied for {user_id}.")
            return
        #return await func(update, context, *args, **kwargs)
        return func(update, context, *args, **kwargs)
    return wrapped
@restricted

############################ Command definition #########################################

def start(update, context):
    reply_markup = main_menu_keyboard()
    message = context.bot.send_message(chat_id=update.effective_chat.id, text="Welcome! Please select a category from the menu below, or type /help", reply_markup=reply_markup)
    context.user_data['messages'] = [message.message_id]

def confirm(update, context):
    message = "Current order: "
    for o in order:
        message += o + " "
    update.message.reply_text(message) # comment this if you dont want to keep the order on the chat
    order.append(str(update.effective_user.id ))
    save_to_csv(order)
    global clear_message
    clear_message= 'Thanks, bye'
    clear(update, context)

def clear(update, context):
    context.bot.send_message(chat_id=update.effective_chat.id,text=clear_message)
    context.bot.delete_message(chat_id=update.message.chat_id, message_id=context.user_data['messages'][-1])
    context.bot.delete_message(chat_id=update.message.chat_id, message_id=context.user_data['messages'][-2])

def help(update, context):
    message = "List of available commands: \n"
    message += "/start - Welcome message with options \n"
    message += "/confirm - Confirm and send order \n"
    message += "/clear - Clear order \n"
    message += "/help - List of available commands"
    update.message.reply_text(message)

############################ Menu definition #########################################

def main_menu_keyboard():
    keyboard = [[InlineKeyboardButton("Flowers", callback_data='1'),
                 InlineKeyboardButton("Herbs", callback_data='2')]]
    return InlineKeyboardMarkup(keyboard)

def main_menu(update, context):
  query = update.callback_query
  query.answer()
  query.edit_message_text(
                        text="Please select a product or type /help",
                        reply_markup=main_menu_keyboard())

def sub_menu(update, context, sub_menu_num):
    query = update.callback_query
    keyboard = []
    query = update.callback_query
    for i in range(len(sub_options[sub_menu_num])):
        keyboard.append([InlineKeyboardButton(sub_options[sub_menu_num][i][0], callback_data=f'{sub_menu_num+1}-{i+1}')])
    keyboard.append([InlineKeyboardButton("Return to main menu", callback_data='main')])
    reply_markup = InlineKeyboardMarkup(keyboard)
    query.edit_message_text(text="Please select a product, the type /confirm to send your order or /clear to restart", reply_markup=reply_markup)

############################ Handle menu options #########################################

def button(update, context):
    query = update.callback_query
    if query.data == '1':
#        context.user_data['messages'].append(message.message_id)
        sub_menu(update,context, 0)
    elif query.data == '2':
#        context.user_data['messages'].append(message.message_id)
        sub_menu(update,context, 1)
    elif query.data == "main":
#        context.user_data['messages'].append(message.message_id)
        main_menu(update,context)    
    else:
        #context.user_data['messages'].append(context.message.message_id)
        sub_menu_num,sub_option_num = [int(x) for x in query.data.split("-")]
        query.answer(sub_options[sub_menu_num-1][sub_option_num-1][1])
        order.append(sub_options[sub_menu_num-1][sub_option_num-1][0])

############################# Handle Commands #########################################
        
start_handler = CommandHandler('start', start)
dispatcher.add_handler(start_handler)

confirm_handler = CommandHandler('confirm', confirm)
dispatcher.add_handler(confirm_handler)

help_handler = CommandHandler('help', help)
dispatcher.add_handler(help_handler)

clear_handler = CommandHandler('clear', clear)
dispatcher.add_handler(clear_handler)

dispatcher.add_handler(CallbackQueryHandler(main_menu, pattern='main'))

callback_handler = CallbackQueryHandler(button)
dispatcher.add_handler(callback_handler)

############################# Start the bot #########################################
updater.start_polling()

############################# Save to csv #########################################
def save_to_csv(options):
    with open("sample.csv", "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["New order"])
        for option in options:
            writer.writerow([option]) Now let’s review the wishes list Pre-registration required - Completed on step 3 Automatic welcome message - Completed on step 4 /start Menu with buttons - Completed on step 5,6, Confirm and clean order - Completed on step 4 /confirm and /clear At the end of the order delete the chat menu- Completed on step 4  /clear That’s all for today, hope you enjoyed and find it useful for similar requests

Creating a Telegram Bot for my Friend's Business

MERU DATA

merudata.com

-- employees

Since n.d.

COMPANY RANKING

MERU DATA

EVERGREEN INDEX #6900

Representing this company? Click here to claim and customize this page!

Meru Data WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

MERU DATA

merudata.com

-- employees

Since n.d.

COMPANY RANKING

MERU DATA

EVERGREEN INDEX #6900

RELATED COMPANIESRANK

STORIES ABOUT MERU DATA

Representing this company? Click here to claim and customize this page!

Meru Data WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!