Best match

Most recent

Facebook is the number one target for scammers, with three out of four websites imitating the platform, new research finds. Read more about Facebook is the number one target for scammers, with three out of four websites imitating the platform, new research ...

Cybernews Team

cybernews

Get the most recent info and news about Docuten on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Soluciones sencillas de factura electrónica, firma digital y voto electrónico. Creadores de Hazteunafacturae.com y signedoc.com, también realizamos integraciones con ERP.

Docuten

HackerNoon Reporter: Please tell us briefly about your  background. I studied Computer Engineering at the University of A Coruña in Spain and spent several years working at different digital signature and electronic invoicing companies like TB Solutions, SERES, and Invinet before starting my own company. What's your startup called? And in a sentence or two, what does it do? Docuten transforms clients into paperless companies by digitally transforming administrative processes through digital signature, and issuing and receiving electronic invoices. By relying on Docuten as their sole provider, companies can reduce costs by 50% and implementation can be carried out 2.5 times faster than working with several different providers. What is the origin story? After working at a number of digital signature and e-invoicing companies, I saw a need in the market to simplify and streamline digital administrative processes that were often made overly complex. I partnered with my colleague Ángel Aparicio and launched Docuten in 2009 (formerly under the name Enxendra). Over the years, our venture has grown. We now have offices in A Coruña and Madrid, and a rapidly expanding team of more than 35 employees. Our product suite has also evolved to include digital signature, and e-invoicing issuance and reception. What do you love about your team, and why are you the ones to solve this problem? The diversity! Docuten is a super diverse, multi-talented team of individuals from all over that bring different perspectives and approaches to our work. The majority of us have years of experience in our area of expertise and are eager to give our clients the best service possible. Why do clients trust us to improve their administrative processes? There are some big players in the digital signature and e-invoicing markets, but we offer bundled solutions for end-to-end administration digitalisation with first-rate support and customer service. If you weren’t building your startup, what would you be doing? The truth is I can't imagine following another path in life. At the moment, how do you measure success? What are your core metrics? I measure success by two interconnected metrics: client and employee satisfaction. Companies with content employees thrive, and clients can feel that. The goal is to ensure that your clients are happy with the service you are providing, and to have a team that is excited to be at work every day. Our Annual Recurring Revenue growth is demonstrative of a high level of client satisfaction:  between 2019 and 2020 Docuten had a 38% growth in ARR. Last year, we brought in 75% more clients that bill over 3000€ annually. With that type of upsurge, we are predicting even more growth in 2021. In fact, this year Docuten has a 72% increase in billing as compared to the same period in 2020; as of July 2021, our ARR is 1.585.945€. What’s most exciting about your traction to date? What’s been most exciting is expanding our client base into different sectors and getting to learn more about (and address the challenges of) diverse industries. We currently have a strong foothold in the industrial sector as well as in construction, but have clients across the board: in fashion, renting, hospitality, food, etc. Docuten also serves a variety of different departments like HR, legal, sales, and finance. Our growing knowledge about these distinct industries and business areas has proven to be invaluable in providing the best service possible to our clients. What technologies are you currently most excited about, and most worried about? And why? In the world of administrative digitalisation, I think OCR technology is pretty exciting. Docuten offers various means for our clients to receive invoices from vendors. Unfortunately, some vendors are less enthusiastic about having to send invoices electronically. That is where our OCR technology comes in. Vendors can easily send invoices in PDF format as an email attachment to the client’s Docuten mailbox. Our OCR reader receives the information from the PDF invoice, structures it, and indexes it directly in the client’s systems. Our OCR technology has a 99.6% accuracy! Alternatively, some advances (especially at the intersection of medicine and technology) bring certain socio-cultural implications that could prove controversial, which is worrisome. What drew you to get published on HackerNoon? What do you like most about our platform? It is important to keep your finger on the pulse of the newest technologies and innovations out there. HackerNoon is a great way to connect to tech professionals all over the world and learn about exciting up-and-coming startups. We are honored to have Docuten nominated as one of HackerNoon’s Startups of the Year alongside other leading companies. What advice would you give to the 21-year-old version of yourself? Believe in yourself and never give up. It might sound cliché but it’s so important to have faith in your ideas and abilities. Also, surround yourself with great people. Docuten wouldn’t be where it is today without our amazing team. What is something surprising you've learned this year that your contemporaries would benefit from knowing? Remote work is the future. I’m obviously not the only one who has come to this conclusion after the events of last year, but it’s worth highlighting. Our entire team has been working remotely since March of 2020. More recently, as restrictions have been lifted, some employees have returned to the office​. Due to the nature of our work, as well as the fact that Docuten has offices in various locations and remote work policies were in place prior to the pandemic, it has been a smooth transition to a digital workplace. Docuten’s product suite has also enabled the majority of our clients to continue working during this period since transactions that were traditionally done on paper and/or in-person can now be handled remotely and electronically. Our services have been crucial for many of the companies we work with. Docuten was nominated as in Startups of the Year hosted by HackerNoon. Go vote for them! one of the best startups in A Coruña

"Companies With Content Employees Thrive, And Clients Can Feel That", Brais Méndez, Docuten CEO

At the intersection of digital transformation and artificial intelligence (AI) lies intelligent document processing (IDP), a burgeoning category of AI. in automating the processing of voluminous unstructured data, revolutionizing various industries globally. This technology is quickly becoming indispensable IDP utilizes , deep learning, and expert systems to scrupulously analyze, categorize, and glean relevant data from unstructured documents. machine learning To comprehend what advanced document understanding implies, we must first delve into the nature of AI.  It is an intricate field, encompassing dynamic content suggestions on social platforms, self-driving automobiles, and generative AI like .  AI can respond to written prompts, solve mathematical problems, and even interpret images. ChatGPT In terms of types, AI is typically categorized into machine learning, deep learning, and . expert systems Machine learning empowers computers to learn without explicit programming, such as Snapchat and . TikTok's interactive filters Deep learning, as seen in , handles more complex patterns and datasets, while expert systems mimic human expert decision-making, scaling up human-level decision-making. Google’s MetNet-2 neural network The use of AI has been skyrocketing, with businesses the use of AI capabilities in 2023.  The most common applications include automating processes through robotics, computer vision, and natural language text understanding.  AI benefits businesses and governments by enhancing efficiency, productivity, speed, and accuracy. expected to double However, incorporating AI into operations calls for careful steps, including defining business needs, setting short-term goals, evaluating business capabilities, preparing data, and starting small. An example of an effective AI solution is Lazarus AI's RikAI platform, a next-gen IDP tool.  This platform deftly handles data extraction from any document, demonstrating the power of advanced document understanding. In essence, advanced document understanding is the embodiment of AI's potential in revolutionizing data processing, improving decision-making, and accelerating efficiency.  As AI continues to evolve, businesses are urged to embrace these innovative tools to stay ahead of the curve.

Unraveling the Intricacies of Intelligent Document Processing

How are you, hacker?
🪐 has got you covered with fresh content from our top 5 stories of the day, every day at noon your local time! Set email preference . What's happening in tech this week: The Noonification by HackerNoon here Lets Write a Video Codec - Part 3: Still Images By [ 13 Min read ]
In this part of the series, we apply the DCT to real images and explore the concept of quantization. Coincidentally, JPEG operates in the same manner. @petertech Read More. How to Add Closed Captions (CC) to Amazon IVS Live Streams By [ 4 Min read ]
Use of OBS plugin to convert speech to text and publish that text as caption data on an Amazon IVS live stream. @amazonivs Read More. Effective Techniques for Debugging Network Connectivity Issues in Mobile Apps By [ 6 Min read ]
Master network debugging for mobile apps. Troubleshoot connectivity issues, enhance performance and improve user experience. @ivyhackwell Read More. Watch Web 2.5 Documentary Trailer By [ 1 Min read ]
Web 2.5 is a Documentary Film by HackerNoon.com. The film was directed by Quang Nong, produced by Trang Dao, and features the HackerNoon team. 🧑‍💻 What happened in your world this week?It's been said that , , . Feeling stuck? We got you covered ⬇️⬇️⬇️ We hope you enjoy this worth of free reading material. Feel free to forward this email to a nerdy friend who'll love you for it.See you on Planet Internet! With love,
The Hacker Noon Team ✌️ @hackernoon Read More. writing can help consolidate technical knowledge establish credibility and contribute to emerging community standards ANSWER THESE GREATEST INTERVIEW QUESTIONS OF ALL TIME

The Noonification: Watch Web 2.5 Documentary Trailer (5/23/2023)

https://www.youtube.com/watch?v=NAi0TtyMX7w&embedable=true&transcript=true COMING SOON to Amazon Prime Video! by HackerNoon.com Web 2.5 Documentary Film Featuring the : David Smooke, Linh Dao Smooke, Kien Dao, Utsav Jaiswal, and Limarc Ambalina HackerNoon team Director: Quang Nong Producer: Trang Dao Director of Photography: Hoang Thao Editor: Marilyn Pham Featured Image, Kien’s drawing of the HackerNoon team

Watch Web 2.5 Documentary Trailer

Ver el tráiler del documental Web 2.5

Regarder la bande-annonce du documentaire Web 2.5

वेब 2.5 वृत्तचित्र ट्रेलर देखें

Web 2.5 ドキュメンタリー トレーラーを見る

Assista ao trailer do documentário Web 2.5

Xem Đoạn giới thiệu phim tài liệu về Web 2.5

观看 Web 2.5 纪录片预告片

How to Create Effective Frontend Design Documents

