Apiday

apiday

This is a story inspired by true events, about a team and the everyday struggles they faced while building an API defined by spreadsheets and documents. What can come to the rescue? API specifications. In analysis Here’s an example of a conversation that you may have been part of sometime in your life as a developer. : Our next user story involves creating an API (let’s call it “Customer API”). : How novel! That’s what I did yesterday and the day before and the day before that. : Great, should I let the clients know that it wouldn’t take as long to build it? : Hold on. We haven’t even heard the requirements for Customer API. : It’s just a couple of hundred fields that Customer API needs to send to another downstream API to perform the transaction. : And how will we know the values for these fields that Customer API needs to send? : I’ll take care of it. I have already spoken to the lead developer from the downstream API team, and he’s sent me a spreadsheet. It has all the fields and the values that need to be part of the request body. He’s also sent me a document with information on the headers and auth details required to call the downstream API. : Is this downstream API available in a testing environment? A playground, maybe? : They’re still working on building the downstream API, so they don’t have a working version yet. Business Analyst Developer A Business Analyst Developer A Business Analyst Developer A Business Analyst Developer A Business Analyst In development Developer A gets to work. She pairs with Developer B, another application developer on her team, to finish the Customer API story. Business Analyst sends them an email with a spreadsheet containing the fields and a document that includes the API currently in development by the downstream API team. It seems like Developer A and Developer B have all the information required to start building the Customer API, so they come up with the following list of tasks: Create the Customer Request model that has all the fields from the spreadsheet. Fill the model with default values. Build the Customer API that will use this model as part of the request body. Seems straightforward. That’s what Developer A and Developer B felt too. In the soup When Developer A and Developer B scanned the spreadsheet, it didn’t have a hundred fields (as Business Analyst said) but 300 fields. Did that slow them down? Yes, it did. Let’s look at some of the challenges they faced and what they did. How did Developer A and Developer B convert fields from the spreadsheet to data members of a class? Developer B started by showing off some editing skills in his favorite integrated development environment (IDE). To be fair, he recently acquired these skills from another developer last week. Now was his chance to shine. He simply showed Developer A how to paste the fields from the spreadsheet to the class file and some shortcuts on the IDE to clean the copy/paste bit and replace it with Kotlin (the language they used) syntax for a class. How did they assign the values to the fields? Not all fields had default values, so assigning defaults to specific fields became a manual process for them, which of course took a while and some patience to complete. Why are we saying they were in the soup? Because here’s what happened over the course of the project. Integration failed due to: Incorrectly spelled fieldsCase sensitive fieldsMismatched data types: Some fields were represented as Boolean when they were actually StringsError parsing issues, since the document misrepresented itMissing responses (200 OK even) for some paths In retrospect I relate to the character of Developer A in this scenario so much, because these are issues that my team has faced. For us, the problems kept popping up frequently, and the integration took a couple of months. I always wondered if there was a better way to communicate or a process to spend less time on the issues we faced. Fast-forward to today, and I am glad to report that I’m now fairly acquainted with API specifications. What are API specifications and why use them? A spreadsheet (or a doc) may be tempting to use because it doesn’t come with a lot of rules, but a specification has the same benefit plus more: Here are a few reasons why I’ve become an advocate of specifications (like the ): OpenAPI Specification Conformance to a format Specifications have a format, and the format could be JSON/YAML, which is much closer to an API than plain text. Examples of APIs and their formats: : Defined in JSON format Twilio Messaging API : Defined in YAML format Postman API Schema objects can be defined, and that would resolve the error response parsing issues we faced earlier. Below is an example of a defined schema object. Schema objects In the , RequestError is a schema object defined as follows: Dolby Media Analyze OpenAPI RequestError: type: object properties: type: description: A URL that uniquely identifies the problem type. type: string example: "/problem/validation-error" title: description: A human readable description of the error. type: string example: "Your request parameters didn't validate" status: description: The HTTP response code. type: number example: 400 instance: description: The URL of the call for which the error occurred. type: string example: "/media/analyze" detail: description: An optional field with more information depending on the type. type: string example: "job_id is required" Schema validations Validations on the specification ensure that at least one successful response is defined for a path. In addition, there are a lot of other validations on the schema. The above screenshot displays validation errors found in the schema. Dive right into the to learn more. Discourse API (Validation Errors Example) Tooling Specifications are supported by extensive -like code generators, mock servers, documentation, etc. Leverage the tooling available in Postman by following the detailed walkthrough . tooling here Helpful API blueprints API specifications are a blueprint for APIs, providing a huge help by describing the structure of the API. Read Postman Chief Evangelist ’s to get a high-level view of API specifications currently available. Kin Lane blog post “Spreadsheets served us well in the information age, but as enterprise organizations wrestle with their digital transformation, they are realizing they need a much more precise set of human- and machine-readable tools that can track the exponentially increasing data being produced each day. Specifications now help teams keep up with the perpetual pace of change and remain competitive in today’s ever-evolving and shifting digital landscape.” — Postman Chief Evangelist Kin Lane To get started, you can define the API schema in Postman using the . Share your experiences with and without specifications, and then give us your feedback by leaving a comment below. API Builder

Specifications over Spreadsheets

A common use case of API Gateway is building API endpoints in top of Lambda functions. It can also be used as an API proxy to connect to AWS services. In this guide, I will walk you through how to create your own API using API Gateway and DynamoDB only and go through advanced features to enhance your API endpoints such as: Mapping templates, Integration Request and Integration Response. Error handling and request validation. Authentication with AWS Cognito and Lambda Authorizer. API Throttling with Plan usage and API keys. API documentation generation. API Gateway custom domain. Setting up DynamoDB To get started, create a DynamoDB table called with an as a partition key (leave the read/write capacity to default values): movies id Next, insert few items into the table, it should look something like this: Next, we need to grant the API Gateway access to DynamoDB table. Therefore we need to create an IAM role assumable by API Gateway: The role will give API Gateway permission to invoke the following DynamoDB operations on table: movies API Endpoints Before going into further detail about the architecture, the following diagram shows how API Gateway and DynamoDB will fit into the API architecture: Serverless API Architecture When calling the API endpoints, the request will go through the API Gateway, which will invoke the appropriate DynamoDB operation. This returns a response which is proxied by the API Gateway to the client in a JSON format. GET /movies Create new API called from , and create a new resource, let’s call it : MoviesAPI API Gateway Console movies Expose a method on resource by clicking on “ ”. Select under the “ ” section, choose the service, set the HTTP method to be and action type to be a operation. GET /movies Create Method AWS Service Integration type DynamoDB POST Scan Next, we need to transform the HTTP request coming into API Gateway to a proper request for DynamoDB. In the API Gateway console, select the “ ”. All the way at the bottom we can select the Body Mapping Templates. Here, create a new mapping template with the following configuration: Scan Integration Request application/json Deploy the API from “ ” and create a new deployment stage, an invocation URL will be displayed: Actions Point your browser to the URL given or use a modern REST client like Postman. The endpoint will return a list of movies in a JSON format: The output is returned in DynamoDB response format, in order to map the raw response to traditional JSON object structure, we will use feature. Integration Response Click on “ ” method and navigate to “ ”, expand the 200 response code. Expand the “ s” section. In choose and create a mapping template that loop through each item from the array, extracts the relevant attributes of the movie’s item and places them into a response structure: GET Integration Response Mapping Template Content-Type application/json Items is a script expressed in and applied to the payload using . Mapping template Velocity Template Language (VTL) JSONPath expressions As a result, you should now see a formatted response. GET /movies/:id The second endpoint will be responsible of fetching a movie based on an ID provided by the client. Hence, a new resource with a path parameter should be created. The value of ID will be made available via the method: $input.params(‘id’) Expose a GET method, and then link the resource to the DynamoDB service. The action will be operation: GetItem Again, specify a body mapping template for the integration request, now with the following template: When the API URL is invoked with an ID, the movie corresponding to the ID is returned if it exists. Similarly we will use integration response to map the raw DynamoDB response to the similar JSON object structure we defined earlier: If you test it out once again, the following JSON will be returned: POST /movies Now we know how the method works with and without path parameters. The next step will be to insert a new item to the table. Create a method with as an action: GET POST PutItem We will create a mapping template to transform the client request into the structure that the DynamoDB API requires. The below mapping template creates the JSON structure required by the DynamoDB PutItem API. The three input variables are referenced from the request JSON using the variable: PutItem $input Back in the “ ” pane click “ ”. Create an example request body that matches the API definition documented above and then choose “ ”. For example, your request body could be: Method Execution TEST Test Navigate to the DynamoDB console and view the table to show that the request really was successfully processed: movies Try to insert a new movie without giving a movie’s name attribute. The following error will returned: It’s a DynamoDB PutItem error. Fortuently, API Gateway allows you to validate your request body before invoking the downstream resources (In our example the DynamoDB table). To achieve this, we will use API Gateway Models. A Model defines the payload data structure. Models definitions are written using JSON Schema draft 4. In the API Gateway, navigate to the Models tab and create a new model. Fill in the form as so: The model above defines a entity with 3 attributes and requires and attributes to be defined (used during validation). movie id name Head back to “ ” page and click on “ ” from the method, enable the request validator option as below: Resources Method Request POST If you try to insert a new movie without providing the required parameters, a bad request message error will be returned: You can override the default 400 message from the “ ” as follows: Gateway Responses As a result, the user defined error message will be returned: Great! Try implementing the and methods: PUT DELETE Authentication The serverless API that we have built so far works like a charms. However, its open to the public, anyone can insert data into DynamoDB table if he/she has the API Gateway invocation URL. Luckily, API Gateway offers two ways to handle authentication: API Gateway Authentication with Cognito and Lambda Authorizer Amazon Cognito Create a new user pool, click on “ ” to create a pool with default settings. A success message should be displayed at the end of the creation process: Review defaults After creating your first user pool, register your serverless API from “ under “ and select “ . Give the application a name and check the server-based authentication option: App clients” General settings” Add an app client” ADMIN_NO_SRP_AUTH Create a new user using the AWS command line: Now that the user pool has been created, we can configure the API Gateway to validate access tokens from a successful user pool authentication before granting access to DynamoDB. To begin securing API access, go to API Gateway console, choose the RESTful API that we built in the previously, and click on “ from the navigation bar. Click on the “ button and select “ . Then, select the user pool that we created earlier and set the token source field to . This defines the name of the incoming request header containing the API caller's identity token for Authorization: Authorizers” Create New Authorizer” Cognito” Authorization You can now secure all of the endpoints, for instance, in order to secure the endpoint responsible for creating an new movie. Click on the corresponding method under the resource. Click on the “ box, then on “ , and select the user pool we created previously: POST /movies Method Request” Authorization” Once done, redeploy the API and try to insert a new movie using the API invocation URL. This time, the endpoint is secured and requires authentication: In order to authenticate, we need to obtain an identity token for the signed-in user from the the user pool and include the identity token in the header for the API Gateway requests. Issue the following AWS CLI command to get a new token: Authorization The command above takes a JSON file with the following attributes: Once executed, the preceding command will return the following JSON response: Copy the ID token and add it to the header of your request: Authorization The API Gateway will verify the token and will invoke the operation on the table, which will insert a new movie into the table: PutItem movies Lambda Authorizer When a client sends a request to your API, it will go through the API Gateway, which will extracts the token from the request and calls your Lambda function authorizer with it. The function evaluates the token, generates a policy and sends it back to API Gateway. API Gateway evaluates the policy and invoke the DynamoDB action registered for the API endpoint. For the sake of simplicity, our function will verify if the token provided by the client equals to our secret (environment variable) and returns a policy document based on the result. The following is the function handler source code written in Node.JS: Head back to API Gateway and created a new “ ” and set to be the header API Gateway will extract the token from: Lambda Authorizer Authorization Choose the method you want to secure, let’s say, it will be the endpoint responsible of deleting a movie from the table. Click on “ ” and under select your new authorizer: Method Request Authorization Let’s try calling the endpoint, As expected, we’re not getting through to our real endpoint: If you include the secret token to the header of your request, you should be able to delete an item: Authorization Looks good! API Throttling You can use usage plans combined with API keys to set method-level throttling limits for your API and define how much and how fast clients can access your API (request rates and quotas). The following procedure describes how to create a usage plan: API Usage Create a usage plan called , with a of 1 request per second and of 10000 requests per day: basic throttling limit quota limit Create a 2nd usage plan called , with a of 10 requests per second and a of 1 million requests per day: premium throlling limit quota limit API Keys Next, create two API keys: Assign the first API key to basic usage plan and second key to premium usage plan: Associate the usage plans we created to the API deployment stage: Configure an API method to require an API key: Deploy or redeploy the API for the requirement to take effect: Now if you added the header. If all goes well you will receive output like this: x-api-key If you exceed the rate limit or quota limit associated with your API key, a “ ” HTTP error will be returned: Too many requests Custom Domains You can use your own domain name for an API and deployment stage, create a backed by an (Amazon Certificate Manager) certificate: Custom Domain Name ACM Create a new custom domain name from API Gateway Console: Add a path mapping to map your domain name to your API deployment stage: Once configured, you can query your API using your custom domain name as follows: https://api.serverlessmovies.com/movies Documentation Before finishing this guide, we will go through how to create documentation for the serverless API we’ve built so far. On the API Gateway console, select the deployment stage that you’re interested in generating documentation for. In the following example, I chose the environment. Then, click on the tab and click on the section: sandbox Export Export as Swagger is an implementation of the , which is a standard defined by the Linux Foundation on how to describe and define APIs. This definition is called the . Swagger OpenAPI OpenAPI specification document You can save the document in either a JSON or YAML file. Then, navigate to and paste the content on the website editor, it will be compiled and an HTML page will be generated as follows: https://editor. swagger. io/ Like what you’re read­ing? Check out my book and learn how to build, secure, deploy and manage production-ready Serverless applications in Golang with AWS Lambda. _Learn to build, secure, deploy, and manage your serverless application in Golang with AWS Lambda_www.packtpub.com Hands-On Serverless Applications with Go | PACKT Books

Full guide to building a Serverless API with zero code

How to Build the Trump Twitter Sentiment Analysis Dashboard

