HelloTag

hellotag

Stop publishing your Android apps manually and start doing this fully automated at any stage. Mobile development, as well as any other software development, requires writing code that has to go through all possible tests. To exclude the possibility of errors, which are likely to be caused by human factors, we have made a mobile CI/CD pipeline to automate the processes of verification and delivery of the application to the test and production environment. This article overviews . the boilerplate for building a CI/CD pipeline for Android via Fastlane and GitHub Actions Why do we need a CI/CD pipeline? Above all, CI/CD allows you to increase productivity with automation. With the help of a CI/CD, you can automate the various tasks within building an app, create artifacts (.apk, .aab), and deploy them into production. This eliminates manual chores and makes the developer’s life easier. What is Fastlane? Fastlane is an open-source platform aimed at simplifying Android and iOS deployment. Fastlane lets you automate every aspect of your development and release workflow. It allows you to customize your app's build types and flavors. Besides building apps, Fastlane handles various tedious tasks such as code signing, generating screenshots, releasing apps, and much more. Its built-in plugin system makes it easy to extend its capabilities. Various tools/plugins allow you to create apps that can be published to the Google Play Store, Firebase App Distribution, or Apple TestFlight. Now it is time to look closer at our boilerplate. Why do you need it? How does our boilerplate work? Components scheme: And there are the following advantages: - With this boilerplate, you can easily build the CI/CD for your android app based on Fastlane. Quick start CI/CD - We use GitLab-ci or GitHub actions as the executor of Fastlane commands and the construction of the workflow. Easy adaptation to external CI/CD tools - It has notifications to Slack about successful operations or errors in the pipeline process. Notification - We build the application inside a docker container with all the dependencies installed; this provides portability and the ability to use standard GitHub agents or GitLab runners. No special build machine setup is required To understand the next steps in a little more detail, you can first check out our video overview: https://www.youtube.com/watch?v=poSugKUtBPU?embedable=true Let’s get started with the Android CI/CD tutorial! Prerequisites First of all, you need to: Create an account in the ; Google cloud platform Create a ; Google cloud project Create a ; Firebase project and activate app distribution Create a . Google Play developer account Only after that can we move to keys for building and releasing Android applications. Prepare keys for build and releasing the application Json-file with configuration for Firebase Prepare the Json-file with the Firebase project settings encoded to base64 - Step 3 https://firebase.google.com/docs/android/setup base64 google-services.json > firebase_setting Service account with access to Firebase Create Service Account for the release application to Firebase Choose your Firebase account --> Project Overview --> Project setting --> Service Account --> create service account Prepare the Service Account key encoded to base64. base64 sa.json > key_firebase Service account with access to Google Play Create Service Account for release applications to Google Play Prepare Service Account key encoded to base64. base64 google_play.json > google_play Keystore for signing an application To sign an application, you need a key, which can be generated with the command. keytool -genkey -v -keystore my-release-key.keystore -alias alias_name -keyalg RSA -keysize 2048 -validity 10000 Prepare signing keystore encoded to base64. base64 my-release-key.keystore > keystore Pay attention please note the parameters that you specify when creating the key.  These parameters will need to be added to the environment variables. Let's prepare the CI/CD to run If you need to prepare the CI/CD in GitLab, please see the . README GitHub Actions We can use environments in GitHub Actions, but the environments are available only in public repositories or corporate subscriptions. In this boilerplate, we don't use environments in GitHub Actions. Prepare environment variables GitHub --> Settings --> Secrets --> Actions --> New repository secret GOOGLE_SERVICES_JSON In the value field, paste your google-services.json encoded to base64. SA_JSON_KEY In the value field, paste your sa.key encoded to base64. SA_JSON_GP_KEY In the value field, paste your google_play.json encoded to base64. KEYSTORE In the value field, paste your my-release-key.keystore encoded to base64. ALIAS Alias name ALIAS_PW Alias password KEYSTORE_PW Keystore password APPROVERS List of approvers for Google Play release. APP_PACKAGE_NAME The default android package name, for example, we use com.boiler.android.hello APP_PACKAGE_NAME_STAGING The package name for the staging environment, for example, we use com.boiler.android.hello.staging APP_VERSION_NAME Application version FIREBASE_APP_ID_PROD Application ID for production Firebase FIREBASE_APP_ID_STG Application ID in for staging Firebase SLACK_WEBHOOK_URL Slack webhook URL You can find more information about environment variables on . Github When you complete all this preparation, you can start to build and release the application to Firebase. That’s all! We hope you will find this boilerplate helpful and you will find it among mobile CI/CD pipeline best practices for Android. We look forward to your feedback on our boilerplate.