Let's learn about via these 62 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Documentation /Learn Repo 1. Tips For Winning a Proposal For Software Engineers Chances are if you're doing freelancing sooner or later you'll come across a need to write some kind of proposal to your potential customer. 2. The Red Death of Flutter Explanation of how Google's Flutter UI startup app was debugged and made to work again and connect with it's central Firebase Database through hours of work. 3. A Guide to Using Data Classes in Python In "C" Language, you have structs. With the help of structs, we can define the return data type. You can do the same using classes in python. 4. How to Make Documentation Easier to Read Let’s see how you can develop the skill of reading documentation! Most importantly, start by getting your answers from the documentation as you struggle. 5. Introduction to Great Expectations, an Open Source Data Science Tool This is the first completed webinar of our “Great Expectations 101” series. The goal of this webinar is to show you what it takes to deploy and run Great Expectations successfully. 6. Trust Signals in Open Source Projects Polish the trust signals of your open source project to increase your user base and grow your community. 7. Tips For Documenting Your Code Some will tell you that good code is self-documenting. In other words, if you write clear code then you won’t need comments. 8. Re: "Nerds Don’t Respond to Marketing" These are 13 --lightly edited-- response comments on how marketing to nerds requires a different approach. 9. An Easy README Makeover In 3 Simple Steps Oh yeah! We’re giving your README a makeover! 10. Autogenerate Your GraphQL Documentation With Magidoc Learn how to autogenerate GraphQL documentation with Magidoc. 11. Online Technical Documentation Is Almost Dead We waste so much time and energy searching for answers because online technical resources are bloated, lack simple examples, rarely improved and have bad UI/UX. 12. Why Programmers Struggle To Write Good Documentation For a programmer, proper documentation is a must-have. Its presence keeps track of the development process and later assists during the maintenance period. Successful documentation will make information accessible while providing limited users with entry points. It further helps new users learn quickly by simplifying the product and cut support costs as well. 13. The Code Is the Documentation; a Paradox That Rings True The first time I heard someone say: “the code is the documentation”, I thought it sounded completely wrong, like a lazy excuse for not producing documentation. 14. Devs - Documentation IS Important Should you write software documentation? This article covers best practices of writing docs in a team or as a solo engineer. 15. Auto-generation of Documentation for Event-driven Architecture Auto-generation of documentation for Event-driven architecture 16. How We Built Our Software Documentation On Docusaurus To cover our bases, we needed to improve and expand our documentation and this time, we wanted to make it scalable with Docusaurus. 17. Create, Edit and Manage Screenshots with Snagit 2021 How does the new version of Snagit help you create, edit, and manage screenshots, and is it worth upgrading from what you currently use? 18. Top Tips and Tricks For When You're Working with PDF Files Are you looking for PDF tips to ease your daily work? Read this article with all tips PDF users might need to achieve the results they want. 19. Use Comments to Unit Test Your Code [A How-To Guide] At Supabase we love writing as little code as possible, so we decided to combine our unit tests with same JSDoc comments that power VSCode's IntelliSense. 20. Rapid Way to Publish Python Docs With Free Hosting and Domain How to create a documentation website based on markdowns and also publish it on GitLab Pages. And as a bonus, how to get a free domain like my-project.py.wiki. 21. 'One of the most pervasive failures (of FTX) is the absence of lasting records of decision-making' FTX + SBF Chapter 11 Court Filing by John J. Ray III, Nov 17, 2022 is part of HackerNoon’s Legal PDF Series. Part 15/20: Information & Retention of Documents 22. Doc-as-Code: Managing Content is Easy When it’s Distributed Few months back, I got a call from GitLab for a technical writer position.
One of the question was about treating document as a code and what’s my
view on that. The question was about treating document as part of a
continuous integration and continuous deployment system. That question
came at the time when I wasn’t treating doc as code and ironically, I now have a perspective. 23. Beware of Documentation Management. A Techlead's Hell Loop. Software documentation can improve developer productivity a lot, but it has to be updated automatically and linked with the codebase which can be time consuming 24. Documenting GraphQL APIs The main reason for writing API documentation is to make your API understandable. For GraphQL there are many options. Both interactive and static documentation. 25. OpenAPI Specification v. 3+ Introduction Mental Checklist 26. Save Yourself the Headaches and Document Agreements the Right Way Agreements are an essential part of software development. They lower development costs and make developers' lives easier. But there is a problem.. 27. 6 Ways Digital Document Management Will Empower Your Business Where does your company fit with today’s paperless trend? If you’re yet to harness a fully digital business, you’re not alone. Research proves that organizations still struggle to reduce paper consumption. In fact, throughout 2023 and 2024, the paper output in the USA is expected to grow, which shows that workplace digitization is proceeding pretty slow. 28. Dealing with a Large Undocumented Codebase I was recently asked to answer the somewhat vague question, “How do you interact with a large undocumented code base?” 29. Demystifying Tech Debt: An Overview of the 4 Types with Actionable Fixes Learn how to manage technical debt in your codebase with this guide on the 4 types of tech debt, with examples. We'll look at how to fix each type of tech debt. 30. Why is the Documentation of Tech Products So Hard to Use? (in the User’s Point of View) Documenting tech products is a key part of making a project sustainable in the long term. Despite that, properly documenting them is incredibly difficult. 31. Software Development Knowledge Sharing Methods Are Broken: Here’s Why Knowledge sharing for engineerings team and software developers is broken. Consuming knowledge at the right time is the key to success. 32. How To Improve Your Software Documentation by Connecting Gitlab with Mkdocs Producing documentation may be painful and need a lot of time to write and operate. In this story, i will share with you, my way of generating docs using the devops approach. To make life easier, we will explore the art of automation 😃. 33. Digital Transformation in Banks – Role of Document Automation Document Automation is the perfect start to digital transformation. It offers a low-risk investment with immediate returns for banks. 34. The Power of Whitepapers: Ensuring Quality Control in the Crypto Industry One of the most pragmatic ways to implement quality control in crypto decision-making process is monitoring a project’s attention to detail in its whitepaper. 35. Setting Up Docs For An Open Source Project Doesn't Have To Be Hard This article describes how we set up docs for our open source project Saasform. Docs are part of the source code, so they're browsable and easy to maintain. Mor 36. Building a ChatGPT-Powered Markdown Documentation Learn to build markdown documentation with Chatgpt and the OpenAI API 37. How to Name Things Properly Perhaps it is not news to everyone that there are two hard things in Computer Science. 38. Why Does it Often Take Nearly a Month to Ship a Few Lines of Code? Ever wondered why it takes nearly a month to ship out a few lines of code change to the star and reliable customers of your company? When the changes made are formally aligned with the product, marketing and application managers, what stops it from being shipped immediately? Why do managers quote timelines for a maintenance release that seems so "unrealistic" to you? These were the thoughts that were going through my mind during my first few months of writing production-quality code. 39. How to Publish a Book with GitBook CLI and GitHub Pages in 7 Minutes Publishing a book or documentation online has never been easier than it is today. 40. How To Define The Good Documentation Skills When comparing products, you want to decide on their usefulness. Yet, we often forget to evaluate the project's documentation 41. Building a Strong Portfolio in the Early Stages of a Startup: Tips and Strategies A startup team may fail to deliver a product but should not fail to deliver a portfolio of value. 42. 5 reasons to ditch the paper and start document automation Document automation is here to stay. Your company needs to change today. Here's five reasons why. You'll make your clients happier, and your employees happier. 43. ...So I Ended up Making DocBrowser - An HTML Template for Documentation Recently I've been working on a couple of projects that required on-line documentation.  After looking at several existing templates and not finding any that were quite right for what was needed, I decided to take the time to build one. 44. Exercises on Dependency Injection in  ASP.NET: Introduction In this post, we will do some exercises to go over the basics of DI (Dependency Injection) in ASP.NET. 45. How To Generate API Blueprint using SwagGo Generating API blueprint REST API Golang using SwagGo tools 46. Remote Work: GitLab CTO Eric Johnson Shares 10 Tips to Make the Most of the New Normal Eric Johnson, the CTO of GitLab (a FULLY REMOTE company with 1500 employees) shares his tips on how to manage a fully remote team async across timezones. 47. Why Git Is A Great Documentation Management Tool Sometimes not only documentation but also the process of working on it may be critical. For example, in the case of projects, the lion’s share of the work is related to preparing documentation, and the wrong process may lead to errors and even loss of information, and, consequently, loss of time and benefits. But even if this topic is not central to your work, the right process can still improve the quality of the document and save you time. 48. Creating Beautiful Documentation Website For Your JavaScript Project Nowadays, as a webdeveloper, you rarely build anything from scratch: your daily job mostly consists of integrating various Javascript libraries together. If you are building a web app you are most likely going to use some framework like React, Vue or Angular for your front-end. To transmit and manage the data you will be using Redux or GraphQL. For the backend, there will be Express and probably Loopback. Then you need to cover everything with tests, so Jest, Mocha or Jasmine must be present too. Finally, there will be UI frameworks like Bootstrap and maybe some charting tools. I have already counted at least 7 core libraries and all of these are in a single project! And what about underlying technologies like Javascript itself, Node.js and, probably, Typescript? Well, that’s a lot! 49. Code as Documentation and Assessment Documenting IT networking lab procedures in code rather than word-processor documents enables more authentic, equitable and consistent assessment. 50. How to Solve Engineering Problems Using Scientific Method On every new software product, feature or project you develop you are bound to come across challenges that don’t have a clear answer at first. 51. How to Lose Developers and Alienate Users: 5 Ways Not to Write Docs I recently joined Jina AI, a startup focusing on neural search. One of the things that got me interested was their documentation — while not perfect, it’s straightforward, practical and easy-to-read. I wish that were just as true of every tech product out there. 52. My Takeaways After Attending Google Summer of Code 2019 This summer, my proposal got selected by Open Source Robotics Foundation for Google Summer of Code 2019. It was an awesome learning experience! 53. How to Initiate a Software Requirements Specification How many times have you felt that it would have been better to contemplate the project requirements? How many times did you feel like including that “one” particular feature/function could have saved it from failure? Hold on to the thought right there! Do you think a System Requirements Specification could have played a pivotal role in success? 54. Open Source Series: Documentation or answering the what and how questions 55. Part 1: Why Software Requirements In The Real World Are Hard This is the first in a series of posts about my experiences developing software in healthcare with my team over the last few years. For most of that time we’ve worked in eye care, with doctors and patients in major centres in Europe, North America and Australia, as well as with global life science companies, on projects aimed at improving care delivery and patient outcomes. 56. We Need to Talk About DX (Developer Experience) I want all involved in development to think about other users. Not about those who use your application to solve their problems. But those who extend your app, run it in production and integrate with other systems. About developers, operations, SREs and many others who make your business running. Those behind the curtains. I want you to think about the Developers Experience (DX). 57. How to Write API Documentation the Right Way API documentation is a critical part of any application's success. 58. 5 Software Documentation Tools That Make Managing Technical Documentation Easier Software documentation is an important step in the process of software development. These are the 5 tools that make the cut when it comes to functionality. 59. Why NPM and Yarn f*cking suck Opinion piece: What we can learn about documentation and logging 60. How I Use Notion to Manage My Relationship A list of reasons why you should try documenting your relationship on Notion 61. Readable Legal Documents Are No Longer a "Nice-to-Have" By writing your company’s privacy policy in a clear and structured way, you influence how privacy policies are written and designed in huge organizations. 62. How to Describe Your Technical Issue to Get Quick and Effective Help Documenting the issue before you ask for help will make everything so much more efficient. Thank you for checking out the 62 most read stories about Documentation on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

62 Stories To Learn About Documentation

PHP Classes Use Case for Database Management in a Document Builder

