Red Access helps companies secure ... productivity or requiring the installation of a browser or extension. Red Access was <strong>founded by leading experts from the Israeli Cyber Community</strong> and is headquartered in Tel Aviv....

Red Access Features the World's First Agentless Secure Browsing ...

Protecting organizations from the ... the <strong>Red</strong> <strong>Access</strong> platform protects every desktop and mobile web app session across all browsers and user devices. It provides comprehensive coverage against browser-based exploits and threats without disruption to <strong>companies</strong>’ existing ...

Red Access - Products, Competitors, Financials, Employees, ...

Red Access <strong>provides the first agentless unified platform to secure all the enterprise browsing activity</strong>, in the complexity of in-office and hybrid work. The lightweight platform protects the employees’ devices from browsing-based cyber threats across any browser, web app, cloud service, and ...

Red Access | LinkedIn

Various <strong>companies</strong> have emerged with different approaches to the problem, including Secure Web Gateway providers (SWG), secure <strong>access</strong> service edge (SASE) providers, browser isolation providers, and secure enterprise browser providers. Despite emerging options, vendors have struggled to find the right mix of user experience and security to enable a safe and successful web session. After extensive market analysis, we believe Israel-based <strong>Red</strong> ...

Why we Invested in Red Access - Ten Eleven

<strong>Red</strong> <strong>Access</strong> was founded by security experts with both offensive and defensive experience from the Israeli Cyber Community. Co-Founders, Dor Zvi (CEO) and Tal Dery (CTO) both bring extensive knowledge in threat detection and response, malware analysis, and information security; having served many years in the Israel Defense Forces (IDF) technology units, followed by senior research and development positions at leading tech <strong>companies</strong>...

Red Access Emerges from Stealth with $6M Round to Secure Every ...

<strong>Red</strong> <strong>Access</strong>, <strong>a</strong> <strong>company</strong> that is offering a SaaS-based security platform for browsing, has announced the completion of a $6 million Seed round, led jointly by Elron Ventures and Ten Eleven Ventures. The <strong>company</strong> is developing software that secures each web session across any browser, claiming to ...

Red Access emerges from stealth, raises $6 million to ...

Red Access is that solution, <strong>the first SaaS-based platform to protect web browsing from cyber threats on any browser &amp; any in-app while ensuring frictionless user experience and maintainability</strong>. ... Security should fit the way employees work. Employees shouldn’t have to adapt their work habits ...

Secure Enterprise Browsing Solution | Red Access

Information on valuation, funding, cap tables, investors, and executives for <strong>Red</strong> <strong>Access</strong>. Use the PitchBook Platform to explore the full profile.

Red Access Company Profile: Valuation & Investors | PitchBook

Red Access was <strong>founded by security experts with both offensive and defensive experience from the Israeli Cyber Community</strong>. The team is composed of cyber researchers and engineers coming from leading security companies and from elite units of the IDF. Co-Founders, Dor Zvi (CEO) and Tal Dery (CTO) ...

About Us | Red Access

Where to find Bunker locations in Call of Duty Warzone by finding <strong>Red</strong> <strong>Access</strong> Cards, as well as the solve the puzzle of …

Call of Duty Warzone Bunkers: How to get Red Access Cards and open ...

Red Access

redaccess

This is a continuation of a series of articles in which I briefly cover the main points of a specific topic in system architecture design. The previous article can be read , and the complete guide you can find on my . here github The cache is a layer that stores a subset of data, typically the most frequently accessed or essential information, in a location quicker to access than its primary storage location. This caching strategy is used to reduce latency and improve the efficiency of across the distributed system. data retrieval Terms of Caching Occurs when the requested data is found in the cache, allowing for faster data retrieval. Cache Hit: This happens when the requested data is not in the cache, necessitating fetching the data from its primary storage location. Cache Miss: The process of removing data from the cache, typically to make space for new data. Cache Eviction: Refers to the situation where the data in the cache is outdated compared to the data in the primary storage. Cache Staleness: The process of preloading the cache with data before it is actively used to avoid cache misses in the early stages of usage. Cache Warm-Up: : The status of data stored in a cache: Cache State : Cache contains data that is being accessed very frequently and recently. Hot : Cache is not as actively used as a hot cache but still contains relatively frequently accessed data. Warm : Cache is first initialized and has not yet had any data loaded. Cold Benefits of using Caching Caching significantly decreases the time it takes to access data, leading to faster response times for user requests. Reduced Latency: By storing frequently accessed data locally, caching reduces the amount of data that must be transmitted over a network, thereby decreasing network congestion. Decreased Network Traffic: Caching reduces the number of queries to primary data sources like databases, decreasing their load and potentially increasing lifespan. Lower Load on Primary Data Stores: Applications and systems often experience a general performance boost, as retrieving data from a cache is typically faster than accessing it from primary storage. Improved Performance: Systems can handle more data and user requests in a given time due to the efficiency gains from caching. Increased Throughput: In some caching strategies, data can still be available even if the primary data source is temporarily unavailable. Data Availability: Challenges of using Caching Ensuring that data remains consistent across multiple caches in a distributed system. Cache Coherence: Deciding when and how to update or remove data in the cache, especially when the original data changes. Cache Invalidation: Handling scenarios where data in the cache is outdated compared to the primary data source. Stale Data: Determining the optimal size of the cache to balance performance gains with resource usage. Cache Sizing: Choosing appropriate algorithms for which data to keep in the cache and which to evict when the cache is full. Cache Eviction Policies: Ensuring data is stored in a cache close to where it is most frequently accessed to minimize latency. Data Locality: Ensuring the cache can scale as the amount of data and the number of users increase. Scalability: Managing the time for a cache to “warm up” and become effective after being cleared or created. Warm-up Time: This occurs when a cached item expires, and multiple clients or processes simultaneously attempt to regenerate the same cache item, causing a surge in load on the data store or compute resources. Thundering Herd Problem: This happens when queries for non-existent data (not in cache or primary storage) repeatedly bypass the cache and hit the database, potentially leading to performance degradation. Cache Penetration: Arises when a single cache key is associated with a large amount of data, leading to inefficiencies in cache utilization and potential performance issues. Big Key Problem: Refers to a situation where a few keys are accessed much more frequently than others, causing load imbalances and potential bottlenecks in the caching system. Hot Key Challenge: Types of Caching Caching web content in a browser or device to accelerate content retrieval. Client Side: Distributing content across multiple geographic locations to improve access speed. CDN (Content Delivery Network): Balancing incoming network traffic and requests across multiple servers and potentially caching these requests. Load Balancer / API Gateway: Caching within an application to improve performance and data access. Application: Stores frequently accessed data to reduce CPU access time. CPU Cache: : Instruction and Data L1 : Shared or per-core L2 cache L2 : Shared among multiple CPU cores L3 Caching data within a single application process. In-memory Cache: Sharing cached data across different processes in the same system. Shared Memory Cache: : Caching read operations from a physical disk. Disk Cache : The file system may cache frequently accessed data and metadata. File System Caching : Modern operating systems often employ disk caching to improve I/O performance system-wide. Operating System-Level Disk Caches : Some applications implement their caching mechanisms to store and manage frequently used data. Application-Specific Caches : Some third-party caching solutions and libraries can be integrated into applications to provide caching capabilities. Third-Party Caching Solutions Sharing cache across multiple systems or services. Sharding techniques: Distributed Cache: : Data is partitioned and distributed across cache nodes based on the keys of cached items. Key-Based Sharding : Distributing data based on a range of values. Range-based : Data is partitioned using a hash function that evenly distributes keys across multiple shards. Hash-Based Sharding : This technique combines the benefits of key-based and hash-based sharding. It uses a consistent hashing algorithm to map keys to cache nodes, allowing for dynamic scaling without significant data redistribution. Consistent Hashing Indexing and searching through documents or logs. Full-text Search: Storing frequently accessed database queries and results to speed up future requests. Database: Top Caching Strategies Cache Aside Also known as "Lazy Loading," this strategy involves loading data into the cache on demand. When an application requests data, it first checks the cache. If the data is not found (cache miss), it is fetched from the database and stored in the cache for future requests. Pros: Prevents unnecessary data from being loaded into the cache. Offers fine-grained control over what is cached. Cons: This can lead to increased latency for cache misses as the application must wait for data to be loaded from the database. Requires additional complexity in application code to manage caching logic. Read Through In this approach, data is automatically loaded into the cache from the database when there is a cache miss. The application only interacts with the cache and not directly with the database for read operations. Pros: Simplifies application logic as the caching layer handles data loading. Ensures that only requested data is loaded into the cache, saving space. Cons: Initial read operations may be slower due to cache misses and subsequent database access. The cache can become a bottleneck if it is not efficiently managed. Write Around When data is written, it is written directly to the database and not to the cache. The cache is only updated when data is read. Pros: Reduces cache churn by avoiding caching data that is infrequently read. Minimizes the risk of cache and database getting out of sync. Cons: Can lead to slower read operations following a write, as the data must be loaded into the cache from the database. May increase database load since every write goes directly to the database. Write Back (Write Behind) Data is first written to the cache and then, after a certain amount of time or under certain conditions, written back to the database. This allows for batch updates. Pros: Improves write performance as operations are done quickly in the cache. Reduces database load by batching write operations. Cons: Risk of data loss if the cache fails before data is written back to the database. Complexity in ensuring that the cache and database are eventually synchronized. Write Through Data is written simultaneously to the cache and the database. This ensures data consistency between the cache and database. Pros: Guarantees data consistency as writes to the cache and database are synchronous. Easy to implement and understand. Cons: Can lead to higher latency for write operations as they must be completed in both cache and database. Increased load on the database for every write operation. Cache Eviction Policies Cache eviction policies are critical in caching systems due to the limited size of caches; they ensure optimal use of available space by determining which data to retain or discard. These policies enhance overall cache performance by keeping the most relevant data accessible while maintaining data accuracy and consistency by removing outdated or less frequently used information. The most well-known strategies include the following: Evicts the oldest items in the cache first, regardless of their usage frequency. First In, First Out (FIFO): Evicts the least recently accessed items first, assuming that items not accessed recently are less likely to be accessed in the future. Least Recently Used (LRU): Opposite of LRU, it evicts the most recently used items first. This can be useful when the most recent items are less likely to be reaccessed. Most Recently Used (MRU): Prioritizes eviction of least frequently accessed items, assuming frequent access implies future relevance. Least Frequently Used (LFU): : Eviction policy is a cache eviction strategy where the cache identifies and removes the data items that are accessed most frequently. Most Frequently Used (MFU) Randomly selects a cache item to evict, which can be simpler to implement and effective in specific scenarios. Random Replacement (RR): Evicts items based on their size to manage the memory footprint, often used in combination with other policies. Size-Based Eviction: Cache invalidation In addition to removing infrequently accessed items, caches often contain data that becomes obsolete or stale. These outdated cache entries need to be identified and slated for removal. The most well-known strategies include the following: Data is invalidated after a specified duration. When the TTL expires, the cached data is either automatically removed or marked as invalid. There are two approaches: Time to Live (TTL): : A background process or thread periodically scans the cache to check the TTL of cache entries. Active expiration : Checks the TTL of a cache entry at its access time. Passive expiration When data is updated in the primary storage, corresponding cache entries are invalidated. This ensures consistency between the cache and the source. Write-Invalidate: The cache listens for notifications from the data source about changes. When notified, the cache invalidates the relevant entries. Change Notification: The cache periodically checks the validity of its entries by comparing them with the source data. Polling: Popular Solutions List of some popular caching solutions widely used in various applications and systems: An in-memory data structure store used as a database, cache, and message broker and known for its performance and flexibility. Redis: A high-performance, distributed memory object caching system primarily used for speeding up dynamic web applications by alleviating database load. Memcached: An open-source, Java-based cache that provides fast, off-heap storage. It’s widely used in Java applications for caching. Ehcache: A distributed database, caching, and processing platform designed for transactional, analytical, and streaming workloads at a large scale. Apache Ignite: An in-memory computing platform that provides distributed caching, messaging, and computing. Often used for performance-critical applications. Hazelcast: A caching and forwarding HTTP web proxy. It can cache web, DNS, and other computer network lookups for people sharing network resources. Squid: These are not traditional caching solutions but are often used for caching static and dynamic content closer to the end users in distributed networks. CDN Solutions (like Akamai, Cloudflare): In conclusion, caching is a critical component in modern computing, offering a powerful solution to enhance performance, reduce latency, and manage data efficiently across various systems and applications. From accelerating web page loading times to optimizing database queries, caching is pivotal in improving user experiences and system responsiveness. Popular solutions like Redis, Memcached, and CDN services demonstrate the versatility and adaptability of caching strategies to different needs, from small-scale applications to large, distributed architectures.