Android CI/CD Boilerplate for Publishing via Fastlane

Last year, I was giving my laptop to my mother. It was a Dell XPS 13 that was a few months old and it had quite a bit of my data on it. So I thought “Why not reset the device so that she could load her own stuff on it?” Alas, if it were only that easy. About half way into the reset, the computer crashed and refused to boot up. Having a flight in two days, I frantically called the Dell helpline to get the issue sorted. The Dell Debacle The experience was not pleasant. I first had to make my way through several steps of automated questions. The IVRS system was good as far as IVRS systems go, but that is not saying much. Each question was read out slowly. The machine confirmed my choices even slower and guess what? After all that hassle, I spent about 30 minutes stuck to the phone listening to Dell’s (actually pleasant) hold music to get connected to a real human being only to find out that this human being’s job was only to connect me to the actual technician. Ridiculous! When I finally got on the line with a technician, my experience was not much better. Now don’t get me wrong, the technician was very nice. He waited while I found another laptop from which I could download my backup and talked me through the process of bootloading it onto my broken laptop. But the backup being downloaded was 7GB large. About 4GB and 2 hours in, the connection failed. Frustrating, but alas what choice did I have, I tried downloading it again. Once again 4GB and it failed. Four hours in and things looked bleak. But what choice did I have but to click the download button again and pray that it worked. Thankfully it worked this time around, the download inched towards completion and I was set! The technician talked me through the process of mounting the file on the usb drive and booting the operating system on my broken machine. But once again, it was short lived. An hour into the reset lo and behold, the computer crashed again. 5 hours with the technician and still no luck. Respite finally! At this point the frustrated technician told me that even my backup was corrupted and I needed to contact Microsoft. Now my experience with Microsoft was similar in a lot of ways. I had to spend hours waiting for the OS backup to download and it did crash a few times. The reset thankfully worked and my computer was fixed. But there was . one key difference which made it far better than my Dell experience The customer support was done through chat. It seems like a trivial difference but in reality it is night and day. Chat based support/service should undoubtedly become a standard. The initial process of getting my issue across did not involve a criminally slow IVRS process. I typed out my issue, sent it over, and proceeded to binge some Casey Neistat vlogs till the technician pinged me back. When they did, I followed their steps to download a new copy of my OS and waited. Since I was on chat though, I had more freedom. I was no longer stuck to my phone. While the download happened and the technician talked me through the process; I could watch TV, talk to my family, pack my bags for my imminent flight and even go out and get a coffee. Perfect solution right? Not quite. I would argue that Microsoft could make their chat experience better still. Why did I have to wait for the technician to ping me? My query was pretty standard and and the instructions the technician gave me were also pretty easy. The person on the other end was nice, but I could have well done the fix on my own if I knew where to look. Now I am not suggesting an FAQ page. Those require too much effort to trawl through a page and find the appropriate answer. I am thinking automation. Having a robot customer support rep available always and instantly. For instance, check this bot out that can solve your technical support queries : https://hellotars.com/convBot/demos/hp_support/ Or this one where I could ask Dominos some basic questions about my meal and order : https://hellotars.com/convBot/demos/dominos_support In the time I spent waiting for the technician to ping me back, I could have potentially found my solution with such a product. It is much faster and requires less investment on my part than IVRS. It requires less waiting time than human chat. And it doesn’t require me to trawl through long FAQ pages or forums. While I could imagine this chatbot to be problematic if there were more than a few standard questions asked regularly, the point still stands that in coming years, as conversational interfaces mature, bots will become the perfect customer support experience. Like my thoughts here? Tap the applause sign below. It lets others see the story and helps me in reaching out to a lot more people :) We are a bunch of nice people working to create something really cool and valuable for our customers. Interested in working with us? Drop me a line at ish[at]hellotars.com

A tale of two Customer Support stories: Why ChatBot should be a standard

Learning Programming: Bewitched by Brilliant Gamification (A Sort of Product Review of Brilliant)

প্রোগ্রামিং শেখা: ব্রিলিয়ান্ট গ্যামিফিকেশন দ্বারা বিমোহিত (ব্রিলিয়ান্টের পণ্য পর্যালোচনার একটি সাজানো)