Node.js Monitoring is essential for companies building competitive products with great user experience — the goal of this article is to discuss the reasons for it. I’ll also make the argument that monitoring is capable of saving tremendous money and is helpful with maintaining a high reputation. This article focuses on monitoring your product on the application-level, mainly from a developer, manager and customer point of view. We’ll talk solely about software issues, and not about hardware anomalies. To help you get started, I’ll provide you list with the 11 essentials of application performance monitoring. What is monitoring? According to the Oxford Dictionary, monitoring means To observe and check the progress or quality of (something) over a period of time; keep under systematic review. Ok, we get it. But what is Application Performance Monitoring/Management ? (APM) Application Performance Management (APM) is the monitoring and management of performance and availability of software applications. Does it mean that applications and software have different quality and quantity metrics what we can observe, compare and even get notified when something changed? Yes, it is. Why is it important for me, and why should it be important for you as well? Let’s see. Why should I care? If you are a manager or a developer in your company, then probably you would like to know when your application stops or when it doesn’t serve your customers need. To get a hold of this information, you’ll need to monitor service downtimes and set up a proper alerting system. Easy, and thankfully, most of the companies are already handling this issue. When you dig a little bit deeper and start caring not just about running your application, you’ll probably become interested in fulfilling user expectations and minimizing the number of bugs in your production system. That’s great, and you have a very good reason to do so, namely, when your users are facing bugs and slowdowns, they will leave your application and search for another one capable of delivering the same benefits without your errors. This is how your errors, bugs, and slowdowns lead to lower conversion rates, causing a drop in your businesses income. With a good monitoring solution, you can catch more than just bugs and slow response times! You can also discover performance bottlenecks on the network and code level and preempt losing money. Talking about losing money: I’m sure you already know that using more resources than you need is expensive. Also, spending time with inefficient debugging will affect your deadlines and wastes your development time. So what is monitoring? Monitoring is a way of preventing the loss of your resources, your customers, and a solution to stop wasting time. Monitoring is essential for not wasting money. I’m sure you agree with this, but you might not know what are the must-have elements of your application that you should keep an eye on. Let me help: What should be monitored? In the next part of the article, I’ll provide you a list of what you should monitor and why. 1. Keep your eye on service downtimes This is the simplest thing that you can monitor. It’s easy to understand that when your application doesn’t work, your customers cannot spend money on your site. Other than that, they will also be disappointed. If this issue is frequently present, or it happens during the customer acquisition process, you may lose users forever. Set up your monitoring solution in a way that it will be able to instantly notify the engineering team in case of a service downtime. 2. Slow response times impact conversion rates — Don’t let them! You can also monitor your services response times. A slow service is less of money bleeder on the short term, but it leads to a broken user experience. Researchers proved that customers prefer faster websites and products. Sometimes they also mention speed as the main reason of why they switched to a competitor’s product. It’s also , that slower response time has an impact on your conversion rate. Finding the correlation between response time and conversion rate is not always obvious, but one thing is for sure: slow services always underperform compared to an equivalent but faster product. proven Make sure you use a monitoring solution that can tell you the exact response time for each of the services of your application — and lets you compare it with your historical data. Monitor slow response times 3. Monitor error rates and crashes to find out about bad code quality A broken functionality may prevent your customers from registering or spending money on your site. To find out about these issues, you should monitor the amount and type of wrong status codes and application crashes. The high number of errors can also be a sign of something important, namely that you are facing code quality issues. Proper monitoring leads you to ask these questions as a manager: Do I give enough time to my developers to ship quality features? Do I have good test coverage? Do I have QA? Bad code quality always requires more developer time to debug and fix broken things. 4. Don’t waste your money on unnecessary resources A good APM solution lets you monitor your applications resource usage. Inefficient services use more resources — and they cost more money to run. Finding performance bottlenecks helps you to scale your software in an efficient way and to optimize your spending. Don’t waste your money on unnecessary hardware because of the bad code you wrote — instead find a tool that will let you know where you should improve your application. To do so, look for solutions that enable you CPU and memory profiling. CPU profiling allows you to analize which functions were running while your application slowed down, while memory heapdumps are useful for finding memory leaks. If you find and fix the performance bottlenecks in your system, you don’t have to scale up when something goes wrong. Finding bottlenecks using profiles 5. Examine your 3rd party API(s) and services Do you use a lot’s of external API(s)? I guess so. You’re paying for them as well, right? If you pay a lot for external services, it makes sense to monitor the quality and availability of them. For example, you can monitor the error rate or response time of your third-party payment provider. Maybe the issue is not in your service. A proper APM tool will help you to find the low performing external parts of your application, and save you money on them. 6. Know the quality and performance of your releases Your performance and code quality can be different with each of the versions of your application. Be sure that you continuously monitor your services and you have a good solution to compare your metrics between multiple deploys and releases. If you do so, you’ll instantly see when a revert is needed to keep up the previously good performance and user experience. (deploys) New is not always better. Not knowing whether new is better is even worse! Monitor using custom metrics 7. Correlate application performance with your business metrics Business metrics and performance metrics can correlate, which will lead you to valuable insights. Usually, it’s worth to check some of your key business metrics together with your performance metrics. Let’s see an example: You recognized that whenever a lot of new users register, your response time gets higher than the usual. In this case, it’s quite possible that the response times are higher because of your service sends a welcome email to your new users, and the email rendering blocks your event loop — so your service is not able to fulfill the requests as fast as usually. When your APM is able to collect and correlate data, you will hunt down performance issues easier, because you can see the business context behind them. 8. Follow distributed transactions through your system If you are building a distributed system (one with a microservices architecture), you probably know how challenging can it be to track down issues when they happen in a call chain with multiple services. What’s just a stack trace on a lower level may cause an unknown anomaly on higher levels. Microservices needs slightly different tools to monitor and debug. Luckily, distributed transaction tracing can help you to catch issues between services. Distributed tracing is a method first mentioned in the , which allows you to monitor complex, large-scale distributed systems. Google Dapper whitepaper With an APM capable of distributed tracing, you can visualize your service calls with databases and external API(s) as well. So instead of extracting the logs from all of the participating services, you can see your whole transaction on a timeline visualization, with the highlighted issues. Find issues in distributed systems using distributed tracing 9. Don’t let security vulnerabilities ruin your day Most of the services are built with using lots of packages from or other package managers. These modules can and usually do contain security vulnerabilities. npm It’s good to know when we should upgrade our dependencies to prevent security breaches. Some of the monitoring tools also provide alerting for security issues — make sure you use one with it. There’s nothing more embarrassing than leaking user data to malicious attackers. 10. Do alerting right It’s not enough to have a place where we can check all of these important metrics since we cannot watch them 24/7; that’s why a good monitoring solution provides an alerting feature as well. Be the first who knows about issues Issues should be found as soon as possible; . Don’t wait for your biggest customer to find them To be up to date about ongoing incidents in your application, you should set up alerts based on them. If you are building a critical service, you should be alerted even in the middle of the night. Always keep in mind: production issues do not respect your working hours. Prevent noise Being notified about the wrong alerts is not just wasting time, it also makes harder to catch critical issues. When you configure an alert, always be sure that you set it with the right criteria and send it to the right channel. It’s also a good practice to use a channel like Pagerduty or Opsgenie to notify the right people in the right way in the right time. Sending alerts via email may just spam your mailbox. (email, SMS, phone, etc.) 11. Monitoring is not easy, so don’t build your own tool! A perfect monitoring tool saves money and makes it easy and quick to hunt down complex issues. As a result, your service will be healthier and faster, and your customers will appreciate it. Building a proper monitoring tool needs a lot of time, knowledge and effort, and it’s like a separate product in your company. Instead of creating your own solution, I highly recommend to choose a third-party APM and spend your time on making your product awesome and your customers happier. Getting Started with Node.js Monitoring Nowadays, most of the monitoring tools are available as a SaaS solution. This means that you don’t have to spend your time to setup and maintain them — you can just use them and enjoy your extra time and money you saved. As a software engineer working on a application, I can only recommend embracing a reliable and insightful monitoring solution. The benefits of using one will be measurable. So, how about start saving some money today? distributed tracing About the author: Peter Marton (@slashdotpeter) is the co-Founder and CTO of RisingStack, currently working on designed for understanding and troubleshooting microservices-based applications on a process level. Trace — a Node.js Performance Monitoring and Debugging tool

Node.js Monitoring Done Right

For many years Nginx has been a default solution to serve as a reverse proxy for Rails applications. However, with the release of Kamal, the Rails community opened Traefik as a new reverse proxy solution. Within my 15 years of experience with Rails, I created an almost perfect configuration for Nginx that migrated through all my projects. With Traefik, I had to start from scratch. Traefik Intro Traefik is an Edge Router; it means that it’s the door to your platform and that it intercepts and routes every incoming request but does not process requests itself. When an incoming request comes to Traefik, it is getting served through the EntryPoint. Traefik can listen to multiple EntryPoints, and each EntryPoint is associated with a port and a protocol (HTTP/HTTPS, TCP, UDP). After the request is received, it is passed to the Router. Router is a rule that tells Traefik how to handle the request. It can be based on the path, the host, the headers, etc. The router will then forward the request to the appropriate service. But before a request is forwarded, it can be modified by the Middleware. Middleware is a piece of code that can modify the request or the response before it reaches the service. Middleware is the place where you can add authentication, rewrite the path, add headers, etc. To better understand how Traefik works, I provide an image from the official . Traefik documentation Compared to Nginx, the Traefik configuration is entirely different. Besides a traditional configuration file (which can be both in YAML and TOML formats), Traefik can be configured with dynamic configuration. It means that you can configure Traefik with a file, but also with a REST API, a Docker label, a Kubernetes annotation, etc. Since Kamal is a Docker orchestration tool, Traefik configuration is done with Docker labels. It means that you don’t need to write a configuration file; instead, you should provide labels to your Docker containers. Labels work dynamically, so you don’t need to reboot Traefik to apply them. At the same time, operating a Docker label can be pretty tricky, especially at the beginning. Traefik Dashboard The good news is that Traefik works pretty good with Kamal out of the box with Kamal (Kamal provides basic default configuration, which I will show later), and maybe you won’t need to change anything. However, if you want to take a look at how Traefik is configured, you may want to enable a . web dashboard To do this, open your Kamal config (usually ), and add the following lines. config/deploy.yml # config/deploy.yml

traefik:
  args:
    api.dashboard: true
  labels:
    traefik.http.routers.dashboard.servixce: api@internal
    traefik.http.routers.dashboard.rule: "Host(`traefik.onetribe.com`)"
    traefik.http.middlewares.auth.basicauth.users: user:$2y$05$us7dsDg56EJ/qojvhLvy9OEshrzoWjGSKXziBqeiFq3Ehf1pAiGSG
    traefik.http.routers.dashboard.middlewares: auth@docker If you have a separate configuration for production and staging environments, you probably will have the last two labels in your environment-specific configuration files. # config/deploy.production.yml

traefik:
  labels:
    traefik.http.routers.dashboard.rule: "Host(`traefik.onetribe.team`)"
    traefik.http.middlewares.auth.basicauth.users: user-production:$2y$05$us7dsDg56EJ/qojvhLvy9OEshrzoWjGSKXziBqeiFq3Ehf1pAiGSG

# config/deploy.staging.yml

traefik:
  labels:
    traefik.http.routers.dashboard.rule: "Host(`traefik.staging.onetribe.team`)"
    traefik.http.middlewares.auth.basicauth.users: user-staging:$2y$05$us7dsDg56EJ/qojvhLvy9OEshrzoWjGSKXziBqeiFq3Ehf1pAiGSG Let’s go line by line in file. config/deploy.yml On line enables Traefik Dashboard, as it is disabled by default. 5, api.dashboard: true On line I defined a router that will serve the dashboard. The internal Traefik API service is called ; I attached it to the router. 7, api@internal dashboard Then, on line I defined a rule that tells Traefik to serve the dashboard on the domain. Rule can be based . 9, traefik.onetribe.team on the path, the host, the headers, etc Since I don’t want to expose the dashboard to the public, I added a basic authentication middleware on lines and . Traefik supports different authentication methods: , , , etc. I used basic authentication, as it is the easiest to configure. 9 10 basic digest forward Password can be encrypted with the command, which is a , and this is really amazing how software, which is 20 years old, is still in use. To encrypt a password for a new user, run the following command. htpasswd part of the Apache toolkit htpasswd -nB user Traefik Logging Besides the visualization of the configuration, it is important to have good logging. Most of my Kamal projects use AWS CloudWatch for logging, so I configured Traefik to send logs to CloudWatch. To do this, I added the following lines to the file. config/deploy.yml logging:
  driver: awslogs
  options:
    awslogs-region: us-east-1
    awslogs-group: application
    awslogs-create-group: true
    tag: "-" This will configure logging for your application containers. In the example above, I used as a log group; you can use any name you want. The option is important; I used the container name and ID to distinguish logs from different containers. The picture below demonstrates how logs are organized in the CloudWatch. application tag As you see, besides application container logs, I also have a Traefik log stream, which includes both error and access logs (which is not the best, but it is how it is). Traefik logging can be configured by passing arguments to the Traefik container. I assume that my health check requests are pretty fast, so I set the minimum duration to 50ms to filter not important data. traefik:
  args:
    log.format: json
    accesslog: true
    accesslog.format: json
    accesslog.filters.minduration: 50ms Middlewares 101 I already talked about middlewares earlier in this article; let’s have a closer look at them. Middlewares are a piece of code that can modify the request or the response before it reaches the service. I used a basic authentication middleware to protect the Traefik dashboard. As we already know, each router has a set of settings and is also a setting that accepts a list of middlewares. Each middleware should be defined with it is own labels. middlewares traefik.http.middlewares.<middleware_1>.basicauth.users: username:<encrypted_password>
traefik.http.middlewares.<middleware_2>.ipwhitelist.sourcerange: 127.0.0.1/32
traefik.http.routers.<router_name>.middlewares: <middleware_1>, <middleware_2>, <middleware_3> : Traefik middlewares are not global. They are attached to the router, so you need to define them for each router separately. Important Kamal adds a to each service that uses Traefik. It is essential to know because if you add a middleware to a router, it will replace the default middleware. If you want to add a middleware to the default middleware, you must add it to the list of middlewares. default middleware WWW Redirect Redirecting from a www to a non-www domain is a common practice. It is important to have a single domain for SEO and security reasons. In Nginx, I used to do this with a simple directive. rewrite server {
  server_name www.onetribe.team;
  return 301 $scheme://onetribe.team$request_uri;
} To do this with Traefik, you need to configure on the router. RedirectRegex middleware servers:
  web:
    hosts:
      - <ip_address>
    labels:
      traefik.http.routers.onetribe-web.middlewares: onetribe-web-www-redirect@docker
      traefik.http.middlewares.onetribe-web-www-redirect.redirectregex.regex: ^http://www.(.*)
      traefik.http.middlewares.onetribe-web-www-redirect.redirectregex.replacement: https://$1 You probably noticed that I used schema in regex. Why not ? In all my configurations with Traefik, I do HTTPS termination on the load balancer before the request reaches Traefik. In Rails, 7.1 introduced to handle such configurations. http:// https:// config.assume_ssl option Compress Almost all Nginx configurations I saw had a directive. Compressing responses to save bandwidth and speed up the website is a good practice. Digital Ocean has an , explaining how HTTP compression works and how to configure it with Nginx. gzip excellent tutorial server {
  # ...
  gzip on;
  gzip_comp_level 2;
  gzip_min_length 1000;
  gzip_proxied any;
  gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
  gzip_vary on;
  # ...
} Traefik has a that can be used to achieve the same result. Compress middleware servers:
  web:
    hosts:
      - <ip_address>
    labels:
      traefik.http.routers.onetribe-web.middlewares: onetribe-web-compress@docker
      traefik.http.middlewares.onetribe-web-compress.compress: true Full Example The example below combines two middleware defined above and a middleware that is added by default by Kamal–Retry. The Retry middleware reissues requests a given number of times to a backend server if that server does not reply. servers:
  web:
    hosts:
      - <ip_address>
    labels:
      traefik.http.routers.onetribe-web.middlewares: onetribe-web-www-redirect@docker,onetribe-web-retry@docker,onetribe-web-compress@docker
      traefik.http.routers.onetribe-web.rule: PathPrefix(`/`)
      traefik.http.services.onetribe-web.loadbalancer.server.scheme: http

      traefik.http.middlewares.onetribe-web-www-redirect.redirectregex.regex: ^http://www.(.*)
      traefik.http.middlewares.onetribe-web-www-redirect.redirectregex.replacement: https://$1

      traefik.http.middlewares.onetribe-web-compress.compress: true

      traefik.http.middlewares.onetribe-web-retry.retry.attempts: 5
      traefik.http.middlewares.onetribe-web-retry.retry.initialinterval: 500ms Rails Assets Handling Last, it is not about the Traefik but about the Rails configuration. With Nginx, I usually didn’t care about how my CSS, JS, and other static assets were handled; Nginx did this for me. All required headers (like compression that we discussed above and cache control) were added by Nginx. Traefik is not a web server; it is an edge router, so it doesn’t handle static assets. It means that you need to configure Rails to handle static assets properly. Stop, Rails static file handling is slow and not efficient. And you are right, or at least you were right. Modern versions of Puma handle static assets well. Besides, in 2024, we usually use cloud storage like AWS S3 to handle user uploads, so Rails will only serve CSS and JS files, which is not a big deal for Puma. I ended with something like this in my file. config/environments/production.rb # config/environments/production.rb
  # ...

  config.public_file_server.enabled = true
  config.public_file_server.headers = {
    "Cache-Control" => "public, max-age=#{30.days.to_i}, must-revalidate"
  } header is important; it tells the browser how long it should cache the file. In this example, I set it to 30 days. Must-revalidate tells the browser to revalidate the file after the cache expires. Cache-Control With such settings, Rails will serve static files only once for each client. If you think this is not enough, you can use a CDN like Cloudflare or AWS CloudFront to cache responses from Rails and dramatically reduce the load on your server. Conclusion As it usually happens with new technologies, it takes time to get used to them. Traefik is not an exception. It took me a while to understand how it works and how to configure it. At the same time, I see the benefits of using Traefik over Nginx with Rails – the main one is, of course, support of Docker out of the box. I believe this was the main reason why Basecamp decided to go with Traefik. Almost a year has passed since I switched our first project to Traefik, and I’m happy with the result. I hope you will find this article useful. Feel free to ask questions in the comments below.