The System Design Cheat Sheet: Cache

TO PROVE BY AUTHORITY A PASSAGE TO BE ON THE NORTH SIDE OF AMERICA

One of the main features of DynamicDocs API is the ability to generate PDFs from JSON to PDF templates. As of today, the JSON to PDF template library consists of contracts, quotes, invoices, statements, proposals and more. To utilise this feature further, we have developed a DynamicDocs Excel Add-in, which can formulate payloads and integrates with DynamicDocs API directly from Excel. Specifically, users can use Excel Add-in to call any template endpoint and download the newly created PDF into a specified folder, all at a click of a button. JSON To make it easier to start using the Add-in, we have built a library of Excel to PDF templates containing XLSX files already set up to generate a large variety of PDFs. In this article, we briefly describe the DynamicDocs Excel Add-in and provide a quick guide on how to get started with it. Advantages of Excel to PDF Add-in Excel to PDF conversion is incredibly useful if your data can be accessed in Excel and you require to include this data into a PDF document. The popularity of Excel rests on its user-friendly interface, which can be used to set up various automations using built-in functions and VBA macros. Piggybacking on this functionality, DynamicDocs Excel Add-in lets users create JSONs which are then used to send to the API to generate the PDF documents. Excel also acts as a layer where the users can make adjustments to the data just before creating the documents, giving the user an additional level of control. Should the user needs further changes after the PDF was made, this is just a button click away. The Excel to PDF templates are set up in a way which lends itself to batch processing. Each template can create 3 PDFs simultaneously, and additional documents can be added easily. The API calls are done at the same time, which means that waiting for 3 or 20 PDFs takes approximately the same amount of time. Additional functionality like naming files or setting a password to the PDF is readily available via the Add-in functions. Instructions to Get Started With DynamicDocs Excel Add-in To get started with DynamicDocs Excel Add-in, you will need to perform the following steps: DynamicDocs Excel Add-in is available for from ADVICEment.io. download Once installed, you will need to generate your API key (called Adv-Security-Token) from your account by going to the Dashboard -> Account Details -> Edit -> Security Settings -> Generate Account Security Token. You need to write down or copy this key somewhere safe. Note that you cannot reaccess it, and should you lose it for security reasons, you will have to generate a new one. Currently, the DynamicDocs Add-in is only available on the paid plans (starting from $49/month), as the Add-in does not work with the Free plan. You can still download and use its functions, but no API calls will be made. Once you have obtained your API key, copy it to the Settings under the DynamicDocs ribbon at the top of Excel. This will authenticate your API calls. In the Settings menu, you can specify the Default Save Location where you want the newly generated PDFs to be saved. Now, you are ready to create PDFs from Excel. Go to the 'Create PDFs' sheet, select one of the cells with the 'DynamicDocsApiCall' function and click 'Active Cell' in the DynamicDocs ribbon. This action will make that specific API call and create the PDF document. To make all the API calls simultaneously, click the 'All' button in the DynamicDocs ribbon. For more information on using DynamicDocs Add-in, please visit the page. DynamicDocs Excel Add-in Documentation If you are looking for a specific template to be made, please . drop us a message Excel to PDF Template Structure Now let's look at one of the Excel to PDF templates to understand how to use it and amend it for your requirements. We will consider the , which can be downloaded on its template page. Create QR Code PDF in Excel v1 In the XLSX file, there are four main sheets, i.e., , , and . Instructions Create PDFs Document Settings Document Content The sheet provides a quick guide to get started, similar to the previous section of this article. Instructions The sheet allows the user to change the typesetting of the document, including fonts, colours, and page dimensions. Note that the colours follow the HEX colour codes. Document Settings The sheet allows the user to edit and change the details and content of an individual template. In this case, the QR code can be encoded with any text or URL, and a caption can be added to the document. Document Content The sheet generates the PDFs using the DynamicDocsApiCall function. Note that before generating the PDFs, the user must add their unique Adv-Security-Token (API key) and default save location in the Settings menu of the Add-in ribbon. The sheet also creates the full JSON and combines the JSONs from the and sheets. All Excel to PDF templates have a similar structure. Create PDFs Document Settings Document Content Summary In summary, DynamicDocs Excel Add-in solves the API integration issue and uses Excel as the interface to streamline the PDF generation process. Suppose your data is in Excel (or can be imported easily), and you need to create high-quality PDFs. In that case, DynamicDocs Excel Add-in is a strong contender to solve this particular problem.

What is the DynamicDocs Excel Add-In and How Do You Use It?

¿Qué es el complemento DynamicDocs Excel y cómo se usa?

Qu'est-ce que le complément DynamicDocs Excel et comment l'utilisez-vous ?

डायनामिक डॉक्स एक्सेल ऐड-इन क्या है और आप इसका उपयोग कैसे करते हैं?

DynamicDocs Excel アドインとは何ですか? どのように使用しますか?

O que é o suplemento DynamicDocs Excel e como usá-lo?

Phần bổ trợ DynamicDocs Excel là gì và bạn sử dụng nó như thế nào?

什么是 DynamicDocs Excel 加载项以及如何使用它？

Generate Gmail — Check Inbox — Read messages — Restore Gmail Sometimes you come across a number of adverts and websites that you need to signup for but don’t completely trust. Temp mail is the most effective solution in this situation. These disposable email addresses replace your original ones and are expired after a certain time limit. There are a number of online sites and services that help you make a temporary email address, however, in this tutorial, I am going to teach you how to create your own temporary Gmail addresses and receive emails at that address using Python. Import Libraries For this tutorial, we will be using only 2 python libraries That are “ and . If you don’t have them already installed, use the commands below to install them: re” “request” pip3 install request
pip3 install re And then import them: import request
import re Generate Gmail The very first step is to subscribe to the API via (It’s totally free). Temp-Gmail Rapid API Once you are subscribed, you will be given a private key that will be used to access the API (by library) and generate new Gmail addresses. “request” The function below shows how you may generate a new Gmail address and print out its address as well as the password. def generate_gmail(ID: str):
  
  # access the API
  url = "https://temp-gmail.p.rapidapi.com/get"
  querystring = {"id":ID,"type":"alias"}
  headers = {
    'x-rapidapi-host': "temp-gmail.p.rapidapi.com",
    'x-rapidapi-key': "f46d0d682dmsh95ed9f4dc7225e2p146570jsn1d8f86b7de46"
    }
  
  # send a request to the API
  response = requests.request("GET", url, headers=headers, params=querystring)
  
  # convert the response to JSON format 
  json_response = response.json()
  # get gmail address
  gmail = json_response['items']['username']
  # get gmail password
  password = json_response['items']['key']

  print('Gmail address: %s' % str(gmail))
  print('Password: %s' % str(password)) Input Example:

generate_gmail(ID=3)

Output Example:

Gmail address: lauraburm.rs.131.9.8.8@gmail.com 
Password: ***********R094ngJVIKMdXhfVCiMEEElE82Es Note that the input “ID” is just an integer that corresponds to a specific Gmail address in the API dataset (contains 1000 Gmails). If you change the value of “ID”, the function will generate a different Gmail address. Check Inbox All right, now that we have created a temporary Gmail address, we can check its inbox. The function scans for the new incoming mails. check_inbox(gmail: str, password: str) If there is none, it returns a message that the inbox is empty. Otherwise, the mail , sender name, date, time, and the subject are printed out. We will need the in the next section to read the body of the mail. message_id message_id def check_inbox(gmail: str,password: str):

  # access the API
  url = "https://temp-gmail.p.rapidapi.com/check"
  querystring = {"username":gmail,"key":password}
  headers = {
      'x-rapidapi-host': "temp-gmail.p.rapidapi.com",
      'x-rapidapi-key': "f46d0d682dmsh95ed9f4dc7225e2p146570jsn1d8f86b7de46"
      }
  
  # send a request to the API
  response = requests.request("GET", url, headers=headers, params=querystring)
  
  # convert the response to JSON format 
  json_response = response.json()
  
  # print the message from the API
  print('API message: %s' % str(json_response['msg']))

  # check whether the inbox is empty or not
  if json_response['items'] == []:
    print("inbox is empty")

  # if the inbox is not empty, print the details of the newest mail
  else:
    message_id = json_response['items'][0]['mid']
    print('Message ID: %s' % str(message_id))
    print('From: %s' % str(json_response['items'][0]['textFrom']))
    print('Date: %s' % str(json_response['items'][0]['textDate']))
    print('Subject: %s' % str(json_response['items'][0]['textSubject'])) Input Example

MyGmail = "lauraburmr.s13198.8@gmail.com"
MyPassword = "***********QEQfM4cFqy2aie6sA6kPpxEMKGFNSQl4"

check_inbox(gmail=MyGmail, password=MyPassword)

Output Example

Message ID: 17e5dd60676eed04 
From: Amir Ali Hashemi 
Date: 2022–01–15 20:03:22 
Subject: TEST EMAIL Read inbox Message In order to read the content of the mail, we should have the Gmail address and the . If we send a request to the API providing these two values, the API returns the body message in the HTML format with all those HTML tags attached to it. See the example below message_id <div dir=”ltr”><div>This is a test mail sent by amir-tech</div><div><br></div></div> Hence, we may use the library to remove the HTML tags and print the cleaned body message. re def read_message(gmail: str, message_id: str):
  
  # access the API
  url = "https://temp-gmail.p.rapidapi.com/read"
  querystring = {"username":gmail,"message_id":message_id}
  headers = {
      'x-rapidapi-host': "temp-gmail.p.rapidapi.com",
      'x-rapidapi-key': "f46d0d682dmsh95ed9f4dc7225e2p146570jsn1d8f86b7de46"
      }
  
  # send a request to the API
  response = requests.request("GET", url, headers=headers, params=querystring)
  
  # convert the response to JSON format 
  json_response = response.json()
  
  # remove the html tags from the body of the mail
  body_message = re.sub(r'<.*?>', '', json_response['items']['body'])
  print('Body message: %s' % str(body_message)) Input Example

MyGmail = 'lauraburmr.s13198.8@gmail.com'
MessageID = '17e5dd60676eed04'

read_message(gmail=MyGmail, message_id=MessageID)

Output Example

Body message: This is a test mail sent by amir-tech Restore Gmail As mentioned at the beginning of this tutorial, temporary emails expire after a certain time limit (Usually after 10 minutes). Meaning that the password will be reset! Therefore, If you have created a Gmail address and want to reaccess it after a period of time, you need to restore it. The function takes your already generated Gmail address and sets a new password for it so it can be reused. restore_gmail(gmail: str) def restore_gmail(gmail: str):
  
  # access the API
  url = "https://temp-gmail.p.rapidapi.com/restore"
  querystring = {"username":gmail}
  headers = {
      'x-rapidapi-host': "temp-gmail.p.rapidapi.com",
      'x-rapidapi-key': "f46d0d682dmsh95ed9f4dc7225e2p146570jsn1d8f86b7de46"
      }
  
  # send a request to the API
  response = requests.request("GET", url, headers=headers, params=querystring)
  
  # convert the response to JSON format 
  json_response = response.json()

  print('Gmail address: %s' % str(json_response['items']['username']))
  print('Password: %s' % str(json_response['items']['key'])) Input Example

restore_gmail(‘lauraburm.rs.131.9.8.8@gmail.com’)

Output Example

Gmail address: lauraburm.rs.131.9.8.8@gmail.com 
Password: *******************m7qLnoGbR094ngJVIKMdXhfVCiMEEElE82Es Conclusion To conclude, temp mails not only may be used for personal purposes but also can be integrated into programming projects to bring more functionality. I personally created a temp Gmail Telegram bot using this API and use it on daily basis to sign up for untrusted websites. Also Published Here

Create a Temporary Gmail Account With Python

About 30 years have passed since the very first ransomware attack. While the combination of a creative human mind and new technologies has helped create working solutions against one of the nastiest cyberattacks in the world, ransomware is still a menace capable of destroying both private and corporate lives. Ransomware works by encrypting the user’s data, making it unreadable. If a user wants their data back, a ransom must be paid. However, nothing guarantees you’ll get your files even if you agree to pay. In most cases, the attacker flees without giving you the key to deciphering your computer or infected files. We can agree that prevention is the best remedy to prevent ransomware. A well-established and secure IT infrastructure is a must, especially if you run a corporate network full of clients’ and business’ sensitive data whose theft might threaten to affect your future. Keep reading to learn more about ransomware, its most common forms, and the best ways to prevent it. How Does Ransomware Work? Ransomware is based on asymmetric encryption, a type of cryptography that uses a pair of keys to encrypt and decrypt files. Once the ransom is paid, the attacker gives the user the private key to unlock their files and reaccess them. However, that’s not always the case. Even though it’s impossible to decipher your files without the key, it’s not recommended to pay the ransom either – the keys to some older versions of ransomware are possible to break, as many antivirus programs have developed that option. Ransomware can enter the system through various channels – downloading files from shady websites, email scams, and targeted attacks. Once exploited, ransomware starts encrypting the victim’s valuable files, including Word documents, images, databases, and programs containing confidential information. But that’s not all. Ransomware can spread very quickly, exploiting other vulnerabilities and potentially infecting the entire organization’s network and systems. The next step toward recovering the files lies in paying the ransom, typically within 24-48 hours, in cryptocurrency. Why is Ransomware Spreading so Quickly? Malware kits are available anywhere, allowing even non-tech-savvy thieves to use the latest encryption methods to take over the victim’s network. Anyone who wants to employ ransomware with filthy end goals may consult a growing ransomware Marketplace and get a malware kit from malware authors, who profit by requesting a cut in ransom processes. Besides, the use of the latest technologies and the companies’ tendency to neglect cybersecurity allow for more efficient ransomware employment, which is now capable of encrypting the entire disc instead of particular files on the user’s device. Which are the Most Common Types of Ransomware? No one can say the exact number of ransomware that emerge every day, but there are two main types of this insidious cyberattack – crypto-ransomware and locker ransomware. Crypto-ransomware works by encrypting the user’s files, making them unreadable and unusable. It’s a more frequent form of ransomware cybercriminals use to generate income, as the solution for data recovery is paying the ransom. In most cases, there is a deadline the victim must meet if they want their files back. On the other hand, locker ransomware aims to lock the user out of their device. Instead of their valuable files, the users face the entire system hijack. To get it back, they must pay a ransom within the deadline set by the attacker. Other common forms of ransomware are the following: Bad Rabbit CryptoLocker CryptoWall CTB-Locker Jigsaw Keep in mind that new forms of ransomware arise every day, and each of them is worse than the previous. For that reason, it’s essential to reinforce your system and mitigate the risk of a cyber threat that could put your company or personal life at risk of being exposed to unreliable sources. And that leads us to the following section – Prevent Ransomware attacks And that leads us to the following section – Prevent Ransomware attacks How to Prevent Ransomware Attacks? You can protect your network from various types of malware by implementing the latest anti-ransomware solutions and being careful when exploring the web. For instance: 1. Install the Latest Antivirus and Anti-Ransomware Program Antivirus software has always been one of the most viable cybersecurity solutions. The most recent programs feature the most advanced technologies like content filters and virus scanners, which allow you to detect and block the threat before it makes any changes to your system. By implementing cutting-edge antivirus software, you can reinforce your system security and do your job with peace of mind. Besides high-end endpoint solutions, you can enjoy free versions that provide a stellar user experience and next-level protection from the most dangerous forms of cybercrime. 2. Avoid Unknown USB Sticks to Prevent Ransomware Attacks USB sticks conveniently transfer malicious software, including ransomware, into a system. For that reason, cybercriminals leave infected devices in public places, hoping to trick someone into using them. Therefore, never use USB sticks from unknown sources, as it may be a way to let the attacker lock your system. 3. Don’t Open Suspicious Email Attachments. Ransomware is widely spread through email attachments. If the sender’s email address seems suspicious, ensure you delete the message immediately – if you open the attachment containing ransomware instead, it will be executed automatically on your device. 4. Use VPN to Prevent Ransomware attacks If you’re using a public WiFi network, it’s recommended to encrypt it with a VPN. Virtual Private Network will keep your computer safe from network vulnerabilities and unauthorized access to your sensitive data, which comes in handy for online transactions or sharing personal files. 5. Ensure Your Systems are Up to Date Obsolete software versions or false licenses expose your system to various kinds of vulnerabilities. For that reason, make sure your programs are up to date, containing the latest security patches. That way, attackers will find it more challenging to find gaps in your system protection. Conclusion Your system security is in your hands. Perform careful actions, avoid suspicious sites and email attachments, and never trust a stranger with a USB stick. All these “amenities” open the door to cyber threats and advanced forms of ransomware that no one can deal with. Backups can save you from the total loss, but you cannot rely on them entirely. If cybercriminals encrypt them, as well, you can say goodbye to your files. Remember that you cannot have too many security measures – be careful, and ransomware will stay away from you!