Programmieren lernen: Verzaubert von Brilliant Gamification (Eine Art Produktrezension von Brilliant)

Aprendiendo a programar: fascinado por la gamificación de Brilliant (una especie de reseña de producto de Brilliant)

Apprendre la programmation : envoûté par la gamification brillante (une sorte de revue de produit de Brilliant)

प्रोग्रामिंग सीखना: ब्रिलियंट गेमिफिकेशन से मोहित (ब्रिलियंट की एक तरह की उत्पाद समीक्षा)

プログラミング学習: Brilliant のゲーミフィケーションに魅了される (Brilliant の製品レビューのようなもの)

프로그래밍 학습: 뛰어난 게임화에 매료되다(뛰어난 제품에 대한 일종의 리뷰)

Aprendendo Programação: Enfeitiçado pela Gamificação Brilhante (Uma Espécie de Análise de Produto da Brilliant)

Обучение программированию: очарованные блестящей геймификацией (своего рода обзор продукта Brilliant)

Programlama Öğrenme: Brilliant Gamification'ın Büyüsü (Brilliant'ın Bir Tür Ürün İncelemesi)

Học lập trình: Mê mẩn với Gamification tuyệt vời (Một dạng đánh giá sản phẩm của Brilliant)

学习编程：着迷于 Brilliant 游戏化（Brilliant 的一种产品评论）

How Digital Platforms Undo Paperwork In Real Estate

Congratulations to all of the participants in our ! You did a wonderful job showcasing your incredible startups and powering through another year. 35,000+ startups and over 600,000+ votes later - it’s time to celebrate the startup scene in ! 2023 Startups of the Year Oceania The startup scene in Oceania is driven by innovation, a bunch of passionate folks, and a supportive environment that's helping cool ventures take off in different industries. With such a vast range of innovative products and ideas, we’re sure it was difficult for you to choose a favorite. 🏆 Key Stats Let’s start out with some general stats for all of you technical folks. Total Startups Participated: 553 Cities Represented: 72 Total Votes Gathered: 168,278 Winning Startups: 32 Without further ado… To see who is a winner in each respective city, visit and pick a city. The name at the top of the list is the winner. startups.hackernoon.com The will announce the winners per region in their respective cities. Startups Winners Announcement Series Now, , here are all the 2023 Startups of the Year winners for : drum roll please Oceania Adelaide, Australia takes the crown with 4 votes! 👑 Mortar Auckland, New Zealand And with 31 votes… takes the title! 👑 Gemini AI Solutions Australian Capital Territory, Australia sweeps the board with 2 votes! 👑 AppSec Fasttrack Belmont, Australia for the win, with 4 votes! 👑 VocaliD Brisbane, Australia takes the crown with 34 votes 👑 Bopple But, we have to give recognition to the runner-up, too! With 5 votes... slides into second place 🥈 Fiskil Canberra, Australia comes out on top with 21 votes! 👑 Knowledge Satnav Christchurch, New Zealand notches a victory with 11 votes! 👑 ioSphere Cremorne, Australia It’s a win for , with 4 votes! 👑 Influx Docklands, New Zealand scores big with 8 votes! 👑 LiteCard Dunedin, New Zealand takes home the glory with 4 votes! 👑 Raum Network Gold Coast, Australia takes the crown with 14 votes! 👑 Tommy Majuro, Marshall Islands seals the deal with 4 votes! 👑 MetaGaming Guild Melbourne, Australia With 3350 votes… clinches the title! 👑 Sharepass New South Wales, Australia The crown goes to , with 14 votes! 👑 Regional CFO New Zealand Misc 12 votes and steals the show! 👑 Odd Jobs Newcastle, Australia scoops the victory with 4 votes! 👑 Cordel Pty North Melbourne, Australia Bagging 21 votes, is the winner! 👑 Peptalk360 Perth, Australia Guess who's the winner? , with 2107 votes! 👑 The Catfisher Project Port Moresby, National Capital District, Papua New Guinea scores the first place with 11 votes! 👑 Alto Trackom Queensland, Australia wins with 21 votes! 👑 Flow Queenstown, New Zealand wins with 4 votes! 👑 Loaded hub South Australia, Australia Air Unique takes the crown with 4 votes! 👑 Surry Hills, Australia With 14 votes, takes the crown! 👑 Zemble Suva, Central Division, Fiji With 11 votes, is Suva’s winner! 👑 eJobsFiji Sydney, Australia takes the cake with 138 votes! 👑 Coviu Thornbury, Australia takes the crown with 11 votes! 👑 Stack Team App Tullamarine, Victoria, Australia is the champ with 2 votes! 👑 HelloTeams Wellington, New Zealand Who won here? With 85 votes... nails it! 👑 Nexustorage Western Australia, Australia takes the crown with 4 votes! 👑 IFN Neurologic Willunga, South Australia, Australia wins with 28 votes! 👑 My Digital CMO Congratulations y’all. We will contact you with details on your winnings! See the global and other regional announcements . here About HackerNoon’s Startups Of The Year Startups of The Year is HackerNoon’s Flagship community-driven event celebrating startups that survived and thrived in 2023. 30,000 startups across 4200+ cities and six continents participated in 2023 to be crowned the best startup in their city. Visit our page to learn more. FAQ Companies that blog more get 67% more leads - Jumpstart your company’s blogging journey by purchasing our . Business Blogging Package The 2023 Startups Of The Year is sponsored by: . . The winners will get a free .Tech Domain, a HackerNoon NFT, and a Tech Company News Page. TECH Domains