A Beginner's Guide to Traefik Tuning for Rails Applications

JWT stands for , and it is an authorization mechanism, not authentication. So let’s figure out what the difference between those two. JSON Web Token is the mechanism that allows verifying that the user is exactly the one he claims to be. It is a login process where a user provides a username and password, and the system verifies them. So authentication answers the question: who is the user? Authentication is the mechanism that allows verification of which access rights the user has to a certain resource.  It is a process of granting users some roles and a set of permissions a particular role has. So, authorization answers that question: what rights does the user have in the system? Authorization It is important to understand that Authentication always comes first and Authorization is second. In other words, you can’t get permission before you verify your identity. But what are the most popular authorization methods? There are two main approaches to handling authorization for the web application. Sessions A traditional approach on the web for authorization users is a cookie-based server-side session. The process starts when a user logs in and a server authenticates him. After that, the server creates a session with a Session ID and stores it somewhere in the server’s memory. The server sends back Session ID to the client and the client stores the Session ID in cookies. For every request, the client sends a Session ID as a part of the request, and the server verifies the Session ID in its memory and the user’s permissions related to this session. Tokens Another popular approach is using tokens for authorization. The process starts similarly when a user enters login, and passwords and a client sends a login request to a server. Instead of creating a session, the server generates a token signed with the secret token. Then, the server sends the token back to the client, and the client has to store it in a local storage. Similar to the session-based approach, the client has to send a token to the server for every request. However, the server does not store any additional information about the user session. The server has to validate that the token has not changed since it was created and signed with the secret key. Session vs Token Session-based authorization approach can be vulnerable to an attack known as Cross-Site Request Forgery (CSRF). It is a kind of attack when the attacker points to a site they are logged into to perform actions they didn’t intend to, like submitting a payment or changing a password. Another thing is that when using a session-based authorization approach creates a stateful session between a client and server. The problem is if a client wants to access different servers in the scope of the same application, those servers have to share a session state. In another case, the client will need to be authorized on each server since the session is going to be different. On the other hand, the token-based authorization approach does not require storing session data on the server side and may simplify authorization between multiple servers. However, tokens can still be stolen by an attacker and it also can be difficult to invalidate tokens. We will see the details and how to handle invalidation further in this article. JWT JSON Web Token (JWT) is an open standard that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed. JWTs can be signed using a secret (with the algorithm) or a public/private key pair using or . HMAC RSA ECDSA JWT structure JSON Web Tokens consist of three parts separated by dots . Header {
  "alg": "HS256",
  "typ": "JWT"
} The header usually consists of two parts: the type of token, and the signing algorithm being used. Payload {
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
} The payload contains the claims, which are statements about the user. The payload is then encoded to form the second part of the JSON Web Token. You can find a description of standard fields that are used as claims . Base64Url here Signature HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret) To create the signature part, you have to take the encoded header, the encoded payload, a secret, and the algorithm specified in the header and sign that. The token typically looks like the following: xxxxx.yyyyy.zzzzz You can navigate to and debug a sample token or your own. Just paste your token into the field and select the of the token signature. jwt.io Encoded Algorithm .NET project Now that we have theoretical knowledge of how JWT works, we can apply it to the real-life project. Let’s assume we have a simple API that represents CRUD operations for the coffee entity. We are going to create an ASP.NET Core API project that represents Coffee API. After that, we will create another ASP.NET Core API project that would represent an Identity API that could generate JWT. In real life, you would probably use or , or for Authentication/Authorization purposes. However, we would create our own Identity API to demonstrate how to generate JWT. When Identity API is done, we can call its controller and generate JWT based on the user’s data. Also, we can protect the Coffee API with an authorization configuration that requires passing JWT with each request. Identity Server Okta Auth0 Coffee API First, we are going to create a simple ASP.NET Core API project that represents Coffee API. Here is the structure of this project: Let’s start with the in the folder. It is a simple entity with an and a properties. Coffee.cs Model Id Name namespace Hackernoon.Coffee.API.Model;

public class Coffee
{
    public int Id { get; set; }
    public string Name { get; set; }
} We need to store our entities while working with the API. So, let’s introduce a simple in-memory storage. It is located in the file in the folder. Storage.cs Data namespace Hackernoon.Coffee.API.Data;

public static class Storage
{
    private static readonly List<Model.Coffee> Data = new();

    public static List<Model.Coffee> GetAll()
    {
        return Data;
    }
    
    public static bool Create(Model.Coffee model)
    {
        if (Data.Any(c => c.Id == model.Id || c.Name == model.Name))
            return false;
        
        Data.Add(new Model.Coffee
        {
            Id = model.Id, 
            Name = model.Name
        });

        return true;
    }
    
    public static bool Delete(int id)
    {
        if (Data.All(c => c.Id != id))
            return false;
        
        Data.Remove(Storage.Data.First(c => c.Id == id));
        return true;
    }
    
    public static bool Update(Model.Coffee model)
    {
        if (Data.All(c => c.Id != model.Id))
            return false;
        
        Data.First(c => c.Id == model.Id).Name = model.Name;
        return true;
    }
} We need a class that would represent requests to the Coffee API. So, let’s create in the folder. CoffeeRequest.cs Contracts namespace Hackernoon.Coffee.API.Contracts;

public class CoffeeRequest
{
    public int Id { get; set; }
    public string Name { get; set; }
} When it is done, we can implement in the folder that represents CRUD operations for the coffee entity. CoffeeController.cs Controller using Hackernoon.Coffee.API.Contracts;
using Hackernoon.Coffee.API.Data;
using Microsoft.AspNetCore.Mvc;

namespace Hackernoon.Coffee.API.Controllers;

[Route("coffee")]
[ApiController]
public class CoffeeController : ControllerBase
{
    [HttpGet]
    public IList<Model.Coffee> GetAll()
    {
        return Storage.GetAll();
    }
    
    [HttpPost]
    public IActionResult Create([FromBody]CoffeeRequest request)
    {
        var model = new Model.Coffee
        {
            Id = request.Id,
            Name = request.Name
        };

        if (!Storage.Create(model))
            return new BadRequestResult();

        return new OkResult();
    }

    [HttpDelete]
    public IActionResult Delete(int id)
    {
        if (!Storage.Delete(id))
            return new BadRequestResult();

        return new OkResult();
    }

    [HttpPut]
    public IActionResult Update([FromBody] CoffeeRequest request)
    {
        var model = new Model.Coffee()
        {
            Id = request.Id,
            Name = request.Name
        };
        
        if (!Storage.Update(model))
            return new BadRequestResult();

        return new OkResult();
    }
} Coffee API is done, and we can run the project and see Swagger UI as follows: Identity API Let’s create another ASP.NET Core API project that represents Identity API. Here is the structure of this project: Let’s start with the in folder, which represents the request for the generation of a new JWT with and properties. TokenGenerationRequest.cs Contracts Email Password namespace Hackernoon.Identity.API.Contracts;

public class TokenGenerationRequest
{
    public string Email { get; set; }
    public string Password { get; set; }
} We need to implement only that represents the logic of generation JWT. But before we do that NuGet package needs to be installed. TokenController.cs Microsoft.AspNetCore.Authentication.JwtBearer using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Hackernoon.Identity.API.Contracts;
using Microsoft.AspNetCore.Mvc;
using Microsoft.IdentityModel.Tokens;

namespace Hackernoon.Identity.API.Controllers;

[Route("token")]
public class TokenController : ControllerBase
{
    private const string SecretKey = "VerySecretAndLongKey-NeedMoreSymbolsHere-123";
    private const string Issuer = "IdentityServerIssuer";
    private const string Audience = "IdentityServerClient";
    private static readonly TimeSpan Lifetime = TimeSpan.FromMinutes(20); 
        
    [HttpPost]
    public string Create([FromBody]TokenGenerationRequest request)
    {
        var claims = new List<Claim> {new Claim(ClaimTypes.Email, request.Email) };

        var jwt = new JwtSecurityToken(
            issuer: Issuer,
            audience: Audience,
            claims: claims,
            expires: DateTime.UtcNow.Add(Lifetime),
            signingCredentials: CreateSigningCredentials());
            
        return new JwtSecurityTokenHandler().WriteToken(jwt);
    }

    private static SigningCredentials CreateSigningCredentials()
    {
        return new SigningCredentials(
            new SymmetricSecurityKey(Encoding.UTF8.GetBytes(SecretKey)), 
            SecurityAlgorithms.HmacSha256);
    }
} Note that sensitive const such as , , and have to be put somewhere in the configuration. They are hardcoded just for simplifying this test project. The field is set to 20 minutes, which means that the token will be valid for that time. You also might configure this parameter. SecretKey Issuer Audience Lifetime Now we can run the project and see Swagger UI as follows: Let’s make a call to the endpoint and generate a new JWT. Try the following payload: /token {
  "email": "john.doe@gmail.com",
  "password": "password"
} Identity API will generate the corresponding JWT: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9lbWFpbGFkZHJlc3MiOiJqb2huLmRvZUBnbWFpbC5jb20iLCJJc0dvdXJtZXQiOiJmYWxzZSIsImV4cCI6MTcwNzc4Mzk4MCwiaXNzIjoiSWRlbnRpdHlTZXJ2ZXJJc3N1ZXIiLCJhdWQiOiJJZGVudGl0eVNlcnZlckNsaWVudCJ9.4odXsbWak1C0uK3Ux-n7f58icYQQwlHjM54OjgMCVPM Enabling Authorization in Coffee API Now, when Identity API is ready and provides us with tokens, we can guard Coffee API with authorization. Again NuGet package needs to be installed. Microsoft.AspNetCore.Authentication.JwtBearer We need to register the required services by authentication services. Add the following code to the file right after creating a builder. Program.cs var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidIssuer = "IdentityServerIssuer",
            ValidateAudience = true,
            ValidAudience = "IdentityServerClient",
            ValidateLifetime = true,
            IssuerSigningKey = 
                new SymmetricSecurityKey(
                    Encoding.UTF8.GetBytes("VerySecretAndLongKey-NeedMoreSymbolsHere-123")),
            ValidateIssuerSigningKey = true,
        };
    });

builder.Services.AddAuthorization(); It is important to remember that order in middleware is important. We enable authentication by calling method and specifying as an authentication schema. It is a constant that contains a value. AddAuthentication() JwtBearerDefaults.AuthenticationScheme Bearer namespace Microsoft.AspNetCore.Authentication.JwtBearer
{
  /// <summary>Default values used by bearer authentication.</summary>
  public static class JwtBearerDefaults
  {
    /// <summary>
    /// Default value for AuthenticationScheme property in the JwtBearerAuthenticationOptions
    /// </summary>
    public const string AuthenticationScheme = "Bearer";
  }
} We need to specify that describes which parameters of JWT will be validated during the authorization. We also specify similar to the in Identity API to verify the JWT signature. Check more details about . TokenValidationParameters IssuerSigningKey signingCredentials TokenValidationParameters here The next piece of code adds middleware to the builder that enables authentication and authorization capabilities. It should be added between the and methods. UseHttpsRedirection() MapControllers() app.UseHttpsRedirection();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers(); Now, we can use the attribute over the controller or its actions. By applying this code, now all the actions in are protected with an authorization mechanism, and JWT has to be sent as a part of the request. Authorize CoffeeController [Route("coffee")]
[ApiController]
[Authorize]
public class CoffeeController : ControllerBase
{
  .. If we make a call to any endpoint of the Coffee API, we can debug and see that it is populated and has an with claims we have specified in JWT. It is an important thing in understanding how ASP.NET Core handles Authorization under the hood. HttpContext.User Identity Add Authorization to Swagger UI We did great work to protect Coffee API with the authorization. But if you run the Coffee API project and open Swagger UI, you won’t be able to send JWT as a part of the request. To fix that, we need to update the file with the following code: Program.cs builder.Services.AddSwaggerGen(option =>
{
    option.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        In = ParameterLocation.Header,
        Description = "Please enter a valid token",
        Name = "Authorization",
        Type = SecuritySchemeType.Http,
        BearerFormat = "JWT",
        Scheme = "Bearer"
    });
    option.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference
                {
                    Type=ReferenceType.SecurityScheme,
                    Id="Bearer"
                }
            },
            new string[]{}
        }
    });
}); After that, we will be able to see the button at the right top corner: Authorize When you click on the button you will be able to enter JWT as follows: Authorize Use Postman for testing You can not limit yourself to using Swagger UI and can perform testing of the API through the Postman tool. Let’s call endpoint of the Identity API first. We need to specify header with the value in the section since we are going to use JSON as a payload. /token Content-Type application/json Headers After that, we can call endpoint and get a new JWT. /token Now, we can copy JWT and use it to call Coffee API. We need to specify header similar to the Identity API if we want to test, create, and update endpoints. header also has to be set with the value . After that, just hit button and see the result. Content-Type Authorization Bearer [your JWT value] Send Role-based authorization As you remember, the payload part of JWT is a set of claims with values that are exactly key-value pairs. Role-based authorization allows you to differentiate access to application resources depending on the role to which the user belongs. If we update the method in the file in Identity API with the code that adds a new claim for the role; we can handle role-based authentication in the Coffee API. is a predefined name of the role claim. Create() TokenController.cs ClaimTypes.Role var claims = new List<Claim>
{
    new Claim(ClaimTypes.Email, request.Email),
    new Claim(ClaimTypes.Role, "Barista")
}; Update the attribute in the file specifying the role name: Authorize CoffeeController.cs [Authorize(Roles = "Barista")] Now, all users who make a call to Coffee API have to have the role claim with the value. Otherwise, they will get status code. Barista 403 Forbidden Claim-based authorization An attribute can easily handle role-based authentication. But what if it is not enough, and we want to differentiate access based on some user properties like age or any other? You have probably already guessed that you can add your claims to JWT and use them to build authorization logic. Role-based authorization itself is a special case of claims-based authorization, just as a role is the same claim object of a predefined type. Authorize Let’s update the method in the file in Identity API with the code that adds a new claim . Create() TokenController.cs IsGourmet var claims = new List<Claim>
{
    new Claim(ClaimTypes.Email, request.Email),
    new Claim("IsGourmet", "true")
}; In the Program.cs file in Coffee API, we need to create a policy that verifies a claim and can be used in the attribute. The following code has to be added right after the method call. Authorize AddAuthentication() builder.Services.AddAuthorization(opts => {
    opts.AddPolicy("OnlyForGourmet", policy => {
        policy.RequireClaim("IsGourmet", "true");
    });
}); Update the attribute in the file specifying the policy name: Authorize CoffeeController.cs [Authorize(Policy = "OnlyForGourmet")] Summary Congratulations! You made a great effort in learning JWT in .NET. Now, you have to have a solid understanding of JWT principles and why it is important to use it to perform authorization in .NET applications. But we just scratched the surface in the area of authentication and authorization in ASP.NET Core applications. I suggest looking into Microsoft documentation regarding the topics we discussed in this article. There are also a lot of built-in capabilities for authorization and role management in the .NET platform. A good addition to this article could be Microsoft about authorization. documentation