How To Prevent Ransomware Attacks: A Threat That’s Real

Tools I use will focus on . Some of the tools you might already know but hopefully not all the functions and features as I try to elaborate on the once not obvious on the first place. Without further ado, please enjoy the tools below. simplifying your life in your communication, grammar, focus at work or study, little notes and two tools for Google Chrome Instant language Translation Around you Google Translate — and play.google.com itunes.apple.com As this is an obvious one to translate text, many might not know about the app having . See how it work in the video. on-the-fly translation using your camera Same goes for pictures. For example, as I am living in Denmark with not speaking Danish at all, I never had any problems reading my letters or anything in the shop with the native Google Translate. It sounds like a small thing, but ! if you travel or live in a foreign country, it can save your life Call or Video Skype — Skype.com Same goes for voice calling or chatting on Skype. They have this new option that you add Skype Translator to your conversation, define your language and . As an example below is a chat message, same goes for voice though. Skype will translate it to the language of the others person Grammar correction Grammarly — grammarly.com I am using Grammarly since blogging more regularly. It helps me . The feature I like the most is if you double click a word — it works live in the browser on any websites or mobile app — you get instant synonyms. This saves me much time switching between and my page plus makes my text more (hopefully) appealing to you guys! 😉 finding obvious mistakes and also recommending me words that are overused Thesaurus I am using the premium features but try out the free version, that is also very helpful compared to none. Email Google Inbox — inbox.google.com If you use or have , you can use Google Inbox straight away, which is only a view on top of your Google emails. Gmail Inbox is One step is it bundles each email in low priority, promo, updates, financial, purchases and your individual categories for you. Another helps you to with this three states: made out of simplicity. use less time on emails and get them done read and mark it as done -> then it will get archived and removed from your inbox not read and mark it important -> it stays distinctive in your inbox or snooze -> it will remind you later that you will not forget Categorisation or bundling Google uses artificial intelligence to bundle your email. This is especially handy when it comes to travel. As you can see in the image below, all emails related to the same trip like hotel, travel, activities or any other email is grouped to the same folder. I didn’t do anything myself everything done automatically — including a lovely picture from each destination. If you click on the trip, you see all email attached to it and also flight details in one view: Of course, Google will read your email content for that purpose, but they do that already so why not making use of it. Automatic suggested replies Another thing is, if you reply to an email, Google tries to give you a standard reply and suggests it to you before even writing one single word. A bit spooky isn’t it? However, if correct, it can save a couple of minutes every day 👌🏻. Other extremely helpful features It saves i . For example normal invites of course, but also concerts, flights and so forth. nvites automatically to your calendar You can save a link for later. Sometimes you have a link you would like to remind you for later, in that case, where should you put it? If you open Inbox, you can besides creating a new email click and remind you That way it stays like an email in your Inbox, pretty cool hah? save for later For more see the video below: Snooze emails in Gmail Boomerang — boomeranggmail.com If you still want to use Gmail but missing the snooze function to remind you or sent email to a later time automatically, you can use the add-on to Gmail that is called Boomerang. Music that keeps you focused Focus @ will — Brain.fm — Noisli — or same no-vocal-music and put into a loop focusatwill.com brain.fm noisli.com As mentioned already in my earlier blog about , I used, and I still do use Focusatwill. However, I am started experimenting with Brain.fm as Focusatwill has a very crapy Android app with lots of bugs which they did not fix it within the last two years. The web version is still fine though, but at work is much more convenient to use the app on my phone. post music while working Nonetheless, what is the reason to use music that keeps or brings you into focus state? Why not if you can is my question? Maybe because you did not know? It is and in the best quality**.** But how do we do that? Right, with music that works like drugs on your brain. As many of us play the wrong music in the background, . crucial to get into a state of deep work if you want to get as much done music is designed to connect with you intellectually and emotionally which lowers comprehension and creates a distraction See the that shows the difference between music from Placebo and Brain.fm: study The three mentioned music apps above are . I am using them for a very long time, and I can assure you, they work! Sometimes I get even a little headache as my brain is in such a deep state of concentration for an extended period. Related to the including some FAQs from Brain.fm it is is a good sign that your brain is hard working and can be avoided by drinking more or using the music less long as the effect also takes place when you start listening and then stop the music after a while. designed by neuroscientists and tested on human brains to not give any distraction HowTo Try it yourself, now?! The perfect headphones Bose QuietComfort 15 — Bose QuietComfort 35 — Bose QuietComfort 15 Cancelling Bose QC35 on Amazon Related to the music that keeps you focused mentioned above, . I am using since three and more years the headphones from Bose. They are quite expensive as you pay the brand as well, but they were the first creating the active noise-cancelling that blocks out loud noise outside of your environment. If you have not experienced it yet yourself, you should try, it is fantastic! Of course, nowadays other companies copied that, and you can get cheaper headphones. I stick to it and recently bought the second noise-cancelling headphones from Bose with Bluetooth, and I do not regret any dollar paid for it. , I do not mind having any delays, crying babies or any other occurrences that can happen during a trip any longer. to get even more focused, you should have a good headphone Especially for travelling See the noise cancelling in action: Little Notes Google Keep — (Android/iPhone) keep.google.com After writing a full post about why should you use another note app? The difference is that OneNote is perfect for sophisticated and comprehensive notes whereas I use Google Keep for small notes with no timeline. Keep is easy and straightforward with little stickers with different colours that you can move around plus useful features like sharing it with your family or friends if you have a common todo-list and you can access it from everywhere either with your mobile app and also on the computer, it is automatically synced (cloud-based). OneNote For example shopping lists, payment list, movies or series to watch etc. Chrome add-ons Besides recently announced tools like RescueTime, LastPass, Xmarks, Grammarly that can also be added to chrome I will introduce here two more apps only for Google Chrome. Momentum Google Chrome — App Store — Momentum This one is a straightforward one. Whenever you open a new Chrome tab, this one will open an . As well you can add simple todos each day. The awe-inspiring mostly landscapes makes me a happy every time I open a new tab instead of having an annoying white tab. Plus it reminds you gently to your todos from today before you open a possible distracting webpage. astonishing picture including a quote changing every day OneTab Google Chrome — App Store — OneTab OneTab is a convenient one. Whenever you find yourself with too many tabs what usually happens pretty fast to me, you can . click the OneTab icon to convert all of your tabs into a list. When you need to reaccess the tabs, you can either restore them individually or all at once When your tabs are in the OneTab list, because you will have reduced the number of tabs open in Google Chrome. I usually have my OneTab pinned to Chrome like shown below: you will save up to 95% of memory Ending words Please also check my or about Microsoft OneNote and also let me know in the comments below if you have other cool, productive tools that you use. Plus stay tuned, there will be a part IV for sure as I still have many tools in the pipeline! part I part II Originally published at www.sspaeti.com on April 7, 2018.

10 Tools That Will Boost Your #Productivity

As programmers, we have probably needed to implement social media login at some point and, this is an increasingly common functionality in today’s applications and websites. Social login allows users to log in to applications or websites using their accounts such as Facebook, Google, Twitter, etc. This saves users time by not having to create an additional account and password and taking advantage of the social network’s security measures. For example, if a user has enabled two-step authentication on their Google account, this security will also apply to the application or website they are using. In this tutorial, we will implement Github and login in a React application with TypeScript. We will use Vite to create our application and pnpm as package manager. Google Login with RRSS’s first steps First of all, to use the authentication services of any platform, we need to create an OAuth application and obtain the necessary keys. For GiHub follow these steps. For Google follow these steps Make sure to keep the keys in a safe place. After this, we are going to start the development of our application. Since in this application we will make use of sensitive and private data such as client secret keys, it is necessary to create a backend and use it on the server side for security reasons. So we will have two applications, backend and client, each in its directory. Setting up Backend We create our application with the following command: pnpm init -y We install the dependencies that we will need in the project: pnpm install express axios cors dotenv tsc ts-node pnpm install @types/cors @types/express @types/node ts-node-dev typescript -D After that, we create the following structure for the project: ├── src/
│   ├── routes/
│   │   ├── github-routes.ts
│   │   └── google-routes.ts
│   ├── controllers/
│   │   ├── github-controller.ts
│   │   └── google-controller.ts
│   └── server.ts
├── .env
├── .env-example Setting up Client We install the dependencies that we will need in the project: pnpm install @octokit/auth @react-oauth/google @nextui-org/react axios react-router-dom After that, we create the following structure for the project: ├── src/
│   ├── assets/
│   │   ├── icons/
│   │   │   ├── Github.tsx
│   │   │   ├── Google.tsx
│   │   │   ├── Logout.tsx
│   │   │   └── index.ts
│   ├── pages/
│   │   ├── home/
│   │   │   ├── services/
│   │   │   │   └── home-services.ts
│   │   │   └── HomePage.tsx
│   │   └── login/
│   │       └── LoginPage.tsx
│   ├── index.tsx
│   ├── App.tsx
│   └── main.tsx
├── .env
├── .env-example GitHub Login Backend File : server.ts import express from 'express';
import cors from 'cors';