We're excited to announce that the official website for has launched! React Native Echarts We're constantly updating the site to provide you with the latest information about our project. On the website, you will find the complete documentation, edit demos online, and view solutions to common issues and other related information. New Logo And Design We've designed a logo that reflects our project's key features: efficiency, simplicity, and technology. The logo is based on a polar coordinate bar chart and has been transformed into a modern and technological style. Hope you like it! Building a Modern Document Website for React Native Library In addition to the website launch information, I will also describe how to build a modern documentation website. If you're interested in building a documentation website for your open-source project, this guide can be a great reference. Initialized with Docusaurus To build a modern documentation website, the first step is to use to initialize your project. Docusaurus provides a framework for building documentation websites quickly and easily. You can initialize your project with the following command. Docusaurus npx create-docusaurus@latest my-website classic --typescript For more information, please refer to . Docusaurus Getting Started Ember Expo Snack is an open-source platform for running React Native apps in the browser. If you are building a website for a React Native library, this is an excellent feature that helps developers easily try out and test their code without having to download anything locally. Expo Snack Integrating Snack in a Docusaurus project can be challenging. I refer to this and the source code at . issue react-native-website Integrating Snack involves the following steps. Write a remarkPlugins call . This plugin will visit all nodes with when compiling markdown files, and replace the node with a SnackPlayer . @react-native-website/remark-snackplayer code node.lang == 'SnackPlayer' div Write a client module call . This module listens for client-side events and call , at the appropriate time. snackPlayerInitializer initSnackPlayers updateSnacksTheme Modify the a configuration file , add to remarkPlugins, add to clientModules, and add to . docusaurus.config.js @react-native-website/remark-snackplayer snackPlayerInitializer https://snack.expo.dev/embed.js scripts In the file, define some styles for snack-player. src/css/custom.css Write code in a markdown file with a code block. SnackPlayer name=Hello%20World
import { Text } from 'react-native';
export default function() {
  return (
    <Text>Hello, world!</Text>
  );
} Now you have an online editor, like the one below. If you are interested in the implementation principles, you can take a look at our as well as . commit Including Snacks in your documentation Use a SnackPlayer Component Ember Expo Snack is cool, but sometimes I want to put the code in a tsx file and then import it to the article where I need it. In this way, my code is easier to edit and reusable. In addition to the online editor, we provide a SnackPlayer component that can be used like below. import SnackPlayer from '@site/src/components/SnackPlayer';
import SimpleLineChart from '!!raw-loader!@site/src/snippets/simple-line-chart/index.tsx';

<SnackPlayer name="Simple Line Chart">{SimpleLineChart}</SnackPlayer> Thanks to Webpack raw-loader, you can import any code file as raw text, and then insert it in a code block. This component is also very simple to implement, accepting snack-related props and code string, and turning them into SnackPlayer , refer to . div this commit You can now use @wuba/react-native-echarts online, . We plan to provide more use cases in the future. try it out now If you want to customize your own components, please refer to . By the way, if you just want to have a live editor for react, is a good choice. Using JSX in Markdown React Live Add Doc Search Algolia is a search engine that can be integrated into your Docusaurus project to provide fast and efficient search functionality for your documentation website. This feature helps users quickly and easily find the information they need. It's easy to integrate Algolia with Docusaurus. You can refer to for more information. Docusaurus Doc Search I18n Support With the increase of international users, supporting multiple languages is becoming increasingly important. Docusaurus provides i18n support to help you create a website that can be easily translated into different languages. Currently, we have only added 2 languages, Chinese and English, if you have other needs, please let us know. For more information, please refer to . Docusaurus i18n Show Github Contributes It's always important to give credit where credit is due. Showing the contributors of your project on your documentation website is a great way to acknowledge their hard work and dedication. We build a on and associate the team with the GitHub repository. react-native-echart team https://opencollective.com/ You can then get the contributor images for the project by assembling the following link: https://cdn.hackernoon.com/images/vJcrvKCc3hh6oCV6ujhOFQ6v9dN2-2023-03-29T13:34:07.603Z-clftqa8dv000r0bs6dt0sg2pl Thanks to the following contributors, if you want to join us, please feel free to submit a PR or issue. Deploying Your Website Use GitHub Pages to Deploys Deploying your website is an important step in making it accessible to the public. Docusaurus makes it easy to deploy your website using GitHub Pages. This is a fast and efficient way to get your website online quickly. For more information, please refer to . Docusaurus Deploying to GitHub Pages Increase Website Traffic Add Global Site Tag for Analytics To better understand how users interact with our website, we can use Google Analytics to track various metrics such as page views, bounce rates, and user demographics. To integrate Google Analytics with Docusaurus, you can use the plugin. @docusaurus/plugin-google-gtag For more information, please refer to . Docusaurus Google Analytics SEO Optimization Search engine optimization (SEO) is critical for ensuring that your documentation website is easily discoverable by search engines. Docusaurus provides a variety of tools and features that can help you optimize your website for SEO. For more information, please refer to . Docusaurus SEO Add Sitemap to Google Search Console A sitemap is a file that lists all the pages on our website and helps search engines like Google index our website more efficiently. By adding a sitemap to Google Search Console, we can help Google to discover and index all the pages on our website. Docusaurus comes with a built-in plugin for generating a sitemap. You can get the sitemap by visiting the /sitemap.xml page on your website. Every language has its sitemap, for example: https://wuba.github.io/react-native-echarts/sitemap.xml https://wuba.github.io/react-native-echarts/zh-Hans/sitemap.xml For more information, please refer to . Once the sitemap is generated, we can submit it to Google Search Console. Docusaurus Sitemap Summary In this article, we have shown you how to use Docusaurus to build a modern documentation website, as well as how to integrate common features such as online editing, document search, multi-language support, contributor display, and analytics. By following these steps, you can create a robust and user-friendly documentation website for your open-source project. Also, the source code of our website is located . here Also published . here

Building a Documentation Website for Your Open-source Project Using Docusaurus​

Storybook V2 Comic Book Builder: Part 2, The Document Generator

During my career, I’ve seen dozens of SRS documents for projects ranging in size using both agile and waterfall development methodologies. Some were better than others, but critically, I can now easily spot a good one from one that will get ignored. And if no one reads your SRS, you will be left with problems like conflicts in features, unrelated data, team members not understanding whether or not the feature they’re building aligns with what the product team has asked for, and the list goes on. Throughout this article, I will delve into what it takes to create one that will serve as a singular source of truth for your development process. An SRS that everyone involved in the process can refer to drive engineering decisions and create preliminary development tickets for the dev planning stage. Thus increasing the chances of successfully executing the technical part of your product. But first, I want to make a quick point on when you should (and should not) use one. Do You Really Need an SRS Document? The short answer to this question is: “Usually an early version of a startup product or MVP doesn’t consist of enough features to need an SRS Document” Thanks to lean and agile methodologies, two kids with little or no experience can literally build an app in their dorm room. This has caused a paradigm shift. Nowadays, startup teams get in the trenches, get hands-on and tend to leave processes like SRS documentation behind. Even here at Altar, we’ve helped more than a few founders build products that have gone on to raise millions ( ) without using an SRS document. We usually only use an SRS document on medium to large projects that consist of over 50 screens and more than two services, for example. like this company for example If you’re building a big product, keep reading, and I’ll take you through everything you need to write your SRS. If you’re building a standard MVP or the first iteration of your product, it may be enough to explain your product to your development team in terms of , epics, or using a BPMN diagram if you have one or high fidelity prototypes. product scope What Is a Software Requirements Specification (SRS) Document? The software requirements specification (SRS) is a document providing a detailed overview of your software product, purpose, requirements and features. A typical SRS document  includes: – including its intended audience, intended use & product scope. The purpose of your product – including your users’ needs and the assumptions and dependencies surrounding your product. An overview of your product – including functional requirements, interface requirements, system features and non-functional requirements. A Detailed rundown of your specific requirements Now let’s go over how it can benefit you. Why Create an SRS Document? An SRS acts as the blueprint for your project, and every team involved in the development process will follow it. It keeps everyone on the same page, from the development team, quality assurance team, operations, maintenance and product team. The software requirements specification document can also help you make decisions about your product during its lifecycle – e.g., when to build a new feature or sunset a feature that has become redundant – or your users simply ignore it. Importantly, however, when done correctly, an SRS can and should reduce your development time and costs. Not let’s look at how you can create a comprehensive SRS document. How to Write an SRS Document in 5 Steps Create an Outline Define Your Purpose Write an Overview of Your Product Detail The System Requirements Implement Your SRS 1. Create an Outline Like with drafting any kind of document, it’s critical you start with the structure, and an SRS is no different. If you decide to create one for yourself, here is a basic, lightweight, incomprehensive outline to give you an idea: Software Requirements Specification (SRS) Document Outline Introduction 1.1 Purpose 1.2 Intended Audience 1.3 Intended Use 1.4 Scope 1.5 Definitions and Acronyms Overall Description 2.1 User Needs 2.2 Assumptions and Dependencies System Features and Requirements 3.1 Functional Requirements 3.2 External Interface Requirements 3.3 System Features 3.4 Nonfunctional Requirements Once you’ve created a structure for your SRS it’s time to start fleshing it out. That all starts with the purpose. 2. Start With a Purpose In this section of your SRS document, outline the purpose of the product starting with: Intended Audience/Use Define which stakeholders will use the SRS and how they will use it. This will most likely include developers, quality assurance, product experts and project managers. However, it may be relevant to share this document with stakeholders in other departments of, such as marketing and sales. Product Scope Here is where you will describe your product from a business perspective. Include the benefits, objectives, and goals. This will help to align all departments on which direction your product is heading and why. At Altar, our Product Team created their own process to do just that. Check out by our co-founder Daniel for more information. In it, he shares the exact process step by step. this resource Glossary of Terms Here, define any terms relevant to your product. This will ensure that everyone is on the same page regardless of technical ability or department. Also, include any references here (i.e., if you have to include any legal or best practice documents). 3. Overview of Your Product In this section, describe the functionality of your product. Outline any informal requirements to give context going to the specific technical requirements explored in the next section. In short, outline what you’re building and who you’re building it for. User Needs It’s vital to outline your user needs (also known as user classes or user characteristics) within your overview. List any primary or secondary users who will use the product on a regular basis and define their journey through the product. This will again ensure the whole team is on the same page and focused on your end-user throughout the product development process. Assumptions and Dependencies This section of your SRS is used to outline any factors that may impede your ability to fulfil the needs of your project. For example, are you making assumptions about your product that may be false? If they are proven false, what will the plan be to fix it? Lastly, is your project dependent on any external factors? For example, an integration from a third-party SaaS may cause SLA issues, etc. 4. Detail The System Requirements Once you have an overview of your product in place, it’s time to become more granular. Keeping in mind your users’ needs, it’s time to give a detailed overview of either the use cases of your product as well as the non-functional requirements. Let’s begin with a quick outline of use cases and non-functional requirements in an SRS document. How to Write Use Cases in your SRS document A use case describes how your user will interact with your product in a simple story format. Creating a use case helps you put yourself in the shoes of the end user. To start, create a full list of your product’s end users. Then take those users one by one and: Break down their interactions into use cases (one case for one interaction) Describe the sequence of events for each case. Write a detailed description of what the user does, and how the system will respond Repeat this process for every user until you’ve completed your list. Non-functional Requirements Your non-functional requirements are just as important as your functional ones. They include performance, safety, security & quality. Here’s an example of how to write a non-functional requirement for a car’s LIDAR sensor: The car’s LIDAR sensors shall send data to the dashboard at the rate of 10Mbps up to (and including) 100Mbps. Once you have your use cases written and non-functional requirements listed and have provided any relevant supplemental information, you’re ready to take it to your stakeholders. 5. Implement Your SRS Document Once you’ve ensured all the teams are happy, and the document is signed, it’s time to implement it. Make it accessible to the whole team, either printed or in a PDF on a shared drive. Or even on an MD file in platforms such as confluence, notion or monday.com. This means presenting the document to all teams involved in your product development process, ticket management platform or code registry. This is a vital step as if your SRS isn’t consumed regularly, its existence makes no sense. Wrapping Up As I stated at the beginning of this article, in fast-paced startup environments where founders are pushed to move faster and faster, documentation like an SRS is often left behind – and if you have the right team around you, that’s not necessarily a bad thing. That being said, should you need to create one, it’s important to make sure you follow the best practices listed above. It will ensure that you create an SRS that clearly communicates the key requirements across all members of your team, reducing development time and costs. With the added benefit that it can help you make decisions about your product’s lifecycle further down the line. If you have any more questions related to writing an SRS document, – I’d be happy to answer any questions you may have. reach out to me here Thanks for reading. This article was previously published by our CTO & Partner Cláudio Teixeira here Cláudio Teixeira Claudio is a partner and CTO at Altar.io. He previously served as full-stack Tech Lead and CTO at multiple startups and companies in London and Amsterdam. He currently focuses his research on Machine Learning at the Edge.