Why do you need JWT in your ASP.NET Core project?

কেন আপনার ASP.NET কোর প্রকল্পে JWT দরকার?

Warum benötigen Sie JWT in Ihrem ASP.NET Core-Projekt?

¿Por qué necesita JWT en su proyecto ASP.NET Core?

Pourquoi avez-vous besoin de JWT dans votre projet ASP.NET Core ?

आपको अपने ASP.NET कोर प्रोजेक्ट में JWT की आवश्यकता क्यों है?

ASP.NET Core プロジェクトに JWT が必要なのはなぜですか?

ASP.NET Core 프로젝트에 JWT가 필요한 이유는 무엇입니까?

Por que você precisa do JWT em seu projeto ASP.NET Core?

Зачем вам нужен JWT в вашем проекте ASP.NET Core?

ASP.NET Core projenizde neden JWT'ye ihtiyacınız var?

Tại sao bạn cần JWT trong dự án ASP.NET Core của mình?

为什么 ASP.NET Core 项目中需要 JWT？

How are you, hacker?
🪐 has got you covered with fresh content from our trending stories of the day! Set email preference . Want to know what's trending right now?: The Techbeat by HackerNoon here A Beginner's Guide to Understanding SQL Window Functions - Part 2 By [ 8 Min read ]
let us explore more advanced SQL concepts. It may sound a bit complicated at first glance, but I will provide simple examples suitable for beginners... @yonatansali Read More. Using Witnet to Overcome The Challenges of Developing A Truly Multichain Oracle Network By [ 4 Min read ]
Tomas Ruiz on overcoming the challenges of developing a truly multi-chain oracle network using Witnet. @oraclesummit Read More. Unveiling the Best of 2023: Top Stories, Writers, Tech Categories, and Templates! 📚 By [ 5 Min read ]
We've compiled a 2023 roundup of the top most-read stories, top active writers, top tech categories, and even the top most popular templates. Take a look! @editingprotocol Read More. Investigating Internet Freedom: Unseen Aspects of Our Online Existence By [ 2 Min read ]
Join award-winning journalist Nicole Scott in her latest video series, exploring digital democracy and our collective role in shaping the online world. @ionos Read More. Web3 Gaming: 7 Predictions for 2024 By [ 6 Min read ]
The resilience of Web3 gaming, bolstered by an emerging crypto bull market, is paving the way for what industry experts are forecasting as a defining year. @ggmetagame Read More. How to Shed Pounds Off Your Docker Image By [ 4 Min read ]
Checkout the best practices for making your Docker images slim and fast. Be Kubernetes ready and streamline your development process! @infinity Read More. Geofencing Made Easy: Implementing Geofencing With ipstack API By [ 6 Min read ]
Would you like to discover the advantages of using geofencing with the ipstack IP API? Learn geofencing in depth with ipstack API. @apilayerapimarketplace Read More. Reverse Proxying — the Backbone of Microservices Architecture By [ 5 Min read ]
Understand how reverse proxies powers almost every service that we use today from monolith to microservices. It is a vital piece of 21st century infrastructure! @infinity Read More. TypeScript Might Not Be Your God: A Case Study of Using JSDoc for JavaScript Projects By [ 10 Min read ]
Unlock JavaScript typing potential using JSDoc & TypeScript synergy. Bridge the gap between clarity and flexibility for seamless development. @wha1s1ove Read More. I Created a React Utility Component for Animations With Tailwind and CSS: AnimateIn By [ 5 Min read ]
<AnimateIn/> is a reusable React component that I’ve made to drop in whenever I want to quickly add some animation effects to my projects. @johnpolacek Read More. A Deep Dive on Digital Identity: Why You Need to Check Out Genies Traits Framework By [ 9 Min read ]
What if your avatar in the Genies Ecosystem encoded not only your visual representation but also who you are – your personality, quirks, and all? @genies Read More. Everything I Achieved With My Mozilla Contribution Sprint By [ 2 Min read ]
After years of supporting Mozilla financially and spreading messages with my peers, I returned as an active contributor. @bogomil Read More. Designing a Video Game: Principles and Rules of Modern Level Design By [ 12 Min read ]
Today's gamers expect levels that are not only visually stunning but also richly interactive and immersive. How can we reach these expectations as developers? @beatboyninja Read More. Stand Up for the Champion Startups of the Year! By [ 2 Min read ]
The Startups of the Year 2023 winners are announced! @startups Read More. Creating the Perfect Dashboard: Visualizing Your Metrics By [ 10 Min read ]
A well-designed dashboard can become a key element in forecasting trends and anticipating outcomes, impacting the efficiency and motivation of the team. @vanpelz Read More. AI's Dirty Secret: The Hidden Cost of its Environmental Impact By [ 6 Min read ]
As AI's carbon footprint expands, the environmental impact becomes an increasingly critical issue. Check out 5 ways  to build a sustainable AI-powered future. @viceasytiger Read More. Become a Productivity Beast With These 16 Killer Work-Flow Tools By [ 4 Min read ]
I've curated 16 tools from website management and content creation to design apps, coding utilities, automation tools, and much more that will save you time. @madzadev Read More. Cybersecurity Essentials: Practical Web App Security Testing Tips for QA Engineers By [ 10 Min read ]
Cybersecurity for QA - web app security: XSS, Header Injections, CSRF, RCE, Command Injection, Web Parameter Tampering, CORS, Content Security Policy (CSP) @shad0wpuppet Read More. Improving Testing Algorithms: Mathematical Approaches in Software Testing By [ 7 Min read ]
Test design, Code coverage, MC/DC, Boolean algebra, Pairwise testing, Combinatorial testing, Orthogonal arrays, System states @shad0wpuppet Read More. Multi-Class Classification: Understanding Activation and Loss Functions in Neural Networks By [ 25 Min read ]
Multi-class classification NN is used with the softmax activation function on its final layer together with CE loss. The final layer size = classes_number. 🧑‍💻 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 HackerNoon Team ✌️ @owlgrey 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 TechBeat: A Beginner's Guide to Understanding SQL Window Functions - Part 2 (1/26/2024)

How are you, hacker?
🪐 has got you covered with fresh content from our trending stories of the day! Set email preference . Want to know what's trending right now?: The Techbeat by HackerNoon here Investigating Internet Freedom: Unseen Aspects of Our Online Existence By [ 2 Min read ]
Join award-winning journalist Nicole Scott in her latest video series, exploring digital democracy and our collective role in shaping the online world. @ionos Read More. A Beginner's Guide to Understanding SQL Window Functions - Part 2 By [ 8 Min read ]
let us explore more advanced SQL concepts. It may sound a bit complicated at first glance, but I will provide simple examples suitable for beginners... @yonatansali Read More. Meeting Customer Needs With User-Centric Product Development By [ 6 Min read ]
In a nutshell, user-centric product development implies attentiveness to the client's needs. This approach puts the customer at the heart of the product @tonythevoit Read More. Unveiling the Best of 2023: Top Stories, Writers, Tech Categories, and Templates! 📚 By [ 5 Min read ]
We've compiled a 2023 roundup of the top most-read stories, top active writers, top tech categories, and even the top most popular templates. Take a look! @editingprotocol Read More. Geofencing Made Easy: Implementing Geofencing With ipstack API By [ 6 Min read ]
Would you like to discover the advantages of using geofencing with the ipstack IP API? Learn geofencing in depth with ipstack API. @apilayerapimarketplace Read More. TypeScript Might Not Be Your God: A Case Study of Using JSDoc for JavaScript Projects By [ 10 Min read ]
Unlock JavaScript typing potential using JSDoc & TypeScript synergy. Bridge the gap between clarity and flexibility for seamless development. @wha1s1ove Read More. Web3 Gaming: 7 Predictions for 2024 By [ 6 Min read ]
The resilience of Web3 gaming, bolstered by an emerging crypto bull market, is paving the way for what industry experts are forecasting as a defining year. @ggmetagame Read More. Using Witnet to Overcome The Challenges of Developing A Truly Multichain Oracle Network By [ 4 Min read ]
Tomas Ruiz on overcoming the challenges of developing a truly multi-chain oracle network using Witnet. @oraclesummit Read More. Everything I Achieved With My Mozilla Contribution Sprint By [ 2 Min read ]
After years of supporting Mozilla financially and spreading messages with my peers, I returned as an active contributor. @bogomil Read More. Reverse Proxying — the Backbone of Microservices Architecture By [ 5 Min read ]
Understand how reverse proxies powers almost every service that we use today from monolith to microservices. It is a vital piece of 21st century infrastructure! @infinity Read More. How to Shed Pounds Off Your Docker Image By [ 4 Min read ]
Checkout the best practices for making your Docker images slim and fast. Be Kubernetes ready and streamline your development process! @infinity Read More. Creating the Perfect Dashboard: Visualizing Your Metrics By [ 10 Min read ]
A well-designed dashboard can become a key element in forecasting trends and anticipating outcomes, impacting the efficiency and motivation of the team. @vanpelz Read More. I Created a React Utility Component for Animations With Tailwind and CSS: AnimateIn By [ 5 Min read ]
<AnimateIn/> is a reusable React component that I’ve made to drop in whenever I want to quickly add some animation effects to my projects. @johnpolacek Read More. Become a Productivity Beast With These 16 Killer Work-Flow Tools By [ 4 Min read ]
I've curated 16 tools from website management and content creation to design apps, coding utilities, automation tools, and much more that will save you time. @madzadev Read More. AI's Dirty Secret: The Hidden Cost of its Environmental Impact By [ 6 Min read ]
As AI's carbon footprint expands, the environmental impact becomes an increasingly critical issue. Check out 5 ways  to build a sustainable AI-powered future. @viceasytiger Read More. How to Build a Decentralized Charity Platform with Next.js, TypeScript, and Solidity By [ 8 Min read ]
Build a decentralized application (Dapp) for a charity marketplace. Learn Solidity, Ethereum, OpenZeppelin, Next.js, TypeScript, Hardhat, EthersJs, Redux-Toolki @daltonic Read More. Designing a Video Game: Principles and Rules of Modern Level Design By [ 12 Min read ]
Today's gamers expect levels that are not only visually stunning but also richly interactive and immersive. How can we reach these expectations as developers? @beatboyninja Read More. How I Improved My English Speaking Skills With AIs That Should Work For You Too By [ 9 Min read ]
With AI language learning apps, such as speaking assistant Pronounce, text checker Grammarly, and ChatGPT, I boosted fluency, grammar, pronunciation, and more. @pronounce Read More. Python's Testing Playbook: Building Bulletproof Code By [ 11 Min read ]
Master Python testing: From unit tests to TDD and BDD, learn to build resilient code with pytest and unittest in this in-depth guide. @nikolaibabkin Read More. Dopamine Pumps: Neurohacking Habits By [ 7 Min read ]
The marketing industry operates on a spectrum of neurohormones, with dopamine at its peak and corticoliberin at its nadir. 🧑‍💻 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 HackerNoon Team ✌️ @cryptobro 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 TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/24/2024)