import githubRoutes from './routes/github-routes';
import googleRoutes from './routes/google-routes';

const PORT = process.env.PORT || 3001

const app = express();

app.use(
  cors({
    origin: ['http://localhost:5173'],
    methods: 'GET,POST',
  }),
);

app.use(express.json());

app.use('/api/github', githubRoutes);
app.use('/api/google', googleRoutes);

app.listen(PORT, () => console.log('Server on port', PORT)); This code creates a server application with Express. The application uses the cors library to enable cross-origin access (CORS) and sets the origin and allowed methods. The application also uses the function to enable the use of JSON in requests and to define routes for the GitHub service and the Google service. app.use() Finally, the application listens on the port specified in the constant, or on port 3001 if no port is specified. PORT File : github-routes.ts import express, { Request, Response, Router } from 'express';
import { getAccessToken, getUserData } from '../controllers/github-controller';

const router: Router = express.Router();

router.get('/accessToken', (req: Request, res: Response) => {
  const code = req.query.code;
  getAccessToken(code as string).then((resp) => res.json(resp));
});

router.get('/userData', (req: Request, res: Response) => {
  const accessToken = req.query.accessToken;
  getUserData(accessToken as string).then((resp) => res.json(resp));
});

export default router; This code creates an Express router which defines two routes y . /accessToken /userData The route s a GET route that takes a parameter from the query and calls the function of the GitHub service. /accessToken code getAccessToken The rute is a GET route that takes an parameter from the query and calls the function of the GitHub service. /userData accessToken getUserData File : google-routes.ts import express, { Request, Response, Router } from 'express';
import { getUserData } from '../controllers/google-controller';

const router: Router = express.Router();

router.get('/userData', (req: Request, res: Response) => {
  const accessToken = req.query.accessToken;
  getUserData(accessToken as string).then((resp) => res.json(resp));
});

export default router; This code creates an Express router that defines a GET route called . The route takes an parameter from the query and calls the function of the Google service. /userData accessToken getUserData File : github-controller.ts import * as dotenv from 'dotenv';
import axios from 'axios';

dotenv.config();

type AccessTokenData = {
  access_token: string;
  token_type: string;
  scope: string;
} | null;

export const getAccessToken = async (
  code: string,
): Promise<AccessTokenData> => {
  try {
    const params = `?client_id=${process.env.GITHUB_CLIENT_ID}&client_secret=${process.env.GITHUB_CLIENT_SECRET}&code=${code}`;

    const { data } = await axios.post(
      `https://github.com/login/oauth/access_token${params}`,
      {},
      {
        headers: {
          Accept: 'application/json',
        },
      },
    );

    return data;
  } catch (error) {
    console.log(error);
    return null;
  }
};

export const getUserData = async (accessToken: string) => {
  try {
    const { data } = await axios.get('https://api.github.com/user', {
      headers: {
        Authorization: `Bearer ${accessToken}`,
      },
    });

    return data;
  } catch (error) {
    return null;
  }
}; The function receives the parameter makes a POST request to the GitHub API to obtain an access token using the provided , and . getAccessToken code client_id client_secret code The function receives the parameter and returns the user information from the GitHub API using the access token provided in the request. getUserData accessToken File : google-controller.ts import axios from 'axios';

export const getUserData = async (accessToken: string) => {
  try {
    const { data } = await axios.get(
      'https://www.googleapis.com/oauth2/v3/userinfo',
      {
        headers: {
          Authorization: `Bearer ${accessToken}`,
        },
      },
    );

    return data;
  } catch (error) {
    return null;
  }
}; The function receives the parameter and performs a GET request to the Google OAuth user information API using the access token provided in the authorization header of the request and returns the user information. getUserData accessToken Now we already have our backend created with the minimum we need, now let’s go for the frontend. Client File : main.tsx import { GoogleOAuthProvider } from "@react-oauth/google"

import ReactDOM from "react-dom/client"

import { NextUIProvider } from "@nextui-org/react"
import { darkTheme } from "./themes/darktheme"

const GOOGLE_CLIENT_ID = import.meta.env.VITE_GOOGLE_CLIENT_ID

import App from "./App"

ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
 <NextUIProvider theme={darkTheme}>
  <GoogleOAuthProvider clientId={GOOGLE_CLIENT_ID}>
   <App />
  </GoogleOAuthProvider>
 </NextUIProvider>
) In this application we will use for the styles, you can use any UI library you want. Next UI The component provides the dark theme to all the components of the application. NextUIProvider The component provides the Google login to the application using the provided . GoogleOAuthProvider clientId Component : App.tsx import { BrowserRouter as Router, Route, Routes } from 'react-router-dom';
import { LoginPage, HomePage } from './pages';

const App = () => {
  return (
    <Router>
      <Routes>
        <Route path="/home" element={<HomePage />}></Route>
        <Route path="/" element={<LoginPage />}></Route>
      </Routes>
    </Router>
  );
};

export default App; In the App component, we will create the routes of the pages that we will use and we will assign the corresponding component. Component LoginPage.tsx import { useGoogleLogin } from "@react-oauth/google"
import { useNavigate } from "react-router-dom"

import { Card, Spacer, Button, Text, Container } from "@nextui-org/react"

import { IconGitHub, IconGoogle } from "../../assets/icons"

const GITHUB_CLIENT_ID = import.meta.env.VITE_GITHUB_CLIENT_ID

const LoginPage = () => {
 const navigate = useNavigate()

 const loginToGithub = () => {
  localStorage.setItem("loginWith", "GitHub")
  window.location.assign(`https://github.com/login/oauth/authorize?client_id=${GITHUB_CLIENT_ID}`)
 }

 const loginToGoogle = useGoogleLogin({
  onSuccess: tokenResponse => {
   localStorage.setItem("loginWith", "Google")
   localStorage.setItem("accessToken", tokenResponse.access_token)
   navigate("/home")
  },
 })

 return (
  <Container display='flex' alignItems='center' justify='center' css={{ minHeight: "100vh" }}>
   <Card css={{ mw: "420px", p: "20px" }}>
    <Text
     size={24}
     weight='bold'
     css={{
      as: "center",
      mb: "20px",
     }}
    >
     Login with
    </Text>
    <Spacer y={1} />
    <Button color='gradient' auto ghost onClick={() => loginToGithub()}>
     <IconGitHub />
     <Spacer x={0.5} />
     GitHub
    </Button>
    <Spacer y={1} />

    <Button color='gradient' auto ghost onClick={() => loginToGoogle()}>
     <IconGoogle />
     <Spacer x={0.5} />
     Google
    </Button>
   </Card>
  </Container>
 )
}

export default LoginPage When the user clicks the GitHub login button, the user is redirected to the GitHub login page and a key is stored in the browser’s local storage indicating that the user is logging in with GitHub. When the user clicks the Google login button, the function of is used to log in with Google. If the login is successful, a key is stored in the browser’s local storage indicating that the user is signing in with Google. useGoogleLogin @react-oauth/google Component : HomePage.tsx import { useEffect, useRef, useState } from "react"
import { useNavigate } from "react-router-dom"
import { Button, Col, Container, Navbar, Row, Text, User } from "@nextui-org/react"

import { getAccessTokenGithub, getUserDataGithub, getUserDataGoogle } from "./services/home-services"

import { LogOutIcon } from "../../assets/icons"

interface UserDataGithub {
 avatar_url: string
 login: string
 bio: string
}

interface UserdataGoogle {
 name: string
 picture: string
 email: string
}

const HomePage = () => {
 const [userDataGithub, setUserDataGithub] = useState<null | UserDataGithub>(null)
 const [userDataGoogle, setUserDataGoogle] = useState<null | UserdataGoogle>(null)

 const loginWith = useRef(localStorage.getItem("loginWith"))

 const navigate = useNavigate()

 useEffect(() => {
  const queryString = window.location.search
  const urlParams = new URLSearchParams(queryString)
  const codeParam = urlParams.get("code")

  const accessToken = localStorage.getItem("accessToken")

  if (codeParam && !accessToken && loginWith.current === "GitHub") {
   getAccessTokenGithub(codeParam).then(resp => {
    localStorage.setItem("accessToken", resp.access_token)
    getUserDataGithub(resp.access_token).then((resp: UserDataGithub) => {
     setUserDataGithub(resp)
    })
   })
  } else if (codeParam && accessToken && loginWith.current === "GitHub") {
   getUserDataGithub(accessToken).then((resp: UserDataGithub) => {
    localStorage.setItem("accessToken", accessToken)
    setUserDataGithub(resp)
   })
  }
 }, [loginWith])

 useEffect(() => {
  const accessToken = localStorage.getItem("accessToken")

  if (accessToken && loginWith.current === "Google") {
   getUserDataGoogle(accessToken).then(resp => {
    setUserDataGoogle(resp)
   })
  }
 }, [loginWith])

 const setLogOut = () => {
  localStorage.removeItem("accessToken")
  localStorage.removeItem("loginWith")
  navigate("/")
 }

 if (!userDataGithub && !userDataGoogle) return null

 return (
  <>
   <Navbar isBordered variant='sticky'>
    <Navbar.Brand>
     <User
      bordered
      color='primary'
      size='lg'
      src={loginWith.current === "GitHub" ? userDataGithub?.avatar_url : userDataGoogle?.picture}
      name={loginWith.current === "GitHub" ? userDataGithub?.login : userDataGoogle?.name}
      description={loginWith.current === "GitHub" ? userDataGithub?.bio : userDataGoogle?.email}
     />
    </Navbar.Brand>
    <Navbar.Content>
     <Navbar.Item>
      <Button
       auto
       flat
       size='sm'
       icon={<LogOutIcon fill='currentColor' />}
       color='primary'
       onClick={() => setLogOut()}
      >
       Log out
      </Button>
     </Navbar.Item>
    </Navbar.Content>
   </Navbar>
   <Container gap={0}>
    <Row gap={1}>
     <Col>
      <Text h2>Login with {loginWith.current}</Text>
     </Col>
    </Row>
   </Container>
  </>
 )
}