Follow these 5 Simple Steps to Write a Software Requirements Specification (SRS) Document

In this blog post, we are going to deep dive into DOM and try to understand what a DOM is, and how it works. Table of Contents:- What is the DOM? How does DOM works The tree structure of the DOM Nodes and Elements properties Methods Selectors What is DOM? DOM stands for Document Object Model It acts as an interface for HTML & XML documents, which represent the content of the document as a tree-like structure. The DOM allows JavaScript & other programming languages to interact with and manipulate the content & structure of HTML or XML documents. We can use DOM to add or remove elements from the page, change the text of elements, or responds to a mouse click or keyboard inputs. How does DOM work? When a web page is loaded, the browser creates a Document Object Model(DOM) of the page. works like a tree structure and converts the HTML code into a tree in which each node represents the elements of that particular HTML code. DOM The root of this tree is document objects and each node represents elements like paragraphs, images, headers, links, etc. <html>
  <head>
    <title> DOM BLOG </title>
  </head>
  <body>
    <button> Click here to read the blog </button>
  </body>
</html> For example, if the above code is simple HTML code, then, what DOM will do is convert this code into a tree-like structure, so that the DOM manipulation can be done easily. Below is the image of how the above code gets converted into a tree structure by DOM. In DOM, Properties & Methods are two types of members associated with each node or element, or object. Properties and Methods along with some attributes and functions help in interacting with and manipulating the HTML to get the desired outcome. Let's Understand Properties and Methods with this example:- The Properties Let's say you have an HTML document with a heading element like this: <h1 id="blog-head">It's a blog about DOM</h1> Now if we want to change this heading without even touching HTML, Then what we going to do is use “DOM”. First we “get” this heading element in JavaScript using a selector called getElementbyID(” ”); It returns the value as an “object”. var heading = document.getElementById('blog-head'); Then we access its inner HTML using “.innerHTML” and change its value/text accordingly. heading.innerHTML = 'Read, Learn and Leave your Feedback!'; By doing all these steps, We change the innerHTML of the heading without even touching HTML. Don’t worry we are going to learn selectors in just a few mins. The Methods Let's say you have a button element in your HTML document like this: <button id="my-button">Click me to read the blog about DOM</button> Now, same as above, first we select the button in JavaScript using a selector called .getElementsbyID(” ”). It returns the value as an “object”. Now, we can manipulate and do changes with the button without touching HTML. Let’s say, we want an alert of “You clicked the button for reading the blog about DOM!” whenever a user clicks the button. In order to do that, we need to do two things. Add event listener which responds to the click a function() that executes the block of code and returns the alert which says “You clicked the button for reading the blog about DOM!”. var button = document.getElementById('my-button');
button.addEventListener('click', function() {
  alert('You clicked the button for reading the blog about DOM!');
}); This .addEventListener() is what we call a Methods in DOM. We passed two arguments in it. click = The click on Button function() = which shows the alert when the click happens. NOTE:- Methods have parenthesis() at the end and Properties do not. In summary, Properties are the value of an element, node, or object, while Methods are similar to Functions() as it has a code that gets executed when that particular Method is called. There are differences b/w Methods() and Functions(), But it's not the topic of this blog. SELECTORS There are many ways to select elements inside DOM. Let’s say we have this HTML code <ul id = title>
  <li class = item> One <li>
  <li class = item> One <li>
  <li class = item> One <li>
</ul> Now, if we want to select the “li” we use selectors:- 1) get Elements by Tag Name(””); This Selector selects all the elements by there Tag names(li, ul, p, h1, h1 etc…) In this case we are selecting “li”. This selector selects all the “li” in the HTML document document.getElementsbyTagName("li");
// HTMLCollection(3) [li.item, li.item, li.item] => Selects all 3 "li" from above HTML code Note: Elements is plural, so it returns more than one value in form of an array. Now, Let's style the “li” document.getElementsbyTagName("li");
document.getElementsbyTagName("li")[0].style.color = "Red"; 
//change color of first li to red
document.getElementsbyTagName("li")[1].style.color = "Blue"; 
//change color of second li to Blue
document.getElementsbyTagName("li")[2].style.color = "Green"; 
//change color of Third li to Green We can also change the text size and text style by using different properties in place of “style”. You can change the style of all three elements at once using loops. var items = document.getElementsByTagName("li");
for (let i = 0; i < 3; i++) {
  items[i].style.backgroundColor = "red";
} 2) get Elements by Class Name(””); This selector selects all the elements with particular class names given to that element. <ul id = title>
  <li class = item> One <li>
  <li class = item> One <li>
  <li class = item> One <li>
</ul>
<button class="btn">Click to read blog</button> document.getElementsbyClassName("btn");
//This selects all the elements with .btn class in it Similar to the above example, we can also add different properties to get a different result like changing text color, text size, and others. document.getElementsByClassName("btn");
document.getElementsByClassName("btn")[0].textContent = "you are reading the blog"
//This changes the text content inside the button. This selector also returns the value as an array. 3)get Element by ID(” ”); This selector selects the element with the unique ID given to it. <ul id = title>
  <li class = item> One <li>
  <li class = item> One <li>
  <li class = item> One <li>
</ul>
<button class="btn">Click to read blog</button> Now, let's select the ul element using its ID. document.getElementbyID("title");
//Selects element with ID Only document.getElementbyID("title").style.color = "red";
//Styles the title element and changes its color to Red. NOTE ⇒ ID selector has “Element” without "s" which means its singular, so it returns only single value. Also, ID is a unique property and on every page, there is only one ID of the same name so that also clears that there’s only one single element with a particular ID. 4)query Selector(””); So, the previous three selectors are used in specific cases(for tag name, for class, for ID) But, in query selector, we can target any element with its name only, whether it be h1,h2,h3 or ID’s like(#title) or class like(.btn) <h1 class = "header" id = "first-head">Follow me for more such informative blogs</h1> We can style and manipulate the h1 element in three ways here; document.querySelector("h1").style.color = "red"
//Here we select the element with its tag name
//This changes color of element to Red document.querySelector("#first-head").style.color = "Blue"
//Here we select the same element with its ID
//This changes color of element to Blue document.querySelector(".header").style.color = "Green"
//Here we select the same element with its class name
//This changes color of element to Green This is all for this blog. Read, Learn, and leave your important feedback so that I can improve my future blogs. There is going to be one more part of this blog. So stay tuned for that one. Thank You! Also published here.

Mastering the Document Object Model (DOM)

Today we're going to learn how to build a system that asks questions and gets accurate answers about documentation. The whole project being built is available . ChatGPT here You can also try an . interactive version https://www.youtube.com/watch?v=-9jL9r9QQm0&embedable=true Overview We're going to cover a few things here, but the big picture is that: We'll need to store our content in a database We'll get the user to type a query We'll search the database for the results that are most similar to the user query (more on that later) We'll create a "context" based on the top 5 most similar results matching the query and ask ChatGPT Answer the question based on the context below, and if the question can't be answered based on the context, say "I don't know"