How are you, hacker?
🪐 has got you covered with fresh content from our trending stories of the day! Set email preference . Want to know what's trending right now?: The Techbeat by HackerNoon here Investigating Internet Freedom: Unseen Aspects of Our Online Existence By [ 2 Min read ]
Join award-winning journalist Nicole Scott in her latest video series, exploring digital democracy and our collective role in shaping the online world. @ionos Read More. Geofencing Made Easy: Implementing Geofencing With ipstack API By [ 6 Min read ]
Would you like to discover the advantages of using geofencing with the ipstack IP API? Learn geofencing in depth with ipstack API. @apilayerapimarketplace Read More. Meeting Customer Needs With User-Centric Product Development By [ 6 Min read ]
In a nutshell, user-centric product development implies attentiveness to the client's needs. This approach puts the customer at the heart of the product @tonythevoit Read More. Unveiling the Best of 2023: Top Stories, Writers, Tech Categories, and Templates! 📚 By [ 5 Min read ]
We've compiled a 2023 roundup of the top most-read stories, top active writers, top tech categories, and even the top most popular templates. Take a look! @editingprotocol Read More. Everything I Achieved With My Mozilla Contribution Sprint By [ 2 Min read ]
After years of supporting Mozilla financially and spreading messages with my peers, I returned as an active contributor. @bogomil Read More. TypeScript Might Not Be Your God: A Case Study of Using JSDoc for JavaScript Projects By [ 10 Min read ]
Unlock JavaScript typing potential using JSDoc & TypeScript synergy. Bridge the gap between clarity and flexibility for seamless development. @wha1s1ove Read More. Creating the Perfect Dashboard: Visualizing Your Metrics By [ 10 Min read ]
A well-designed dashboard can become a key element in forecasting trends and anticipating outcomes, impacting the efficiency and motivation of the team. @vanpelz Read More. Web3 Gaming: 7 Predictions for 2024 By [ 6 Min read ]
The resilience of Web3 gaming, bolstered by an emerging crypto bull market, is paving the way for what industry experts are forecasting as a defining year. @ggmetagame Read More. How to shed Pounds off your Docker image? By [ 4 Min read ]
Checkout the best practices for making your Docker images slim and fast. Be Kubernetes ready and streamline your development process! @infinity Read More. Reverse Proxying — the Backbone of Microservices Architecture By [ 5 Min read ]
Understand how reverse proxies powers almost every service that we use today from monolith to microservices. It is a vital piece of 21st century infrastructure! @infinity Read More. How to Build a Decentralized Charity Platform with Next.js, TypeScript, and Solidity By [ 8 Min read ]
Build a decentralized application (Dapp) for a charity marketplace. Learn Solidity, Ethereum, OpenZeppelin, Next.js, TypeScript, Hardhat, EthersJs, Redux-Toolki @daltonic Read More. Python's Testing Playbook: Building Bulletproof Code By [ 11 Min read ]
Master Python testing: From unit tests to TDD and BDD, learn to build resilient code with pytest and unittest in this in-depth guide. @nikolaibabkin Read More. I Created a React Utility Component for Animations With Tailwind and CSS: AnimateIn By [ 5 Min read ]
<AnimateIn/> is a reusable React component that I’ve made to drop in whenever I want to quickly add some animation effects to my projects. @johnpolacek Read More. Become a Productivity Beast With These 16 Killer Work-Flow Tools By [ 4 Min read ]
I've curated 16 tools from website management and content creation to design apps, coding utilities, automation tools, and much more that will save you time. @madzadev Read More. Meet the Writer: HackerNoon's Contributor Aayush Naik, Software Engineer @ Apple By [ 3 Min read ]
Meet Aayush Naik, Apple Software Engineer, as he shares insights into his tech and writing journey, personal interests, and future goals. @aayn Read More. How I Improved My English Speaking Skills With AIs That Should Work For You Too By [ 9 Min read ]
With AI language learning apps, such as speaking assistant Pronounce, text checker Grammarly, and ChatGPT, I boosted fluency, grammar, pronunciation, and more. @pronounce Read More. AI's Dirty Secret: The Hidden Cost of its Environmental Impact By [ 6 Min read ]
As AI's carbon footprint expands, the environmental impact becomes an increasingly critical issue. Check out 5 ways  to build a sustainable AI-powered future. @viceasytiger Read More. Designing a Video Game: Principles and Rules of Modern Level Design By [ 12 Min read ]
Today's gamers expect levels that are not only visually stunning but also richly interactive and immersive. How can we reach these expectations as developers? @beatboyninja Read More. Dopamine Pumps: Neurohacking Habits By [ 7 Min read ]
The marketing industry operates on a spectrum of neurohormones, with dopamine at its peak and corticoliberin at its nadir. @cryptobro Read More. Helium Mining in 2024: Still Worthwhile with Helium Farm By [ 2 Min read ]
With its innovative approach and lucrative mining plans, Helium Farm continues to make Helium mining not only accessible but highly profitable. 🧑‍💻 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 HackerNoon Team ✌️ @CryptoAdventure 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 TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/22/2024)

How are you, hacker?
🪐 has got you covered with fresh content from our trending stories of the day! Set email preference . Want to know what's trending right now?: The Techbeat by HackerNoon here Investigating Internet Freedom: Unseen Aspects of Our Online Existence By [ 2 Min read ]
Join award-winning journalist Nicole Scott in her latest video series, exploring digital democracy and our collective role in shaping the online world. @ionos Read More. Everything I Achieved With My Mozilla Contribution Sprint By [ 2 Min read ]
After years of supporting Mozilla financially and spreading messages with my peers, I returned as an active contributor. @bogomil Read More. Geofencing Made Easy: Implementing Geofencing With ipstack API By [ 6 Min read ]
Would you like to discover the advantages of using geofencing with the ipstack IP API? Learn geofencing in depth with ipstack API. @apilayerapimarketplace Read More. Meeting Customer Needs With User-Centric Product Development By [ 6 Min read ]
In a nutshell, user-centric product development implies attentiveness to the client's needs. This approach puts the customer at the heart of the product @tonythevoit Read More. TypeScript Might Not Be Your God: A Case Study of Using JSDoc for JavaScript Projects By [ 10 Min read ]
Unlock JavaScript typing potential using JSDoc & TypeScript synergy. Bridge the gap between clarity and flexibility for seamless development. @wha1s1ove Read More. Unveiling the Best of 2023: Top Stories, Writers, Tech Categories, and Templates! 📚 By [ 5 Min read ]
We've compiled a 2023 roundup of the top most-read stories, top active writers, top tech categories, and even the top most popular templates. Take a look! @editingprotocol Read More. Creating the Perfect Dashboard: Visualizing Your Metrics By [ 10 Min read ]
A well-designed dashboard can become a key element in forecasting trends and anticipating outcomes, impacting the efficiency and motivation of the team. @vanpelz Read More. Web3 Gaming: 7 Predictions for 2024 By [ 6 Min read ]
The resilience of Web3 gaming, bolstered by an emerging crypto bull market, is paving the way for what industry experts are forecasting as a defining year. @ggmetagame Read More. Python's Testing Playbook: Building Bulletproof Code By [ 11 Min read ]
Master Python testing: From unit tests to TDD and BDD, learn to build resilient code with pytest and unittest in this in-depth guide. @nikolaibabkin Read More. Reverse Proxying — the Backbone of Microservices Architecture By [ 5 Min read ]
Understand how reverse proxies powers almost every service that we use today from monolith to microservices. It is a vital piece of 21st century infrastructure! @infinity Read More. How to Build a Decentralized Charity Platform with Next.js, TypeScript, and Solidity By [ 8 Min read ]
Build a decentralized application (Dapp) for a charity marketplace. Learn Solidity, Ethereum, OpenZeppelin, Next.js, TypeScript, Hardhat, EthersJs, Redux-Toolki @daltonic Read More. Crypto ETFs Have Been Approved — A Simple Guide to What it Means for Investing in Crypto & Beyond By [ 4 Min read ]
The approval of the ETF allows hundreds of millions of investors around the world to access Bitcoin like never before. @janinegrainger Read More. Futurism in Africa: Creating New Realities With The Power of Technology By [ 6 Min read ]
How should we use technology for our benefit? What are the risks, and how do we manage them in the Gambia? @zraso Read More. How I Improved My English Speaking Skills With AIs That Should Work For You Too By [ 9 Min read ]
With AI language learning apps, such as speaking assistant Pronounce, text checker Grammarly, and ChatGPT, I boosted fluency, grammar, pronunciation, and more. @pronounce Read More. Meet the Writer: HackerNoon's Contributor Aayush Naik, Software Engineer @ Apple By [ 3 Min read ]
Meet Aayush Naik, Apple Software Engineer, as he shares insights into his tech and writing journey, personal interests, and future goals. @aayn Read More. How to shed Pounds off your Docker image? By [ 4 Min read ]
Checkout the best practices for making your Docker images slim and fast. Be Kubernetes ready and streamline your development process! @infinity Read More. Dopamine Pumps: Neurohacking Habits By [ 7 Min read ]
The marketing industry operates on a spectrum of neurohormones, with dopamine at its peak and corticoliberin at its nadir. @cryptobro Read More. Helium Mining in 2024: Still Worthwhile with Helium Farm By [ 2 Min read ]
With its innovative approach and lucrative mining plans, Helium Farm continues to make Helium mining not only accessible but highly profitable. @CryptoAdventure Read More. I Created a React Utility Component for Animations With Tailwind and CSS: AnimateIn By [ 5 Min read ]
<AnimateIn/> is a reusable React component that I’ve made to drop in whenever I want to quickly add some animation effects to my projects. @johnpolacek Read More. Become a Productivity Beast With These 16 Killer Work-Flow Tools By [ 4 Min read ]
I've curated 16 tools from website management and content creation to design apps, coding utilities, automation tools, and much more that will save you time. 🧑‍💻 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 HackerNoon Team ✌️ @madzadev 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 TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/20/2024)

How are you, hacker?
🪐 has got you covered with fresh content from our trending stories of the day! Set email preference . Want to know what's trending right now?: The Techbeat by HackerNoon here Python's Testing Playbook: Building Bulletproof Code By [ 11 Min read ]
Master Python testing: From unit tests to TDD and BDD, learn to build resilient code with pytest and unittest in this in-depth guide. @nikolaibabkin Read More. Investigating Internet Freedom: Unseen Aspects of Our Online Existence By [ 2 Min read ]
Join award-winning journalist Nicole Scott in her latest video series, exploring digital democracy and our collective role in shaping the online world. @ionos Read More. Everything I Achieved With My Mozilla Contribution Sprint By [ 2 Min read ]
After years of supporting Mozilla financially and spreading messages with my peers, I returned as an active contributor. @bogomil Read More. Meeting Customer Needs With User-Centric Product Development By [ 6 Min read ]
In a nutshell, user-centric product development implies attentiveness to the client's needs. This approach puts the customer at the heart of the product @tonythevoit Read More. Geofencing Made Easy: Implementing Geofencing With ipstack API By [ 6 Min read ]
Would you like to discover the advantages of using geofencing with the ipstack IP API? Learn geofencing in depth with ipstack API. @apilayerapimarketplace Read More. Creating the Perfect Dashboard: Visualizing Your Metrics By [ 10 Min read ]
A well-designed dashboard can become a key element in forecasting trends and anticipating outcomes, impacting the efficiency and motivation of the team. @vanpelz Read More. Unveiling the Best of 2023: Top Stories, Writers, Tech Categories, and Templates! 📚 By [ 5 Min read ]
We've compiled a 2023 roundup of the top most-read stories, top active writers, top tech categories, and even the top most popular templates. Take a look! @editingprotocol Read More. TypeScript Might Not Be Your God: A Case Study of Using JSDoc for JavaScript Projects By [ 10 Min read ]
Unlock JavaScript typing potential using JSDoc & TypeScript synergy. Bridge the gap between clarity and flexibility for seamless development. @wha1s1ove Read More. Crypto ETFs Have Been Approved — A Simple Guide to What it Means for Investing in Crypto & Beyond By [ 4 Min read ]
The approval of the ETF allows hundreds of millions of investors around the world to access Bitcoin like never before. @janinegrainger Read More. Why 2024 is the Year of BRC-20 Tokens By [ 7 Min read ]
As the crypto industry continues to evolve, we are seeing the emergence of fungible tokens on other blockchains, with the most recent one being Bitcoin BRC-20. @evanluthra Read More. Dopamine Pumps: Neurohacking Habits By [ 7 Min read ]
The marketing industry operates on a spectrum of neurohormones, with dopamine at its peak and corticoliberin at its nadir. @cryptobro Read More. How to Build a Decentralized Charity Platform with Next.js, TypeScript, and Solidity By [ 8 Min read ]
Build a decentralized application (Dapp) for a charity marketplace. Learn Solidity, Ethereum, OpenZeppelin, Next.js, TypeScript, Hardhat, EthersJs, Redux-Toolki @daltonic Read More. Reverse Proxying — the Backbone of Microservices Architecture By [ 5 Min read ]
Understand how reverse proxies powers almost every service that we use today from monolith to microservices. It is a vital piece of 21st century infrastructure! @infinity Read More. 995 Stories To Learn About Good Company By [ 160 Min read ]
Learn everything you need to know about Good Company via these 995 free HackerNoon stories. @learn Read More. Meet the Writer: HackerNoon's Contributor Aayush Naik, Software Engineer @ Apple By [ 3 Min read ]
Meet Aayush Naik, Apple Software Engineer, as he shares insights into his tech and writing journey, personal interests, and future goals. @aayn Read More. Futurism in Africa: Creating New Realities With The Power of Technology By [ 6 Min read ]
How should we use technology for our benefit? What are the risks, and how do we manage them in the Gambia? @zraso Read More. Helium Mining in 2024: Still Worthwhile with Helium Farm By [ 2 Min read ]
With its innovative approach and lucrative mining plans, Helium Farm continues to make Helium mining not only accessible but highly profitable. @CryptoAdventure Read More. Cryptocurrency Horizons: A 2023 Recap and Glimpse into 2024 Trends By [ 6 Min read ]
Let’s explore about the top crypto-adopters countries in 2023, and also about some other relevant factors for crypto adoption last year and 2024. @obyte Read More. How I Improved My English Speaking Skills With AIs That Should Work For You Too By [ 9 Min read ]
With AI language learning apps, such as speaking assistant Pronounce, text checker Grammarly, and ChatGPT, I boosted fluency, grammar, pronunciation, and more. @pronounce Read More. Memory Management in Swift: Pointers, Object Creation, Copying, Binding, and Collections By [ 4 Min read ]
Learn manual memory management in Swift with pointers, object creation, copying, binding, and collections—an essential guide for developers. 🧑‍💻 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 HackerNoon Team ✌️ @bugorbn 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 TechBeat: Python's Testing Playbook: Building Bulletproof Code (1/18/2024)

How are you, hacker?
🪐 has got you covered with fresh content from our trending stories of the day! Set email preference . Want to know what's trending right now?: The Techbeat by HackerNoon here Python's Testing Playbook: Building Bulletproof Code By [ 11 Min read ]
Master Python testing: From unit tests to TDD and BDD, learn to build resilient code with pytest and unittest in this in-depth guide. @nikolaibabkin Read More. Everything I Achieved With My Mozilla Contribution Sprint By [ 2 Min read ]
After years of supporting Mozilla financially and spreading messages with my peers, I returned as an active contributor. @bogomil Read More. Creating the Perfect Dashboard: Visualizing Your Metrics By [ 10 Min read ]
A well-designed dashboard can become a key element in forecasting trends and anticipating outcomes, impacting the efficiency and motivation of the team. @vanpelz Read More. Crypto ETFs Have Been Approved — A Simple Guide to What it Means for Investing in Crypto & Beyond By [ 4 Min read ]
The approval of the ETF allows hundreds of millions of investors around the world to access Bitcoin like never before. @janinegrainger Read More. Investigating Internet Freedom: Unseen Aspects of Our Online Existence By [ 2 Min read ]
Join award-winning journalist Nicole Scott in her latest video series, exploring digital democracy and our collective role in shaping the online world. @ionos Read More. Why 2024 is the Year of BRC-20 Tokens By [ 7 Min read ]
As the crypto industry continues to evolve, we are seeing the emergence of fungible tokens on other blockchains, with the most recent one being Bitcoin BRC-20. @evanluthra Read More. Embracing the Shift-Left Approach: Revolutionizing Quality Assurance in Software Development By [ 4 Min read ]
Shift-Left is a paradigm shift that has redefined the QA landscape. Early involvement of QA practices offers manifold benefits to organizations. @malykhpaul Read More. Dopamine Pumps: Neurohacking Habits By [ 7 Min read ]
The marketing industry operates on a spectrum of neurohormones, with dopamine at its peak and corticoliberin at its nadir. @cryptobro Read More. Helium Mining in 2024: Still Worthwhile with Helium Farm By [ 2 Min read ]
With its innovative approach and lucrative mining plans, Helium Farm continues to make Helium mining not only accessible but highly profitable. @CryptoAdventure Read More. Geofencing Made Easy: Implementing Geofencing With ipstack API By [ 6 Min read ]
Would you like to discover the advantages of using geofencing with the ipstack IP API? Learn geofencing in depth with ipstack API. @apilayerapimarketplace Read More. Meet the Writer: HackerNoon's Contributor Aayush Naik, Software Engineer @ Apple By [ 3 Min read ]
Meet Aayush Naik, Apple Software Engineer, as he shares insights into his tech and writing journey, personal interests, and future goals. @aayn Read More. Life After Smartphones: Are Critics of Apple’s iPhone Sales Slump Missing the Bigger Picture? By [ 5 Min read ]
Sales issues surrounding the iPhone have led to Apple’s stock receiving two rating downgrades within a week, sending share values tumbling in the new year. @dmytrospilka Read More. Li Auto Prepares to Make EV Investing Cool Again as New Innovations Bring Investor Optimism By [ 5 Min read ]
Recent months have posed a challenge for EV stocks as the generative AI boom has seen more investor interest funnelled into artificial intelligence. @dmytrospilka Read More. Token Engineering: A Blueprint for Building Sustainable Decentralized Economies By [ 11 Min read ]
Learn why token engineering is essential for sustainable digital economies, and gain practical insights into this dynamic field. @idrees535 Read More. Unveiling the Best of 2023: Top Stories, Writers, Tech Categories, and Templates! 📚 By [ 5 Min read ]
We've compiled a 2023 roundup of the top most-read stories, top active writers, top tech categories, and even the top most popular templates. Take a look! @editingprotocol Read More. How to Connect a MetaMask Wallet with HackerNoon By [ 4 Min read ]
This guide contains step-by-step process on how to connect a MetaMask wallet with your HackerNoon profile. @omotundeedun_356grio8 Read More. Futurism in Africa: Creating New Realities With The Power of Technology By [ 6 Min read ]
How should we use technology for our benefit? What are the risks, and how do we manage them in the Gambia? @zraso Read More. 995 Stories To Learn About Good Company By [ 160 Min read ]
Learn everything you need to know about Good Company via these 995 free HackerNoon stories. @learn Read More. Using ChatGPT to be More Productive: 100 Days of AI - Day 4 By [ 5 Min read ]
But the point is clear, using ChatGPT, you can be more productive and creative in your daily job. So, knowing some techniques below will help you @sindamnataraj Read More. Cryptocurrency Horizons: A 2023 Recap and Glimpse into 2024 Trends By [ 6 Min read ]
Let’s explore about the top crypto-adopters countries in 2023, and also about some other relevant factors for crypto adoption last year and 2024. 🧑‍💻 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 HackerNoon Team ✌️ @obyte 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 TechBeat: Python's Testing Playbook: Building Bulletproof Code (1/16/2024)