Startups of the Year 2023: Oceania Winners

2023 সালের স্টার্টআপ: ওশেনিয়া বিজয়ীরা

Startups des Jahres 2023: Ozeanien-Gewinner

Startups del año 2023: ganadoras de Oceanía

Startups de l'année 2023 : les gagnants d'Océanie

वर्ष 2023 के स्टार्टअप: ओशिनिया विजेता

Startups of the Year 2023: オセアニア受賞者

2023년 올해의 스타트업: 오세아니아 우승자

Startups do ano 2023: Vencedores da Oceania

Стартапы 2023 года: победители Океании

2023 Yılının Startup'ları: Okyanusya Kazananları

Công ty khởi nghiệp của năm 2023: Người chiến thắng ở Châu Đại Dương

2023 年度初创企业：大洋洲获奖者

Building a CI/CD Pipeline with AWS, K8S, Docker, Ansible, Git, Github, Apache Maven, and Jenkins

AWS, K8S, Docker, Ansible, Git, Github, Apache Maven এবং Jenkins এর সাথে একটি CI/CD পাইপলাইন তৈরি করা

Aufbau einer CI/CD-Pipeline mit AWS, K8S, Docker, Ansible, Git, Github, Apache Maven und Jenkins

Creación de una canalización de CI/CD con AWS, K8S, Docker, Ansible, Git, Github, Apache Maven y Jenkins

Création d'un pipeline CI/CD avec AWS, K8S, Docker, Ansible, Git, Github, Apache Maven et Jenkins

AWS, K8S, Docker, Ansible, Git, Github, Apache Maven और जेनकिंस के साथ CI/CD पाइपलाइन का निर्माण

AWS、K8S、Docker、Ansible、Git、Github、Apache Maven、Jenkins を使用した CI/CD パイプラインの構築

AWS, K8S, Docker, Ansible, Git, Github, Apache Maven 및 Jenkins를 사용하여 CI/CD 파이프라인 구축

Construindo um pipeline de CI/CD com AWS, K8S, Docker, Ansible, Git, Github, Apache Maven e Jenkins

Создание конвейера CI/CD с помощью AWS, K8S, Docker, Ansible, Git, Github, Apache Maven и Jenkins

AWS, K8S, Docker, Ansible, Git, Github, Apache Maven ve Jenkins ile CI/CD İşlem Hattı Oluşturma

Xây dựng quy trình CI/CD với AWS, K8S, Docker, Ansible, Git, Github, Apache Maven và Jenkins

使用 AWS、K8S、Docker、Ansible、Git、Github、Apache Maven 和 Jenkins 构建 CI/CD 管道

ADB: What Developers Need to Know