Context:
[CONTEXT]
---
Question:
[QUESTION]
Answer: Diving into the implementation Alright, let's get started Here's what you'll be needing for this tutorial: A database that allows you to find "most similar results". Not all databases are suited for this kind of job. Today we'll be using Embedbase which allows you to do just that. Embedbase allows you to find "semantic similarity" between a search query and stored content. : that's for the ChatGPT part. OpenAI api key Nextra: . NodeJS installed Write the Embedbase and OpenAI API keys in : .env OPENAI_API_KEY="<YOUR KEY>"
EMBEDBASE_API_KEY="<YOUR KEY>" As a reminder, we will create with the amazing documentation framework Nextra which allows you to write documentation using NextJS, tailwindcss, and MDX (Markdown + React). We will also use as a database together with OpenAI to make use of ChatGPT. QA documentation powered by ChatGPT Embedbase Creating a Nextra doc You can find and use the official Nextra documentation template . Once you have created your documentation with this template, open it with your favorite editor. here # we won't use "pnpm" here, rather the traditional "npm"
rm pnpm-lock.yaml
npm i
npm run dev Now just head here. Try to edit some of the documents and see the content changing. .mdx Preparing and storing the documents The first step requires us to store our documentation in Embedbase. There's a small caveat, though, this works better if we store relatively small chunks in the DB. We'll chunk our text by sentences. Let's start by writing a script called in the folder .You'll need the library to list files (we'll use the 8.1.0 version). sync.js scripts glob npm i glob@8.1.0 const glob = require("glob");
const fs = require("fs");

const sync = async () => {
	// 1. read all files under pages/* with .mdx extension
	// for each file, read the content
	const documents = glob.sync("pages/**/*.mdx").map((path) => ({
		// we use as id /{pagename} which could be useful to
		// provide links in the UI
		id: path.replace("pages/", "/").replace("index.mdx", "").replace(".mdx", ""),
		// content of the file
		data: fs.readFileSync(path, "utf-8")
	}));
	
	// 2. here we split the documents in chunks, you can do it in many different ways, pick the one you prefer
	// split documents into chunks of 100 lines
	const chunks = [];
	documents.forEach((document) => {
		const lines = document.data.split("\n");
		const chunkSize = 100;
		for (let i = 0; i < lines.length; i += chunkSize) {
			const chunk = lines.slice(i, i + chunkSize).join("\n");
				chunks.push({
				// and use id like path/chunkIndex
				id: document.id + "/" + i,
				data: chunk
			});
		}
	});
}

sync(); Now that we have our chunks we need to store them in a DB, we'll extend our script so that it adds the chunks to Embedbase. To query Embedbase, we'll install the version of by running . 2.6.9 node-fetch npm i node-fetch@2.6.9 const fetch = require("node-fetch");

// your Embedbase api key
const apiKey = process.env.EMBEDBASE_API_KEY;

const sync = async () => {
	// ...
	// 3. we then insert the data in Embedbase
	const response = await fetch("https://embedbase-hosted-usx5gpslaq-uc.a.run.app/v1/documentation", { // "documentation" is your dataset ID
		method: "POST",
		headers: {
			"Authorization": "Bearer " + apiKey,
			"Content-Type": "application/json"
		},
		body: JSON.stringify({
			documents: chunks
		})
	});
	const data = await response.json();
	console.log(data);
}

sync(); Great, you can run it now: EMBEDBASE_API_KEY="<YOUR API KEY>" node scripts/sync.js If it worked well, you should be seeing: Getting the user’s query Now, we  will modify the Nextra documentation theme to replace the built-in search bar with one that will be ChatGPT-powered. We'll add a component to with the following content: Modal theme.config.tsx // update the imports
import { DocsThemeConfig, useTheme } from 'nextra-theme-docs'
const Modal = ({ children, open, onClose }) => {
	const theme = useTheme();
	if (!open) return null;
	return (
		<div
			style={{
				position: 'fixed',
				top: 0,
				left: 0,
				right: 0,
				bottom: 0,
				backgroundColor: 'rgba(0,0,0,0.5)',
				zIndex: 100,
			}}
			onClick={onClose}>			
			<div
				style={{
					position: 'absolute',
					top: '50%',
					left: '50%',
					transform: 'translate(-50%, -50%)',
					backgroundColor: theme.resolvedTheme === 'dark' ? '#1a1a1a' : 'white',
					padding: 20,
					borderRadius: 5,
					width: '80%',
					maxWidth: 700,
					maxHeight: '80%',
					overflow: 'auto',
				}}
				onClick={(e) => e.stopPropagation()}>			
			{children}
			</div>
		</div>
	);
}; Now we want to create the search bar: // update the imports
import React, { useState } from 'react'
// we create a Search component
const Search = () => {
	const [open, setOpen] = useState(false);
	const [question, setQuestion] = useState("");
	// ...
	// All the logic that we will see later
	const answerQuestion = () => {  }
	// ...
	return (
		<>
			<input
				placeholder="Ask a question"
				// We open the modal here
				// to let the user ask a question
				onClick={() => setOpen(true)}
				type="text"
			/>
			<Modal open={open} onClose={() => setOpen(false)}>
				<form onSubmit={answerQuestion} className="nx-flex nx-gap-3">
					<input
						placeholder="Ask a question"
						type="text"
						value={question}
						onChange={(e) => setQuestion(e.target.value)}
					/>
					<button type="submit">					
						Ask
					</button>
				</form>
			</Modal>
		</>
	);
} Last, update the config to set the search bar we created: const config: DocsThemeConfig = {
	logo: <span>My Project</span>,
	project: {
		link: 'https://github.com/shuding/nextra-docs-template',
	},
	chat: {
		link: 'https://discord.com',
	},
	docsRepositoryBase: 'https://github.com/shuding/nextra-docs-template',
	footer: {
		text: 'Nextra Docs Template',
	},
	// add this to use our Search component
	search: {
		component: <Search />
	}
} Building the context Here you will need the OpenAI token-counting library so run . tiktoken npm i @dqbd/tiktoken Now we are going to build the prompt to contextualize ChatGPT in a NextJS API endpoint. Create a file with the code: pages/api/buildPrompt.ts // pages/api/buildPrompt.ts
import { get_encoding } from "@dqbd/tiktoken";

// Load the tokenizer which is designed to work with the embedding model
const enc = get_encoding('cl100k_base');
const apiKey = process.env.EMBEDBASE_API_KEY;

// this is how you search Embedbase with a string query
const search = async (query: string) => {
	return fetch("https://embedbase-hosted-usx5gpslaq-uc.a.run.app/v1/documentation/search", {
		method: "POST",
		headers: {
			Authorization: "Bearer " + apiKey,
			"Content-Type": "application/json"
		},
		body: JSON.stringify({
			query: query
		})
	}).then(response => response.json());
};

const createContext = async (question: string, maxLen = 1800) => {
	// get the similar data to our query from the database
	const searchResponse = await search(question);
	let curLen = 0;
	const returns = [];
	// We want to add context to some limit of length (tokens)
	// because usually LLM have limited input size
	for (const similarity of searchResponse["similarities"]) {
		const sentence = similarity["data"];
		// count the tokens
		const nTokens = enc.encode(sentence).length;
		// a token is roughly 4 characters, to learn more
		// https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them
		curLen += nTokens + 4;
		if (curLen > maxLen) {
			break;
		}
		returns.push(sentence);
	}
	// we join the entries we found with a separator to show it's different
	return returns.join("\n\n###\n\n");
}

// this is the endpoint that returns an answer to the client
export default async function buildPrompt(req, res) {
	const prompt = req.body.prompt;
	const context = await createContext(prompt);
	const newPrompt = `Answer the question based on the context below, and if the question can't be answered based on the context, say "I don't know"\n\nContext: ${context}\n\n---\n\nQuestion: ${prompt}\nAnswer:`;
	res.status(200).json({ prompt: newPrompt });
} Making calls to ChatGPT First, add some utility function that is used to make stream calls to OpenAI in the file , you'll need to install by running . utils/OpenAIStream.ts eventsource-parser npm i eventsource-parser import {
	createParser,
	ParsedEvent,
	ReconnectInterval,
} from "eventsource-parser";

  
export interface OpenAIStreamPayload {
	model: string;
	// this is a list of messages to give ChatGPT
	messages: { role: "user"; content: string }[];
	stream: boolean;
}

  
export async function OpenAIStream(payload: OpenAIStreamPayload) {
	const encoder = new TextEncoder();
	const decoder = new TextDecoder();
	
	let counter = 0;
	const res = await fetch("https://api.openai.com/v1/chat/completions", {
		headers: {
			"Content-Type": "application/json",
			"Authorization": `Bearer ${process.env.OPENAI_API_KEY ?? ""}`,
		},
		method: "POST",
		body: JSON.stringify(payload),
	});
	
	const stream = new ReadableStream({
		async start(controller) {
			// callback
			function onParse(event: ParsedEvent | ReconnectInterval) {
				if (event.type === "event") {
					const data = event.data;
					// https://beta.openai.com/docs/api-reference/completions/create#completions/create-stream
					if (data === "[DONE]") {
						controller.close();
						return;
					}
					try {
						const json = JSON.parse(data);
						// get the text response from ChatGPT
						const text = json.choices[0]?.delta?.content;
						if (!text) return;
						if (counter < 2 && (text.match(/\n/) || []).length) {
							// this is a prefix character (i.e., "\n\n"), do nothing
							return;
						}
						const queue = encoder.encode(text);
						controller.enqueue(queue);
						counter++;
					} catch (e) {
						// maybe parse error
						controller.error(e);
					}
				}
			}
		
			// stream response (SSE) from OpenAI may be fragmented into multiple chunks
			// this ensures we properly read chunks and invoke an event for each SSE event stream
			const parser = createParser(onParse);
			// https://web.dev/streams/#asynchronous-iteration
			for await (const chunk of res.body as any) {
				parser.feed(decoder.decode(chunk));
			}
		},
	});
	
	  
	return stream;
} Then, create a file which will be an endpoint to simply make a streaming call to ChatGPT. pages/api/qa.ts // pages/api/qa.ts
import { OpenAIStream, OpenAIStreamPayload } from "../../utils/OpenAIStream";
export const config = {
	// We are using Vercel edge function for this endpoint
	runtime: "edge",
};

interface RequestPayload {
	prompt: string;
}

const handler = async (req: Request, res: Response): Promise<Response> => {
	const { prompt } = (await req.json()) as RequestPayload;
	if (!prompt) {
		return new Response("No prompt in the request", { status: 400 });
	}
	const payload: OpenAIStreamPayload = {
		model: "gpt-3.5-turbo",
		messages: [{ role: "user", content: prompt }],
		stream: true,
	};
	const stream = await OpenAIStream(payload);
	return new Response(stream);
};
export default handler; Connect everything & Asking questions Now it is time to ask questions through API calls. Edit to add the function to the component: theme.config.tsx Search // theme.config.tsx
const Search = () => {
	const [open, setOpen] = useState(false);
	const [question, setQuestion] = useState("");
	const [answer, setAnswer] = useState("");
	const answerQuestion = async (e: any) => {
		e.preventDefault();
		setAnswer("");
		// build the contextualized prompt
		const promptResponse = await fetch("/api/buildPrompt", {
			method: "POST",
			headers: {
				"Content-Type": "application/json",
			},
			body: JSON.stringify({
				prompt: question,
			}),
		});
		const promptData = await promptResponse.json();
		// send it to ChatGPT
		const response = await fetch("/api/qa", {
			method: "POST",
			headers: {
				"Content-Type": "application/json",
			},
			body: JSON.stringify({
				prompt: promptData.prompt,
			}),
		});
		if (!response.ok) {
			throw new Error(response.statusText);
		}
		const data = response.body;
		if (!data) {
			return;
		}
		
		const reader = data.getReader();
		const decoder = new TextDecoder();
		let done = false;
		// read the streaming ChatGPT answer
		while (!done) {
			const { value, done: doneReading } = await reader.read();
			done = doneReading;
			const chunkValue = decoder.decode(value);
			// update our interface with the answer
			setAnswer((prev) => prev + chunkValue);
		}
	};
	return (
		<>
			<input
				placeholder="Ask a question"
				onClick={() => setOpen(true)}
				type="text"
			/>
			<Modal open={open} onClose={() => setOpen(false)}>
				<form onSubmit={answerQuestion} className="nx-flex nx-gap-3">
					<input
						placeholder="Ask a question"
						type="text"
						value={question}
						onChange={(e) => setQuestion(e.target.value)}
					/>
					<button type="submit">
						Ask
					</button>
				</form>
				<p>
					{answer}
				</p>
			</Modal>
		</>
	);
} You should have this by now: Of course, feel free to improve the style 😁. Closing thoughts In summary, we have: Created a Nextra documentation Prepared and store our documents in Embedbase Built an interface to get the user's query Searched for the context of the question in our database to provide ChatGPT Built the prompt with this context and call ChatGPT Let the user ask a question by connecting everything together Thank you for reading this document, there is an open-source template to create this type of documentation . here Further reading Embeddings are a machine learning concept that allows you to represent the semantics of your data as a number, which allows you to create features such as: semantic search (e.g., what is the similarity between "the cow eats grass" and "the monkey eats bananas", which also works for comparing images, etc.) recommendation systems (if you like the movie Avatar, you might like Star Wars) classification ("this movie is amazing" is a positive sentence, "this movie sucks" is a negative sentence) generative search (chatbot that answers questions about a PDF, a website, a YouTube video, etc.) Embeddings are not a new technology, but they have been made more popular, more general, and more accessible recently thanks to the OpenAI embeddings endpoint which is fast and cheap. We won't dive into the technical subject of embeddings, there is a lot of information about them on the internet. AI embeddings can be thought of as a sorting hat of Harry Potter. Just like the sorting hat assigns houses based on the traits of the students, AI embeddings are assigned to similar content based on their features. When we want to find similar items, we can ask AI to provide us with embeddings of the items, and then calculate the distance between them. The closer the distance between the embeddings, the more similar the items. This process is similar to how the sorting hat uses the traits of each student to determine their best fit for a house. By using AI embeddings, we can quickly and easily compare items based on their features, resulting in smarter decisions and more efficient search results. The method described above is simply to embed words, but today, sentences, images, sentences + images, and many other things are possible. When you want to use embeddings in production software, there are some pitfalls to be careful with: All the infra of storing embeddings at scale Cost optimization (e.g. avoid calculating data twice) Segmentation of user embeddings (you don't want your search function to display another user's data) Dealing with the model input size limit Integration with popular app infras (supabase, firebase, google cloud, etc.) Preparing the data continuously in GitHub Actions The point of embeddings is to be able to index any kind of unstructured data, we want our documentation to be indexed every time we modify it, right? This is a GitHub action that will index every markdown file when a is done on the branch: git push main # .github/workflows/index.yaml
name: Index documentation
on:
	push:
		branches:
			- main