In the realm of programming, there exists a powerful utility known as . This often-overlooked gem enables developers to orchestrate concurrent execution of multiple asynchronous tasks, leading to improved performance and efficiency. Dart Future.wait() In this blog post, we will explore the problem domain where can save the day and delve into best practices for utilizing it effectively. Future.wait() The Problem Imagine you are developing a Dart application that needs to fetch data from multiple remote APIs simultaneously? That was our case and we got PR for this case scenario in a Dart/Flutter code I am managing, as it is listed in the code snippet below! Given I can’t share the whole code, I will embody this code smell with the power of later in this blog: Future.wait() void fetchFromRemoteApis() {
  final apiAFuture = fetchDataFromApi('API A');
  final apiBFuture = fetchDataFromApi('API B');
  final apiCFuture = fetchDataFromApi('API C');

  apiAFuture.then((resultA) {
    print('Received result from API A: $resultA');
    apiBFuture.then((resultB) {
      print('Received result from API B: $resultB');
      apiCFuture.then((resultC) {
        print('Received result from API C: $resultC');
        print('All API calls completed successfully!');
      }).catchError((errorC) {
        print('An error occurred while fetching data from API C: $errorC');
      });
    }).catchError((errorB) {
      print('An error occurred while fetching data from API B: $errorB');
    });
  }).catchError((errorA) {
    print('An error occurred while fetching data from API A: $errorA');
  });
} In this suboptimal approach, the code chained the callbacks sequentially for each API call. This results in nested callbacks, commonly known as the "callback hell" or "pyramid of doom" pattern. It leads to less readable and more error-prone code, especially when handling errors. then The code also first fetches data from API A. Upon successful completion, it proceeds to fetch data from API B. Finally, when API B completes successfully, it proceeds to fetch data from API C. At each stage, error handling is implemented using to capture and handle any errors that may occur during the API calls. catchError() The main disadvantage of this approach is that it lacks the efficiency of concurrent execution, as each API call waits for the previous one to complete before initiating the next. This can lead to longer overall execution time, especially when dealing with multiple independent asynchronous tasks. Traditionally, when dealing with asynchronous tasks, you might resort to executing them one after another, waiting for each one to complete them before starting the next. This sequential approach can lead to suboptimal performance, especially when network latencies come into play. , is a function that enables concurrent execution of asynchronous tasks. With this mighty tool at our disposal, we can dramatically enhance the efficiency of our code by fetching data from multiple remote APIs concurrently, taking advantage of parallelism and reducing overall execution time. Harnessing the Power of Future.wait() : Future.wait() : Here's how Future.wait() works We create a list of objects, each representing an asynchronous task, such as fetching data from a remote API. Future We pass this list of objects to . Future Future.wait() returns a new that completes when all the provided objects have completed. Future.wait() Future Future Saving the Day with Future.wait() Consider a scenario where your application needs to fetch data from three different remote APIs: A, B, and C. Without , you might fetch data from A, wait for it to complete, then fetch data from B, and finally fetch data from C. This sequential approach can be time-consuming and inefficient. Future.wait() However, by utilizing , you can kick off all three asynchronous tasks concurrently, reducing the overall execution time. The returned by will complete only when all three API calls have finished, allowing you to collect the results efficiently. Future.wait() Future Future.wait() So, I reviewed the code smell to make it better. Let’s proceed to that. : Writing Better Code To make the most of , here are a few best practices: Future.wait() Use when the tasks are truly independent and can be executed concurrently. If there are dependencies between tasks, consider using or to handle them. Future.wait() Future.then() async/await Ensure that the tasks passed to are truly asynchronous and return a . If not, consider wrapping synchronous code in a using or . Future.wait() Future Future Future.value() Future.microtask() Utilize error-handling mechanisms like or callbacks to handle exceptions that might occur during the execution of concurrent tasks. try-catch onError If there's a need to set a timeout for the completion of , you can use to handle situations where certain tasks take an unusually long time. Future.wait() Future.wait(...).timeout(...) The Fix: So here, I embodied the code smell and used to make it better. I have also chosen open random endpoints for you to see how effective it can serve concurrent execution: Future.wait() API import 'dart:async';
import 'dart:convert';
import 'package:http/http.dart' as http;

void main() {
  fetchFromRemoteApis();
}

void fetchFromRemoteApis() async {
  final apiAFuture = fetchDataFromApi('https://jsonplaceholder.typicode.com/posts');
  final apiBFuture = fetchDataFromApi('https://jsonplaceholder.typicode.com/comments');
  final apiCFuture = fetchDataFromApi('https://jsonplaceholder.typicode.com/todos');

  try {
    List<dynamic> results = await Future.wait<dynamic>([apiAFuture, apiBFuture, apiCFuture]);
    
    for (var result in results) {
      print('Received result: $result');
    }
    
    print('All API calls completed successfully!');
  } catch (error) {
    print('An error occurred: $error');
  }
}

Future<dynamic> fetchDataFromApi(String apiUrl) async {
  final response = await http.get(Uri.parse(apiUrl));

  // Check the response status
  if (response.statusCode == 200) {
    final jsonResponse = jsonDecode(response.body);
    return jsonResponse;
  } else {
    throw Exception('API request failed with status ${response.statusCode}');
  }
} As much as different software engineers can have differing opinions such as using with inside , which I think is unnecessary nested callbacks, or use only with which creates an additional callback function and introduces an extra layer of complexity, I believe the algorithmic complexity of the code smell is reduced drastically by the fix provided in this blog. .map() .then() Future.wait() .then() Future.wait() Conclusion In the ever-evolving world of Dart programming, it's essential to leverage the right tools for improved performance and efficiency. is a valuable utility that empowers developers to achieve concurrent execution of asynchronous tasks, effectively reducing execution time and optimizing resource utilization. By incorporating into your code, you can unlock the magic of concurrent programming and embrace the power of Dart to its fullest potential. Future.wait() Future.wait() So, the next time you find yourself juggling multiple asynchronous tasks, remember the spellbinding capabilities of and watch as your code performs its own brand of magic. Future.wait() If you need more resources on , kindly refer to and . Future.wait() https://api.dart.dev/stable/2.1.0/dart-async/Future/wait.html https://api.flutter.dev/flutter/dart-async/Future/wait.html Happy coding!

Harnessing Concurrent Execution with “Future.wait()” in Dart

The Life and Love of the Insect by Jean-Henri Fabre, is part of the HackerNoon Books Series. You can jump to any chapter in this book here . THE ONTHOPHAGI CHAPTER VI. THE ONTHOPHAGI After the notabilities of the Dung-beetle tribe, there remain, in the very limited radius of my research, the small fry of the Onthophagi, of whom I could gather a dozen different species around my house. What will these little ones teach us? Even more zealous than their larger comrades, they are the first to hasten to the exploiting of the heap left by the passing mule. They come up in crowds and stay long, working under the spread table that gives them shade and coolness. Turn over the heap with your foot. You will be surprised at the swarming population whose presence no outward sign betrayed. The largest are scarce the size of a pea, but many are much smaller still, are dwarfs, no less busy than the others, no less eager to crumble the filth whose prompt disappearance the public health demands. In works of major interest, there is none like the humble, with their concerted weakness, for realizing immense strength. Swollen by numbers, the next to nothing becomes an enormous total. Hurrying in detachments at the first news of the event, assisted moreover in their wholesome task by their partners, the Aphodians, who are as weak as they, the tiny Onthophagi soon clear the ground of its dirt. Not that [ ]their appetite is equal to the consumption of such plentiful provisions. What food do those pigmies need? An atom. But that atom, selected from among the exudations, must be hunted amid the fragments of the masticated fodder. Hence, an endless division and subdivision of the lump, reducing it to crumbs which the sun sterilizes and the wind dispels. As soon as the work is done—and very well done—the troop of scavengers goes in search of another refuse-yard. Outside the period of intense cold, which puts a stop to all activity, they know no dead season. 80 And do not run away with the idea that this filthy task entails an inelegant shape and a ragged dress. The insect knows none of our squalor. In its world, a navvy dons a sumptuous jerkin; an undertaker decks himself in a triple saffron sash; a wood-cutter works in a velvet coat. In like manner, the Onthophagus has his own luxury. True, the costume is always severe: brown and black are the predominant colours, now dull, now polished as ebony; but, on this background, what details of sober and graceful ornament! The graver’s work completes the beauty of the dress. Tiny chasings in parallel grooves, gnarly beads, dainty rows of knobs, seed-plots of pearly papillæ are distributed in profusion among nearly all of them. Yes, the little Onthophagi, with their stunted bodies and their nimble activity, are really pretty to look at. PLATE V 1.Onthophagus Taurus. 2.Onthophagus Vacca. 3.The Stercoraceous Geotrupe. 4.The Wide-necked Scarab. 5.Cleonus Opthalmicus. 6.Cerceris Tuberculata. 7.Buprestis Ærea. And then how original are their frontal decorations! These peace-lovers delight in the panoply of war, as though they, the inoffensive ones, thirsted for battle. Many of them crown their heads with threatening horns. Let us mention that horned one whose story will occupy us more particularly. I mean Onthophagus [ ]Taurus, clad in raven black. He wears a pair of long horns, gracefully curved and branching to either side. No pedigree bull, in the Swiss meadows, can match them for curve or elegance. 81 The Onthophagus is a very indifferent artist: his nest is a rudimentary piece of work, hardly fit to be acknowledged. I obtain it in profusion from the six species which I have brought up in my jars and flower-pots. Onthophagus Taurus alone provides me with nearly a hundred; and I find no two precisely alike, as pieces should be that come from the same mould and the same laboratory. To this lack of exact similarity, we must add inaccuracy of shape, now more, now less accentuated. It is easy, however, to recognize among the bulk the prototype from which the clumsy nest-builder works. It is a sack shaped like a thimble and standing erect, with the spherical thimble-end at the bottom and the circular opening at the top. Sometimes, the insect establishes itself in the central region of my apparatus, in the heart of the earthy mass; then, the resistance being the same in every direction, the sack-like shape is pretty accurate. But, generally, the Onthophagus prefers a solid basis to a dusty support and builds against the walls of the jar, especially against the bottom wall. When the support is vertical, the sack is a short cylinder divided lengthwise, with a smooth, flat surface against the glass and a rugged convexity every elsewhere. If the support be horizontal, as is most frequently the case, the cabin is a sort of undefined oval pastille, flat at the bottom, bulging and vaulted at the top. To the general inaccuracy of these contorted shapes, ruled by no very definite pattern, we must add the coarseness of the surfaces, all of which, with the [ ]exception of the parts touching the glass, are covered with a crust of sand. 82 The manner of procedure explains this uncouth exterior. As laying-time draws nigh, the Onthophagus bores a cylindrical pit and descends underground to a middling depth. Here, working with the shield, the chine and the fore-legs, which are toothed like a rake, he forces back and heaps around him the materials which he has moved, so as to obtain as best he may a nest of suitable size. The next thing is to cement the crumbling walls of the cavity. The insect climbs back to the surface by way of its pit; it gathers on its threshold an armful of mortar taken from the cake whereunder it has elected to set up house; it goes down again with its burden, which it spreads and presses upon the sandy wall. Thus it produces a concrete casing, the flint of which is supplied by the wall itself and the cement by the produce of the sheep. After a few trips and repeated strokes of the trowel, the pit is plastered on every side; the walls, encrusted with grains of sand, are no longer liable to give way. The cabin is ready: it now wants only a tenant and stores. First, a large free space is contrived at the bottom: the hatching-chamber, on whose inner wall the egg is laid. Next comes the gathering of the provisions intended for the worm, a gathering made with nice precautions. Lately, when building, the insect worked upon the outside of the doughy mass and took no notice of the earthy blemishes. Now, it penetrates to the very centre of the lump, through a gallery that looks as though it were contrived with a punch. When trying a cheese, the buyer employs a hollow cylindrical taster, which he [ ]drives well in and pulls out with a sample taken from the middle of the cheese. The Onthophagus, when collecting for her grub, goes to work as though equipped with one of these tasters. She bores an exactly round hole into the piece which she is exploiting; she goes straight to the middle, where the material, not being exposed to the contact of the air, has kept more savoury and pliable. Here and here alone are gathered the armfuls which, gradually stowed away, kneaded and heaped up to the requisite extent, fill the sack to the top. Finally, a plug of the same mortar, the sides of which are made partly of sand and partly of stercoral cement, roughly closes the cell, in such a way that an outward inspection does not allow one to distinguish front from back. 83 To judge the work and its merit, we must open it. A large empty space, oval in shape, occupies the rear end. This is the birth-chamber, huge in dimensions compared with its content, the egg fixed on the wall, sometimes at the bottom of the cell and sometimes on the side. The egg is a tiny white cylinder, rounded at either end and measuring a millimetre in length immediately after it is laid. With no other support than the spot on which the oviduct has planted it, it stands on its hind-end and projects into space. 1 A more or less enquiring glance is quite surprised to find so small a germ contained in so large a box. What does that tiny egg want with all that space? When carefully examined within, the walls of the chamber prompt another question. They are coated with a fine greenish pap, semi-fluid and shiny, the appearance of which does not agree with the outward or inward aspect of the lump from which the insect has extracted its [ ]materials. A similar lime-wash is observed in the nest which the Sacred Beetle, the Copris, the Sisyphus, the Geotrupe and other makers of stercoraceous preserves contrive in the very heart of the provisions, to receive the egg; but nowhere have I seen it so plentiful, in proportion, as in the hatching-chamber of the Onthophagus. Long puzzled by this brothy wash, of which the Sacred Beetle provided me with the first instance, I began by taking the thing for a layer of moisture oozing from the bulk of the victuals and collecting on the surface of the enclosure without other effort than capillary action. That was the interpretation which I accepted originally. 84 I was wrong. The truth is worthy of attention in a very different way. To-day, better-informed by the Onthophagus, I know that this lime-wash itself, this semi-fluid cream, is the product of maternal foresight. What, then, is this lime-wash found in every cell? The answer is compulsory: it is a produce of the mother, a special gruel, a milk-food elaborated for the benefit of the new-born grub. The young Pigeon puts his beak into that of his parents, who, with convulsive efforts, force down his gullet first a caseous mash secreted in the crop and next a broth of grains softened by being partially digested. He is fed upon disgorged foods, which are helpful to the weaknesses of an inexperienced stomach. The grub of the Onthophagus is brought up in much the same way, at the start. To assist its first attempts at swallowing, the mother prepares for it, in her crop, a light and strengthening cream. To pass the dainty from mouth to mouth is, in her case, impossible: the construction of other cells keeps her busy elsewhere. Moreover—and this is a more serious detail—the laying takes place egg by egg, at very long [ ]intervals, and the hatching is pretty slow: time would fail, had the family to be brought up in the manner of the Pigeons. Another method is perforce needed. The childish pap is disgorged all over the walls of the cabin in such a way that the nursling finds itself surrounded by an abundance of bread-and-jam, in which the bread, the food of the sturdy age, is represented by the uncooked material, as supplied by the sheep, whereas the jam, the mess of the puny age, is represented by the same material daintily prepared beforehand in the mother’s stomach. We shall see the babe presently lick first the jam, all around it, and then stoutly attack the bread. A child among ourselves would behave no otherwise. 85 I should have liked to catch the mother in the act of disgorging and spreading her broth. I was not able to succeed. Things happen in a narrow retreat, which the eye cannot enter when the pastry-cook is busy; and also her fluster at being exhibited in broad daylight at once stops the work. If direct observation be lacking, at least the appearance of the material speaks very clearly and tells us that the Onthophagus, here rivalling the Pigeon, but with a different method, disgorges the first mouthfuls for her sons. And the same may be said of the other Dung-beetles skilled in the art of building a hatching-chamber in the centre of the provisions. No elsewhere, in the insect order, except among the Apidæ, who prepare disgorged food in the shape of honey, is this affection present. The Dung-workers edify us with their morals. Several of them practise association in couples and found a household; several anticipate the suckling, the supreme expression of maternal solicitude, by turning their crop into a nipple. Life has its freaks. [ ]It settles amid ordure the creatures most highly-endowed with family qualities. True, from there it mounts, with a sudden flight, to the sublimities of the bird. 86 The little worm is hatched in about a week: a strange and paradoxical being. On its back, it has an enormous sugar-loaf hump, the weight of which drags it over and capsizes it each time it tries to stand on its legs and walk. At every moment, it staggers and falls under the burden of the hunch. Unable to keep its hump upright, the grub of the Onthophagus lies down on its side and licks the cream of its cell all around it. There is cream everywhere, on the ceiling, on the walls, on the floor. As soon as one spot is thoroughly bared, the consumer moves on a little with the help of its well-shaped legs; it capsizes again and starts licking again. The room is large and plentifully supplied; and the jam-diet lasts some time. The fat babies of the Geotrupe, the Copris and the Sacred Beetle finish at one brief sitting the dainty wherewith their cabined lodge is hung, a dainty scantily served and just sufficient to stimulate the appetite and prepare the stomach for a coarser fare; but the Onthophagus grub, that lean pigmy, has enough to last it for a week and more. The spacious natal chamber, which is out of all proportion with the size of the nursling, has permitted this wastefulness. At last, the real loaf is attacked. In about a month, everything is consumed, except the wall of the sack. And now the splendid part played by the hump stands revealed. Glass tubes, prepared in view of events, allow me to follow the more and more plump and hunch-backed grub at work. I see it withdraw to one end of the cell, which has become a crumbling ruin. Here it builds a [ ]casket in which the transformation will take place. Its materials are the digestive residuum, converted into mortar and heaped up in the hump. The stercoral architect is about to construct a masterpiece of elegance out of its own ordure, held in reserve in that receptacle. 87 I follow its movements under the magnifying-glass. It buckles itself, closes the circuit of the digestive apparatus, brings the two poles into contact and, with the end of its mandibles, seizes a pellet of dung ejaculated at that moment. This pellet, moulded and measured to perfection, is very neatly gathered. A slight bend of the neck sets the rubble-stone in place. Others follow, laid one above the other in minutely regular courses. Giving a tap here and there with its feelers, the grub makes sure of the stability of the parts, their accurate binding, their orderly arrangement. It turns round in the centre of the work as the edifice rises, even as a mason does when building a tower. Sometimes, the laid stone becomes loose, because the cement has given way. The worm takes it up again with its mandibles, but, before replacing it, coats it with an adhesive moisture. It holds it to its anus, whence trickles, on the moment, almost imperceptibly, a gummy consolidating extract. The hump supplies the materials; the intestines give, if necessary, the connecting glue. In this way, a nice house is produced, ovoid in shape, polished as stucco within and adorned on the outside with slightly projecting scales, similar to those on a cedar-cone. Each of these scales is one of the rubble-stones out of the hump. The casket is not large: a cherry-stone would about represent its dimensions; but it is so accurate, so prettily fashioned that it will bear comparison with the finest products of entomological industry. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Jean-Henri Fabre (2022). The Life and Love of the Insect. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/68974/pg68974-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html .