In our last post, we introduced you to the project and how it offers a revolutionary set of language extensions for Java, including the ability to parse and process files seamlessly in Java. Today, we will take a look at another exciting feature of the Manifold project: string templates. Manifold JSON https://www.youtube.com/watch?v=ite6a5y50yQ&embedable=true But before we get to that, some of the feedback I got from the previous post was that I was unclear about Manifold. Manifold is a combination of an IDE plugin and plugins to Maven or Gradle. Once used we can enhance the Java language (or environment) almost seamlessly in a fluid way. A frequent question was how is it different from something like ? Lombok There are many similarities and in fact, if you understand Lombok then you are on your way to understand Manifold. Lombok is a great solution for some problems in the Java language. It is a bandaid on the verbosity of Java and some of its odd limitations (I mean bandaid as a compliment, no hate mail). Manifold differs from Lombok in several critical ways: It’s modular - all the extensions built into Manifold are separate from one another. You can activate a particular feature or leave it out of the compiler toolchain. It’s bigger - Lombok has many features but Manifold's scope is fantastic and far more ambitious. It tries to do the “right thing” - Lombok is odd. We declare private fields but then use getters and setters as if they aren’t private. Manifold uses properties (which we will discuss later) that more closely resemble what the Java language “should have offered”. Manifold also has some drawbacks: It only works as a compiler toolchain and only in one way. Lombok can be compiled back to plain Java source code and removed. It only supports one IDE - IntelliJ. These partially relate to the age of Manifold which is a new project by comparison. But it also relates to the different focus. Manifold focuses on language functionality and a single working fluid result. JEP 430 String Interpolation One of the big features coming to JDK 21 is , which is a string interpolation language change. JEP 430 It will allow writing code like this: String name = "Joan";
String info = STR."My name is \{name}"; In this case, will have the value . This is just the tip of the iceberg in this JSR as the entire architecture is pluggable. I will discuss this in a future video but for now, the basic functionality we see here is pretty fantastic. info “My name is Joan” Unfortunately, it will take years to use this in production. It will be in preview in JDK 21, then it will be approved. We will wait for an LTS, and then wait for the LTS to reach critical mass. In the meantime, can we use something as nice as this today? Maven Dependencies Before we dive into the code, I want to remind you that all the code for this and other videos in this series is available on (feel free to star it and follow). GitHub String templating has no dependencies. We still need to make changes to the pom file but we don’t need to add dependencies. I’m adding one dependency here for the advanced templates we will discuss soon. All that’s needed is the compiler plugin. That means that string templates are a compile-time feature and have no runtime impact! <dependencies>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-templates-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
</dependencies>

<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-strings</artifactId>
                       <version>${manifold.version}</version>
                   </path>
                   <path>
                       <groupId>systems.manifold</groupId>
                       <artifactId>manifold-templates</artifactId>
                       <version>${manifold.version}</version>
                   </path>
               </annotationProcessorPaths>
           </configuration>
       </plugin>
   </plugins>
</build> Manifold String Interpolation To begin, we can create a new variable that we can use to get external input. In the second line, we integrate that variable into the printout: String world = args.length > 0 ? args[0] : "world";
System.out.println("Hello $world! I can write \$world as the variable..."); The backslash syntax implicitly disables the templating behavior, just like in other string elements in Java. This will print . “Hello world! I can write $world as the variable…” There’s something that you can’t really see in the code, you need to look at a screenshot of the same code: ![]( align="center") https://cdn.hashnode.com/res/hashnode/image/upload/v1683029461078/84f52be2-30c3-435f-bbf6-4a53937b3859.png It’s subtle, do you see it? Notice the expression, it is colored differently. It's no longer just a string but a variable embedded in a string. This means that we can control-click it and go to the variable declaration, rename it, or see find its usage. $world There's another way to escape a string, and we can use the annotation on a method or a class to disable this functionality in the respective block of code. @DisableStringLiteralTemplates This can be useful if we use the dollar sign frequently in a block of code: @DisableStringLiteralTemplates
private static void noTemplate(String word) {
   System.out.println("Hello $world!");
} Templates The Manifold project allows us to create JSP-like templates without all of the baggage. We can define a base class to a template to create generic code for the templates and place common functionality in a single location. We can create a file called HelloTemplate.html.mtl in the resources/templates directory with the following content. Notice the params we define in the template file can be anything: <%@ params(String title, String body) %>
<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <title>${title}</title>
</head>
<body>
   ${body}