jobs:
	index:
		runs-on: ubuntu-latest
		steps:
			- uses: actions/checkout@v2
			- uses: actions/setup-node@v2
			with:
				node-version: 14
			- run: npm install
			- run: node scripts/sync.js
				env:
					EMBEDBASE_API_KEY: ${{ secrets.EMBEDBASE_API_KEY }} Don't forget to add to your . EMBEDBASE_API_KEY GitHub secrets

Building a ChatGPT-Powered Markdown Documentation 

Agreements are an essential part of software development. They lower development costs and make developers' lives easier. But there is a problem - they often complicate things because they aren't properly documented and conveyed across the team by word of mouth, like old fairy tales. While spreading, agreements change. Suddenly, new details appear, and old ones are gone. By the end, every team member has their own agreement picture in the head, and even that picture sometimes fades away. Even worse - when teams start documenting these agreements, they do it haphazardly and often create a mess of loosely coupled documents, half of which are not even up-to-date. In this article, I'll tell you of documenting agreements, so they will help you. the right way So, how can we make agreements helpful? We not only have to document them but also do it so that: they were easy to use; following these agreements required minimal effort; it would be easy to understand if these agreements are still valid; it would be easy to understand why these agreements even exist; ideally - they were automated. One can come up with lots of ways to classify agreements. I will split them by their abstraction level: code-level agreements; architecture-level agreements; processes-level agreements. Agreements on different levels require different ways to document them and bring different benefits. Let's take a look at each level. Code-level conventions The aim of these agreements is to make code uniform, comprehensive, and readable. Here are some examples: We use double quotes instead of single ones. We don't call ENV directly from the code except in the class, where we wrap these calls into methods. Config Service objects have postfix and one public method . Service call These types of agreements are created to lower the reader's cognitive load and help him become used to unknown code faster. Like Martin said, code is read up to 10 times more than written. Despite your opinion on the Ruby on Rails framework - it has an incredible principle at its core, which allows any Rails developer to open someone else's project and immediately navigate it pretty well. convention over configuration So how to document these conventions? Linter tool! If there is no suitable linter rule, write your own lint. Almost every linter allows you to do that: here is an example in , and here is for . Go language Ruby Using linter for such conventions brings you three benefits: There is no need for a developer to think about them - linter will highlight every error and often even fix them for you. If you use code reviews in your team - you free your reviewers from thinking about these things and give them more time to look at more important things. The developer will see a problem at the very start of the development cycle, so he will fix it immediately without spending time to return to the context later. It becomes cheaper to keep the agreement. One more bonus: writing a new linter rule is excellent training for a junior developer. While completing this task, he will learn a lot about code parsing and building AST and understand language more deeply. Architecture-level conventions This is a higher-level type of agreement that aims to make your architecture thoughtful, coherent, and uniform. A few examples: We use the Python to write regular services and Elixir in the highloaded parts of the system. The backend returns errors in described format. Each service is required to send metrics in prometheus, on the endpoint, the port for sending metrics is configured by the environment variable. /metrics PROMETHEUS_PORT Such agreements not only reduce cognitive load, but also solve three more problems: Reduce operating costs. If the services are launched in the same way, with same logs format, publishing the same metrics, then it is much easier to maintain the service and cope with incidents. Reduce design costs. The developer doesn't need to design the architecture from scratch every time - you thought in advance, and now he needs to design only a specific feature or service, without worrying about basic things. Reduce communication costs. If the server's response or event format in Kafka is predetermined, developers don't need to discuss their interaction each time, instead they can simply refer to the convention. Such agreements are more complex, and I prefer to fix them in two steps. Step 1 - Describe Architecture Decision Record (ADR) is a tool for documenting such agreements. Its charm is that it captures meta information along with an agreement: why such an agreement was adopted; what alternatives were discussed; when it was last revised; is the agreement still valid? This allows the new team member to understand the reasons for the decisions made and not ask people around about it. ADR consists of several main blocks: What problem does the agreement solve? What options for solving the problem were considered, and what were their pros and cons? Which option was chosen in the end? There may be additional blocks - for example, implementation costs calculation. It's more convenient to keep ADR in a system where one can see the history of changes and discussions. My choice is Github and Notion, each with its pros and cons. The advantage of Github is that it has a review tool and version history out of the box. Notion can be a good solution due to the convenience of working with databases and tags. And also - non-developers can easily handle it. If you want to get started with ADR, I recommend looking at the , where you can find different ADR templates and examples of how to use them. repository Step 2 - Automate ADRs are more challenging to automate than code-level conventions: design linters have yet to be invented (what a pity!). Nevertheless, it is possible to partially automate them, depending on what kind of agreement it is. Create and update service templates for agreements on languages, libraries, and embedding services into infrastructure. Then the developer won't write new services from scratch but rather copy it from the template and immediately receive the configured Dockerfile, metrics publishing, etc. Similarly, you can create class generators within one application. Suppose you had agreed on several application layers (controller => form => service object). In that case, you can make a simple console command that will generate all layers for a new feature at once. If you have agreed on some principles that cannot be automated in this way, you can organize checklists that are automatically added to a merge request or a task in the tracker; thus, the developer can quickly go through them before passing the task on. Processes-level agreements There are many agreements for processes in each company, for example: Description of how hiring in the company works. Description of the release rollout process. Requirement for design reviews for large tasks. Conducting a team meeting twice a week with a discussion of current tasks and obstacles. Until recently, I did not think about documenting these agreements, although they significantly affect the company's success. Documentation of these agreements not only carries benefits of the types mentioned above but also allows you to rationalize the processes, transfer them to the visible plane and think about their expediency. I got the idea from . He proposed a tool similar to ADR - Process Decision Record (PDR). The only difference is that instead of architectural decisions, it describes decisions about processes. In addition, he suggested putting a "rethink date" in each PDR - a date when you return to the document to see if it still solves your problems in the best way, months after adoption (by the way, the same can be done with ADRs ). Vitaly Sharovatov n As for automation, there is little you can do. You can automate some processes by setting up a workflow in Jira, setting reminders for meetings, or creating a bot that automatically prepares a presentation of the week's results (I did this, though, in a foreign company). But often, you can't really automate processes, and your main goal is to make them easier to follow than not follow. Nevertheless, documenting agreements will still be helpful, even if your processes are already easy to follow - formalization and rationalization will allow you to improve them. So, what's the result? Documentation and subsequent automation are beneficial: time spent on development decreases, applications become more supportable, and processes become smarter. One could think that all this is unnecessary bureaucracy because "we are good guys - we can develop code without it." But in fact, agreements will save you substantial amounts of time and money and protect employees' nervous cells. Sure, you don't need to deal in absolute and reject anything that goes against agreements - this may be a sign that the agreement needs to be updated or that you didn't initially think about some of its aspects. If you haven't yet started documenting agreements in your team, move from lower abstraction levels to higher ones: start from code-level agreements, then architecture-level, and only then cope with the processes-level. Agreements documentation is a habit to develop in your team, and starting with less abstract concepts is much easier. In addition, not all types are described in the article. For example, you can document the design agreement as library components. Each new type of agreement goes through the same three stages: Figure out how to document it. Figure out how to automate it. As time passes, ensure it saves more resources than it takes to keep it. And the last one. During the documentation process, it may be found that some of the existing agreements are apparently, not justified by anything, waste your team's time, and are generally harmful, but you are already used to them. In this case, you have to overcome the habit barrier in the team's minds and convince your team that the rejection of agreements is sometimes more important than accepting them. But that's an entirely different story. Also published . here

Save Yourself the Headaches and Document Agreements the Right Way

Ahórrese los dolores de cabeza y documente los acuerdos de la manera correcta

Épargnez-vous les maux de tête et documentez les accords de la bonne façon

अपने आप को सिरदर्द से बचाएं और सही तरीके से अनुबंधों को दस्तावेज़ करें

適切な方法で頭の痛い問題や文書契約を回避する

Salve-se das dores de cabeça e documente os acordos da maneira certa

Tự cứu mình khỏi những cơn đau đầu và thỏa thuận tài liệu đúng cách

以正确的方式避免头痛和文件协议

The first time I heard someone saying: “the code is the documentation”, I thought it sounded completely wrong, like a lazy excuse for not producing documentation. However, it kept me thinking and I realized that there is also truth in this statement. Its paradoxical quality makes it a proper mantra for agile practitioners, as it expresses a fundamental agile value: . working software over comprehensive documentation Before going into the details, I ought to dismiss the notion that agile developers don’t write documentation or that they disregard its worth. Nope. We still produce documentation. However, we also apply the following principle to it: Simplicity, the art of maximizing the amount of work not done, is essential. It is expedient to minimize by adhering to practices that reduce the need for it. In agile development, documentation takes on the role of accessory parts whereas the primary attention is given to the code base. Or more succinctly: documentation "Truth can only be found in one place: the code." (Robert C. Martin, Clean Code) The code base is the ultimate source of truth. It is referenced in case of doubt, when a question is either too detailed or if the documentation is out-of-date. The code provides insight where no other method of reference is available. With this in mind, it is evident that code should be written in a way that is well-structured and understandable. Self-documenting code reduces or disposes of the need for external documentation. Knowledge is represented in a single artefact and there is no need to synchronize multiple sources. Unfortunately, most real-world code bases do not have these ideal qualities. There could be many reasons for that, but the most common reason is that software entropy has taken its toll over time and that too little attention was paid to refactoring. So, code quality, self-documenting code, and continuous refactoring go hand in hand. It is important to understand that the highest code quality is achieved through conceptual clarity. Conceptual clarity comes from good naming and good structure. This is by far more important than coding style, naming conventions, formatting, and other external features, although the latter do of course contribute to code quality. Naming and structure cannot be tested automatically. Unlike code style, conventions, and formatting, they require human perception and intelligence. This is one more reason to adopt practices such as code reviews and pair programming. Coming back to “the code is the documentation”, I think the best way to understand this phrase is as an abstract ideal that ought to be worked towards. In an ideal world, code doesn’t need additional documentation, because it is so clear that it can be read easily and understood by anyone without any prior knowledge. It answers all questions that might arise about the software. It clarifies the intentions of the programmer and it is therefore also easy to maintain and change. Obviously, this is really difficult to achieve in the real world, especially across a large code base, but self-documenting properties are quite likely the best measure of code quality. Lead image source.