export default HomePage After the user has logged in and is redirected to Home, we will use the hook to perform a series of actions when the page loads. useEffect First, we get the authorization code from the page URL and, if the user has logged in with GitHub, we get an access token and then we get the user’s data from GitHub. If the user has logged in with Google, we simply get the Google user data. In addition, we have a “Logout” button that removes the access token and login from local storage and redirects the user to the application’s home page. That’s it! Now we can log in to GitHub or Google. The next steps are to register the user and save the user information in a database or whatever suits you. The application looks something like this: Repo here. Conclusion Social login is a feature that offers many advantages for both users and developers. It is simple to integrate and can improve the user experience and security of the application or website. Therefore, it is a good idea to consider using it in your projects. Also published here.

Implementing Social Login for a React and Backend App

Discussing with a brazilian friend about the situation in our country, we realised how difficult it is to find information about public spending, and when available, how difficult it can be to reason about it. Joining our forces, we decided to explore some data exposed by the Brazilian government, aiming to provide an easier way to visualise and understand how the public resources has been used. The starting point would be: finding some data to analyse, that is relatively easy (at least from a developer’s perspective) to collect. A good candidate is the (in literal translation, Transparency Portal), an initiative to make public data available via APIs or downloading CSV files. Portal da Transparência Is there a better way to learn about an API than writing a client for it? So let’s do it with + ! ZIO http4s client Why ZIO? After , someone asked me what has called my attention in the Scala ecosystem recently. I believe ZIO can be a game changer, because it is not “just for functional programmers”. Even though it is strongly based in functional principles, it doesn’t assume the users already understand functional concepts (this is just a !), which can be scary for new joiners. my talk in Scala UA Monad Among all the powerful features ZIO provides, it’s designed to be easy to use and adopt, what is from my perspective, by far, its best feature. ZIO Team! #ScalaThankYou Time to code, let’s start . defining a ZIO module The module HttpClient The API supports only GET requests, what makes the trait definition very simple: pdt.http io.circe. org.http4s.client. zio._ { = [ ] { rootUrl = [ ](uri: , parameters: [ , ])
              ( d: [ ]): [ ]
  } : [ [ [ ]], , ] = ???
} package import Decoder import Client import object HttpClient type HttpClient Has Service trait Service protected val "http://www.transparencia.gov.br/api-de-dados/" def get T String Map String String implicit Decoder T Task T def http4s ZLayer Has Client Task Nothing HttpClient has only one method with arguments and , which will become part of the url in the format . It takes an implicit as well, used to decode the json result into . Service get[T] resource: String parameters: Map[String, String] "resource?key=value" io.circe.Decoder[T] T returns a , , which represents an effect that has no requirements, and may fail with a value, or succeed with a . get[T] zio.Task[T] a type alias for ZIO[Any, Throwable, T] Throwable T , we have: Following the module recipe = [ ] type HttpClient Has Service In simple terms, allows us to use our as a dependency. The next line makes it easier to understand: Has Service : [ [ [ ]], , ] = ??? def http4s ZLayer Has Client Task Nothing HttpClient The method will create a , which is very similar to ; it requires a to be built, won’t produce any errors (that’s what that means) and will return an implementation of our : , the one we defined using . http4s ZLayer data type ZIO Has[Client[Task]] Nothing Service HttpClient Has We should use type aliases to make more expressive as well. Knowing our layer can’t fail, we can use : ZLayer URLayer : [ [ [ ]], ] = ??? def http4s URLayer Has Client Task HttpClient In order to answer this question, we need to implement first. What will http4s actually return? HttpClient.Service The implementation Http4s Implementing the get request is straightforward: pdt.http io.circe. org.http4s. org.http4s.circe. .circeEntityDecoder org.http4s.client. org.http4s.client.dsl. zio._ zio.interop.catz._ [http] . [ ] { [ ](resource: , parameters: [ , ])
            ( d: [ ]): [ ] = { uri = (path = rootUrl + resource).withQueryParams(parameters)

    client.expect[ ](uri.toString())
  } package import Decoder import Uri import CirceEntityCodec import Client import Http4sClientDsl import import private final case ( ) class Http4s client: [ ] Client Task extends HttpClient Service with Http4sClientDsl Task def get T String Map String String implicit Decoder T Task T val Uri T Maybe you are scratching your head due to that . is built on top of the Cats Effect stack, therefore we need . import zio.interop.catz._ http4s the module for interoperability interop-catz An instance of this class can’t be created outside the package; the instance will be provided through our . Let’s go back to , it’s time to implement it! http ZLayer HttpClient.http4s Providing an through HttpClient.Service ZLayer Having a service definition, seems appropriate: ZLayer.fromService { : [ [ [ ]], ] = .fromService[ [ ], ] { http4sClient => (http4sClient)
    }
} object HttpClient def http4s URLayer Has Client Task HttpClient ZLayer Client Task Service Http4s Okay, this layer makes our HttpClient available. How can we access it? Let’s start defining something that uses the client, a concrete example always makes learning easier :) A couple of useful helpers The first resource, is a good candidate: Acordos de Leniência GET returns an object; /acordos-leniencia/{id} GET (with filters as query params) returns a list of objects; /acordos-leniencia The rest of the API exposes basically the same for other resources, just with more filters. Knowing that, we can define two helpers, one for each case: { [ ](resource: , id: )
            ( d: [ ]): [ , ] = .accessM[ ](_.get.get[ ]( , ())) [ ](resource: , parameters: [ , ] = ())
            ( d: [ ]): [ , [ ]] = .accessM[ ](_.get.get[ [ ]](resource, parameters))
} object HttpClient // ... def get T String Long implicit Decoder T RIO HttpClient T RIO HttpClient T s" / " $resource $id Map def get T String Map String String Map implicit Decoder T RIO HttpClient List T RIO HttpClient List T effectfully accesses the environment of our effect, giving us , so we call the first get to access the effect wrapped by - our Service - while the second is the actual get request. RIO.accessM[HttpClient] Has[HttpClient.Service] Has get To make it clear, if we had a method, the code would be: post .accessM[ ](_.get.post[ ](resource, parameters)) RIO HttpClient T Alright, let’s make the whole thing work! A concrete HttpClient… client (?!?!?) Then again, is our resource. This is a case class for its possible filters (brazilian api, names in portuguese): Acordos de Leniência case ( ) class AcordoLenienciaRequest cnpjSancionado: [ ] = ,
              nomeSancionado: [ ] = ,
              situacao: [ ] = ,
              dataInicialSancao: [ ] = ,
              dataFinalSancao: [ ] = ,
              pagina: = 1 Option String None Option String None Option String None Option LocalDate None Option LocalDate None Int And the response: case ( ) class AcordoLeniencia id: ,
              nomeEmpresa: ,
              dataInicioAcordo: ,
              dataFimAcordo: ,
              orgaoResponsavel: ,
              cnpj: ,
              razaoSocial: ,
              nomeFantasia: ,
              ufEmpresa: ,
              situacaoAcordo: ,
              quantidade: Long String LocalDate LocalDate String String String String String String Int couldn’t be simpler: AcordosLenienciaClient io.circe.generic.auto._ pdt.client.decoders.localDateDecoder pdt.http. .{ , get} pdt.domain.{ , => } pdt.http.implicits. zio._ { (id: ): [ , ] =
    get[ ]( , id) (request: ): [ , [ ]] =
    get[ ]( , request.parameters)
} import import import HttpClient HttpClient import AcordoLeniencia AcordoLenienciaRequest ALRequest import HttpRequestOps import object AcordosLenienciaClient def by Long RIO HttpClient AcordoLeniencia AcordoLeniencia "acordos-leniencia" def by ALRequest RIO HttpClient List AcordoLeniencia AcordoLeniencia "acordos-leniencia" The implicit method transforms any request into a . . HttpRequestOps.parameters Map[String, String] Check it out how I used shapeless to do so Now we just need to put all the pieces together, sort out dependencies, this kind of thing. That happens at the end of the world… also known as . Main ZIO Modules, assemble! Here is a program that makes a request to get a list of : AcordoLeniencia program = {
  result <- .by( ())
  _ <- putStrLn(result.toString())
} () val for AcordosLeniencia AcordoLenienciaRequest yield It requires a that produces an , which has as its own dependency. Let’s create the as a first: ZLayer HttpClient Client[Task] Client[Task] managed resource : [ [ [ ]]] = .runtime[ ].map { rts => .apply[ ]( .global)
        .resource
        .toManaged
    } private def makeHttpClient UIO TaskManaged Client Task ZIO Any implicit BlazeClientBuilder Task Implicits Now we can sort out the layers: httpClientLayer = makeHttpClient.toLayer.orDie http4sClientLayer = httpClientLayer >>> .http4s val val HttpClient and finally, provide our with the required layer: program program.provideSomeLayer[ ](http4sClientLayer) ZEnv Ready to go: program.foldM(
  e => putStrLn( ) *> .succeed( ),
  _ => .succeed( )
) s"Execution failed with: " ${e.printStackTrace()} ZIO 1 ZIO 0 And this is how I built it. Some code is different here from the original, for learning purposes. . You can find the code on Github Before we jump to the conclusion, let’s consolidate what we’ve learnt adding a new dependency, a that prints in the console the url requested, and the error message if it fails. logger Adding a new dependency, step by step The module definition: Logger { = [ ] { (message: => ): [ ] (t: )(message: => ): [ ]
  }
} object Logger type Logger Has Service trait Service def info String UIO Unit def error Throwable String UIO Unit The implementation, printing to the console: zio.console.{ => } . { (message: => ): [ ] =
    console.putStrLn(message) (t: )(message: => ): [ ] = {
      _ <- console.putStrLn(message)
      _ <- console.putStrLn(t.stackTrace)
    } ()
} import Console ConsoleZIO case ( ) class Console console: . ConsoleZIO Service extends Logger Service def info String UIO Unit def error Throwable String UIO Unit for yield makes the implementation available via : Logger ZLayer { : [ , ] = .fromService[ . , ] { console => (console)
    }
} object Logger def console URLayer ConsoleZIO Logger ZLayer ConsoleZIO Service Service Console can now receive and use a instance: Http4s logger [http] . [ ] { [ ](resource: , parameters: [ , ])
            ( d: [ ]): [ ] = { uri = (path = rootUrl + resource).withQueryParams(parameters)

    logger.info( ) *>
      client
        .expect[ ](uri.toString())
        .foldM(
          e => logger.error(e)( ) *> .fail(e), .succeed(_))
  }
} private final case ( ) class Http4s logger: . , client: [ ] Logger Service Client Task extends HttpClient Service with Http4sClientDsl Task def get T String Map String String implicit Decoder T Task T val Uri s"GET REQUEST: " $uri T "Request failed" IO ZIO The layer needs to adapt: http4s { : [ [ [ ]], ] = .fromServices[ . , [ ], ] {
      (logger, http4sClient) => (logger, http4sClient)
    }
} object HttpClient def http4s URLayer Logger with Has Client Task HttpClient ZLayer Logger Service Client Task Service Http4s Let’s feed our with the new dependency. The change is in the layer provided: program http4sClientLayer = (loggerLayer ++ httpClientLayer) >>> .http4s val HttpClient Done! Summary My first experience with ZIO has been very pleasant. In order to solve dependencies, the compiler plays on our side; every time something is missing, we have an error in compile time, with a clear indication of what is missing. Besides, makes dependency resolution extremely simple and extensible (think about adding a for example) without magic. ZLayer FileLogger Any suggestions to improve that code? Please share! References ZIO - Using modules and Layers Solving the Dependency Injection Problem with ZIO From idea to product with ZLayer ZIO, Http4s, Auth, Codecs and zio-test Http4s Client Originally published at https://juliano-alves.com on April 20, 2020.