</body>
</html> This will seem very familiar to those of us with a JSP background. We can then use the file in the Java code like this, we can pass the parameters and they will replace the appropriate blocks in the HTML file: System.out.println(HelloTemplate.render("My Title", "My Body")); Notice the generated template it compiled to a class, similar to JSP. Unlike JSP this template isn’t a servlet and can be used in any context. A local application, a server, etc. The templating language is more lightweight and doesn’t depend on various server APIs. It is also less mature. The main value is in using such an API to generate arbitrary files like Java source files or configuration files. The templating capabilities are powerful yet simple. Just like we could in JSP, we can embed Java source code into the template e.g. we can include control flow and similar restrictions just like we could in JSP: <% if(body != null) {%>
   ${body}
<% } %> Why Not: JSP, Velocity, Thymeleaf, or Freemarker? There are so many templating languages in Java already… Adding yet another one seems like a heavy burden of replication. I think all of those are great and this isn’t meant to replace them, at least not yet. Their focus is very much on web generation, they might not be ideal for more fluid use cases like code generation or web frameworks like Spark. Another big advantage is size and performance. All of these frameworks have many dependencies and a lot of runtime overhead. Even JSP performs the initial compilation in runtime by default. This templating support is compiled and Spartan, in a good way. It’s fast, simple, and deeply integrated into the application flow. Import We can import Java packages just like we can in every Java class using code like this: <%@ import com.debugagent.stringtemplates.* %> Once imported we can use any class within the code. Notice that this import statement must come above other lines in the code, just like a regular import statement. Include We can use include to simply include another template into the current template, allowing us to assemble sophisticated templates like headers and footers. If we want to generate a complex Java class, we can wrap the boilerplate in a generic template and include that in. We can conditionally include a template using an if statement and use a for loop to include multiple entries: <%@ include JavaCode("ClassName", classBody) %> Notice that we can include an entry with parameters and pass them along to the underlying template. We can pass hardcoded strings or variables along the included chain. A Lot More I skipped extends because of a documentation issue, which has since been fixed. it has a lot of potential. There’s layout functionality that has a lot of potentials but is missing parameter passing at the moment. But the main value is in the simplicity and total integration. When I define a dependency on a class and remove it from the code the error appears even in the template file. This doesn’t happen in Thymeleaf. Final Word In conclusion, with the Manifold project, we can write fluent text processing code today without waiting for a future JVM enhancement. The introduction of String templates can help Java developers generate files that aren't a web application, which is useful in several cases e.g. where code generation is needed. Manifold allows us to create JSP-like templates without all of the baggage and generate any arbitrary file we want. With the inclusion of sophisticated options like layout, the sky's the limit. There’s a lot more to Manifold and we will dig deeper into it as we move forward. Also published here.

The Manifold Project: Exploring String Templates for Java Development

As software applications become increasingly complex, file handling has become a significant challenge for developers. In light of this, I have taken it upon myself to address this problem by creating a simple yet insightful post that will help developers understand the ins and outs of file handling in JavaScript. Disclaimer: All the code samples in this article are AI-generated. 11 Best Practices for Javascript File Handling When dealing with files, errors are inevitable. Ensure that errors are handled gracefully and meaningful error messages are displayed to the users. Always handle errors: Example: const file = new File(['Hello, world!'], 'hello.txt', {type: 'text/plain'});
const reader = new FileReader();

reader.onerror = (event) => {
  console.error(`Error occurred while reading file: ${event.target.error}`);
};

reader.readAsText(file); Always validate file types before accepting file uploads from users to prevent malicious or invalid files from being uploaded. Use appropriate file types: Example: const fileInput = document.getElementById('file-input');
const allowedFileTypes = ['image/jpeg', 'image/png', 'application/pdf'];

fileInput.addEventListener('change', (event) => {
  const file = event.target.files[0];
  if (!allowedFileTypes.includes(file.type)) {
    alert('Invalid file type. Please upload a JPEG, PNG, or PDF file.');
    event.target.value = null;
  } else {
    // Handle file upload
  }
}); If you are reading or writing files, close the file stream when you are done to free up system resources. Close file streams when done: Example: const file = new File(['Hello, world!'], 'hello.txt', {type: 'text/plain'});
const writer = new FileWriter();

writer.write(file);

// Close file stream when done
writer.close(); on files can be time-consuming and block the main thread. In order to avoid freezing the UI and improve performance, always use asynchronous methods. Use asynchronous methods: I/O operations Example: const file = new File(['Hello, world!'], 'hello.txt', {type: 'text/plain'});

async function readFile() {
  const reader = new FileReader();
  return new Promise((resolve, reject) => {
    reader.onload = (event) => resolve(event.target.result);
    reader.onerror = (event) => reject(event.target.error);
    reader.readAsText(file);
  });
}