The Code Is the Documentation; a Paradox That Rings True

Welcome to the realm where creativity meets protection—a world where digital explorers such as you embark on a journey to fortify their mobile apps against bugs and security vulnerabilities. Together, we'll uncover hidden flaws and wield powerful , ensuring your creations emerge triumphant and secure. So grab your virtual toolbelt and prepare for a dive into the magical realm of debugging mobile apps with unwavering resilience. security testing tools Understanding Mobile App Security Testing Mobile app security testing uncovers vulnerabilities, protecting user data and preventing unauthorized access. It empowers developers to fortify their apps against the ever-evolving tactics of malicious actors. Empowering App Developers By staying ahead of hackers, security testing equips developers to design robust apps that withstand sophisticated attacks. It assures users of a safe mobile experience and builds trust. Proactive Approach Mobile app security testing takes a proactive stance by identifying vulnerabilities before exploitation. Developers become guardians of their creations, creating a hostile environment for hackers. Collaboration with Security Testing Tools Leveraging advanced security testing tools, developers unveil risks from all angles. These tools provide static and dynamic analysis, penetration testing, and comprehensive features for effective vulnerability detection. Key to User Trust Investing in security testing practices demonstrates a commitment to user privacy and security. This fosters loyalty, enhances satisfaction, and establishes an unbreakable bond of trust. A Continuous Journey Mobile app security testing is an ongoing process. Developers must continuously monitor, update, and refine their security measures to keep pace with evolving threats. Selecting the Right Security Testing Tools Mobile app security requires a diverse set of tools. Look for options that cover areas such as code analysis, vulnerability scanning, encryption testing, and penetration testing. A well-rounded toolkit ensures comprehensive protection. Compatibility Matters: Evaluate the compatibility of security testing tools with your development environment. Ensure they seamlessly integrate with your existing workflow, saving time and effort. User-Friendly, Developer-Friendly: Opt for tools with intuitive user interfaces and clear documentation. Additionally, consider tools that offer automation capabilities and robust APIs for streamlined testing. The Power of Automation: is essential in fast-paced development cycles. Choose tools that offer automated security testing features to continuously monitor your app's security and protect against emerging threats. Automation Community Support and Updates: Select tools with active communities that provide regular updates. This demonstrates a commitment to staying ahead of evolving cybersecurity threats and offers opportunities for knowledge sharing. Scalability and Flexibility: Ensure the tools can scale and adapt to changing requirements as your app grows. Look for solutions that can handle both small-scale projects and enterprise-level applications without compromising performance. Budget Constraints: Consider both open-source and commercial options, striking a balance between cost-effectiveness and functionality. Many open-source security testing tools offer robust features without significant financial burdens. Setting Up the Development Environment Before diving into the intricacies of debugging, it's essential to prepare your development environment for the challenges ahead. Start by setting up a dedicated workspace, ensuring it meets the requirements of your chosen platform (iOS, Android, etc.). Organize your tools, libraries, and resources in a structured manner, allowing for seamless access and efficient development. Tool Selection: Your Armor and Weapons: Choose appropriate debugging tools based on compatibility, features, and ease of use. Consider tools like , Android Studio, Xcode, and security-focused options such as . Sentry OWASP ZAP Integrating Security Testing Tools: Identify areas requiring attention, such as authentication or data storage, and integrate specialized security testing tools seamlessly into your workflow. Embracing Automation: Automate security testing with tools like Checkmarx or AppScan to efficiently identify vulnerabilities. Static analysis and dynamic analysis tools are invaluable for code scanning and simulating attacks. Harnessing Emulators and Simulators: Utilize emulators and simulators to test your app across various configurations, platforms, and operating systems. Replicate user interactions and evaluate app security in different scenarios. Encrypted Connections: The Secure Gateway: Ensure all connections within your development environment are encrypted using secure protocols like HTTPS and SSH. Protect sensitive data during debugging. Continuous Vigilance: Staying Updated: Regularly update your tools, libraries, and frameworks to stay current with security enhancements and patches. Stay informed about emerging threats through security mailing lists and forums. Performing Static Analysis examines the app's codebase to identify potential security loopholes before they manifest. It offers developers a unique insight into their app's inner workings, enabling them to patch vulnerabilities and protect user data. Static analysis X-ray Vision: Spotting Vulnerabilities Static analysis acts as X-ray vision, revealing hidden vulnerabilities like weak authentication and insecure data storage. Armed with this knowledge, developers can strengthen their app's defenses and thwart potential attacks. Unmasking Code Complexity: Enhancing Security Static analysis untangles complex code dependencies, detects code smells, and highlights areas needing optimization. By addressing code complexity, developers can bolster app security and enhance performance. Automation: Boosting Efficiency Automated static analysis tools scan large codebases, apply security rules, and generate reports swiftly. This efficiency empowers developers to focus on security practices and user experience. Balancing False Positives and Negatives Static analysis faces challenges with false positives and negatives. Striking a balance through rule calibration helps minimize false results and ensure accurate vulnerability detection. Collaboration: Integrating Static Analysis Seamless integration of static analysis into the development workflow is crucial. Conducting checks during code reviews, continuous integration, or the build process allows early detection and prevention of vulnerabilities. Evolving Threats: Staying Ahead Static analysis tools evolve to address emerging threats. Regular updates and utilization of the latest versions help developers proactively identify and mitigate evolving security risks. Conducting Dynamic Analysis Test Case Generation: By following these steps, you'll unearth the secrets of generating effective test cases: a. Identify critical functionalities and core app components. b. Design test cases to cover a range of inputs, data types, and user interactions. c. Implement automated testing frameworks to streamline the test case generation process. d. Embrace creativity and consider edge cases that may expose vulnerabilities. Dynamic Analysis Process: This technique involves executing the mobile app and observing its real-time behavior. Here's how to embark on this thrilling adventure: a. Prepare a controlled testing environment, including emulators or physical devices. b. Execute the app while capturing critical runtime data, such as network traffic and memory usage. c. Simulate various user interactions and inputs to trigger different app behaviors. d. Monitor and record the app's responses, logging any suspicious or unexpected actions. Result Interpretation: Dynamic analysis uncovers a treasure trove of insights through the results it produces. Now, it's time to decipher these clues and understand their security implications. Here's how to interpret and act upon the results of dynamic analysis: a. Analyze runtime logs and capture data for anomalies, errors, or unusual behaviors. b. Compare the observed app behavior against the expected behavior defined by the test cases. c. Identify potential security vulnerabilities, such as data leakage, insecure network communication, or improper authentication. d. Prioritize identified issues based on severity, potential impact, and the app's core functionalities. e. Collaborate with the development team to implement necessary fixes and security patches. Monitoring and Logging Real-Time Vigilance: Monitoring and logging provide a comprehensive view of your app's activities, enabling you to track critical metrics and detect anomalous patterns or suspicious activities in real time. Unveiling Hidden Anomalies: Comprehensive log files allow you to trace and examine events, errors, and exceptions, helping you identify and address vulnerabilities, bugs, or malicious activities compromising your app's security. Proactive Issue Resolution: Insights gained from monitoring and logging empower you to take swift actions, patch vulnerabilities, and enhance security controls to ensure a resilient and trustworthy user experience. Enhanced Forensics and Incident Response: Detailed logs play a crucial role in incident response and forensic investigations, enabling you to reconstruct events, identify root causes, and bolster your app's security posture. Best Practices for Effective Monitoring and Logging: To harness the full potential of monitoring and logging, it is essential to follow the best practices: Define clear monitoring objectives aligned with your app's security requirements. Select the right monitoring tools and frameworks that suit your app's architecture and technology stack. Implement comprehensive log management practices, including log rotation, retention, and secure storage. Regularly review and analyze logs to uncover hidden vulnerabilities or emerging threats. Collaborate with security experts to establish robust monitoring and logging practices. Addressing Common Security Vulnerabilities Insecure Data Storage: Address weak data storage by using security testing tools. Encrypt data and adopt secure storage practices to protect user information. Improper Authentication: Ensure strong authentication by exposing vulnerabilities through . Strengthen password policies and implement multi-factor authentication. security testing Inadequate Network Communication: Protect against interception and tampering by identifying insecure communication channels with security testing tools. Encrypt data transmissions and use secure protocols. Code Injection Attacks: Defend against malicious scripts by identifying vulnerabilities through security testing. Improve input validation and sanitize user inputs. Insufficient Transport Layer Protection: Secure sensitive data during transit by using security testing tools to identify flaws. Implement secure transport layer protocols and proper cipher suite configuration. ** Analyzing Test Results and Reporting Leverage tools like OWASP ZAP, MobSF, and AppScan for thorough security testing. These tools identify vulnerabilities through code analysis, penetration testing, and vulnerability scanning. Analyzing Test Results: Analyze test results to understand the severity and potential impact of identified security issues. Consider the likelihood of exploitation, data sensitivity, and consequences of successful attacks. Prioritizing Security Issues: Prioritize issues based on severity, exploitability, and impact. Critical and high-severity vulnerabilities demand immediate attention, especially if easily exploitable or with high potential impact. Generating Comprehensive Reports: Effective communication with stakeholders and developers is key when reporting identified security issues. To create comprehensive reports, follow these steps: Document all identified security issues with detailed descriptions, including the affected components, the steps to reproduce, and the potential impact. This documentation will serve as a reference for developers during the debugging process. Clear Documentation: Utilize visual aids such as charts, graphs, and tables to present the overall security status of the application. This will help stakeholders quickly grasp the security posture and understand the urgency of addressing each vulnerability. Visual Representation: Provide actionable recommendations for each identified security issue. Explain the steps required to mitigate the vulnerability, including code changes, configuration updates, or additional security measures. This empowers developers to address the issues effectively. Actionable Recommendations: Engage in collaborative discussions with stakeholders and developers to clarify any doubts and address concerns. Follow up regularly to ensure that the identified security issues are being addressed in a timely manner. Collaboration and Follow-up: Conclusion In today's digital landscape, the security of mobile apps is paramount. By following the comprehensive guide outlined above, we gain the knowledge and tools to uncover vulnerabilities, protect user data, and fortify our apps against attacks. But this journey goes beyond debugging; it's about embracing a security mindset, integrating testing into our workflows, and staying vigilant as threats evolve. Together, let's create a future where innovation and security coexist, empowering users to embrace mobile apps with confidence.