THE ONTHOPHAGI

THE POISON OF THE BEE

Java developers have often envied JavaScript for its ease of parsing JSON. Although Java offers more robustness, it tends to involve more work and boilerplate code. Thanks to the Manifold project, Java now has the potential to outshine JavaScript in parsing and processing JSON files. Manifold is a revolutionary set of language extensions for Java that completely changes the way we handle JSON (and much more…). https://www.youtube.com/watch?v=AoBnGZ7q6rk&embedable=true Getting Started With Manifold The code for this tutorial can be found on my . Manifold is relatively young but already vast in its capabilities. You can learn more about the project on their website and Slack channel. GitHub page To begin, you'll need to install the Manifold plugin, which is currently only available for JetBrains IDEs. The project supports LTS releases of Java, including the latest JDK 19. We can install the plugin from IntelliJ/IDEAs settings UI by navigating to the marketplace and searching for Manifold. The plugin makes sure the IDE doesn’t collide with the work done by the Maven/Gradle plugin. Manifold consists of multiple smaller projects, each offering a custom language extension. Today, we'll discuss one such extension, but there's much more to explore. Setting Up a Maven Project To demonstrate Manifold, we'll use a simple Maven project (it also works with Gradle). We first need to paste the current Manifold version from their website and add the necessary dependencies. The main dependency for JSON is the dependency. manifold-json-rt Other dependencies can be added for YAML, XML, and CSV support. We need to add this to the file in the project. pom.xml I'm aware of the irony where the boilerplate reduction for JSON starts with a great deal of configuration in the Maven build script. But this is configuration, not "actual code"; it's mostly copy & paste. Notice that if you want to reduce this code, the Gradle equivalent code is terse by comparison. This line needs to go into the properties section: <manifold.version>2023.1.5</manifold.version> The dependencies we use are these: <dependencies>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-json-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency> The compilation plugin is the boilerplate that weaves Manifold into the bytecode and makes it seamless for us. It’s the last part of the pom setup: <build>
   <plugins>
       <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.0</version>
           <configuration>
               <source>19</source>
               <target>19</target>
               <encoding>UTF-8</encoding>
               <compilerArgs>
                   
                   <arg>-Xplugin:Manifold</arg>
               </compilerArgs>

               
               <annotationProcessorPaths>
                   <path>
                       <groupId>systems.manifold</groupId>
                       <artifactId>manifold-json</artifactId>
                       <version>${manifold.version}</version>
                   </path>
               </annotationProcessorPaths>
           </configuration>
       </plugin>
   </plugins>
</build> With the setup complete, let's dive into the code. Parsing JSON With Manifold We place a sample JSON file in the project directory under the resources hierarchy. I placed this file under : src/main/resources/com/debugagent/json/Test.json {
  "firstName": "Shai",
  "surname": "Almog",
  "website": "https://debugagent.com/",
  "active": true,
  "details":[
    {"key": "value"}
  ]
} In the main class, we refresh the Maven project, and you'll notice a new Test class appears. This class is dynamically created by Manifold based on the JSON file. If you change the JSON and refresh Maven, everything updates seamlessly. It’s important to understand that Manifold isn’t a code generator. It compiles the JSON we just wrote into bytecode. The Test class comes with several built-in capabilities, such as a type-safe builder API that lets you construct JSON objects using builder methods. You can also generate nested objects and convert the JSON to a string by using the and methods. write() toJson() It means we can now write: Test test = Test.builder().withFirstName("Someone")
        .withSurname("Surname")
        .withActive(true)
        .withDetails(List.of(
                Test.details.detailsItem.builder().
                        withKey("Value 1").build()
        ))
        .build(); Which will printout the following JSON: {
  "firstName": "Someone",
  "surname": "Surname",
  "active": true,
  "details": [
    {
      "key": "Value 1"
    }
  ]
} We can similarly read a JSON file using code such as this: Test readObject = Test.load().fromJson("""
        {
          "firstName": "Someone",
          "surname": "Surname",
          "active": true,
          "details": [
            {
              "key": "Value 1"
            }
          ]
        }
        """); Note the use of Java 15 syntax for writing a long string. The method returns an object that includes various APIs for reading the JSON. In this case, it is read from a but there are APIs for reading it from a URL, file, etc. TextBlock load() String Manifold supports various formats, including CSV, XML, and YAML, allowing you to generate and parse any of these formats without writing any boilerplate code or sacrificing type safety. In order to add that support, we will need to add additional dependencies to the pom.xml file: <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-csv-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-xml-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-yaml-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
</dependencies> With these additional dependencies, this code will print out the same data as the JSON file... With the output would be: test.write().toCsv() "firstName","surname","active","details"
"Someone","Surname","true","[manifold.json.rt.api.DataBindings@71070b9c]" Notice that the Comma Separated Values (CSV) output doesn’t include hierarchy information. That’s a limitation of the CSV format and not the fault of Manifold. With the output is familiar and surprisingly concise: test.write().toXml() <root_object firstName="Someone" surname="Surname" active="true">
  <details key="Value 1"/>
</root_object> With we again get a familiar printout: test.write().toYaml() firstName: Someone
surname: Surname
active: true
details:
- key: Value 1 Working With JSON Schema Manifold also works seamlessly with JSON schema, allowing you to enforce strict rules and constraints. This is particularly useful when working with dates and enums. Manifold seamlessly creates/updates byte code that adheres to the schema, making it much easier to work with complex JSON data. This schema is copied and pasted from the : Manifold GitHub project {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "http://example.com/schemas/User.json",
  "type": "object",
  "definitions": {
    "Gender": {
      "type": "string",
      "enum": ["male", "female"]
    }
  },
  "properties": {
    "name": {
      "type": "string",
      "description": "User's full name.",
      "maxLength": 80
    },
    "email": {
      "description": "User's email.",
      "type": "string",
      "format": "email"
    },
    "date_of_birth": {
      "type": "string",
      "description": "Date of uses birth in the one and only date standard: ISO 8601.",
      "format": "date"
    },
    "gender": {
      "$ref" : "#/definitions/Gender"
    }
  },
  "required": ["name", "email"]
} It’s a relatively simple schema, but I’d like to turn your attention to several things here. It defines name and email as required. This is why when we try to create a object using a builder in Manifold, the method requires both parameters: User build() User.builder("Name", "email@domain.com") That is just the start... The schema includes a date. Dates are a painful prospect in JSON, the standardization is poor and fraught with issues. The schema also includes a gender field which is effectively an enum. This is all converted to type-safe semantics using common Java classes such as LocalDate: User u = User.builder("Name", "email@domain.com")
       .withDate_of_birth(LocalDate.of(1999, 10, 11))
       .withGender(User.Gender.male)
       .build(); That can be made even shorter with static imports, but the gist of the idea is clear. JSON is effectively native to Java in Manifold. The Tip of The Iceberg Manifold is a powerful and exciting project. It revolutionizes JSON parsing in Java, but that’s just one tiny portion of what it can do! We've only scratched the surface of its capabilities in this post. In the next article, we'll dive deeper into Manifold and explore some additional unexpected features. Please share your experience and thoughts about Manifold in the comments section. If you have any questions, don't hesitate to ask.

How Manifold Revolutionizes JSON Parsing in Java

জাভাতে JSON পার্সিংকে কীভাবে ম্যানিফোল্ড বিপ্লব করে

Wie Manifold das JSON-Parsing in Java revolutioniert

Cómo Manifold revoluciona el análisis de JSON en Java

Comment Manifold révolutionne l'analyse JSON en Java

कैसे कई गुना जावा में JSON पार्सिंग में क्रांति लाता है

Manifold が Java での JSON 解析に革命を起こす方法

Manifold가 Java에서 JSON 구문 분석을 혁신하는 방법

Como o Manifold revoluciona a análise JSON em Java

Manifold, Java'da JSON Ayrıştırmada Nasıl Devrim Yaratıyor?

Cách Manifold cách mạng hóa phân tích cú pháp JSON trong Java

Manifold 如何革新 Java 中的 JSON 解析