readFile()
  .then((content) => console.log(content))
  .catch((error) => console.error(error)); It is important to keep in mind the performance impact of large files on an end user's device when working with them. Use streaming techniques to load the file into memory in small chunks rather than loading it all at once. Be mindful of file size: Example: const file = new File(['Hello, world!'.repeat(1000000)], 'hello.txt', {type: 'text/plain'});

function processFile() {
  const stream = file.stream();
  const reader = stream.getReader();

  function readChunk() {
    return reader.read()
      .then(({value, done}) => {
        if (done) {
          console.log('Finished processing file');
          return;
        }
        console.log(`Read chunk of size ${value.byteLength}`);
        return readChunk();
      });
  }

  return readChunk();
}

processFile(); Choose file names that accurately reflect the contents and purposes of the files. A file containing utility functions, for example, could be named Use descriptive file names: utils.js. Organize your code into modular components to make it easier to understand and maintain. The use of modules allows you to organize related code and reduce the chance of naming conflicts. Use modular design: Adding to your JavaScript file will enforce stricter syntax rules, catch common errors, and improve performance. Use strict mode: use strict Describe the purpose, behavior, and limitations of your code in the comments. You will be able to make your code more understandable to other developers and to yourself in the future. Use comments: You can use a linter to find and correct syntax errors, style issues, and potential bugs. Linting tools such as JSLint, ESLint, and JSHint are widely used. Use linting tools: Track changes to your code and collaborate with other developers with a version control system like Git. In this way, you can avoid version conflicts and revert to previous versions of your code if necessary. Use version control: The following JavaScript file implements some of these best practices: 'use strict';

// This module contains utility functions.

// Returns the sum of two numbers.
function add(num1, num2) {
  return num1 + num2;
}

// Returns the difference between two numbers.
function subtract(num1, num2) {
  return num1 - num2;
}

// Exports the functions for use in other modules.
module.exports = {
  add: add,
  subtract: subtract
}; In this example, indicates that it contains utility functions. Each function is defined separately in the code, which is broken into modular components. The directive enforces stricter syntax rules. Comments are used to explain the purpose of each function. Finally, the functions are exported for use in other modules using the object. utils.js use strict module.exports Wrap-up File handling in JavaScript is an important skill for any programmer. By following the 11 golden rules outlined in this article, programmers can ensure that they are creating robust and efficient code that is easy to maintain and debug. With a solid understanding of these best practices, developers can take their file-handling capabilities to the next level and create truly exceptional applications. These are just a few examples of JavaScript file-handling best practices. Also, be sure to follow web application security best practices when working with user-generated files.

Javascript File Handling: 11 Golden Rules to Follow as a Programmer

The right feature at the right place Before moving to Developer Relations, I transitioned from Software Architect to Solution Architect long ago. It’s a reasonably common career move. The problem in this situation is two-fold: You know perfectly well software libraries You don’t know well infrastructure components It seems logical that people in this situation try to solve problems with the solutions they are most familiar with. However, it doesn’t mean it’s the best approach. It’s a bad one in most cases. A concrete example Imagine an API application. It runs on the JVM, and it’s written in the "Reactive" style with the help of the Spring Boot framework. One of the requirements is to limit the number of calls a user can make in a timeframe. In the API world, such a Rate Limiting feature is widespread. With my software architect hat on, I’ll search for a JVM library that does it. Because I have a bit of experience, I know of the excellent Bucket4J library: Java rate-limiting library based on token-bucket algorithm — Bucket4J It’s just a matter of integrating the library into my code: val beans = beans {
    bean {
        val props = ref<BucketProperties>()                  (1)
        BucketFactory().create(                              (2)
            props.size,
            props.refresh.tokens,
            props.refresh.duration
        )
    }
    bean {
        coRouter {
            val handler = HelloHandler(ref())                (3)
            GET("/hello") { handler.hello(it) }
            GET("/hello/{who}") { handler.helloWho(it) }
        }
    }
}

class HelloHandler(private val bucket: Bucket) {             (3)

    private suspend fun rateLimit(                           (4)
        req: ServerRequest,
        f: suspend (ServerRequest) -> ServerResponse
    ) = if (bucket.tryConsume(1))
            f.invoke(req)
        else
            ServerResponse.status(429).buildAndAwait()