How To Create Simple API Client with ZIO and Http4s

Disclaimer: This article discusses the technical aspects of working with Spotify's API to create a playlist cover generator. While I'll be referencing a tool I developed for this purpose, the focus is on the development process and insights gained. The Genesis of the Idea As a developer and music enthusiast, I've always been fascinated by the potential of music APIs. The idea to create a Spotify playlist cover maker came from a simple desire to make playlist customization more accessible to users. In this article, I'll walk you through the development process, challenges faced, and lessons learned while working with Spotify's API. Understanding Spotify's API Before diving into development, it's crucial to understand Spotify's API. The Spotify for Developers platform provides comprehensive documentation and tools for working with their API. Key resources I found helpful: Spotify Web API Documentation
Authorization Guide
Endpoints Reference Tech Stack Selection For this project, I chose: Frontend: React.js with Tailwind CSS
Backend: Node.js with Express
Database: MongoDB
Image Processing: Sharp.js
API Integration: Spotify Web API This stack allowed for a dynamic UI, seamless Spotify integration, flexible data storage, and powerful image processing capabilities, all essential for creating a robust Spotify cover generator. Key Development Challenges 1. Spotify API Authentication Authentication is a crucial first step. Spotify uses OAuth 2.0, and here's a basic example of how to handle it: const SpotifyWebApi = require('spotify-web-api-node');

const spotifyApi = new SpotifyWebApi({
  clientId: process.env.SPOTIFY_CLIENT_ID,
  clientSecret: process.env.SPOTIFY_CLIENT_SECRET,
  redirectUri: process.env.SPOTIFY_REDIRECT_URI
});

app.get('/login', (req, res) => {
  const scopes = ['user-read-private', 'playlist-read-collaborative'];
  res.redirect(spotifyApi.createAuthorizeURL(scopes));
});

app.get('/callback', (req, res) => {
  const { code } = req.query;
  spotifyApi.authorizationCodeGrant(code).then(
    function(data) {
      spotifyApi.setAccessToken(data.body['access_token']);
      spotifyApi.setRefreshToken(data.body['refresh_token']);
      res.redirect('/');
    },
    function(err) {
      console.log('Something went wrong!', err);
      res.send(err);
    }
  );
}); 2. Fetching Playlist Data Once authenticated, you can fetch playlist data. Here's an example: async function getPlaylistData(playlistId) {
  try {
    const data = await spotifyApi.getPlaylist(playlistId);
    return {
      name: data.body.name,
      description: data.body.description,
      images: data.body.images,
      tracks: data.body.tracks.items.map(item => item.track.name)
    };
  } catch (error) {
    console.error('Error fetching playlist:', error);
    throw error;
  }
} 3. Image Processing For creating custom covers, I used Sharp.js. Here's a basic image processing function: const sharp = require('sharp');

async function processImage(buffer, text) {
  try {
    const image = sharp(buffer);
    const processedBuffer = await image
      .resize({
        width: 300,
        height: 300,
        fit: sharp.fit.cover,
        position: sharp.strategy.entropy
      })
      .composite([
        {
          input: Buffer.from(`<svg>...</svg>`),
          top: 10,
          left: 10
        }
      ])
      .toBuffer();
    
    return processedBuffer;
  } catch (error) {
    console.error('Error processing image:', error);
    throw error;
  }
} This function forms the core of the image manipulation in my playlist cover creator. Lessons Learned Rate Limiting is Crucial: Spotify's API has rate limits. Implementing proper error handling and retries is essential.
Keep Authentication Updated: Access tokens expire. Implement a robust token refresh mechanism to ensure uninterrupted access to the API.
Respect User Privacy: Only request the permissions you need. Spotify's Authorization Scopes guide is a must-read.
Optimize for Performance: Caching responses and optimizing API calls can significantly improve your application's performance. Looking Ahead As I continue to enhance the playlist cover generator, I'm exploring ideas like: Implementing AI-generated cover suggestions
Adding support for collaborative playlists
Creating a mobile app version For developers interested in music-related projects, Spotify's API offers a wealth of possibilities. I encourage you to explore their API Guidelines and Terms of Service for more information. Conclusion Working with Spotify's API to create a custom playlist cover tool has been an enriching experience. It's a testament to how developers can leverage powerful APIs to create tools that enhance users' music experiences. What innovative ideas do you have for using music APIs? What challenges have you faced in your API integration projects? Let's discuss in the comments! Tags: JavaScript, Web Development, Spotify API, Image Processing, React, API Integration Disclaimer: This article discusses the technical aspects of working with Spotify's API to create a playlist cover generator. While I'll be referencing a tool I developed for this purpose, the focus is on the development process and insights gained. Disclaimer: This article discusses the technical aspects of working with Spotify's API to create a playlist cover generator. While I'll be referencing a tool I developed for this purpose, the focus is on the development process and insights gained. tool I developed The Genesis of the Idea As a developer and music enthusiast, I've always been fascinated by the potential of music APIs. The idea to create a Spotify playlist cover maker came from a simple desire to make playlist customization more accessible to users. In this article, I'll walk you through the development process, challenges faced, and lessons learned while working with Spotify's API. Spotify playlist cover maker Understanding Spotify's API Before diving into development, it's crucial to understand Spotify's API. The Spotify for Developers platform provides comprehensive documentation and tools for working with their API. Spotify for Developers Key resources I found helpful: Spotify Web API Documentation Authorization Guide Endpoints Reference Spotify Web API Documentation Authorization Guide Endpoints Reference Tech Stack Selection For this project, I chose: Frontend: React.js with Tailwind CSS Backend: Node.js with Express Database: MongoDB Image Processing: Sharp.js API Integration: Spotify Web API Frontend: React.js with Tailwind CSS Backend: Node.js with Express Database: MongoDB Image Processing: Sharp.js API Integration: Spotify Web API This stack allowed for a dynamic UI, seamless Spotify integration, flexible data storage, and powerful image processing capabilities, all essential for creating a robust Spotify cover generator . Spotify cover generator Key Development Challenges 1. Spotify API Authentication Authentication is a crucial first step. Spotify uses OAuth 2.0, and here's a basic example of how to handle it: const SpotifyWebApi = require('spotify-web-api-node');

const spotifyApi = new SpotifyWebApi({
  clientId: process.env.SPOTIFY_CLIENT_ID,
  clientSecret: process.env.SPOTIFY_CLIENT_SECRET,
  redirectUri: process.env.SPOTIFY_REDIRECT_URI
});

app.get('/login', (req, res) => {
  const scopes = ['user-read-private', 'playlist-read-collaborative'];
  res.redirect(spotifyApi.createAuthorizeURL(scopes));
});

app.get('/callback', (req, res) => {
  const { code } = req.query;
  spotifyApi.authorizationCodeGrant(code).then(
    function(data) {
      spotifyApi.setAccessToken(data.body['access_token']);
      spotifyApi.setRefreshToken(data.body['refresh_token']);
      res.redirect('/');
    },
    function(err) {
      console.log('Something went wrong!', err);
      res.send(err);
    }
  );
}); const SpotifyWebApi = require('spotify-web-api-node');