If you work as a freelancer in the digital economy, it is likely that you have a global perspective when it comes to new prospects and collaborators. A huge, worldwide pool of potential clients and opportunities is available to you. For this reason, it's not uncommon for Designers, Marketing Specialists, Web Developers, or Sales Reps to work with business partners which are based in different countries. Sometimes, a client may be willing to pay you in its local currency only. Of course, this is a slight inconvenience but, after all, setting up a multicurrency account is usually easy and inexpensive, so it might be best to accept the arrangement and plan to convert the money later. The problem This was precisely the situation I was in just a few months ago: I was doing the work, I invoiced monthly, and I was being paid. Nothing to write home about. However, after a few iterations, I started noticing some issues with this approach. Obviously, from time to time I needed to convert small amounts of money to my local currency to buy stuff, and doing so at an advantageous rate wasn't trivial: it wasn't wise to just do the conversion whenever I needed the cash and without looking at the current rates: currency pairs like or fluctuate a lot, and a difference of just a few (aka ) can lead to very different outcomes for your bank account. Why leave money on the table? USD/EUR USD/GBP price-interest points Pips converting currencies always comes at a cost: variable fees, spreads, and platform subscriptions. It doesn't matter how, a broker always finds a way to take its cut. for fiscal purposes, the only rate that mattered was the one being used when I created the invoice. However, after I got paid and wanted to transfer the money a few days later, the market was already operating at a totally different rate. Unfortunately, the Tax Man didn't care if in the past 2 years the economy has been a crazy rollercoaster and historically strong currencies were plummeting - he just wanted his money. As you can see, many different variables were at work here, mostly against me. I didn't like it. «Damn!» I thought «I am an engineer, I will find a solution if there is any chance to make some beer money!» The solution Well, how to turn the tables in my favor? Let's start with a couple of assumptions. The harsh reality is that Forex Trading is complex and risky. I could have poured hundreds of hours into it to educate myself, attempting to come up with bright strategies to gain an edge against the market. However, this approach requires lots of time and money, it's incredibly difficult to pull off as a retail investor, and it simply wouldn't play to my strengths. I concluded that I would just adhere to a naive price-based strategy: buy low, sell high. In the second place, I needed a way to constantly monitor the current rate and act on it whenever it became convenient to convert my money. Initially, I used to visit websites like TradingView to browse the currency pairs rates. As a lowly human, however, I quickly grew tired of such a repetitive and boring task: in fact, I realized, a bot would be much happier to do this kind of work! The bot The strategy was simple: sending a notification every 2 hours with the current rate and the potential gain or loss I could make at that point in time. The most critical part was getting correct, timely data about exchanges: there are myriads of APIs that can help with this, I just chose the path of least resistance and implemented APILayer's because it's free and simple but honestly, any API would work just fine. My function would be something like . Exchange Rates Data API fetchRate this Where, obviously, the and arguments represent any currency pair I am interested in. As soon as I have the current rate, from my average price is trivial. from to computing the pips difference Finally, I just needed a way to send a message to myself with this juicy info. Again, there is no need to complicate things: Telegram API can serve this purpose very well and is very simple to set up. After interceding with the to request a personal bot-friend, I was ready to get loose with the @BotFather messages. Deploying on Lambda Having a personal Forex bot is very useful only if it is always up and running. AWS Lambda is a virtually free solution to host a simple program like mine (or even small microservice architectures), so I refactored my code to run as a serverless function. There are a few ugly parts though, like the fact that some features are not supported for Golang and it's necessary to create a zip archive to upload the files (eww). However, Lambda functions allow for a lot of flexibility and can be triggered by cronjob tasks, SQS messages, or even API calls. For my use case, I decided to set up a bihourly cronjob and added a to specify some input variables. simple JSON payload Let the money flow in! 💸💸💸 References forex-bot repo on github.com What Are Pips in Forex Trading and What Is Their Value? AWS Lambda documentation for Go How to set up a Telegram Bot Exchange Rates Data API Also published . here

How I Built a Simple Forex App with Telegram Bots and AWS Lambda

Astounding Stories of Super-Science March 1931, by Astounding Stories is part of HackerNoon’s Book Blog Post series. You can jump to any chapter in this book here . Phalanxes of Atlans: Chapter X CHAPTER X With sharp anxiety, Victor Nelson kept watching the towers of Jezreel rise ever clearer above the great, warm plain of Jarmuth, but, for all that, he noted how distinctly Jezreel differed from Heliopolis. The Jarmuthian capital was predominantly amber-yellow instead of white in color; its towers were flat-topped, angular, hideous structures that compared not at all favorably with the graceful Grecian architecture of Atlantean public buildings. The populace, he decided, as he strode along in the midst of half a dozen silent guards, were as harsh and graceless as their architecture. Whereas the Atlanteans had been white skinned and uniformly red haired—save for those of Hudsonian blood—the inhabitants of Jarmuth almost without exception were black haired and had dark, olive-hued skins. "They're the lost tribes of Israel, all right," Nelson decided after a brief sojourn in that savage land lying beyond Apidanus—the great boiling river, whose bubbling and scalding currents had for centuries served as a natural boundary between the two realms. But now the Jarmuthian armies had crossed it and were steadily pushing back the demoralized and despairing Atlanteans with savage energy that heaped the dead in hillocks. "Their armor," mused the ragged, barefoot prisoner, studying his silent guards, "looks a lot like a Roman legionnaire's, but that six pointed star on their helmets is pure Semitic. Yes, this sure is an Asiatic outfit." His eyes wandered from one fierce, big-nosed infantryman to another and noted the splendid physical structure of the majority. Evidently hardier, much less refined and luxury-loving than the Atlanteans, these swart warriors disdained robes and other garments. Save for helmet, armor and brief black kilts, they were quite naked. Like the Atlantean hoplites the infantrymen carried spears, steam retortii and quantities of grenades. The country side through which the prisoner passed had a holiday air, for garlands of flowers hung in every doorway, and naked, pot-bellied children squatted by the roadside, industriously weaving crowns and streamers of gay blossoms. "Look, Atlantean dog!" commanded the black-bearded leader of the escort. "Let thine infidel eyes gaze upon the mightiest city of the world. Seest thou yonder Ziggurat which o'er towers all others?" Nelson raised eyes red-rimmed from sleeplessness and deep anxiety—for the crafty Jarmuthians had proved unexpectedly unwilling to credit him as the Atlantean outcast and would-be renegade he had pretended to be. "Yes," he said in reply to the English-speaking jehar's—captain's—question. "What's it for?" "'Tis the temple of the almighty Beelzebub, Steam God of Jarmuth. Without his hot breath no wheel would turn, our armies would be powerless and this land would perish under the ice of the outer world." The dark eyed officer's eye fell speculatively upon his bound and dust-covered prisoner. "Perchance, dog of a spy, thou wilt die during to-day's fourth division together with Altara, pale daughter of the feeble, false god Poseidon." The Atlantean day was divided into six divisions of four hours each; due to the flame suns there was no sunrise or sunset. This afternoon? Nelson could not realize that the time had flown so quickly. Four short hours separated him from the crisis of his life. A thousand doubts assailed him. What if Alden or Hero Giles failed in their share of the great scheme for rescue? Narrowly, the aviator's eye searched the great, rich plain, then swept the amber-hued sky where, far above the plain, Jilboa, the nearest flame sun, beat off the Arctic chill and darkness. The great, black-bearded jehar eased the straps from which was suspended the brass coil of his retortii. "Aye," he chuckled, his thick lips parted in a crafty smile. "Ere long will the fair flesh of Altara grace the ceremonial board of His Exaltation, the King, and his priests and princes." Nelson gasped in horror. The divinely beautiful Altara—butchered for meat like a calf? Grotesque! Ghastly! "What! You eat your prisoners?" He felt sick, nauseated. For answer, the swart Jarmuthian raised an enormous hand and dealt the captive American a stinging cuff which made his teeth rattle. "Peace!" he snarled. "Else I slit thy spying throat ere we pass yonder walls." Fingering a short blue-black beard that was frizzed into tight curls in the Assyrian manner, the jehar lengthened his stride as the little detachment clanked into the shadow of a great wall surrounding Jezreel, and through a huge gate guarded by two hideous, jackal-headed effigies. Hurrying into the city were throngs of eager men, women and children, interspersed with muscular, black bearded soldiers who cast threatening, baleful eyes on the pale-skinned prisoner. At first the great metropolis of Jezreel seemed boundless, for everywhere arose tall, massive monuments of yellow marble whose facades were engraved with Sanskrit charac ters, thus bearing out Nelson's surmise that this was indeed a race of Semitic origin. Here and there hurried grey-bearded, vulture-eyed priests oddly garbed in corrupt Occhive and Tyrian regalia. Nelson found it odd to see the Tablet of the Laws, which Jarmuth so openly ignored, swaying on their yellow robed breasts; and none cried out more menacingly nor more loudly against the limping, wan-faced captive, than these same ecclesiastics, who must have long since forgotten all worship of Jehovah in the foul service of a bestial golden effigy. A stone sailed through the air, narrowly missing the American; then another, which struck his shoulder. "God, what a rough looking crowd," thought Nelson, as the guards, cursing, held back the screaming mob. "At this rate I won't live to even reach the temple!" Every second his life stood in great danger. Unkempt, sloe-eyed women hurled themselves, shrieking with fury, against the armored chests of the guards, who were hard pressed to beat them off with their spear hafts. Nelson's one small ray of comfort in this evil hour was the fact that his .45 pistol remained untouched in a food wallet. At the border the jehar had cast one contemptuous glance at the weapon, but, no doubt deeming it some strange culinary tool, he had made no effort to remove it. It was a continual struggle for the guards to win their way up a long flight of stairs, for ever the great stream of humanity grew denser and more menacing. Nelson felt a violent sense of revolt grip his being. "I must win free," he thought. "If I fail, Alden dies, and—and—" For the first time he realised how much he wanted to actually see Altara. Like a clear cameo, an image of her had remained fresh in his memory. Except for her Grecian garments she might have been a lovely, carefree English or American girl. "And these decadent swine would sacrifice her!" The thought was sickening. Yet how could he prevent the pitiful tragedy? Fortunately, a detachment of troops—tall, sinewy fellows with conical helmets, crested with six-pointed stars—reenforced the guards just as clawing hands began to snatch and tug at the prisoner's ragged Atlantean chiton of blue cotton. Almost before he realized it, Nelson was dragged inside a great gloomy building and into a circular chamber where four eagle-featured elders sat in council beneath the six-pointed star of Sem. On approaching, the jehar in command sank on one knee and in humble salute raised both hands to the tribunal. "A tough looking desk sergeant they've got," muttered the prisoner to himself as his eye met the chilling regard of a lean, yellow-faced priest. "Wonder what I'm booked for?" Idiotically, he recalled being summoned before a traffic court, years back. "Guess I don't get off with vagrancy; it'll probably be everything from speeding to mayhem, with maybe arson and well-poisoning thrown in." The deliberations of this ominous court proved to be appallingly short. The dour-faced elders merely put their heads together, muttered a few sentences, then straightened up almost immediately. The chief priest—he with the yellow face—thrust out his fist and made the immemorial signal of death by jerking his thumb at the black marble floor. Before the outraged and astounded aviator could utter a word of protest, powerful guards seized and hauled him off down a dark, narrow passageway in which the fetid prison smell was very strong. Too wise to struggle against overwhelming odds, yet appalled at the thought of his impending doom, Nelson was dragged into a room where four or five furtive, enslaved Atlanteans, made dumb by the removal of their tongues, were engaged in a curious occupation. On a bare stone bench, five other Atlantean captives were sitting in miserable silence. They made a grotesque array, for their heads were crowned with gay yellow and blue flowers, and the upper half of their perfectly formed bodies gleamed with an application of a sweet-smelling oil. About their wrists and waists were twined fragrant garlands of yellow roses which hid the leather straps confining their hands. Struggling, Nelson was forced on to the bench, whereupon slaves, skipping to avoid the lash of a scarred, olive-hued slave driver, hurried to wash the newly arrived prisoner's limbs, face and hands. A weary-looking old slave with sunken, rheumy eyes listlessly pulled the blue chiton from Nelson's broad shoulders, and would have removed the food pouch had not the prisoner winked vigorously. The ministering slave glanced swiftly sidewise and, discovering the slave driver's attention directed to another corner, pulled the upper folds of the chiton over the food pouch and its precious contents, then set a crown of yellow roses more or less askew on the American's head. For all the peril of the situation Nelson could not suppress a fleeting smile as the phrase, "For I'm to be Queen of the May, Mother," leaped nonsensically into his brain. "Yes, I guess they are getting us all dolled up for a sacrifice of some kind." Nelson's heart began to pound at the thought. Then he fought for self control. It must be a hideously realistic nightmare! He, Victor Nelson, American citizen, a quiet birdman, member of the Caterpillar Club and ex-flight commander of the A. E. F. was about to be offered as a sacrifice to some hideous, pagan god? Nonsense! He'd wake up in a minute and hear the drone of a ship on the line. He blinked, staring fixedly at a single ray of light that came streaming in through a small, barred window, then glanced sidewise at his fellow victims, who with Spartan indifference sat waiting for the end of all things. It was no dream! From the tiny window came the shrill discordant braying of many trumpets, and a roar like that of a football crowd arose surprisingly near. In response, the slave driver lashed the gaudily bedecked sacrificial victims to their feet with vicious cuts of his pliant whip, and herded them like a drove of calves down a very long passage, lit at intervals by those strange column lamps of incandescent gas. In their red glare the doomed six seemed as though already bathed in blood. "Must be some crowd of people outside," muttered Nelson as a great gale of sound deafened him. Yonder the amber glare of the flame suns glimmered, and now it was his turn to step into the open! On a sort of spiral roadway he paused, breathless, awed, bewildered, for there, eddying restlessly about the bases of towers and other huge structures, was a great sea of up-turned faces. To his surprise he found the passage he had followed opened perhaps halfway up what must be the great Ziggurat of Beelzebub. He judged the tower's height must be immense, for already the crowd was a good hundred feet below. "Zarotoa! Zarotoa! ù Wlanka!" Nelson shivered. How terrible was the wild, bloodthirsty clamor of that vast throng, when they beheld the six flower-decked prisoners appear upon the circular winding road which led to the lofty and wind-swept summit of the great conical pyramid of the people of Jezreel. Death to the victims! Behind the victims marched perhaps eighteen or twenty spearmen gorgeously uniformed in yellow and black painted armor. Their retortii were plated with gold, and in the center of a star forming the crest of each helmet was set a diamond large as a hickory nut. Preceding the despairing prisoners marched a squad of tall, clean-shaven priests with great gold hoops in their ears. They blew mightily upon long, curved horns, and were followed by perhaps a dozen lithe, posturing girls, half clothed in diaphanous yellow robes. These priestesses swung golden censers which flung bluish clouds of aromatic smoke high into the humid air above. Up and up, around and around the great tower temple, Nelson was dragged, while the vast city of Jezreel, palaces, towers, courts, dwellings and all, lay like a great panorama below. Up and up, and the wind grew stronger while Nelson marvelled at the great height of the structure he was mounting. Immediately in front of him swayed the naked shoulders of the three captive Atlanteans; he could see rose petals from their crowns fluttering in the strong warm breeze sweeping that man-made pinnacle for the worship of a heathen god. Despairingly, the American's eyes searched the horizon, to discover nothing but a few great birds wheeling lazily in the bronze-hued sky. Very clearly he could discern three of the flame suns, casting flame high from their peaks. "Alden!" he groaned. "Oh God, Alden, don't fail me!" Chilled by the fate in store, he scanned the dark and hostile faces below, but found no friendly visage. Up and up. The procession was now nearing the summit. There were hosts of poignant problems before him, each vital if Altara and the Empire of Atlans were to be saved; but one primary question immediately confronted him. How could he get his hands free? He ventured a few words in English to the stolid Atlantean at his side, whereat the fellow only stared dully and shook his red, flower-crowned head. He next tried to cautiously work loose his hands, but to no avail. The rope of plaited skin binding his aching wrists together was tough as any rawhide. Cursing, he abandoned the effort, and, as his eyes once more swept the great bloodthirsty throng below, he felt himself doomed indeed. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various. 2009. Astounding Stories of Super-Science, March 1931. Urbana, Illinois: Project Gutenberg. Retrieved May 2022 from https://www.gutenberg.org/files/30166/30166-h/30166-h.htm#Page_376 . This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html

Stories, News & Mentions about APIDAY

Apiday’s Stories on HackerNoon