    suspend fun hello(req: ServerRequest) = rateLimit(req) { (5)
        ServerResponse.ok().bodyValueAndAwait("Hello World!")
    }
} Get configuration properties from a -annotated class @ConfigurationProperties Create a properly-configured bucket Pass the bucket to the handler Create a reusable rate-limiting wrapper based on the bucket Wrap the call At this point, the bucket is for the whole app. If we want a dedicated bucket per user, as per the requirements, we need to: Bring in Spring Security to authenticate users (or write our own authentication mechanism) Create a bucket per user Store the bucket server-side and bind it to the user session While it’s perfectly acceptable, it’s a lot of effort for a feature that one can implement cheaper elsewhere. The golden case for API Gateways A place for everything, everything in its place. This quote is associated with Samuel Smiles, Mrs. Isabella Beeton, and Benjamin Franklin. In any case, cross-cutting features don’t belong in the application but in infrastructure components. Our feature is an API, so it’s a perfect use-case for an API Gateway. We can simplify the code by removing Bucket4J and configuring an API Gateway in front of the application. Here’s how to do it with . Apache APISIX consumers:
  - username: joe
    plugins:
      key-auth:                               (1)
        key: joe
  - username: jane
    plugins:
      key-auth:                               (1)
        key: jane
routes:
  - uri: /hello*
    upstream:
      type: roundrobin
      nodes:
        "resilient-boot:8080": 1
    plugins:
      limit-req:                              (2)
        rate: 1
        burst: 0
        key: consumer_name                    (3)
        rejected_code: 429
      key-auth: ~                             (1) We use a simple HTTP header for authentication for demo purposes. Real-world apps would use OAuth2.0 or OpenID Connect, but the principle is the same Rate limiting plugin Configure a bucket per consumer Discussion: what belongs where? Before answering the question, let me go through a detour first. The book makes the case that the brain has two "modes": Thinking, Fast and Slow The book’s main thesis is that of a dichotomy between two modes of thought: "System 1" is fast, instinctive and emotional; "System 2" is slower, more deliberative, and more logical. Also, System 2 is much more energy-consuming. Because we are lazy, we tend to favor System 1 - fast and instinctive. Hence, as architects, we will generally favor the following: Solutions we are familiar with, , libraries for former software architects e.g. Rules to apply blindly. As a side comment, it’s the main reason for herd mentality in the tech industry, such as "microservices everywhere" Hence, take the following advice as guidelines and not rules. Now that this has been said, here’s my stance. First, you need to categorize whether the feature is purely technical. For example, classical rate-limiting to prevent DDoS is purely technical. Such technical features belong in the infrastructure: every Reverse-Proxy worth its salt has this kind of rate-limiting. The more business-related a feature, the closer it must be to the application. Our use-case is slightly business-related because rate-limiting is per user. Still, the API Gateway provides the feature out of the box. Then, know your infrastructure components. It’s impossible to know all the components, but you should have a passing knowledge of the elements available inside your org. If you’re using a Cloud Provider, get a map of all their proposed services. Regarding the inability to know all the components, talk to your SysAdmins. My experience has shown me that most organizations must utilize their SysAdmins effectively. The latter would like to be more involved in the overall system architecture design but are rarely requested to. Most SysAdmins love to share their knowledge! You also need to think about configuration. If you need to configure each library component on each instance, that’s a huge red flag; prefer an infrastructure component. Some libraries offer a centralized configuration solution, , . Carefully evaluate the additional complexity of such a component and its failure rate compared to other dedicated infrastructure components. e.g. Spring Cloud Config Organizations influence choice . The same problem in two different organizational contexts may result in two opposite solutions. Familiarity with a solution generally trumps other solutions' better fit. a lot Finally, as I mentioned in the introduction, your experience will influence your choices: former software architects prefer app-centric solutions, and former sys admins infrastructure solutions. One should be careful to limit one’s bias toward one’s preferred solution, which might not be the best fit in a different context. Conclusion In this post, I’ve taken the example of per-user rate limiting to show how one can implement it in a library and an infrastructure component. Then, I generalized this example and gave a couple of guidelines. I hope they will help you make better choices regarding where to place a feature in your system. To go further: Bucket4J Spring Cloud Config Apache APISIX rate limiting plugin The complete source code for this post can be found on . Originally published at on February 19th, 2023. GitHub A Java Geek Image Credit, prompt of ‘someone who perfectly well knows software libraries and doesn’t perfectly well know infrastructure components smiles at his pixelated remote desk.’ HackerNoon AI

From the Software Architect Mindset to Solution Architect Mindset (and back again)

Stories, News & Mentions about HELLOTAG

Hellotag’s Stories on HackerNoon