const spotifyApi = new SpotifyWebApi({
  clientId: process.env.SPOTIFY_CLIENT_ID,
  clientSecret: process.env.SPOTIFY_CLIENT_SECRET,
  redirectUri: process.env.SPOTIFY_REDIRECT_URI
});

app.get('/login', (req, res) => {
  const scopes = ['user-read-private', 'playlist-read-collaborative'];
  res.redirect(spotifyApi.createAuthorizeURL(scopes));
});

app.get('/callback', (req, res) => {
  const { code } = req.query;
  spotifyApi.authorizationCodeGrant(code).then(
    function(data) {
      spotifyApi.setAccessToken(data.body['access_token']);
      spotifyApi.setRefreshToken(data.body['refresh_token']);
      res.redirect('/');
    },
    function(err) {
      console.log('Something went wrong!', err);
      res.send(err);
    }
  );
}); 2. Fetching Playlist Data Once authenticated, you can fetch playlist data. Here's an example: async function getPlaylistData(playlistId) {
  try {
    const data = await spotifyApi.getPlaylist(playlistId);
    return {
      name: data.body.name,
      description: data.body.description,
      images: data.body.images,
      tracks: data.body.tracks.items.map(item => item.track.name)
    };
  } catch (error) {
    console.error('Error fetching playlist:', error);
    throw error;
  }
} async function getPlaylistData(playlistId) {
  try {
    const data = await spotifyApi.getPlaylist(playlistId);
    return {
      name: data.body.name,
      description: data.body.description,
      images: data.body.images,
      tracks: data.body.tracks.items.map(item => item.track.name)
    };
  } catch (error) {
    console.error('Error fetching playlist:', error);
    throw error;
  }
} 3. Image Processing For creating custom covers, I used Sharp.js. Here's a basic image processing function: const sharp = require('sharp');

async function processImage(buffer, text) {
  try {
    const image = sharp(buffer);
    const processedBuffer = await image
      .resize({
        width: 300,
        height: 300,
        fit: sharp.fit.cover,
        position: sharp.strategy.entropy
      })
      .composite([
        {
          input: Buffer.from(`<svg>...</svg>`),
          top: 10,
          left: 10
        }
      ])
      .toBuffer();
    
    return processedBuffer;
  } catch (error) {
    console.error('Error processing image:', error);
    throw error;
  }
} const sharp = require('sharp');

async function processImage(buffer, text) {
  try {
    const image = sharp(buffer);
    const processedBuffer = await image
      .resize({
        width: 300,
        height: 300,
        fit: sharp.fit.cover,
        position: sharp.strategy.entropy
      })
      .composite([
        {
          input: Buffer.from(`<svg>...</svg>`),
          top: 10,
          left: 10
        }
      ])
      .toBuffer();
    
    return processedBuffer;
  } catch (error) {
    console.error('Error processing image:', error);
    throw error;
  }
} This function forms the core of the image manipulation in my playlist cover creator . playlist cover creator Lessons Learned Rate Limiting is Crucial: Spotify's API has rate limits. Implementing proper error handling and retries is essential. Keep Authentication Updated: Access tokens expire. Implement a robust token refresh mechanism to ensure uninterrupted access to the API. Respect User Privacy: Only request the permissions you need. Spotify's Authorization Scopes guide is a must-read. Optimize for Performance: Caching responses and optimizing API calls can significantly improve your application's performance. Rate Limiting is Crucial : Spotify's API has rate limits. Implementing proper error handling and retries is essential. Rate Limiting is Crucial Keep Authentication Updated : Access tokens expire. Implement a robust token refresh mechanism to ensure uninterrupted access to the API. Keep Authentication Updated Respect User Privacy : Only request the permissions you need. Spotify's Authorization Scopes guide is a must-read. Respect User Privacy Optimize for Performance : Caching responses and optimizing API calls can significantly improve your application's performance. Optimize for Performance Looking Ahead As I continue to enhance the playlist cover generator, I'm exploring ideas like: Implementing AI-generated cover suggestions Adding support for collaborative playlists Creating a mobile app version Implementing AI-generated cover suggestions Adding support for collaborative playlists Creating a mobile app version For developers interested in music-related projects, Spotify's API offers a wealth of possibilities. I encourage you to explore their API Guidelines and Terms of Service for more information. Conclusion Working with Spotify's API to create a custom playlist cover tool has been an enriching experience. It's a testament to how developers can leverage powerful APIs to create tools that enhance users' music experiences. custom playlist cover tool What innovative ideas do you have for using music APIs? What challenges have you faced in your API integration projects? Let's discuss in the comments! Tags: JavaScript, Web Development, Spotify API, Image Processing, React, API Integration Tags: JavaScript, Web Development, Spotify API, Image Processing, React, API Integration

From Idea to Implementation: Building a Spotify Playlist Cover Generator

من الفكرة إلى التنفيذ: إنشاء مولد أغلفة قائمة تشغيل Spotify

De la idea a la implementació: creació d'un generador de cobertes de llistes de reproducció de Spotify

Fra idé til implementering: Opbygning af en Spotify Playlist Cover Generator

De la idea a la implementación: creación de un generador de portadas para listas de reproducción de Spotify

از ایده تا اجرا: ساختن یک سازنده پوشش لیست پخش Spotify

Գաղափարից մինչև իրականացում. Spotify երգացանկերի ծածկույթի գեներատորի ստեղծում

アイデアから実装まで: Spotify プレイリスト カバー ジェネレーターの構築

Kobanda na likanisi tii na kosalela: Kotonga Générateur ya couverture ya playlist ya Spotify

Санаанаас хэрэгжүүлэх хүртэл: Spotify тоглуулах жагсаалтын хавтас үүсгэгчийг бүтээх

Från idé till implementering: Bygg en Spotify Playlist Cover Generator

Mula sa Ideya hanggang sa Pagpapatupad: Pagbuo ng Spotify Playlist Cover Generator

Fikirden Uygulamaya: Spotify Çalma Listesi Kapak Oluşturucu Oluşturma

In our profession, it's common to work on an unfamiliar codebase. It happens every time one joins a new project or even needs to work on a previously untouched part in big ones. This occurrence is not limited to a developer having to fix a bug; it can be a solution architect having to design a new feature or an OpenSource contributor working on a GitHub issue in their free time. Hence, I want to describe how I approach the situation so it can benefit others. An Example Issue To illustrate my point, I'll use a common GitHub issue requesting a new feature on an Open Source project. While working for Hazelcast, I regularly scanned the so-called "good first issues" to work on at hackathons. I never could run such a hackathon, but that is beside the point. My idea was to help people interested in contributing to Open Source start getting familiar with the code base. At the time, I found this interesting issue: Add support for getQuiet operation ? http://ehcache.org/apidocs/net/sf/ehcache/Cache.html#getQuiet(java.lang.Object) The idea is to be able to get an entry without touching it, meaning that it will not update the last accessed time stamp. The use case behind it is to be able to monitor existence of a key without changing the eviction of that key. -- Distributed Map: Add support for getQuiet operation As an OpenSource contributor, how would I approach the work? Diagramming Is Key Documentation is the first step to embark on a new project. On a regular project, the documentation will probably be missing, incomplete, or partly (if not entirely) misleading; at a hackathon, time may be too short to read it in detail. Successful Open Source projects do have good documentation in general. However, documentation is mainly oriented toward users, rarely toward developers. Even when it's the case, the chances that the documentation addresses the issue are low. For this reason, my entry point is to draw a diagram. Note that while some tools can reverse engineer code and draw diagrams automatically, I don't use them on purpose. Manually drawing a diagram has many benefits over an automatically-generated one: It focuses on areas of the code relevant to the issue at hand. It forces the drawer to read and understand the code, which is the only source of truth. It builds our mental model of the code. It documents our findings to be accessible later on. However, note that the documentation value decreases with time as the underlying code evolves and both part ways. Let's create a diagram for the code for the issue. First, we shall clone the repo locally to open it in our favorite IDE;  the only required feature is that when one clicks on a method call, one is directed to the method. For the diagram itself, call me old-fashioned, but I still favor for two reasons: UML sequence diagrams I've some experience with them. Semantics are not but shared among people who know UML, up to a point. ad-hoc Without further ado, here it is: Having drawn the diagram, we can locate pretty quickly where the issue is: public abstract class AbstractCacheRecordStore<R extends CacheRecord, CRM extends SampleableCacheRecordMap<Data, R>>
        implements ICacheRecordStore, EvictionListener<Data, R> {

    protected long onRecordAccess(Data key, R record, ExpiryPolicy expiryPolicy, long now) {
        record.setAccessTime(now);                                            // 1
        record.incrementAccessHit();
        return updateAccessDuration(key, record, expiryPolicy, now);
    }

    //...
} The reads the , which triggers the update of the last access time. DefaultRecordStore Record Fixing the issue is outside of the scope of this post. It involves talking to people more familiar with the overall design to develop the best solution. A good approach in a hackathon is first to offer at least two alternatives and document their respective trade-offs. For the tooling, plenty of alternatives are available. My preferences go to : PlantUML It offers a and a web app Docker container It generates SVG or PNG images It's skinnable It's Open Source and free It's maintained regularly Conclusion Understanding an existing codebase is a crucial skill regardless of one's exact technical role. Creating a diagram goes a long way toward this goal, with the additional benefit of documentation. I like UML diagrams because I'm familiar with them, and they offer shared semantics. Hence, if you want to understand a codebase better, you need more than to just read its code; you need to draw diagrams. Originally published at on May 14th, 2023 A Java Geek

Stories, News & Mentions about REDACCESS

Redaccess’s Stories on HackerNoon

Redaccess's News & Mentions