A Basic Intro to Mobile App Debugging with Security Testing Tools

Una introducción básica a la depuración de aplicaciones móviles con herramientas de prueba de seguridad

Une introduction de base au débogage d'applications mobiles avec des outils de test de sécurité

सुरक्षा परीक्षण उपकरणों के साथ मोबाइल ऐप डिबगिंग का एक बुनियादी परिचय

セキュリティ テスト ツールを使用したモバイル アプリのデバッグの基本的な紹介

Uma introdução básica à depuração de aplicativos móveis com ferramentas de teste de segurança

Giới thiệu cơ bản về gỡ lỗi ứng dụng dành cho thiết bị di động với các công cụ kiểm tra bảo mật

使用安全测试工具调试移动应用程序的基本介绍

Let's learn about via these 59 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Python Basics /Learn Repo 1. Type Annotation In Python Type Annotation are a quick way to validate the actual type of the variables or arguments that are being passed to the functions it is also called type hinting. 2. Learn To Code With Nursery Rhymes and Fairy Tales Classic nursery rhymes and fairy tales are translated into Python code in my upcoming picture book that teaches Python programming to beginners. 3. How to Encrypt a PDF Using Python Encryption is a way of encoding human-readable data with encrypted code that enables the use of a password to view the source and data stored. 4. How to Read Text File in Python? Python provides built-in functions to perform file operations, such as creating, reading, and writing into text files. 5. Pixelated Images Using Python We use PIL (Pillow) to create pixelated Image using Python. Firstly, resize down an image and then resize it up to get pixelated effect. Basic image operations. 6. The Surprising Case Of Mutable Default Arguments Mutable arguments get bind to the function the moment the function definition ends and are therefore modified each time instead of re-initialisation. 7. A Beginner's Introduction to the Python Programming Language Python is a language known for being modular. It has an extensive standard library and its simple to use syntax facilitates coding in the language. 8. Python Tutorial: 4 Methods to Getting the File Size in Python We can get the file size in Python using OS module and Pathlib module. The other methods we can use are os.path.getsize(), os.stat(), and path.stat().st_mode. 9. When Everyone Corrected the World's Smartest Woman I find the Monty Hall Problem one of the most fascinating brain teasers, because it seems deceivingly simple. When Marilyn Von Savant, the woman with the highest IQ, answered this brainteaser correctly in 1991, she was inundated with over 10,000 letters from academics and Ph.Ds criticizing her “error”, only to be proven later that she was correct. 10. A Complete Guide to Python Dictionaries In this guide, we will cover everything you need to know about Python dictionaries. 11. How to Write on an Image in Python In this Python tutorial, we will learn how to Write a text on an image, Change the size of the text and Centre the text on an image 12. Network Scanner Working and Implementation In this blog, we will see how a network mapper works and how we can implement these network security tools in Python for our cybersecurity related projects 13. Short Guide to Best Practices When Naming Variables in Python These are some best practices in python being followed by the python community when it comes to naming your variables. 14. Introduction to Tuples in Python In this guide, we'll cover how to use Tuples, as well as some of the methods and things you'd want to do with them. 15. 3 Ways to Learn Python Online Python Is beginner-friendly, has a strong ecosystem, and is a popular choice for AI, research, and automation. Here's how to teach yourself python online. 16. Took - A Twitter Bot that Tweets Books. Usually I found myself reading more than 100 tweets per day, so I thought that using all that 'reading power' to read a book using tweets could be a good idea. 17. Basic Python features When you say, what could be the future of programming or which programming language will boom, it should be Python, always. Just look at the 2019 survey from Stack overflow. It is quite obvious that python is taking the lead now. 18. Analyzing Python Compilers: CPython Vs. Cython Vs. PyPy Brief reviews on popular Python compilers like Cython, PyPy, and the default Python interpreter CPython. 19. A Beginner's Guide to Getting User Input in Python Getting input from the user is what makes a program more interactive with the user. 20. Building Your First Python GUI With Tkinter Beginner Python tutorial explaining the basics of Tkinter GUI application development 21. Python vs C++: What should a beginner choose? If you’re new to programming, are a computer teacher, or just a parent planning to get his child started with programming – you must be wondering where to start. C++, C, Java, Python – there are just too many options out there! While all these languages are great in their own right and popular, the debate between C++ and python has been intense for sometime. 22. A Complete Guide to Python Lists Let's start with some of the basics, and then dive into useful ways you'll be able to work with lists. 23. Hello, World! - Why Python is the Most Beginner-Friendly Coding Language Let’s start this journey of programming with gaining some knowledge on the Python programming language. 24. Colors of Python Interpreters As you know, Python is a very popular language and already takes 1st place in the TIOBE rating. And in the classical understanding of Python, in 90% of cases, CPython is meant. It is a reference implementation of the interpreter under the guidance of Guido van Rossum. Version 3.10 is current as of November 14, 2021. By now, Python means only version 3, but before this version appeared, mentions of version 2 can still be found. Now version 2 is not supported and most companies are removing the remnants of the code from version 2. by porting the code to version 3. As of January 1, 2020, Python 2 is no longer supported [https://www.python.org/doc/sunset-python-2/]. And this is quite understandable since, after the release of Python 3 in 2006, developers had to support 2 versions at the same time, which is laborious. 25. Python for Beginners, Part 6: Strings Let's discuss the strings primitive data type and it means. This will answer the question of what's the difference between variables and strings. 26. How to Learn Python Without Any Programming Background You are not a programmer. You have zero coding experience. You probably consider yourself “not a math person”. So let’s find out how you can learn Python, even if you’ve never had any exposure to a programming language. 27. What You Need to Know About Python’s Data Model A Concise Overview of Data Model, Special Methods and the Collection API in Python. 28. Cracking 3 Python Easter Eggs Python lessons for beginner and advanced level at the same time 29. Python for Beginners, Part 5: Variables We will discover what are variables in this video. How is data stored into variables and then how you can retrieve it later for easier access. We will look at all this through a visualization using the Turtle library from Python. 30. Python for Beginners, Part 2: Hello World Exercise We cover the most basic 'hello world' exercise! This will be fun and now you are on your way to an exciting journey! 31. Integrating Python and SQL: A Guide for Beginners SQL is a structured query language that is used to communicate with a database where the database is the organized collection of data that is usually stored electronically on your computer. 32. 10 Ways To Refactor Your Python Code 10 Ways to refactor Python code to make it more Pythonic 33. Python List Comprehension Beginner's Guide Today you’re going to learn about python list comprehension, a very powerful feature of python to use when creating a python List based on certain constraints. 34. Python for Beginners, Part 10: Primitive Data Types Let's cover the awesomeness of primitive data types. What are integers, floats, or strings!? I don't know... Let's find out! 35. Best Practices for Setting Up the 'Perfect' Python Project When starting a new Python project, it is tempting to just dive in and start coding. Spending a tiny amount of time to setup a project with the best tools will 36. Learning Python Variables As with all other languages, Python has variables that can be defined to hold data. 37. 40 Python Projects Ideas For Students Hello guys , in this blog post I have organized 40 Python projects that you might be interested trying out ranging from webscraping to to natural language processing. 38. Basic Data Types in Python Data types are one of the building blocks of python.
And You can do a lot of things with data types! 39. Top 5 Career Options and Online Courses for Python Developers (2021) Here are a few job roles that you can fill after completing your Python learning. 40. Python Substrings: Everything You Need to Know A python substring is a sequence of characters within a string, in this article you will learn various operations related to them and how to use them. 41. Introduction to the Print Function in Python print() function and input() function makes the program more interactive with the user. 42. Python for Beginners, Part 4: Interactive Shell vs. Script We will discuss the difference between an interactive python terminal vs. A python script. 43. Functions in Python—Easy or Hard to Learn & Master? In this post, I'll give the brief intro of each 6 highly used ML packages, what is the purpose and when to use. 44. Python for Beginners, Part 15: Solution Circle of Squares (Exercise) Let's go over the solution of how to create a circle out of squares, the exercise which I gave you in the last tutorial. 45. Python Basics: File Handling In this article you’re going to learn how to work with files in python, you gonna learn various techniques on how open, read, manipulate, and save files in python. 46. Python for Beginners, Part 9: Loops In this one, we explore the concept of looping constructs, visually, in computer programming. 47. Python for Beginners, Part 3: The Turtle Module In this part of the Learn Python for Beginners series... We go over how to use the turtle module and learn computer programming in a fun visual way. Things like functions, variables, and more will start to make sense instantly. 48. Python for Beginners, Part 14: E-1 Circle of Squares Learn how to write a function that makes a circle of squares! 49. Python for Beginners, Part 7: Fun Fun Functions What are functions? We discuss how functions work and allow you to use clean, reusable code. We do this while visualizing our code through the Turtle library in python. 50. Python for Beginners, Part 12: Lists of Things Let's talk about the list data structure of python and discuss why it's so wonderful. 51. Python for Beginners, Part 8: Function Arguments Let's see how functions accept multiple arguments, or parameters, or inputs. Those are interchangeable terms. 52. Python for Beginners, Part 13: Append List-Method Let's talk about the append method of a list and how it works 53. [Tutorial] Recognize Handwritten Numbers in Python without any ML-Library This little image classifier is a showcase of how easy it is to create a functional image classifier using just basic python and some easy to use and well-documented libraries. 54. Python for Beginners, Part 17: Boolean Algebra Jiu-Jitsu Let's talk about the most important thing in programming... BOOOOOOOLEAN ALGEBRA. Hmm... Is that a True statement OR False? Watch the video AND find out... Or NOT... Up to you. 55. Python for Beginners, Part 11: String Slicing Let's discuss string slicing and you'll know how string slicing is an amazing aspect of python programming. 56. Python for Beginners, Part 19: Conditionals and Control Flow Let's cover conditionals and control flow! This includes your Boolean logic combined with Boolean operators combined with if then type of statements! 57. Python for Beginners, Part 16: Dictionaries Let's talk about yet another fascinating data structure known as dictionaries. Ever wondered how your iPhone stores phone numbers and then allows for simple and efficient lookups? Well, no need to wonder anymore after you watch this video! 58. Python for Beginners, Part 18: Logical AND, OR, NOT Let's cover logical AND, OR & NOT.. 59. Python for Beginners, Part 20: For Loops Let's talk about 'for' loops and why they are so important! Anything that requires repetition. 'For' loops are your friends! Thank you for checking out the 59 most read stories about Python Basics on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

Docuten News on
HackerNoon and Around the Web

Winner for Best Startup in A Coruña, Southern Europe!

docuten.com

31 employees

Since 2009

Docuten Story Mentions

Articles Around the Web

Read More Tech Stories Related to #Docuten

Docuten News on HackerNoon and Around the Web